@typeberry/lib 0.5.9 → 0.5.10

package/packages/jam/safrole/safrole.test.js

@@ -125,20 +125,12 @@ describe("Safrole", () => {
         const safrole = new Safrole(tinyChainSpec, blake2b, state, bwasm);
         const timeslot = tryAsTimeSlot(2);
         const entropy = Bytes.zero(HASH_SIZE).asOpaque();
-        let extrinsic;
-        try {
-            extrinsic = asKnownSize([
-                {
-                    attempt: tryAsTicketAttempt(tinyChainSpec.ticketsPerValidator + 2, tinyChainSpec),
-                    signature: Bytes.zero(BANDERSNATCH_PROOF_BYTES).asOpaque(),
-                },
-            ]);
-        }
-        catch {
-            // Expected: invalid ticket attempt throws during creation
-            // Skip this test as the validation now happens earlier
-            return;
-        }
+        const extrinsic = asKnownSize([
+            {
+                attempt: tryAsTicketAttempt(tinyChainSpec.ticketsPerValidator + 2),
+                signature: Bytes.zero(BANDERSNATCH_PROOF_BYTES).asOpaque(),
+            },
+        ]);
         const input = {
             slot: timeslot,
             entropy,
@@ -177,7 +169,7 @@ describe("Safrole", () => {
         const entropy = Bytes.zero(HASH_SIZE).asOpaque();
         const extrinsic = asKnownSize([
             {
-                attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                attempt: tryAsTicketAttempt(0),
                 signature: Bytes.zero(BANDERSNATCH_PROOF_BYTES).asOpaque(),
             },
         ]);
@@ -222,11 +214,11 @@ describe("Safrole", () => {
         const entropy = Bytes.zero(HASH_SIZE).asOpaque();
         const extrinsic = asKnownSize([
             {
-                attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                attempt: tryAsTicketAttempt(0),
                 signature: Bytes.zero(BANDERSNATCH_PROOF_BYTES).asOpaque(),
             },
             {
-                attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                attempt: tryAsTicketAttempt(0),
                 signature: Bytes.zero(BANDERSNATCH_PROOF_BYTES).asOpaque(),
             },
         ]);
@@ -271,11 +263,11 @@ describe("Safrole", () => {
         const entropy = Bytes.zero(HASH_SIZE).asOpaque();
         const extrinsic = asKnownSize([
             {
-                attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                attempt: tryAsTicketAttempt(0),
                 signature: Bytes.fill(BANDERSNATCH_PROOF_BYTES, 1).asOpaque(),
             },
             {
-                attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                attempt: tryAsTicketAttempt(0),
                 signature: Bytes.zero(BANDERSNATCH_PROOF_BYTES).asOpaque(),
             },
         ]);
@@ -310,51 +302,51 @@ describe("Safrole", () => {
             nextValidatorData: validators,
             ticketsAccumulator: asKnownSize([
                 Ticket.create({
-                    attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                    attempt: tryAsTicketAttempt(0),
                     id: Bytes.fill(HASH_SIZE, 1),
                 }),
                 Ticket.create({
-                    attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                    attempt: tryAsTicketAttempt(0),
                     id: Bytes.fill(HASH_SIZE, 2),
                 }),
                 Ticket.create({
-                    attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                    attempt: tryAsTicketAttempt(0),
                     id: Bytes.fill(HASH_SIZE, 3),
                 }),
                 Ticket.create({
-                    attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                    attempt: tryAsTicketAttempt(0),
                     id: Bytes.fill(HASH_SIZE, 4),
                 }),
                 Ticket.create({
-                    attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                    attempt: tryAsTicketAttempt(0),
                     id: Bytes.fill(HASH_SIZE, 5),
                 }),
                 Ticket.create({
-                    attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                    attempt: tryAsTicketAttempt(0),
                     id: Bytes.fill(HASH_SIZE, 6),
                 }),
                 Ticket.create({
-                    attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                    attempt: tryAsTicketAttempt(0),
                     id: Bytes.fill(HASH_SIZE, 7),
                 }),
                 Ticket.create({
-                    attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                    attempt: tryAsTicketAttempt(0),
                     id: Bytes.fill(HASH_SIZE, 8),
                 }),
                 Ticket.create({
-                    attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                    attempt: tryAsTicketAttempt(0),
                     id: Bytes.fill(HASH_SIZE, 9),
                 }),
                 Ticket.create({
-                    attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                    attempt: tryAsTicketAttempt(0),
                     id: Bytes.fill(HASH_SIZE, 10),
                 }),
                 Ticket.create({
-                    attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                    attempt: tryAsTicketAttempt(0),
                     id: Bytes.fill(HASH_SIZE, 11),
                 }),
                 Ticket.create({
-                    attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                    attempt: tryAsTicketAttempt(0),
                     id: Bytes.fill(HASH_SIZE, 12),
                 }),
             ]),
@@ -368,51 +360,51 @@ describe("Safrole", () => {
         const extrinsic = asKnownSize([]);
         const tickets = asKnownSize([
             Ticket.create({
-                attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                attempt: tryAsTicketAttempt(0),
                 id: Bytes.fill(HASH_SIZE, 1),
             }),
             Ticket.create({
-                attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                attempt: tryAsTicketAttempt(0),
                 id: Bytes.fill(HASH_SIZE, 12),
             }),
             Ticket.create({
-                attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                attempt: tryAsTicketAttempt(0),
                 id: Bytes.fill(HASH_SIZE, 2),
             }),
             Ticket.create({
-                attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                attempt: tryAsTicketAttempt(0),
                 id: Bytes.fill(HASH_SIZE, 11),
             }),
             Ticket.create({
-                attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                attempt: tryAsTicketAttempt(0),
                 id: Bytes.fill(HASH_SIZE, 3),
             }),
             Ticket.create({
-                attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                attempt: tryAsTicketAttempt(0),
                 id: Bytes.fill(HASH_SIZE, 10),
             }),
             Ticket.create({
-                attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                attempt: tryAsTicketAttempt(0),
                 id: Bytes.fill(HASH_SIZE, 4),
             }),
             Ticket.create({
-                attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                attempt: tryAsTicketAttempt(0),
                 id: Bytes.fill(HASH_SIZE, 9),
             }),
             Ticket.create({
-                attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                attempt: tryAsTicketAttempt(0),
                 id: Bytes.fill(HASH_SIZE, 5),
             }),
             Ticket.create({
-                attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                attempt: tryAsTicketAttempt(0),
                 id: Bytes.fill(HASH_SIZE, 8),
             }),
             Ticket.create({
-                attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                attempt: tryAsTicketAttempt(0),
                 id: Bytes.fill(HASH_SIZE, 6),
             }),
             Ticket.create({
-                attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                attempt: tryAsTicketAttempt(0),
                 id: Bytes.fill(HASH_SIZE, 7),
             }),
         ]);
@@ -429,51 +421,51 @@ describe("Safrole", () => {
         deepEqual(result.ok.ticketsMark, TicketsMarker.create({
             tickets: asKnownSize([
                 Ticket.create({
-                    attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                    attempt: tryAsTicketAttempt(0),
                     id: Bytes.fill(HASH_SIZE, 1),
                 }),
                 Ticket.create({
-                    attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                    attempt: tryAsTicketAttempt(0),
                     id: Bytes.fill(HASH_SIZE, 12),
                 }),
                 Ticket.create({
-                    attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                    attempt: tryAsTicketAttempt(0),
                     id: Bytes.fill(HASH_SIZE, 2),
                 }),
                 Ticket.create({
-                    attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                    attempt: tryAsTicketAttempt(0),
                     id: Bytes.fill(HASH_SIZE, 11),
                 }),
                 Ticket.create({
-                    attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                    attempt: tryAsTicketAttempt(0),
                     id: Bytes.fill(HASH_SIZE, 3),
                 }),
                 Ticket.create({
-                    attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                    attempt: tryAsTicketAttempt(0),
                     id: Bytes.fill(HASH_SIZE, 10),
                 }),
                 Ticket.create({
-                    attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                    attempt: tryAsTicketAttempt(0),
                     id: Bytes.fill(HASH_SIZE, 4),
                 }),
                 Ticket.create({
-                    attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                    attempt: tryAsTicketAttempt(0),
                     id: Bytes.fill(HASH_SIZE, 9),
                 }),
                 Ticket.create({
-                    attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                    attempt: tryAsTicketAttempt(0),
                     id: Bytes.fill(HASH_SIZE, 5),
                 }),
                 Ticket.create({
-                    attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                    attempt: tryAsTicketAttempt(0),
                     id: Bytes.fill(HASH_SIZE, 8),
                 }),
                 Ticket.create({
-                    attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                    attempt: tryAsTicketAttempt(0),
                     id: Bytes.fill(HASH_SIZE, 6),
                 }),
                 Ticket.create({
-                    attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                    attempt: tryAsTicketAttempt(0),
                     id: Bytes.fill(HASH_SIZE, 7),
                 }),
             ]),
@@ -502,7 +494,7 @@ describe("Safrole", () => {
         const entropy = Bytes.zero(HASH_SIZE).asOpaque();
         const extrinsic = asKnownSize([
             {
-                attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                attempt: tryAsTicketAttempt(0),
                 signature: Bytes.zero(BANDERSNATCH_PROOF_BYTES).asOpaque(),
             },
         ]);
@@ -616,51 +608,51 @@ describe("Safrole", () => {
             nextValidatorData: validators,
             ticketsAccumulator: asKnownSize([
                 Ticket.create({
-                    attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                    attempt: tryAsTicketAttempt(0),
                     id: Bytes.fill(HASH_SIZE, 1),
                 }),
                 Ticket.create({
-                    attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                    attempt: tryAsTicketAttempt(0),
                     id: Bytes.fill(HASH_SIZE, 2),
                 }),
                 Ticket.create({
-                    attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                    attempt: tryAsTicketAttempt(0),
                     id: Bytes.fill(HASH_SIZE, 3),
                 }),
                 Ticket.create({
-                    attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                    attempt: tryAsTicketAttempt(0),
                     id: Bytes.fill(HASH_SIZE, 4),
                 }),
                 Ticket.create({
-                    attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                    attempt: tryAsTicketAttempt(0),
                     id: Bytes.fill(HASH_SIZE, 5),
                 }),
                 Ticket.create({
-                    attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                    attempt: tryAsTicketAttempt(0),
                     id: Bytes.fill(HASH_SIZE, 6),
                 }),
                 Ticket.create({
-                    attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                    attempt: tryAsTicketAttempt(0),
                     id: Bytes.fill(HASH_SIZE, 7),
                 }),
                 Ticket.create({
-                    attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                    attempt: tryAsTicketAttempt(0),
                     id: Bytes.fill(HASH_SIZE, 8),
                 }),
                 Ticket.create({
-                    attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                    attempt: tryAsTicketAttempt(0),
                     id: Bytes.fill(HASH_SIZE, 9),
                 }),
                 Ticket.create({
-                    attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                    attempt: tryAsTicketAttempt(0),
                     id: Bytes.fill(HASH_SIZE, 10),
                 }),
                 Ticket.create({
-                    attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                    attempt: tryAsTicketAttempt(0),
                     id: Bytes.fill(HASH_SIZE, 11),
                 }),
                 Ticket.create({
-                    attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                    attempt: tryAsTicketAttempt(0),
                     id: Bytes.fill(HASH_SIZE, 12),
                 }),
             ]),
@@ -709,51 +701,51 @@ describe("Safrole", () => {
         const extrinsic = asKnownSize([]);
         const tickets = tryAsPerEpochBlock([
             Ticket.create({
-                attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                attempt: tryAsTicketAttempt(0),
                 id: Bytes.fill(HASH_SIZE, 1),
             }),
             Ticket.create({
-                attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                attempt: tryAsTicketAttempt(0),
                 id: Bytes.fill(HASH_SIZE, 2),
             }),
             Ticket.create({
-                attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                attempt: tryAsTicketAttempt(0),
                 id: Bytes.fill(HASH_SIZE, 3),
             }),
             Ticket.create({
-                attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                attempt: tryAsTicketAttempt(0),
                 id: Bytes.fill(HASH_SIZE, 4),
             }),
             Ticket.create({
-                attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                attempt: tryAsTicketAttempt(0),
                 id: Bytes.fill(HASH_SIZE, 5),
             }),
             Ticket.create({
-                attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                attempt: tryAsTicketAttempt(0),
                 id: Bytes.fill(HASH_SIZE, 6),
             }),
             Ticket.create({
-                attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                attempt: tryAsTicketAttempt(0),
                 id: Bytes.fill(HASH_SIZE, 7),
             }),
             Ticket.create({
-                attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                attempt: tryAsTicketAttempt(0),
                 id: Bytes.fill(HASH_SIZE, 8),
             }),
             Ticket.create({
-                attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                attempt: tryAsTicketAttempt(0),
                 id: Bytes.fill(HASH_SIZE, 9),
             }),
             Ticket.create({
-                attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                attempt: tryAsTicketAttempt(0),
                 id: Bytes.fill(HASH_SIZE, 10),
             }),
             Ticket.create({
-                attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                attempt: tryAsTicketAttempt(0),
                 id: Bytes.fill(HASH_SIZE, 11),
             }),
             Ticket.create({
-                attempt: tryAsTicketAttempt(0, tinyChainSpec),
+                attempt: tryAsTicketAttempt(0),
                 id: Bytes.fill(HASH_SIZE, 12),
             }),
         ], tinyChainSpec);

package/packages/jam/state/safrole-data.d.ts

@@ -46,7 +46,7 @@ export declare class SafroleData {
         sealingKeySeries: import("@typeberry/codec").Descriptor<SafroleSealingKeys, SafroleSealingKeys>;
         ticketsAccumulator: import("@typeberry/codec").Descriptor<readonly Ticket[] & import("@typeberry/utils").WithOpaque<"0...EpochLength">, import("@typeberry/codec").SequenceView<Ticket, import("@typeberry/codec").ViewOf<Ticket, {
             id: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32>, import("@typeberry/bytes").Bytes<32>>;
-            attempt: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<1> & import("@typeberry/utils").WithOpaque<"TicketAttempt[0|1|2]">, import("@typeberry/numbers").U32>;
+            attempt: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<1> & import("@typeberry/utils").WithOpaque<"TicketAttempt[u8]">, import("@typeberry/numbers").U32>;
         }>>>;
     }>>;
     static create({ nextValidatorData, epochRoot, sealingKeySeries, ticketsAccumulator }: CodecRecord<SafroleData>): SafroleData;

package/packages/jam/state/test.utils.js

@@ -275,7 +275,7 @@ export const testState = () => {
 };
 const emptyHash = () => b32("0x0000000000000000000000000000000000000000000000000000000000000000");
 const testAuth = () => b32("0x0b27478648cd19b4f812f897a26976ecf312eac28508b4368d0c63ea949c7cb0");
-const attempt = (x) => tryAsTicketAttempt(x, spec);
+const attempt = (x) => tryAsTicketAttempt(x);
 const b32 = (s) => Bytes.parseBytes(s, HASH_SIZE).asOpaque();
 const repeat = (len, factory) => Array.from({ length: len }, factory);
 const activityRecord = (blocks, tickets, preimages, preimagesSize, guarantees, assurances) => {

package/packages/jam/state-json/dump.js

@@ -20,8 +20,8 @@ export const fullStateDumpFromJson = (spec) => json.object({
     beta: json.nullable(recentBlocksHistoryFromJson),
     gamma: {
         gamma_k: json.array(validatorDataFromJson),
-        gamma_a: json.array(ticketFromJson(spec)),
-        gamma_s: TicketsOrKeys.fromJson(spec),
+        gamma_a: json.array(ticketFromJson),
+        gamma_s: TicketsOrKeys.fromJson(),
         gamma_z: json.fromString((v) => Bytes.parseBytes(v, BANDERSNATCH_RING_ROOT_BYTES).asOpaque()),
     },
     psi: disputesRecordsFromJson,

package/packages/jam/state-json/safrole.d.ts

@@ -3,9 +3,9 @@ import type { ChainSpec } from "#@typeberry/config";
 import type { BandersnatchKey } from "#@typeberry/crypto";
 import { type FromJson } from "#@typeberry/json-parser";
 import { type SafroleSealingKeys } from "#@typeberry/state";
-export declare const ticketFromJson: (spec: ChainSpec) => FromJson<Ticket>;
+export declare const ticketFromJson: FromJson<Ticket>;
 export declare class TicketsOrKeys {
-    static fromJson(spec: ChainSpec): FromJson<TicketsOrKeys>;
+    static fromJson(): FromJson<TicketsOrKeys>;
     keys?: BandersnatchKey[];
     tickets?: Ticket[];
     static toSafroleSealingKeys(data: TicketsOrKeys, chainSpec: ChainSpec): SafroleSealingKeys;

package/packages/jam/state-json/safrole.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"safrole.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/state-json/safrole.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,6BAA6B,CAAC;AAErD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,EAAE,KAAK,QAAQ,EAAQ,MAAM,wBAAwB,CAAC;AAC7D,OAAO,EAAE,KAAK,kBAAkB,EAA0B,MAAM,kBAAkB,CAAC;AAEnF,eAAO,MAAM,cAAc,GAAI,MAAM,SAAS,KAAG,QAAQ,CAAC,MAAM,CAO7D,CAAC;AAEJ,qBAAa,aAAa;IACxB,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,SAAS,GAAG,QAAQ,CAAC,aAAa,CAAC;IAOzD,IAAI,CAAC,EAAE,eAAe,EAAE,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IAEnB,MAAM,CAAC,oBAAoB,CAAC,IAAI,EAAE,aAAa,EAAE,SAAS,EAAE,SAAS,GAAG,kBAAkB;CAW3F"}
+{"version":3,"file":"safrole.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/state-json/safrole.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,6BAA6B,CAAC;AAErD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,EAAE,KAAK,QAAQ,EAAQ,MAAM,wBAAwB,CAAC;AAC7D,OAAO,EAAE,KAAK,kBAAkB,EAA0B,MAAM,kBAAkB,CAAC;AAEnF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,MAAM,CAM3C,CAAC;AAEF,qBAAa,aAAa;IACxB,MAAM,CAAC,QAAQ,IAAI,QAAQ,CAAC,aAAa,CAAC;IAO1C,IAAI,CAAC,EAAE,eAAe,EAAE,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IAEnB,MAAM,CAAC,oBAAoB,CAAC,IAAI,EAAE,aAAa,EAAE,SAAS,EAAE,SAAS,GAAG,kBAAkB;CAW3F"}

package/packages/jam/state-json/safrole.js

@@ -3,15 +3,15 @@ import { Ticket } from "#@typeberry/block/tickets.js";
 import { fromJson } from "#@typeberry/block-json";
 import { json } from "#@typeberry/json-parser";
 import { SafroleSealingKeysData } from "#@typeberry/state";
-export const ticketFromJson = (spec) => json.object({
+export const ticketFromJson = json.object({
     id: fromJson.bytes32(),
-    attempt: fromJson.ticketAttempt(spec),
+    attempt: fromJson.ticketAttempt,
 }, Ticket.create);
 export class TicketsOrKeys {
-    static fromJson(spec) {
+    static fromJson() {
         return {
             keys: json.optional(json.array(fromJson.bytes32())),
-            tickets: json.optional(json.array(ticketFromJson(spec))),
+            tickets: json.optional(json.array(ticketFromJson)),
         };
     }
     keys;

package/packages/jam/state-merkleization/in-memory-state-codec.d.ts

@@ -58,7 +58,7 @@ export declare const inMemoryStateCodec: (spec: ChainSpec) => Descriptor<InMemor
     sealingKeySeries: Descriptor<import("@typeberry/state").SafroleSealingKeys, import("@typeberry/state").SafroleSealingKeys>;
     ticketsAccumulator: Descriptor<readonly Ticket[] & import("@typeberry/utils").WithOpaque<"0...EpochLength">, import("@typeberry/codec").SequenceView<Ticket, import("@typeberry/codec").ViewOf<Ticket, {
         id: Descriptor<import("@typeberry/bytes").Bytes<32>, import("@typeberry/bytes").Bytes<32>>;
-        attempt: Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<1> & import("@typeberry/utils").WithOpaque<"TicketAttempt[0|1|2]">, import("@typeberry/numbers").U32>;
+        attempt: Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<1> & import("@typeberry/utils").WithOpaque<"TicketAttempt[u8]">, import("@typeberry/numbers").U32>;
     }>>>;
     disputesRecords: Descriptor<import("@typeberry/state").DisputesRecords, import("@typeberry/state").DisputesRecords>;
     entropy: Descriptor<import("@typeberry/collections").FixedSizeArray<import("@typeberry/hash").Blake2bHash & import("@typeberry/utils").WithOpaque<"EntropyHash">, 4>, import("@typeberry/collections").FixedSizeArray<import("@typeberry/hash").Blake2bHash & import("@typeberry/utils").WithOpaque<"EntropyHash">, 4>>;

package/packages/jam/state-vectors/index.d.ts

@@ -1,6 +1,5 @@
 import { Block, type BlockView, Header, type StateRootHash } from "#@typeberry/block";
 import type { BytesBlob } from "#@typeberry/bytes";
-import { type ChainSpec } from "#@typeberry/config";
 import { type TruncatedHash } from "#@typeberry/hash";
 import { type FromJson } from "#@typeberry/json-parser";
 export declare class StateKeyVal {
@@ -33,7 +32,7 @@ export declare class TestState {
     keyvals: StateKeyVal[];
 }
 export declare class StateTransitionGenesis {
-    static fromJson(spec?: ChainSpec): FromJson<StateTransitionGenesis>;
+    static fromJson: FromJson<StateTransitionGenesis>;
     static Codec: import("@typeberry/codec").Descriptor<{
         header: Header & import("@typeberry/codec").CodecRecord<Header>;
         state: {
@@ -80,7 +79,7 @@ export declare class StateTransition {
                 ticketsMarker: import("@typeberry/codec").Descriptor<import("@typeberry/block").TicketsMarker | null, import("@typeberry/codec").ViewOf<import("@typeberry/block").TicketsMarker, {
                     tickets: import("@typeberry/codec").Descriptor<readonly import("@typeberry/block").Ticket[] & import("@typeberry/utils").WithOpaque<"EpochLength">, import("@typeberry/codec").SequenceView<import("@typeberry/block").Ticket, import("@typeberry/codec").ViewOf<import("@typeberry/block").Ticket, {
                         id: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32>, import("@typeberry/bytes").Bytes<32>>;
-                        attempt: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<1> & import("@typeberry/utils").WithOpaque<"TicketAttempt[0|1|2]">, import("@typeberry/numbers").U32>;
+                        attempt: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<1> & import("@typeberry/utils").WithOpaque<"TicketAttempt[u8]">, import("@typeberry/numbers").U32>;
                     }>>>;
                 }> | null>;
                 bandersnatchBlockAuthorIndex: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<2> & import("@typeberry/utils").WithOpaque<"ValidatorIndex[u16]">, import("@typeberry/bytes").Bytes<2>>;
@@ -90,7 +89,7 @@ export declare class StateTransition {
             }>>;
             extrinsic: import("@typeberry/codec").Descriptor<import("@typeberry/block").Extrinsic, import("@typeberry/codec").ViewOf<import("@typeberry/block").Extrinsic, {
                 tickets: import("@typeberry/codec").Descriptor<readonly import("@typeberry/block").SignedTicket[] & import("@typeberry/utils").WithOpaque<"Size: [0..chainSpec.maxTicketsPerExtrinsic)">, import("@typeberry/codec").SequenceView<import("@typeberry/block").SignedTicket, import("@typeberry/codec").ViewOf<import("@typeberry/block").SignedTicket, {
-                    attempt: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<1> & import("@typeberry/utils").WithOpaque<"TicketAttempt[0|1|2]">, import("@typeberry/numbers").U32>;
+                    attempt: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<1> & import("@typeberry/utils").WithOpaque<"TicketAttempt[u8]">, import("@typeberry/numbers").U32>;
                     signature: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<784> & import("@typeberry/utils").WithOpaque<"BandersnatchRingSignature">, import("@typeberry/bytes").Bytes<784>>;
                 }>>>;
                 preimages: import("@typeberry/codec").Descriptor<import("@typeberry/block").Preimage[], import("@typeberry/codec").SequenceView<import("@typeberry/block").Preimage, import("@typeberry/codec").ViewOf<import("@typeberry/block").Preimage, {
@@ -214,7 +213,7 @@ export declare class StateTransition {
                 ticketsMarker: import("@typeberry/codec").Descriptor<import("@typeberry/block").TicketsMarker | null, import("@typeberry/codec").ViewOf<import("@typeberry/block").TicketsMarker, {
                     tickets: import("@typeberry/codec").Descriptor<readonly import("@typeberry/block").Ticket[] & import("@typeberry/utils").WithOpaque<"EpochLength">, import("@typeberry/codec").SequenceView<import("@typeberry/block").Ticket, import("@typeberry/codec").ViewOf<import("@typeberry/block").Ticket, {
                         id: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32>, import("@typeberry/bytes").Bytes<32>>;
-                        attempt: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<1> & import("@typeberry/utils").WithOpaque<"TicketAttempt[0|1|2]">, import("@typeberry/numbers").U32>;
+                        attempt: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<1> & import("@typeberry/utils").WithOpaque<"TicketAttempt[u8]">, import("@typeberry/numbers").U32>;
                     }>>>;
                 }> | null>;
                 bandersnatchBlockAuthorIndex: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<2> & import("@typeberry/utils").WithOpaque<"ValidatorIndex[u16]">, import("@typeberry/bytes").Bytes<2>>;
@@ -224,7 +223,7 @@ export declare class StateTransition {
             }>>;
             extrinsic: import("@typeberry/codec").Descriptor<import("@typeberry/block").Extrinsic, import("@typeberry/codec").ViewOf<import("@typeberry/block").Extrinsic, {
                 tickets: import("@typeberry/codec").Descriptor<readonly import("@typeberry/block").SignedTicket[] & import("@typeberry/utils").WithOpaque<"Size: [0..chainSpec.maxTicketsPerExtrinsic)">, import("@typeberry/codec").SequenceView<import("@typeberry/block").SignedTicket, import("@typeberry/codec").ViewOf<import("@typeberry/block").SignedTicket, {
-                    attempt: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<1> & import("@typeberry/utils").WithOpaque<"TicketAttempt[0|1|2]">, import("@typeberry/numbers").U32>;
+                    attempt: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<1> & import("@typeberry/utils").WithOpaque<"TicketAttempt[u8]">, import("@typeberry/numbers").U32>;
                     signature: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<784> & import("@typeberry/utils").WithOpaque<"BandersnatchRingSignature">, import("@typeberry/bytes").Bytes<784>>;
                 }>>>;
                 preimages: import("@typeberry/codec").Descriptor<import("@typeberry/block").Preimage[], import("@typeberry/codec").SequenceView<import("@typeberry/block").Preimage, import("@typeberry/codec").ViewOf<import("@typeberry/block").Preimage, {
@@ -348,7 +347,7 @@ export declare class StateTransition {
                 ticketsMarker: import("@typeberry/codec").Descriptor<import("@typeberry/block").TicketsMarker | null, import("@typeberry/codec").ViewOf<import("@typeberry/block").TicketsMarker, {
                     tickets: import("@typeberry/codec").Descriptor<readonly import("@typeberry/block").Ticket[] & import("@typeberry/utils").WithOpaque<"EpochLength">, import("@typeberry/codec").SequenceView<import("@typeberry/block").Ticket, import("@typeberry/codec").ViewOf<import("@typeberry/block").Ticket, {
                         id: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<32>, import("@typeberry/bytes").Bytes<32>>;
-                        attempt: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<1> & import("@typeberry/utils").WithOpaque<"TicketAttempt[0|1|2]">, import("@typeberry/numbers").U32>;
+                        attempt: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<1> & import("@typeberry/utils").WithOpaque<"TicketAttempt[u8]">, import("@typeberry/numbers").U32>;
                     }>>>;
                 }> | null>;
                 bandersnatchBlockAuthorIndex: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<2> & import("@typeberry/utils").WithOpaque<"ValidatorIndex[u16]">, import("@typeberry/bytes").Bytes<2>>;
@@ -358,7 +357,7 @@ export declare class StateTransition {
             }>>;
             extrinsic: import("@typeberry/codec").Descriptor<import("@typeberry/block").Extrinsic, import("@typeberry/codec").ViewOf<import("@typeberry/block").Extrinsic, {
                 tickets: import("@typeberry/codec").Descriptor<readonly import("@typeberry/block").SignedTicket[] & import("@typeberry/utils").WithOpaque<"Size: [0..chainSpec.maxTicketsPerExtrinsic)">, import("@typeberry/codec").SequenceView<import("@typeberry/block").SignedTicket, import("@typeberry/codec").ViewOf<import("@typeberry/block").SignedTicket, {
-                    attempt: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<1> & import("@typeberry/utils").WithOpaque<"TicketAttempt[0|1|2]">, import("@typeberry/numbers").U32>;
+                    attempt: import("@typeberry/codec").Descriptor<number & import("@typeberry/numbers").WithBytesRepresentation<1> & import("@typeberry/utils").WithOpaque<"TicketAttempt[u8]">, import("@typeberry/numbers").U32>;
                     signature: import("@typeberry/codec").Descriptor<import("@typeberry/bytes").Bytes<784> & import("@typeberry/utils").WithOpaque<"BandersnatchRingSignature">, import("@typeberry/bytes").Bytes<784>>;
                 }>>>;
                 preimages: import("@typeberry/codec").Descriptor<import("@typeberry/block").Preimage[], import("@typeberry/codec").SequenceView<import("@typeberry/block").Preimage, import("@typeberry/codec").ViewOf<import("@typeberry/block").Preimage, {

package/packages/jam/state-vectors/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/state-vectors/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,KAAK,SAAS,EAAE,MAAM,EAAE,KAAK,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAErF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAElD,OAAO,EAAE,KAAK,SAAS,EAAiB,MAAM,mBAAmB,CAAC;AAClE,OAAO,EAAkC,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrF,OAAO,EAAE,KAAK,QAAQ,EAAQ,MAAM,wBAAwB,CAAC;AAE7D,qBAAa,WAAW;IACtB,MAAM,CAAC,QAAQ,EAAE,QAAQ,CAAC,WAAW,CAAC,CAGpC;IACF,GAAG,EAAG,aAAa,CAAC;IACpB,KAAK,EAAG,SAAS,CAAC;CACnB;AAED,qBAAa,SAAS;IACpB,MAAM,CAAC,QAAQ,EAAE,QAAQ,CAAC,SAAS,CAAC,CAGlC;IAEF,MAAM,CAAC,KAAK;;;;;;;;;;;;;;;;;;SAQT;IAEH,UAAU,EAAG,aAAa,CAAC;IAC3B,OAAO,EAAG,WAAW,EAAE,CAAC;CACzB;AAED,qBAAa,sBAAsB;IACjC,MAAM,CAAC,QAAQ,CAAC,IAAI,GAAE,SAAyB,GAAG,QAAQ,CAAC,sBAAsB,CAAC;IAOlF,MAAM,CAAC,KAAK;;;;;;;;;;;;;;;;;;SAGT;IAEH,MAAM,EAAG,MAAM,CAAC;IAChB,KAAK,EAAG,SAAS,CAAC;CACnB;AAED,qBAAa,eAAe;IAC1B,MAAM,CAAC,QAAQ,EAAE,QAAQ,CAAC,eAAe,CAAC,CAIxC;IAEF,MAAM,CAAC,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAIT;IAEH,SAAS,EAAG,SAAS,CAAC;IACtB,UAAU,EAAG,SAAS,CAAC;IACvB,KAAK,EAAG,SAAS,CAAC;CACnB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/state-vectors/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,KAAK,SAAS,EAAE,MAAM,EAAE,KAAK,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAErF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAGlD,OAAO,EAAkC,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrF,OAAO,EAAE,KAAK,QAAQ,EAAQ,MAAM,wBAAwB,CAAC;AAE7D,qBAAa,WAAW;IACtB,MAAM,CAAC,QAAQ,EAAE,QAAQ,CAAC,WAAW,CAAC,CAGpC;IACF,GAAG,EAAG,aAAa,CAAC;IACpB,KAAK,EAAG,SAAS,CAAC;CACnB;AAED,qBAAa,SAAS;IACpB,MAAM,CAAC,QAAQ,EAAE,QAAQ,CAAC,SAAS,CAAC,CAGlC;IAEF,MAAM,CAAC,KAAK;;;;;;;;;;;;;;;;;;SAQT;IAEH,UAAU,EAAG,aAAa,CAAC;IAC3B,OAAO,EAAG,WAAW,EAAE,CAAC;CACzB;AAED,qBAAa,sBAAsB;IACjC,MAAM,CAAC,QAAQ,EAAE,QAAQ,CAAC,sBAAsB,CAAC,CAG/C;IAEF,MAAM,CAAC,KAAK;;;;;;;;;;;;;;;;;;SAGT;IAEH,MAAM,EAAG,MAAM,CAAC;IAChB,KAAK,EAAG,SAAS,CAAC;CACnB;AAED,qBAAa,eAAe;IAC1B,MAAM,CAAC,QAAQ,EAAE,QAAQ,CAAC,eAAe,CAAC,CAIxC;IAEF,MAAM,CAAC,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAIT;IAEH,SAAS,EAAG,SAAS,CAAC;IACtB,UAAU,EAAG,SAAS,CAAC;IACvB,KAAK,EAAG,SAAS,CAAC;CACnB"}

package/packages/jam/state-vectors/index.js

@@ -28,12 +28,10 @@ export class TestState {
     keyvals;
 }
 export class StateTransitionGenesis {
-    static fromJson(spec = tinyChainSpec) {
-        return {
-            header: headerFromJson(spec),
-            state: TestState.fromJson,
-        };
-    }
+    static fromJson = {
+        header: headerFromJson,
+        state: TestState.fromJson,
+    };
     static Codec = codec.object({
         header: Header.Codec,
         state: TestState.Codec,

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

@@ -40,7 +40,7 @@ describe("TransitionHasher", () => {
         }
         function prepareTickets() {
             return rawTickets.map(({ attempt, signature }) => SignedTicket.create({
-                attempt: tryAsTicketAttempt(attempt, tinyChainSpec),
+                attempt: tryAsTicketAttempt(attempt),
                 signature: Bytes.parseBytes(signature, BANDERSNATCH_PROOF_BYTES).asOpaque(),
             }));
         }

package/packages/workers/block-authorship/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../packages/workers/block-authorship/main.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAgB3E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAE3D,OAAO,KAAK,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAK9E,KAAK,MAAM,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAC;AAkBlD,wBAAsB,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,eAAe,iBAgPpG"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../packages/workers/block-authorship/main.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAgB3E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAE3D,OAAO,KAAK,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAK9E,KAAK,MAAM,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAC;AAkBlD,wBAAsB,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,eAAe,iBA+OpG"}

package/packages/workers/block-authorship/main.js

@@ -152,7 +152,7 @@ export async function main(config, comms, networkingComms) {
                 // After epoch change, it has been shifted to index 2.
                 const ticketEntropy = isNewEpoch ? state.entropy[1] : state.entropy[2];
                 logger.info `Epoch ${epoch}, slot ${slotInEpoch}/${chainSpec.contestLength}. Generating tickets for ${validatorKeys.length} validators...`;
-                const ticketsResult = await generateTickets(bandersnatch, ringKeys, validatorKeys, ticketEntropy, chainSpec.ticketsPerValidator, chainSpec);
+                const ticketsResult = await generateTickets(bandersnatch, ringKeys, validatorKeys, ticketEntropy, chainSpec.ticketsPerValidator);
                 if (ticketsResult.isError) {
                     logger.warn `Failed to generate tickets for epoch ${epoch}: ${ticketsResult.error}`;
                 }