@typeberry/lib 0.5.1-aff8b4f → 0.5.1-eb84786

package/packages/extensions/ipc/jamnp/handler.js

@@ -0,0 +1,164 @@
+import { BytesBlob } from "#@typeberry/bytes";
+import { Decoder, Encoder } from "#@typeberry/codec";
+import { Logger } from "#@typeberry/logger";
+import { NewStream, StreamEnvelope, StreamEnvelopeType } from "./stream.js";
+const logger = Logger.new(import.meta.filename, "ext-ipc-jamnp");
+export class JamnpIpcHandler {
+    sender;
+    /** already initiated streams */
+    streams = new Map();
+    /** streams awaiting confirmation from the other side. */
+    pendingStreams = new Map();
+    /** a collection of handlers for particular stream kind */
+    streamHandlers = new Map();
+    /** termination promise + resolvers */
+    onEnd;
+    constructor(sender) {
+        this.sender = sender;
+        let resolve = () => { };
+        let reject = (_error) => { };
+        const listen = new Promise((res, rej) => {
+            resolve = res;
+            reject = rej;
+        });
+        this.onEnd = {
+            finished: false,
+            listen,
+            resolve,
+            reject,
+        };
+    }
+    /** Register stream handlers. */
+    registerStreamHandlers(...handlers) {
+        for (const handler of handlers) {
+            this.streamHandlers.set(handler.kind, handler);
+        }
+    }
+    /** Re-use an existing stream of given kind if present. */
+    withStreamOfKind(streamKind, work) {
+        // find first stream id with given kind
+        for (const [streamId, handler] of this.streams.entries()) {
+            if (handler.kind === streamKind) {
+                work(handler, new EnvelopeSender(streamId, this.sender));
+                return;
+            }
+        }
+        throw new Error(`Missing handler for ${streamKind}!`);
+    }
+    /** Open a new stream of given kind. */
+    withNewStream(kind, work) {
+        const handler = this.streamHandlers.get(kind);
+        if (handler === undefined) {
+            throw new Error(`Stream with unregistered handler of kind: ${kind} was requested to be opened.`);
+        }
+        // pick a stream id
+        const getRandomStreamId = () => Math.floor(Math.random() * 2 ** 16);
+        const streams = this.streams;
+        const streamId = (function findStreamId() {
+            const s = getRandomStreamId();
+            if (!streams.has(s)) {
+                return s;
+            }
+            return findStreamId();
+        })();
+        // register the stream
+        this.streams.set(streamId, handler);
+        this.pendingStreams.set(streamId, true);
+        const sender = new EnvelopeSender(streamId, this.sender);
+        sender.open(NewStream.create({ streamByte: kind }));
+        work(handler, sender);
+    }
+    /** Handle incoming message on that socket. */
+    async onSocketMessage(msg) {
+        // decode the message as `StreamEnvelope`
+        const envelope = Decoder.decodeObject(StreamEnvelope.Codec, msg);
+        const streamId = envelope.streamId;
+        logger.log `[${streamId}] incoming message: ${envelope.type} ${envelope.data}`;
+        // check if this is a already known stream id
+        const streamHandler = this.streams.get(streamId);
+        const streamSender = new EnvelopeSender(streamId, this.sender);
+        // we don't know that stream yet, so it has to be a new one
+        if (streamHandler === undefined) {
+            // closing or message of unknown stream - ignore.
+            if (envelope.type !== StreamEnvelopeType.Open) {
+                logger.warn `[${streamId}] (unknown) got invalid type ${envelope.type}.`;
+                return;
+            }
+            const newStream = Decoder.decodeObject(NewStream.Codec, envelope.data);
+            const handler = this.streamHandlers.get(newStream.streamByte);
+            if (handler !== undefined) {
+                logger.log `[${streamId}] new stream for ${handler.kind}`;
+                // insert the stream
+                this.streams.set(streamId, handler);
+                // Just send back the same stream byte.
+                streamSender.open(newStream);
+                return;
+            }
+            // reply with an error, because we don't know how to handle that stream kind.
+            streamSender.close();
+            return;
+        }
+        // close the stream
+        if (envelope.type === StreamEnvelopeType.Close) {
+            const handler = this.streams.get(streamId);
+            handler?.onClose(streamId, false);
+            this.streams.delete(streamId);
+            return;
+        }
+        if (envelope.type !== StreamEnvelopeType.Msg) {
+            // display a warning but only if the stream was not pending for confirmation.
+            if (!this.pendingStreams.delete(streamId)) {
+                logger.warn `[${streamId}] got invalid type ${envelope.type}.`;
+            }
+            return;
+        }
+        // this is a known stream, so just dispatch the message.
+        streamHandler.onStreamMessage(streamSender, envelope.data);
+    }
+    /** Notify about termination of the underlying socket. */
+    onClose({ error }) {
+        logger.log `Closing the handler. Reason: ${error !== undefined ? error.message : "close"}.`;
+        // Socket closed - we should probably clear everything.
+        for (const [streamId, handler] of this.streams.entries()) {
+            handler.onClose(streamId, error === undefined);
+        }
+        this.streams.clear();
+        // finish the handler.
+        this.onEnd.finished = true;
+        if (error !== undefined) {
+            this.onEnd.reject(error);
+        }
+        else {
+            this.onEnd.resolve();
+        }
+    }
+    /** Wait for the handler to be finished either via close or error. */
+    waitForEnd() {
+        logger.log `Waiting for the handler to be closed.`;
+        return this.onEnd.listen;
+    }
+}
+class EnvelopeSender {
+    streamId;
+    sender;
+    constructor(streamId, sender) {
+        this.streamId = streamId;
+        this.sender = sender;
+    }
+    open(newStream) {
+        const msg = Encoder.encodeObject(NewStream.Codec, newStream);
+        this.sender.send(Encoder.encodeObject(StreamEnvelope.Codec, StreamEnvelope.create({ streamId: this.streamId, type: StreamEnvelopeType.Open, data: msg })));
+    }
+    bufferAndSend(msg) {
+        this.sender.send(Encoder.encodeObject(StreamEnvelope.Codec, StreamEnvelope.create({ streamId: this.streamId, type: StreamEnvelopeType.Msg, data: msg })));
+        // we are buffering until we run OOM
+        return true;
+    }
+    close() {
+        this.sender.send(Encoder.encodeObject(StreamEnvelope.Codec, StreamEnvelope.create({
+            streamId: this.streamId,
+            type: StreamEnvelopeType.Close,
+            data: BytesBlob.blobFromNumbers([]),
+        })));
+    }
+}

package/packages/extensions/ipc/jamnp/server.d.ts

@@ -0,0 +1,8 @@
+import type { HeaderHash } from "#@typeberry/block";
+import type { ChainSpec } from "#@typeberry/config";
+import { ce129, up0 } from "#@typeberry/jamnp-s";
+import type { Listener } from "#@typeberry/listener";
+import type { TrieNode } from "#@typeberry/trie/nodes.js";
+/** An IPC endpoint exposing network-like messaging protocol. */
+export declare function startJamnpIpcServer(nodeName: string, chainSpec: ChainSpec, announcements: Listener<up0.Announcement>, getHandshake: () => up0.Handshake, getBoundaryNodes: (hash: HeaderHash, startKey: ce129.Key, endKey: ce129.Key) => TrieNode[], getKeyValuePairs: (hash: HeaderHash, startKey: ce129.Key, endKey: ce129.Key) => ce129.KeyValuePair[]): () => void;
+//# sourceMappingURL=server.d.ts.map

package/packages/extensions/ipc/jamnp/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../../../../packages/extensions/ipc/jamnp/server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,oBAAoB,CAAC;AAChD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAIzD,gEAAgE;AAChE,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,SAAS,EACpB,aAAa,EAAE,QAAQ,CAAC,GAAG,CAAC,YAAY,CAAC,EACzC,YAAY,EAAE,MAAM,GAAG,CAAC,SAAS,EACjC,gBAAgB,EAAE,CAAC,IAAI,EAAE,UAAU,EAAE,QAAQ,EAAE,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,GAAG,KAAK,QAAQ,EAAE,EAC1F,gBAAgB,EAAE,CAAC,IAAI,EAAE,UAAU,EAAE,QAAQ,EAAE,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,GAAG,KAAK,KAAK,CAAC,YAAY,EAAE,cA8BrG"}

package/packages/extensions/ipc/jamnp/server.js

@@ -0,0 +1,27 @@
+import { ce129, up0 } from "#@typeberry/jamnp-s";
+import { startIpcServer } from "../server.js";
+import { JamnpIpcHandler } from "./handler.js";
+/** An IPC endpoint exposing network-like messaging protocol. */
+export function startJamnpIpcServer(nodeName, chainSpec, announcements, getHandshake, getBoundaryNodes, getKeyValuePairs) {
+    return startIpcServer(`typeberry-jamnp-${nodeName}`, (sender) => {
+        const handler = new JamnpIpcHandler(sender);
+        // Send block announcements
+        const listener = (announcement) => {
+            if (announcement instanceof up0.Announcement) {
+                handler.withStreamOfKind(up0.STREAM_KIND, (handler, sender) => {
+                    handler.sendAnnouncement(sender, announcement);
+                });
+            }
+            else {
+                throw new Error(`Invalid annoncement received: ${announcement}`);
+            }
+        };
+        announcements.on(listener);
+        handler.waitForEnd().finally(() => {
+            announcements.off(listener);
+        });
+        handler.registerStreamHandlers(new up0.Handler(chainSpec, getHandshake, () => { }, () => { }));
+        handler.registerStreamHandlers(new ce129.Handler(true, getBoundaryNodes, getKeyValuePairs));
+        return handler;
+    });
+}

package/packages/extensions/ipc/jamnp/stream.d.ts

@@ -0,0 +1,30 @@
+import type { BytesBlob } from "#@typeberry/bytes";
+import { type CodecRecord } from "#@typeberry/codec";
+import type { StreamId, StreamKind } from "#@typeberry/jamnp-s";
+import { type U8 } from "#@typeberry/numbers";
+export declare enum StreamEnvelopeType {
+    Msg = 0,
+    Open = 1,
+    Close = 2
+}
+export declare class StreamEnvelope {
+    readonly streamId: StreamId;
+    readonly type: StreamEnvelopeType;
+    readonly data: BytesBlob;
+    static Codec: import("@typeberry/codec").Descriptor<StreamEnvelope, import("@typeberry/codec").ViewOf<StreamEnvelope, {
+        streamId: import("@typeberry/codec").Descriptor<import("@typeberry/numbers").U32, import("@typeberry/bytes").Bytes<4>>;
+        type: import("@typeberry/codec").Descriptor<StreamEnvelopeType, U8>;
+        data: import("@typeberry/codec").Descriptor<BytesBlob, BytesBlob>;
+    }>>;
+    static create({ streamId, type, data }: CodecRecord<StreamEnvelope>): StreamEnvelope;
+    private constructor();
+}
+export declare class NewStream {
+    readonly streamByte: StreamKind;
+    static Codec: import("@typeberry/codec").Descriptor<NewStream, import("@typeberry/codec").ViewOf<NewStream, {
+        streamByte: import("@typeberry/codec").Descriptor<U8, U8>;
+    }>>;
+    static create({ streamByte }: CodecRecord<NewStream>): NewStream;
+    private constructor();
+}
+//# sourceMappingURL=stream.d.ts.map

package/packages/extensions/ipc/jamnp/stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../../../../../packages/extensions/ipc/jamnp/stream.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,KAAK,WAAW,EAAS,MAAM,kBAAkB,CAAC;AAC3D,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAC/D,OAAO,EAAW,KAAK,EAAE,EAAE,MAAM,oBAAoB,CAAC;AAEtD,oBAAY,kBAAkB;IAC5B,GAAG,IAAI;IACP,IAAI,IAAI;IACR,KAAK,IAAI;CACV;AAED,qBAAa,cAAc;aA0BP,QAAQ,EAAE,QAAQ;aAClB,IAAI,EAAE,kBAAkB;aACxB,IAAI,EAAE,SAAS;IA3BjC,MAAM,CAAC,KAAK;;;;QAkBT;IAEH,MAAM,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,WAAW,CAAC,cAAc,CAAC;IAInE,OAAO;CAKR;AAED,qBAAa,SAAS;aASgB,UAAU,EAAE,UAAU;IAR1D,MAAM,CAAC,KAAK;;QAET;IAEH,MAAM,CAAC,MAAM,CAAC,EAAE,UAAU,EAAE,EAAE,WAAW,CAAC,SAAS,CAAC;IAIpD,OAAO;CACR"}

package/packages/extensions/ipc/jamnp/stream.js

@@ -0,0 +1,49 @@
+import { codec } from "#@typeberry/codec";
+import { tryAsU8 } from "#@typeberry/numbers";
+export var StreamEnvelopeType;
+(function (StreamEnvelopeType) {
+    StreamEnvelopeType[StreamEnvelopeType["Msg"] = 0] = "Msg";
+    StreamEnvelopeType[StreamEnvelopeType["Open"] = 1] = "Open";
+    StreamEnvelopeType[StreamEnvelopeType["Close"] = 2] = "Close";
+})(StreamEnvelopeType || (StreamEnvelopeType = {}));
+export class StreamEnvelope {
+    streamId;
+    type;
+    data;
+    static Codec = codec.Class(StreamEnvelope, {
+        streamId: codec.u32,
+        type: codec.u8.convert((i) => tryAsU8(i), (o) => {
+            switch (o) {
+                case StreamEnvelopeType.Msg:
+                    return StreamEnvelopeType.Msg;
+                case StreamEnvelopeType.Open:
+                    return StreamEnvelopeType.Open;
+                case StreamEnvelopeType.Close:
+                    return StreamEnvelopeType.Close;
+                default:
+                    throw new Error(`Invalid 'StreamEnvelopeType' value: ${o}`);
+            }
+        }),
+        data: codec.blob,
+    });
+    static create({ streamId, type, data }) {
+        return new StreamEnvelope(streamId, type, data);
+    }
+    constructor(streamId, type, data) {
+        this.streamId = streamId;
+        this.type = type;
+        this.data = data;
+    }
+}
+export class NewStream {
+    streamByte;
+    static Codec = codec.Class(NewStream, {
+        streamByte: codec.u8,
+    });
+    static create({ streamByte }) {
+        return new NewStream(streamByte);
+    }
+    constructor(streamByte) {
+        this.streamByte = streamByte;
+    }
+}

package/packages/extensions/ipc/server.d.ts

@@ -0,0 +1,14 @@
+import { type Socket } from "node:net";
+import type { BytesBlob } from "#@typeberry/bytes";
+import type { IpcHandler } from "#@typeberry/fuzz-proto";
+/** Sending data abstraction on a socket. */
+export declare class IpcSender {
+    private readonly socket;
+    constructor(socket: Socket);
+    /** Write given data to the outgoing socket. */
+    send(data: BytesBlob): void;
+    /** Close the socket. */
+    close(): void;
+}
+export declare function startIpcServer(name: string, newMessageHandler: (socket: IpcSender) => IpcHandler): () => void;
+//# sourceMappingURL=server.d.ts.map

package/packages/extensions/ipc/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../../../packages/extensions/ipc/server.ts"],"names":[],"mappings":"AACA,OAAO,EAAgB,KAAK,MAAM,EAAE,MAAM,UAAU,CAAC;AAIrD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAIxD,4CAA4C;AAC5C,qBAAa,SAAS;IACR,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,MAAM;IAE3C,+CAA+C;IAC/C,IAAI,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI;IAI3B,wBAAwB;IACxB,KAAK,IAAI,IAAI;CAGd;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,iBAAiB,EAAE,CAAC,MAAM,EAAE,SAAS,KAAK,UAAU,cAiFhG"}

package/packages/extensions/ipc/server.js

@@ -0,0 +1,96 @@
+import * as fs from "node:fs";
+import { createServer } from "node:net";
+import * as os from "node:os";
+import * as path from "node:path";
+import { Logger } from "#@typeberry/logger";
+import { encodeMessageLength, handleMessageFragmentation } from "#@typeberry/networking";
+/** Sending data abstraction on a socket. */
+export class IpcSender {
+    socket;
+    constructor(socket) {
+        this.socket = socket;
+    }
+    /** Write given data to the outgoing socket. */
+    send(data) {
+        sendWithLengthPrefix(this.socket, data.raw);
+    }
+    /** Close the socket. */
+    close() {
+        this.socket.end();
+    }
+}
+export function startIpcServer(name, newMessageHandler) {
+    // Define the path for the socket or named pipe
+    const isWindows = os.platform() === "win32";
+    const linuxPath = name.startsWith("/") ? name : path.join(os.tmpdir(), `${name}`);
+    const socketPath = isWindows ? `\\\\.\\pipe\\${name}` : linuxPath;
+    const logger = Logger.new(import.meta.filename, "ext-ipc");
+    // Create the IPC server
+    const server = createServer((socket) => {
+        logger.log `Client connected`;
+        const messageHandler = newMessageHandler(new IpcSender(socket));
+        // Handle incoming data from the client
+        socket.on("data", handleMessageFragmentation(async (data) => {
+            try {
+                // to avoid buffering too much data in our memory, we pause
+                // reading more data from the socket and only resume when the message
+                // is processed.
+                socket.pause();
+                await messageHandler.onSocketMessage(data);
+            }
+            catch (e) {
+                logger.error `Received invalid data on socket: ${e}. Closing connection.`;
+                socket.end();
+            }
+            finally {
+                socket.resume();
+            }
+        }, () => {
+            logger.error `Received too much data on socket. Closing connection.`;
+            socket.end();
+        }));
+        // Handle client disconnection
+        socket.on("end", () => {
+            logger.log `Client disconnected`;
+            messageHandler.onClose({});
+        });
+        socket.on("error", (error) => {
+            logger.error `Socket error: ${error}`;
+            messageHandler.onClose({ error });
+            socket.end();
+        });
+    });
+    // Start the server (remove old socket if present)
+    try {
+        fs.unlinkSync(socketPath);
+    }
+    catch { }
+    const controller = new AbortController();
+    server.listen({
+        path: socketPath,
+        signal: controller.signal,
+    }, () => {
+        logger.log `IPC server is listening at ${socketPath}`;
+    });
+    // Handle server errors
+    server.on("error", (err) => {
+        throw err;
+    });
+    return () => {
+        logger.info `Closing IPC server.`;
+        // stop accepting new connections
+        server.close();
+        // abort the server
+        controller.abort();
+        // unrefing
+        server.unref();
+    };
+}
+/**
+ * Send a message to the socket, prefixed with a 32-bit length
+ * so the receiver can determine the boundaries between data items.
+ */
+function sendWithLengthPrefix(socket, data) {
+    socket.write(encodeMessageLength(data));
+    socket.write(data);
+}

package/packages/jam/block/assurances.d.ts

@@ -0,0 +1,57 @@
+import type { BitVec } from "#@typeberry/bytes";
+import { type CodecRecord, type DescribedBy } from "#@typeberry/codec";
+import type { KnownSizeArray } from "#@typeberry/collections";
+import { type Ed25519Signature } from "#@typeberry/crypto";
+import { WithDebug } from "#@typeberry/utils";
+import type { ValidatorIndex } from "./common.js";
+import type { HeaderHash } from "./hash.js";
+/**
+ *
+ * A work-report is said to become available iff there are a clear
+ * 2/3 supermajority of validators who have marked its core as set within
+ * the block's assurance extrinsic.
+ * https://graypaper.fluffylabs.dev/#/579bd12/145800145c00
+ */
+export declare class AvailabilityAssurance extends WithDebug {
+    /**
+     * The assurances must all be anchored on the parent.
+     * https://graypaper.fluffylabs.dev/#/579bd12/145800145c00
+     */
+    readonly anchor: HeaderHash;
+    /**
+     * A series of binary values, one per core.
+     *
+     * Value of `1` implies that  the validator assures they are contributing
+     * to that's core validity.
+     */
+    readonly bitfield: BitVec;
+    /** Validator index that signed this assurance. */
+    readonly validatorIndex: ValidatorIndex;
+    /** Signature over the anchor and the bitfield. */
+    readonly signature: Ed25519Signature;
+    static Codec: import("@typeberry/codec").Descriptor<AvailabilityAssurance, import("@typeberry/codec").ViewOf<AvailabilityAssurance, {
+        anchor: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"HeaderHash">, import("@typeberry/bytes").Bytes<32>>;
+        bitfield: import("@typeberry/codec").Descriptor<BitVec, BitVec>;
+        validatorIndex: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<2> & import("@typeberry/utils").WithOpaque<"ValidatorIndex[u16]">, import("@typeberry/bytes").Bytes<2>>;
+        signature: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<64> & import("@typeberry/utils").WithOpaque<"Ed25519Signature">, import("@typeberry/bytes").Bytes<64>>;
+    }>>;
+    static create({ anchor, bitfield, validatorIndex, signature }: CodecRecord<AvailabilityAssurance>): AvailabilityAssurance;
+    private constructor();
+}
+declare const AssurancesExtrinsicBounds = "[0 .. ValidatorsCount)";
+/**
+ * `E_A`: Sequence with at most one item per validator.
+ *
+ * Assurances must be ordered by validator index.
+ * https://graypaper.fluffylabs.dev/#/579bd12/145800145c00
+ */
+export type AssurancesExtrinsic = KnownSizeArray<AvailabilityAssurance, typeof AssurancesExtrinsicBounds>;
+export declare const assurancesExtrinsicCodec: import("@typeberry/codec").Descriptor<readonly AvailabilityAssurance[] & import("@typeberry/utils").WithOpaque<"[0 .. ValidatorsCount)">, import("@typeberry/codec").SequenceView<AvailabilityAssurance, import("@typeberry/codec").ViewOf<AvailabilityAssurance, {
+    anchor: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32> & import("@typeberry/utils").WithOpaque<"HeaderHash">, import("@typeberry/bytes").Bytes<32>>;
+    bitfield: import("@typeberry/codec").Descriptor<BitVec, BitVec>;
+    validatorIndex: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<2> & import("@typeberry/utils").WithOpaque<"ValidatorIndex[u16]">, import("@typeberry/bytes").Bytes<2>>;
+    signature: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<64> & import("@typeberry/utils").WithOpaque<"Ed25519Signature">, import("@typeberry/bytes").Bytes<64>>;
+}>>>;
+export type AssurancesExtrinsicView = DescribedBy<typeof assurancesExtrinsicCodec.View>;
+export {};
+//# sourceMappingURL=assurances.d.ts.map

package/packages/jam/block/assurances.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assurances.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/block/assurances.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,KAAK,WAAW,EAAS,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC7E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,EAA2B,KAAK,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAEnF,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE7C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAE5C;;;;;;GAMG;AACH,qBAAa,qBAAsB,SAAQ,SAAS;IAehD;;;OAGG;aACa,MAAM,EAAE,UAAU;IAClC;;;;;OAKG;aACa,QAAQ,EAAE,MAAM;IAChC,kDAAkD;aAClC,cAAc,EAAE,cAAc;IAC9C,kDAAkD;aAClC,SAAS,EAAE,gBAAgB;IA7B7C,MAAM,CAAC,KAAK;;;;;QAOT;IAEH,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,EAAE,SAAS,EAAE,EAAE,WAAW,CAAC,qBAAqB,CAAC;IAIjG,OAAO;CAoBR;AAED,QAAA,MAAM,yBAAyB,2BAA2B,CAAC;AAC3D;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,GAAG,cAAc,CAAC,qBAAqB,EAAE,OAAO,yBAAyB,CAAC,CAAC;AAE1G,eAAO,MAAM,wBAAwB;;;;;IAUnC,CAAC;AAEH,MAAM,MAAM,uBAAuB,GAAG,WAAW,CAAC,OAAO,wBAAwB,CAAC,IAAI,CAAC,CAAC"}

package/packages/jam/block/assurances.js

@@ -0,0 +1,60 @@
+import { codec } from "#@typeberry/codec";
+import { ED25519_SIGNATURE_BYTES } from "#@typeberry/crypto";
+import { HASH_SIZE } from "#@typeberry/hash";
+import { WithDebug } from "#@typeberry/utils";
+import { codecKnownSizeArray, codecWithContext } from "./codec-utils.js";
+/**
+ *
+ * A work-report is said to become available iff there are a clear
+ * 2/3 supermajority of validators who have marked its core as set within
+ * the block's assurance extrinsic.
+ * https://graypaper.fluffylabs.dev/#/579bd12/145800145c00
+ */
+export class AvailabilityAssurance extends WithDebug {
+    anchor;
+    bitfield;
+    validatorIndex;
+    signature;
+    static Codec = codec.Class(AvailabilityAssurance, {
+        anchor: codec.bytes(HASH_SIZE).asOpaque(),
+        bitfield: codecWithContext((context) => {
+            return codec.bitVecFixLen(context.coresCount);
+        }),
+        validatorIndex: codec.u16.asOpaque(),
+        signature: codec.bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
+    });
+    static create({ anchor, bitfield, validatorIndex, signature }) {
+        return new AvailabilityAssurance(anchor, bitfield, validatorIndex, signature);
+    }
+    constructor(
+    /**
+     * The assurances must all be anchored on the parent.
+     * https://graypaper.fluffylabs.dev/#/579bd12/145800145c00
+     */
+    anchor, 
+    /**
+     * A series of binary values, one per core.
+     *
+     * Value of `1` implies that  the validator assures they are contributing
+     * to that's core validity.
+     */
+    bitfield, 
+    /** Validator index that signed this assurance. */
+    validatorIndex, 
+    /** Signature over the anchor and the bitfield. */
+    signature) {
+        super();
+        this.anchor = anchor;
+        this.bitfield = bitfield;
+        this.validatorIndex = validatorIndex;
+        this.signature = signature;
+    }
+}
+const AssurancesExtrinsicBounds = "[0 .. ValidatorsCount)";
+export const assurancesExtrinsicCodec = codecWithContext((context) => {
+    return codecKnownSizeArray(AvailabilityAssurance.Codec, {
+        minLength: 0,
+        maxLength: context.validatorsCount,
+        typicalLength: context.validatorsCount / 2,
+    }, AssurancesExtrinsicBounds);
+});