@typeberry/lib 0.5.1-a4d7c93 → 0.5.1-eb84786

package/packages/jam/transition/assurances.js

@@ -0,0 +1,148 @@
+import { BytesBlob } from "#@typeberry/bytes";
+import { asKnownSize, FixedSizeArray } from "#@typeberry/collections";
+import { ed25519 } from "#@typeberry/crypto";
+import { check, OK, Result } from "#@typeberry/utils";
+/** Possible error during assurances transition. */
+export var AssurancesError;
+(function (AssurancesError) {
+    /** Assurances must all be anchored in `parentHash`. */
+    AssurancesError[AssurancesError["InvalidAnchor"] = 0] = "InvalidAnchor";
+    /** Assurances must be ordered by `validatorIndex`. */
+    AssurancesError[AssurancesError["InvalidOrder"] = 1] = "InvalidOrder";
+    /** One of the signatures is invalid. */
+    AssurancesError[AssurancesError["InvalidSignature"] = 2] = "InvalidSignature";
+    /** There is no report pending availability on a core which validator indicated assurance. */
+    AssurancesError[AssurancesError["NoReportPending"] = 3] = "NoReportPending";
+    /** Unknown validator index. */
+    AssurancesError[AssurancesError["InvalidValidatorIndex"] = 4] = "InvalidValidatorIndex";
+})(AssurancesError || (AssurancesError = {}));
+/**
+ * `U`: The period in timeslots after which reported but unavailable work may be replaced.
+ *
+ * https://graypaper.fluffylabs.dev/#/4bb8fd2/418300418500
+ */
+export const REPORT_TIMEOUT_GRACE_PERIOD = 5;
+/** Performs the transition of assurances state given some input. */
+export class Assurances {
+    chainSpec;
+    state;
+    blake2b;
+    constructor(chainSpec, state, blake2b) {
+        this.chainSpec = chainSpec;
+        this.state = state;
+        this.blake2b = blake2b;
+    }
+    async transition(input) {
+        const coresCount = this.chainSpec.coresCount;
+        /**
+         * The signature must be one whose public key is that of the validator assuring
+         * and whose message is the serialization of the parent hash Hp and the
+         * aforementioned bitstring.
+         * https://graypaper.fluffylabs.dev/#/579bd12/14b40014b600
+         */
+        const signaturesVerification = this.verifySignatures(input.assurances);
+        // materialize the assurances
+        const assurances = input.assurances.map((x) => x.materialize());
+        // calculate number of assurances for each of the core
+        const perCoreAssurances = FixedSizeArray.new(Array(coresCount).fill(0), coresCount);
+        /**
+         * The assurances must all be anchored on the parent and ordered by validator index.
+         * https://graypaper.fluffylabs.dev/#/579bd12/149a00149a00
+         */
+        let prevValidatorIndex = -1;
+        for (const assurance of assurances) {
+            const { anchor, validatorIndex, bitfield } = assurance;
+            if (!anchor.isEqualTo(input.parentHash)) {
+                return Result.error(AssurancesError.InvalidAnchor, () => `anchor: expected: ${input.parentHash}, got ${anchor}`);
+            }
+            if (prevValidatorIndex >= validatorIndex) {
+                return Result.error(AssurancesError.InvalidOrder, () => `order: expected: ${prevValidatorIndex + 1}, got: ${validatorIndex}`);
+            }
+            prevValidatorIndex = assurance.validatorIndex;
+            check `${bitfield.bitLength === coresCount} Invalid bitfield length of ${bitfield.bitLength}`;
+            const setBits = bitfield.indicesOfSetBits();
+            for (const idx of setBits) {
+                perCoreAssurances[idx] += 1;
+            }
+        }
+        const availableReports = [];
+        const coresToClear = [];
+        const validatorsSuperMajority = this.chainSpec.validatorsSuperMajority;
+        const availabilityAssignment = input.disputesAvailAssignment.slice();
+        for (let c = 0; c < coresCount; c++) {
+            const noOfAssurances = perCoreAssurances[c];
+            const workReport = availabilityAssignment[c];
+            const isReportPending = workReport !== null;
+            /**
+             * Verify if availability is pending: A bit may only be set if the corresponding
+             * core has a report pending availability on it:
+             * https://graypaper.fluffylabs.dev/#/579bd12/14e90014ea00
+             */
+            if (noOfAssurances > 0 && !isReportPending) {
+                return Result.error(AssurancesError.NoReportPending, () => `no report pending for core ${c} yet we got an assurance`);
+            }
+            /**
+             * Remove work report if it's became available or timed out.
+             * https://graypaper.fluffylabs.dev/#/1c979cb/141302144402?v=0.7.1
+             */
+            if (isReportPending) {
+                if (input.slot >= workReport.timeout + REPORT_TIMEOUT_GRACE_PERIOD) {
+                    coresToClear.push(c);
+                }
+                if (noOfAssurances >= validatorsSuperMajority) {
+                    availableReports.push(workReport.workReport);
+                    coresToClear.push(c);
+                }
+            }
+        }
+        // asynchronously verify the signatures
+        const allSignaturesValid = await signaturesVerification;
+        if (allSignaturesValid.isError) {
+            return allSignaturesValid;
+        }
+        /**
+         * ρ‡ - equivalent to ρ† except for the removal of items
+         * which are either now available or have timed out
+         * https://graypaper.fluffylabs.dev/#/1c979cb/141302144402?v=0.7.1
+         */
+        for (const c of coresToClear) {
+            availabilityAssignment[c] = null;
+        }
+        return Result.ok({
+            availableReports,
+            stateUpdate: {
+                // Since we are copying the original array and only assigning to
+                // existing cores, this cast is safe here.
+                availabilityAssignment: asKnownSize(availabilityAssignment),
+            },
+        });
+    }
+    /** Asynchronously verify all signatures. */
+    async verifySignatures(assurances) {
+        const validatorData = this.state.currentValidatorData;
+        const signatures = [];
+        for (const assurance of assurances) {
+            const v = assurance.view();
+            const key = validatorData[v.validatorIndex.materialize()];
+            if (key === undefined) {
+                return Result.error(AssurancesError.InvalidValidatorIndex, () => `Invalid validator index: ${v.validatorIndex.materialize()}`);
+            }
+            signatures.push({
+                signature: v.signature.materialize(),
+                key: key.ed25519,
+                message: signingPayload(this.blake2b, v.anchor.encoded(), v.bitfield.encoded()),
+            });
+        }
+        const signaturesValid = await ed25519.verify(signatures);
+        const isAllSignaturesValid = signaturesValid.every((x) => x);
+        if (!isAllSignaturesValid) {
+            const invalidIndices = signaturesValid.reduce((acc, isValid, idx) => (isValid ? acc : acc.concat(idx)), []);
+            return Result.error(AssurancesError.InvalidSignature, () => `invalid signatures at ${invalidIndices.join(", ")}`);
+        }
+        return Result.ok(OK);
+    }
+}
+const JAM_AVAILABLE = BytesBlob.blobFromString("jam_available").raw;
+function signingPayload(blake2b, anchor, blob) {
+    return BytesBlob.blobFromParts(JAM_AVAILABLE, blake2b.hashBytes(BytesBlob.blobFromParts(anchor.raw, blob.raw)).raw);
+}

package/packages/jam/transition/assurances.test.d.ts

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

package/packages/jam/transition/assurances.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assurances.test.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/transition/assurances.test.ts"],"names":[],"mappings":""}

package/packages/jam/transition/assurances.test.js

@@ -0,0 +1,256 @@
+import assert from "node:assert";
+import { before, describe, it } from "node:test";
+import { reencodeAsView, tryAsCoreIndex, tryAsPerValidator, tryAsTimeSlot, tryAsValidatorIndex, } from "#@typeberry/block";
+import { AvailabilityAssurance, assurancesExtrinsicCodec, } from "#@typeberry/block/assurances.js";
+import { testWorkReportHex } from "#@typeberry/block/test-helpers.js";
+import { WorkReport } from "#@typeberry/block/work-report.js";
+import { BitVec, Bytes, BytesBlob } from "#@typeberry/bytes";
+import { Decoder } from "#@typeberry/codec";
+import { tinyChainSpec } from "#@typeberry/config";
+import { BANDERSNATCH_KEY_BYTES, BLS_KEY_BYTES, ED25519_KEY_BYTES, ED25519_SIGNATURE_BYTES, initWasm, } from "#@typeberry/crypto";
+import { Blake2b, HASH_SIZE } from "#@typeberry/hash";
+import { AvailabilityAssignment, tryAsPerCore, VALIDATOR_META_BYTES, ValidatorData, } from "#@typeberry/state";
+import { asOpaqueType, deepEqual } from "#@typeberry/utils";
+import { Assurances, AssurancesError } from "./assurances.js";
+import { copyAndUpdateState } from "./test.utils.js";
+let blake2b;
+before(async () => {
+    await initWasm();
+    blake2b = await Blake2b.createHasher();
+});
+function assurancesAsView(spec, assurances) {
+    return reencodeAsView(assurancesExtrinsicCodec, asOpaqueType(assurances), spec);
+}
+const DEFAULT_HEADER_HASH = Bytes.parseBytes("0xd61a38a0f73beda90e8c1dfba731f65003742539f4260694f44e22cabef24a8e", HASH_SIZE).asOpaque();
+describe("Assurances", () => {
+    const testAssignment = (data = INITIAL_ASSIGNMENT.slice()) => tryAsPerCore(data, tinyChainSpec);
+    it("should perform a transition with empty state", async () => {
+        const initialState = {
+            availabilityAssignment: testAssignment([null, null]),
+            currentValidatorData: tryAsPerValidator(VALIDATORS, tinyChainSpec),
+        };
+        const assurances = new Assurances(tinyChainSpec, initialState, blake2b);
+        const input = {
+            parentHash: DEFAULT_HEADER_HASH,
+            slot: tryAsTimeSlot(12),
+            assurances: assurancesAsView(tinyChainSpec, []),
+            disputesAvailAssignment: initialState.availabilityAssignment,
+        };
+        const res = await assurances.transition(input);
+        assert.strictEqual(res.isOk, true);
+        deepEqual(res.ok.availableReports, []);
+        const state = copyAndUpdateState(assurances.state, res.ok.stateUpdate);
+        deepEqual(state, {
+            availabilityAssignment: testAssignment([null, null]),
+            currentValidatorData: tryAsPerValidator(VALIDATORS, tinyChainSpec),
+        });
+    });
+    it("should perform some transition", async () => {
+        const initialState = {
+            availabilityAssignment: testAssignment([null, null]),
+            currentValidatorData: tryAsPerValidator(VALIDATORS, tinyChainSpec),
+        };
+        const assurances = new Assurances(tinyChainSpec, initialState, blake2b);
+        const input = {
+            parentHash: DEFAULT_HEADER_HASH,
+            slot: tryAsTimeSlot(12),
+            assurances: assurancesAsView(tinyChainSpec, [
+                {
+                    bitfield: "0x02",
+                    validatorIndex: 0,
+                    signature: "0x8ca67779a98b2cb44a45082ec9fd9222462b8310115e23df0b4df9959efe90055009dc9c11da1ae59abd076aeb455b4e82883fd0cf35f69ba2cb0f3a8ee3800e",
+                },
+                {
+                    bitfield: "0x01",
+                    validatorIndex: 1,
+                    signature: "0x08a112654c32d117fb4ceb0e6a7edf92e4de6cb27532d3ceda8bb2fcf8337aeec85a734f7c36531b61e34570a3e090ffe8ab1839f412eaebde451aabf786a500",
+                },
+                {
+                    bitfield: "0x03",
+                    validatorIndex: 2,
+                    signature: "0xdbd50734b049bcc9e25f5c4d2d2b635e22ec1d4eefcc324863de9e1673bacb4b7ac4424a946abae83755908a3f77470776c160e7d5b42991c1b8914bfc16b700",
+                },
+                {
+                    bitfield: "0x03",
+                    validatorIndex: 3,
+                    signature: "0x2e1c0fe5ada7046355c7a8b23320dea86edf0df6410d13126f738755dec8f45652fd8c7ac2c84e682d745d2273977d03916865236fa93c9484bc41ed4318d30a",
+                },
+                {
+                    bitfield: "0x03",
+                    validatorIndex: 4,
+                    signature: "0xa3afee85825aefb49cfe10000b72d22321f6d562f89f57f56da813f62761130774e2540b2c0ce33da3c28fcbffe52ea0d1eccfbd859be46835128c4cc87fb50c",
+                },
+                {
+                    bitfield: "0x01",
+                    validatorIndex: 5,
+                    signature: "0x507b0321d73c495135f311c42022eb1a46c89bfab80bd21e8ca0a38823a84e57e848154bf9c9f2065a63b678bf2d7bc78f449e1bebd2beb69c68fbb14c04eb08",
+                },
+            ].map(intoAssurances)),
+            disputesAvailAssignment: tryAsPerCore(INITIAL_ASSIGNMENT.slice(), tinyChainSpec),
+        };
+        const res = await assurances.transition(input);
+        assert.strictEqual(res.isOk, true);
+        deepEqual(res.ok.availableReports, [INITIAL_ASSIGNMENT[0].workReport], { context: "result" });
+        const state = copyAndUpdateState(assurances.state, res.ok.stateUpdate);
+        deepEqual(state, {
+            availabilityAssignment: testAssignment([null, INITIAL_ASSIGNMENT[1]]),
+            currentValidatorData: tryAsPerValidator(VALIDATORS, tinyChainSpec),
+        }, { context: "state" });
+    });
+    it("should reject invalid signatures", async () => {
+        const initialState = {
+            availabilityAssignment: testAssignment(),
+            currentValidatorData: tryAsPerValidator(VALIDATORS, tinyChainSpec),
+        };
+        const assurances = new Assurances(tinyChainSpec, initialState, blake2b);
+        const input = {
+            parentHash: DEFAULT_HEADER_HASH,
+            slot: tryAsTimeSlot(12),
+            assurances: assurancesAsView(tinyChainSpec, [
+                {
+                    bitfield: "0x02",
+                    validatorIndex: 0,
+                    signature: "0xdeadbeefa98b2cb44a45082ec9fd9222462b8310115e23df0b4df9959efe90055009dc9c11da1ae59abd076aeb455b4e82883fd0cf35f69ba2cb0f3a8ee3800e",
+                },
+            ].map(intoAssurances)),
+            disputesAvailAssignment: initialState.availabilityAssignment,
+        };
+        const res = await assurances.transition(input);
+        deepEqual(res, {
+            isOk: false,
+            isError: true,
+            error: AssurancesError.InvalidSignature,
+            details: () => "invalid signatures at 0",
+        }, { context: "result" });
+        deepEqual(assurances.state, {
+            availabilityAssignment: testAssignment(),
+            currentValidatorData: tryAsPerValidator(VALIDATORS, tinyChainSpec),
+        }, { context: "state" });
+    });
+    it("should reject invalid validator index", async () => {
+        const initialState = {
+            availabilityAssignment: testAssignment(),
+            currentValidatorData: tryAsPerValidator(VALIDATORS, tinyChainSpec),
+        };
+        const assurances = new Assurances(tinyChainSpec, initialState, blake2b);
+        const input = {
+            parentHash: DEFAULT_HEADER_HASH,
+            slot: tryAsTimeSlot(12),
+            assurances: assurancesAsView(tinyChainSpec, [
+                {
+                    bitfield: "0x02",
+                    validatorIndex: 1023,
+                    signature: "0xdeadbeefa98b2cb44a45082ec9fd9222462b8310115e23df0b4df9959efe90055009dc9c11da1ae59abd076aeb455b4e82883fd0cf35f69ba2cb0f3a8ee3800e",
+                },
+            ].map(intoAssurances)),
+            disputesAvailAssignment: initialState.availabilityAssignment,
+        };
+        const res = await assurances.transition(input);
+        deepEqual(res, {
+            isOk: false,
+            isError: true,
+            error: AssurancesError.InvalidValidatorIndex,
+            details: () => "Invalid validator index: 1023",
+        }, { context: "result" });
+        deepEqual(assurances.state, {
+            availabilityAssignment: testAssignment(),
+            currentValidatorData: tryAsPerValidator(VALIDATORS, tinyChainSpec),
+        }, { context: "state" });
+    });
+    it("should reject invalid order", async () => {
+        const initialState = {
+            availabilityAssignment: testAssignment(),
+            currentValidatorData: tryAsPerValidator(VALIDATORS, tinyChainSpec),
+        };
+        const assurances = new Assurances(tinyChainSpec, initialState, blake2b);
+        const input = {
+            parentHash: DEFAULT_HEADER_HASH,
+            slot: tryAsTimeSlot(12),
+            assurances: assurancesAsView(tinyChainSpec, [
+                {
+                    bitfield: "0x01",
+                    validatorIndex: 1,
+                    signature: "0x08a112654c32d117fb4ceb0e6a7edf92e4de6cb27532d3ceda8bb2fcf8337aeec85a734f7c36531b61e34570a3e090ffe8ab1839f412eaebde451aabf786a500",
+                },
+                {
+                    bitfield: "0x02",
+                    validatorIndex: 0,
+                    signature: "0x8ca67779a98b2cb44a45082ec9fd9222462b8310115e23df0b4df9959efe90055009dc9c11da1ae59abd076aeb455b4e82883fd0cf35f69ba2cb0f3a8ee3800e",
+                },
+            ].map(intoAssurances)),
+            disputesAvailAssignment: initialState.availabilityAssignment,
+        };
+        const res = await assurances.transition(input);
+        deepEqual(res, {
+            isOk: false,
+            isError: true,
+            error: AssurancesError.InvalidOrder,
+            details: () => "order: expected: 2, got: 0",
+        }, { context: "result" });
+        deepEqual(assurances.state, {
+            availabilityAssignment: testAssignment(),
+            currentValidatorData: tryAsPerValidator(VALIDATORS, tinyChainSpec),
+        }, { context: "state" });
+    });
+});
+function intoAssurances(data) {
+    const anchor = DEFAULT_HEADER_HASH;
+    const bitfield = BitVec.fromBytes(Bytes.parseBytes(data.bitfield, 1), tinyChainSpec.coresCount);
+    const validatorIndex = tryAsValidatorIndex(data.validatorIndex);
+    const signature = Bytes.parseBytes(data.signature, ED25519_SIGNATURE_BYTES).asOpaque();
+    return AvailabilityAssurance.create({ anchor, bitfield, validatorIndex, signature });
+}
+function intoValidatorData({ bandersnatch, ed25519 }) {
+    return ValidatorData.create({
+        ed25519: Bytes.parseBytes(ed25519, ED25519_KEY_BYTES).asOpaque(),
+        bandersnatch: Bytes.parseBytes(bandersnatch, BANDERSNATCH_KEY_BYTES).asOpaque(),
+        bls: Bytes.zero(BLS_KEY_BYTES).asOpaque(),
+        metadata: Bytes.zero(VALIDATOR_META_BYTES),
+    });
+}
+function newAvailabilityAssignment(core, timeout) {
+    const source = BytesBlob.parseBlob(testWorkReportHex());
+    const report = Decoder.decodeObject(WorkReport.Codec, source, tinyChainSpec);
+    const { workPackageSpec, context, authorizerHash, authorizationOutput, segmentRootLookup, results, authorizationGasUsed, } = report;
+    const workReport = WorkReport.create({
+        workPackageSpec,
+        context,
+        coreIndex: tryAsCoreIndex(core),
+        authorizerHash,
+        authorizationOutput,
+        segmentRootLookup,
+        results,
+        authorizationGasUsed,
+    });
+    return AvailabilityAssignment.create({ workReport, timeout: tryAsTimeSlot(timeout) });
+}
+const INITIAL_ASSIGNMENT = [
+    newAvailabilityAssignment(0, 11),
+    newAvailabilityAssignment(1, 11),
+];
+const VALIDATORS = [
+    {
+        bandersnatch: "0x5e465beb01dbafe160ce8216047f2155dd0569f058afd52dcea601025a8d161d",
+        ed25519: "0x3b6a27bcceb6a42d62a3a8d02a6f0d73653215771de243a63ac048a18b59da29",
+    },
+    {
+        bandersnatch: "0x3d5e5a51aab2b048f8686ecd79712a80e3265a114cc73f14bdb2a59233fb66d0",
+        ed25519: "0x22351e22105a19aabb42589162ad7f1ea0df1c25cebf0e4a9fcd261301274862",
+    },
+    {
+        bandersnatch: "0xaa2b95f7572875b0d0f186552ae745ba8222fc0b5bd456554bfe51c68938f8bc",
+        ed25519: "0xe68e0cf7f26c59f963b5846202d2327cc8bc0c4eff8cb9abd4012f9a71decf00",
+    },
+    {
+        bandersnatch: "0x7f6190116d118d643a98878e294ccf62b509e214299931aad8ff9764181a4e33",
+        ed25519: "0xb3e0e096b02e2ec98a3441410aeddd78c95e27a0da6f411a09c631c0f2bea6e9",
+    },
+    {
+        bandersnatch: "0x48e5fcdce10e0b64ec4eebd0d9211c7bac2f27ce54bca6f7776ff6fee86ab3e3",
+        ed25519: "0x5c7f34a4bd4f2d04076a8c6f9060a0c8d2c6bdd082ceb3eda7df381cb260faff",
+    },
+    {
+        bandersnatch: "0xf16e5352840afb47e206b5c89f560f2611835855cf2e6ebad1acc9520a72591d",
+        ed25519: "0x837ce344bc9defceb0d7de7e9e9925096768b7adb4dad932e532eb6551e0ea02",
+    },
+].map(intoValidatorData);

package/packages/jam/transition/authorization.d.ts

@@ -0,0 +1,45 @@
+import { type CoreIndex, type TimeSlot } from "#@typeberry/block";
+import type { AuthorizerHash } from "#@typeberry/block/refine-context.js";
+import type { HashSet } from "#@typeberry/collections/hash-set.js";
+import type { ChainSpec } from "#@typeberry/config";
+import { type State } from "#@typeberry/state";
+/** Authorization state. */
+export type AuthorizationState = Pick<State, "authPools" | "authQueues">;
+/** Authorization state update. */
+export type AuthorizationStateUpdate = Pick<AuthorizationState, "authPools">;
+/** Input to the authorization. */
+export type AuthorizationInput = {
+    /** Current time slot. */
+    slot: TimeSlot;
+    /**
+     * This is an excerpt from Guarantees extrinsic, containing just the core
+     * index and the authorizer hash turned into a fast-lookup `Map+Set`.
+     */
+    used: Map<CoreIndex, HashSet<AuthorizerHash>>;
+};
+/**
+ * Maintain a list of available authorizations per core.
+ *
+ * The authorizer hashes are first added to the `queue` by some service via `assign`
+ * host call (up to `Q` elements).
+ * Each block we fill up the `pool` to always have `O` entries and we use the `queue`
+ * to take missing values.
+ * Every time there is a guaranteed work report (we know that from Guarantees Extrinsic),
+ * we check what `authorizerHash` was used for that work report and we remove it from
+ * the `queue`.
+ *
+ * https://graypaper.fluffylabs.dev/#/68eaa1f/0f94020f9402?v=0.6.4
+ */
+export declare class Authorization {
+    readonly chainSpec: ChainSpec;
+    readonly state: AuthorizationState;
+    constructor(chainSpec: ChainSpec, state: AuthorizationState);
+    /**
+     * The state transition of a block involves placing a new authorization
+     * into the pool from the queue.
+     *
+     * https://graypaper.fluffylabs.dev/#/68eaa1f/103e00103f00?v=0.6.4
+     */
+    transition(input: AuthorizationInput): AuthorizationStateUpdate;
+}
+//# sourceMappingURL=authorization.d.ts.map

package/packages/jam/transition/authorization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authorization.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/transition/authorization.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,QAAQ,EAAkB,MAAM,kBAAkB,CAAC;AACjF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAEzE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oCAAoC,CAAC;AAClE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAgD,KAAK,KAAK,EAAgB,MAAM,kBAAkB,CAAC;AAE1G,2BAA2B;AAC3B,MAAM,MAAM,kBAAkB,GAAG,IAAI,CAAC,KAAK,EAAE,WAAW,GAAG,YAAY,CAAC,CAAC;AAEzE,kCAAkC;AAClC,MAAM,MAAM,wBAAwB,GAAG,IAAI,CAAC,kBAAkB,EAAE,WAAW,CAAC,CAAC;AAE7E,kCAAkC;AAClC,MAAM,MAAM,kBAAkB,GAAG;IAC/B,yBAAyB;IACzB,IAAI,EAAE,QAAQ,CAAC;IAEf;;;OAGG;IACH,IAAI,EAAE,GAAG,CAAC,SAAS,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC;CAC/C,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,qBAAa,aAAa;aAEN,SAAS,EAAE,SAAS;aACpB,KAAK,EAAE,kBAAkB;gBADzB,SAAS,EAAE,SAAS,EACpB,KAAK,EAAE,kBAAkB;IAG3C;;;;;OAKG;IACH,UAAU,CAAC,KAAK,EAAE,kBAAkB,GAAG,wBAAwB;CAkChE"}

package/packages/jam/transition/authorization.js

@@ -0,0 +1,60 @@
+import { tryAsCoreIndex } from "#@typeberry/block";
+import { asKnownSize } from "#@typeberry/collections";
+import { AUTHORIZATION_QUEUE_SIZE, MAX_AUTH_POOL_SIZE, tryAsPerCore } from "#@typeberry/state";
+/**
+ * Maintain a list of available authorizations per core.
+ *
+ * The authorizer hashes are first added to the `queue` by some service via `assign`
+ * host call (up to `Q` elements).
+ * Each block we fill up the `pool` to always have `O` entries and we use the `queue`
+ * to take missing values.
+ * Every time there is a guaranteed work report (we know that from Guarantees Extrinsic),
+ * we check what `authorizerHash` was used for that work report and we remove it from
+ * the `queue`.
+ *
+ * https://graypaper.fluffylabs.dev/#/68eaa1f/0f94020f9402?v=0.6.4
+ */
+export class Authorization {
+    chainSpec;
+    state;
+    constructor(chainSpec, state) {
+        this.chainSpec = chainSpec;
+        this.state = state;
+    }
+    /**
+     * The state transition of a block involves placing a new authorization
+     * into the pool from the queue.
+     *
+     * https://graypaper.fluffylabs.dev/#/68eaa1f/103e00103f00?v=0.6.4
+     */
+    transition(input) {
+        const authPoolsUpdate = this.state.authPools.slice();
+        const authQueues = this.state.authQueues;
+        // we transition authorizations for each core.
+        for (let coreIndex = tryAsCoreIndex(0); coreIndex < this.chainSpec.coresCount; coreIndex++) {
+            let pool = authPoolsUpdate[coreIndex].slice();
+            // the queue is only read (we should most likely use `ArrayView` here).
+            const queue = authQueues[coreIndex];
+            // if there were any used hashes - remove them
+            const usedHashes = input.used.get(coreIndex);
+            if (usedHashes !== undefined) {
+                pool = pool.filter((x) => {
+                    // we only remove the left-most first occurrence.
+                    const wasRemoved = usedHashes.delete(x);
+                    return !wasRemoved;
+                });
+            }
+            // fill the pool with authorizer for current slot.
+            pool.push(queue[input.slot % AUTHORIZATION_QUEUE_SIZE]);
+            // remove the excess from the front
+            while (pool.length > MAX_AUTH_POOL_SIZE) {
+                pool.shift();
+            }
+            // assign back to state
+            authPoolsUpdate[coreIndex] = asKnownSize(pool);
+        }
+        return {
+            authPools: tryAsPerCore(authPoolsUpdate, this.chainSpec),
+        };
+    }
+}

package/packages/jam/transition/authorization.test.d.ts

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

package/packages/jam/transition/authorization.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authorization.test.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/transition/authorization.test.ts"],"names":[],"mappings":""}

package/packages/jam/transition/authorization.test.js

@@ -0,0 +1,75 @@
+import { describe, it } from "node:test";
+import { tryAsTimeSlot } from "#@typeberry/block";
+import { Bytes } from "#@typeberry/bytes";
+import { asKnownSize } from "#@typeberry/collections";
+import { HashSet } from "#@typeberry/collections/hash-set.js";
+import { tinyChainSpec } from "#@typeberry/config";
+import { HASH_SIZE } from "#@typeberry/hash";
+import { MAX_AUTH_POOL_SIZE, tryAsPerCore } from "#@typeberry/state";
+import { deepEqual } from "#@typeberry/utils";
+import { Authorization } from "./authorization.js";
+import { copyAndUpdateState } from "./test.utils.js";
+const authQueues = (core1, core2) => {
+    return tryAsPerCore([asKnownSize(core1), asKnownSize(core2)], tinyChainSpec);
+};
+const authPools = (core1, core2) => {
+    return tryAsPerCore([asKnownSize(core1), asKnownSize(core2)], tinyChainSpec);
+};
+const h = (n) => Bytes.fill(HASH_SIZE, n).asOpaque();
+const used = (...data) => {
+    const used = new Map();
+    for (const [core, hash] of data) {
+        const perCore = used.get(core) ?? HashSet.new();
+        perCore.insert(hash);
+        used.set(core, perCore);
+    }
+    return used;
+};
+describe("Authorization", () => {
+    it("should perform a transition with empty state", async () => {
+        const authorization = new Authorization(tinyChainSpec, {
+            authPools: authPools([], []),
+            authQueues: authQueues([h(1)], [h(1)]),
+        });
+        const input = {
+            slot: tryAsTimeSlot(0),
+            used: used(),
+        };
+        const stateUpdate = authorization.transition(input);
+        const state = copyAndUpdateState(authorization.state, stateUpdate);
+        deepEqual(state.authPools, authPools([h(1)], [h(1)]), { context: "pools" });
+        deepEqual(state.authQueues, authQueues([h(1)], [h(1)]), { context: "queues" });
+    });
+    it("should perform a transition and remove existing entries", async () => {
+        const authorization = new Authorization(tinyChainSpec, {
+            authPools: authPools([h(0), h(0)], [h(2), h(3), h(2)]),
+            authQueues: authQueues([h(1)], [h(1)]),
+        });
+        const input = {
+            slot: tryAsTimeSlot(0),
+            used: used([0, h(1)], [1, h(2)]),
+        };
+        const stateUpdate = authorization.transition(input);
+        const state = copyAndUpdateState(authorization.state, stateUpdate);
+        deepEqual(state.authPools, authPools([h(0), h(0), h(1)], [h(3), h(2), h(1)]), { context: "pools" });
+        deepEqual(state.authQueues, authQueues([h(1)], [h(1)]), { context: "queues" });
+    });
+    it("should perform a transition and keep last items in pool", async () => {
+        const authorization = new Authorization(tinyChainSpec, {
+            authPools: authPools(Array(MAX_AUTH_POOL_SIZE + 1)
+                .fill(0)
+                .map((_, idx) => h(idx)), [h(2), h(3), h(2)]),
+            authQueues: authQueues([h(10), h(11)], [h(1), h(2)]),
+        });
+        const input = {
+            slot: tryAsTimeSlot(1),
+            used: used([0, h(13)], [1, h(2)]),
+        };
+        const stateUpdate = authorization.transition(input);
+        const state = copyAndUpdateState(authorization.state, stateUpdate);
+        deepEqual(state.authPools, authPools([h(2), h(3), h(4), h(5), h(6), h(7), h(8), h(11)], [h(3), h(2), h(2)]), {
+            context: "pools",
+        });
+        deepEqual(state.authQueues, authQueues([h(10), h(11)], [h(1), h(2)]), { context: "queues" });
+    });
+});

package/packages/jam/transition/block-verifier.d.ts

@@ -0,0 +1,24 @@
+import type { BlockView, HeaderHash } from "#@typeberry/block";
+import type { BlocksDb } from "#@typeberry/database";
+import { Result } from "#@typeberry/utils";
+import type { TransitionHasher } from "./hasher.js";
+export declare enum BlockVerifierError {
+    ParentNotFound = 0,
+    InvalidTimeSlot = 1,
+    InvalidExtrinsic = 2,
+    StateRootNotFound = 3,
+    InvalidStateRoot = 4,
+    AlreadyImported = 5
+}
+type BlockVerificationOptions = {
+    /** Skip verification of parent (for state-transition vectors) */
+    skipParentAndStateRoot: boolean;
+};
+export declare class BlockVerifier {
+    readonly hasher: TransitionHasher;
+    private readonly blocks;
+    constructor(hasher: TransitionHasher, blocks: BlocksDb);
+    verifyBlock(block: BlockView, options?: BlockVerificationOptions): Promise<Result<HeaderHash, BlockVerifierError>>;
+}
+export {};
+//# sourceMappingURL=block-verifier.d.ts.map

package/packages/jam/transition/block-verifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block-verifier.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/transition/block-verifier.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE9D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAEpD,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC1C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEpD,oBAAY,kBAAkB;IAC5B,cAAc,IAAI;IAClB,eAAe,IAAI;IACnB,gBAAgB,IAAI;IACpB,iBAAiB,IAAI;IACrB,gBAAgB,IAAI;IACpB,eAAe,IAAI;CACpB;AAID,KAAK,wBAAwB,GAAG;IAC9B,iEAAiE;IACjE,sBAAsB,EAAE,OAAO,CAAC;CACjC,CAAC;AAEF,qBAAa,aAAa;aAEN,MAAM,EAAE,gBAAgB;IACxC,OAAO,CAAC,QAAQ,CAAC,MAAM;gBADP,MAAM,EAAE,gBAAgB,EACvB,MAAM,EAAE,QAAQ;IAG7B,WAAW,CACf,KAAK,EAAE,SAAS,EAChB,OAAO,GAAE,wBAA4D,GACpE,OAAO,CAAC,MAAM,CAAC,UAAU,EAAE,kBAAkB,CAAC,CAAC;CAgEnD"}