@typeberry/convert 0.5.1-aff8b4f → 0.5.1

package/index.js

@@ -3871,17 +3871,6 @@ module.exports = __nccwpck_require__.p + "ccf8ada94096a8f232f5.js?reed_solomon_w
 /******/ 	__nccwpck_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
 /******/ })();
 /******/ 
-/******/ /* webpack/runtime/make namespace object */
-/******/ (() => {
-/******/ 	// define __esModule on exports
-/******/ 	__nccwpck_require__.r = (exports) => {
-/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
-/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-/******/ 		}
-/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
-/******/ 	};
-/******/ })();
-/******/ 
 /******/ /* webpack/runtime/publicPath */
 /******/ (() => {
 /******/ 	var scriptUrl;
@@ -3924,44 +3913,6 @@ module.exports = __nccwpck_require__.p + "ccf8ada94096a8f232f5.js?reed_solomon_w
 /************************************************************************/
 var __webpack_exports__ = {};
 
-// NAMESPACE OBJECT: ./packages/core/codec/descriptors.ts
-var descriptors_namespaceObject = {};
-__nccwpck_require__.r(descriptors_namespaceObject);
-__nccwpck_require__.d(descriptors_namespaceObject, {
-  Class: () => (Class),
-  TYPICAL_DICTIONARY_LENGTH: () => (TYPICAL_DICTIONARY_LENGTH),
-  bitVecFixLen: () => (bitVecFixLen),
-  bitVecVarLen: () => (bitVecVarLen),
-  blob: () => (blob),
-  bool: () => (bool),
-  bytes: () => (bytes),
-  custom: () => (custom),
-  dictionary: () => (dictionary),
-  forEachDescriptor: () => (forEachDescriptor),
-  i16: () => (i16),
-  i24: () => (i24),
-  i32: () => (i32),
-  i64: () => (i64),
-  i8: () => (i8),
-  nothing: () => (nothing),
-  object: () => (object),
-  optional: () => (optional),
-  pair: () => (pair),
-  readonlyArray: () => (readonlyArray),
-  select: () => (descriptors_select),
-  sequenceFixLen: () => (sequenceFixLen),
-  sequenceVarLen: () => (sequenceVarLen),
-  string: () => (string),
-  u16: () => (u16),
-  u24: () => (u24),
-  u32: () => (u32),
-  u64: () => (u64),
-  u8: () => (u8),
-  union: () => (union),
-  varU32: () => (varU32),
-  varU64: () => (varU64)
-});
-
 ;// CONCATENATED MODULE: ./packages/core/logger/options.ts
 var Level;
 (function (Level) {
@@ -6676,48 +6627,6 @@ const pair = (a, b) => {
 };
 /** Custom encoding / decoding logic. */
 const custom = ({ name, sizeHint = { bytes: 0, isExact: false }, }, encode, decode, skip) => Descriptor.new(name, sizeHint, encode, decode, skip);
-/** Tagged union type encoding. */
-const union = (name, variants) => {
-    const keys = Object.keys(variants).map(Number);
-    const variantMap = Object.fromEntries(keys.map((key, idx) => [key, idx]));
-    const indexToKey = Object.fromEntries(keys.map((key, idx) => [idx, key]));
-    // Calculate size hint as the minimum variant size + index size
-    const minVariantSize = Math.max(...keys.map((key) => variants[key].sizeHint.bytes));
-    const sizeHint = {
-        bytes: 1 + minVariantSize, // varU32 index + smallest variant
-        isExact: false,
-    };
-    const encode = (e, x) => {
-        const idx = variantMap[x.kind];
-        if (idx === undefined) {
-            throw new Error(`Unknown variant type: ${x.kind} for ${name}`);
-        }
-        e.varU32(numbers_tryAsU32(idx));
-        const codec = variants[x.kind];
-        // I'm sorry but I can't figure out a better typing here :)
-        codec.encode(e, x);
-    };
-    const decode = (d) => {
-        const idx = d.varU32();
-        const kind = indexToKey[idx];
-        if (kind === undefined) {
-            throw new Error(`Unknown variant index: ${idx} for ${name}`);
-        }
-        const codec = variants[kind];
-        const value = codec.decode(d);
-        return { kind, ...value };
-    };
-    const skip = (s) => {
-        const idx = s.decoder.varU32();
-        const kind = indexToKey[idx];
-        if (kind === undefined) {
-            throw new Error(`Unknown variant index: ${idx} for ${name}`);
-        }
-        const codec = variants[kind];
-        codec.skip(s);
-    };
-    return Descriptor.new(name, sizeHint, encode, decode, skip);
-};
 /** Choose a descriptor depending on the encoding/decoding context. */
 const descriptors_select = ({ name, sizeHint, }, chooser) => {
     const Self = chooser(null);
@@ -6869,11 +6778,6 @@ function sequenceViewFixLen(type, { fixedLength }) {
 
 
 
-// additional re-export of descriptors namespace under `codec`
-// note we export descriptors in top level as well,
-// because writing `codec.codec.u32` when using the library looks weird
-
-const codec_codec = descriptors_namespaceObject;
 
 ;// CONCATENATED MODULE: ./node_modules/@typeberry/native/chunk-CPmnHcRE.js
 //#region rolldown:runtime
@@ -9213,7 +9117,7 @@ function codecWithContext(chooser) {
     const defaultContext = chain_spec_fullChainSpec;
     const { name, sizeHint } = chooser(defaultContext);
     const cache = new Map();
-    return codec_codec.select({
+    return descriptors_select({
         name,
         sizeHint: { bytes: sizeHint.bytes, isExact: false },
     }, (context) => {
@@ -9240,9 +9144,9 @@ function codecWithContext(chooser) {
 /** Codec for a known-size array with length validation. */
 const codecKnownSizeArray = (val, options, _id) => {
     if ("fixedLength" in options) {
-        return codec_codec.readonlyArray(codec_codec.sequenceFixLen(val, options.fixedLength)).convert(seeThrough, sized_array_asKnownSize);
+        return readonlyArray(sequenceFixLen(val, options.fixedLength)).convert(seeThrough, sized_array_asKnownSize);
     }
-    return codec_codec.readonlyArray(codec_codec.sequenceVarLen(val, options)).convert(seeThrough, sized_array_asKnownSize);
+    return readonlyArray(sequenceVarLen(val, options)).convert(seeThrough, sized_array_asKnownSize);
 };
 /** Codec for a fixed-size array with length validation. */
 const codecFixedSizeArray = (val, len) => {
@@ -9251,7 +9155,7 @@ const codecFixedSizeArray = (val, len) => {
             throw new Error(`[${val.name}] Invalid size of fixed-size array. Got ${actual}, expected: ${len}`);
         }
     };
-    return codec_codec.sequenceFixLen(val, len).convert((i) => {
+    return sequenceFixLen(val, len).convert((i) => {
         checkLength(i.length);
         return i;
     }, (o) => {
@@ -9260,7 +9164,7 @@ const codecFixedSizeArray = (val, len) => {
     });
 };
 /** Codec for a hash-dictionary. */
-const codecHashDictionary = (value, extractKey, { typicalLength = codec_codec.TYPICAL_DICTIONARY_LENGTH, compare = (a, b) => extractKey(a).compare(extractKey(b)), } = {}) => {
+const codecHashDictionary = (value, extractKey, { typicalLength = TYPICAL_DICTIONARY_LENGTH, compare = (a, b) => extractKey(a).compare(extractKey(b)), } = {}) => {
     return Descriptor.new(`HashDictionary<${value.name}>[?]`, {
         bytes: typicalLength * value.sizeHint.bytes,
         isExact: false,
@@ -9312,13 +9216,13 @@ class AvailabilityAssurance extends WithDebug {
     bitfield;
     validatorIndex;
     signature;
-    static Codec = codec_codec.Class(AvailabilityAssurance, {
-        anchor: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
+    static Codec = Class(AvailabilityAssurance, {
+        anchor: bytes(hash_HASH_SIZE).asOpaque(),
         bitfield: codecWithContext((context) => {
-            return codec_codec.bitVecFixLen(context.coresCount);
+            return bitVecFixLen(context.coresCount);
         }),
-        validatorIndex: codec_codec.u16.asOpaque(),
-        signature: codec_codec.bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
+        validatorIndex: u16.asOpaque(),
+        signature: bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
     });
     static create({ anchor, bitfield, validatorIndex, signature }) {
         return new AvailabilityAssurance(anchor, bitfield, validatorIndex, signature);
@@ -9410,11 +9314,11 @@ class Fault extends WithDebug {
     wasConsideredValid;
     key;
     signature;
-    static Codec = codec_codec.Class(Fault, {
-        workReportHash: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        wasConsideredValid: codec_codec.bool,
-        key: codec_codec.bytes(ED25519_KEY_BYTES).asOpaque(),
-        signature: codec_codec.bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
+    static Codec = Class(Fault, {
+        workReportHash: bytes(hash_HASH_SIZE).asOpaque(),
+        wasConsideredValid: bool,
+        key: bytes(ED25519_KEY_BYTES).asOpaque(),
+        signature: bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
     });
     static create({ workReportHash, wasConsideredValid, key, signature }) {
         return new Fault(workReportHash, wasConsideredValid, key, signature);
@@ -9442,10 +9346,10 @@ class Culprit extends WithDebug {
     workReportHash;
     key;
     signature;
-    static Codec = codec_codec.Class(Culprit, {
-        workReportHash: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        key: codec_codec.bytes(ED25519_KEY_BYTES).asOpaque(),
-        signature: codec_codec.bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
+    static Codec = Class(Culprit, {
+        workReportHash: bytes(hash_HASH_SIZE).asOpaque(),
+        key: bytes(ED25519_KEY_BYTES).asOpaque(),
+        signature: bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
     });
     static create({ workReportHash, key, signature }) {
         return new Culprit(workReportHash, key, signature);
@@ -9470,10 +9374,10 @@ class Judgement extends WithDebug {
     isWorkReportValid;
     index;
     signature;
-    static Codec = codec_codec.Class(Judgement, {
-        isWorkReportValid: codec_codec.bool,
-        index: codec_codec.u16.asOpaque(),
-        signature: codec_codec.bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
+    static Codec = Class(Judgement, {
+        isWorkReportValid: bool,
+        index: u16.asOpaque(),
+        signature: bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
     });
     static create({ isWorkReportValid, index, signature }) {
         return new Judgement(isWorkReportValid, index, signature);
@@ -9502,12 +9406,11 @@ class Verdict extends WithDebug {
     workReportHash;
     votesEpoch;
     votes;
-    static Codec = codec_codec.Class(Verdict, {
-        workReportHash: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        votesEpoch: codec_codec.u32.asOpaque(),
+    static Codec = Class(Verdict, {
+        workReportHash: bytes(hash_HASH_SIZE).asOpaque(),
+        votesEpoch: u32.asOpaque(),
         votes: codecWithContext((context) => {
-            return codec_codec
-                .readonlyArray(codec_codec.sequenceFixLen(Judgement.Codec, context.validatorsSuperMajority))
+            return readonlyArray(sequenceFixLen(Judgement.Codec, context.validatorsSuperMajority))
                 .convert(seeThrough, sized_array_asKnownSize);
         }),
     });
@@ -9549,10 +9452,10 @@ class DisputesExtrinsic extends WithDebug {
     verdicts;
     culprits;
     faults;
-    static Codec = codec_codec.Class(DisputesExtrinsic, {
-        verdicts: codec_codec.sequenceVarLen(Verdict.Codec),
-        culprits: codec_codec.sequenceVarLen(Culprit.Codec),
-        faults: codec_codec.sequenceVarLen(Fault.Codec),
+    static Codec = Class(DisputesExtrinsic, {
+        verdicts: sequenceVarLen(Verdict.Codec),
+        culprits: sequenceVarLen(Culprit.Codec),
+        faults: sequenceVarLen(Fault.Codec),
     });
     static create({ verdicts, culprits, faults }) {
         return new DisputesExtrinsic(verdicts, culprits, faults);
@@ -9598,9 +9501,9 @@ class DisputesExtrinsic extends WithDebug {
 class WorkPackageInfo extends WithDebug {
     workPackageHash;
     segmentTreeRoot;
-    static Codec = codec_codec.Class(WorkPackageInfo, {
-        workPackageHash: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        segmentTreeRoot: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
+    static Codec = Class(WorkPackageInfo, {
+        workPackageHash: bytes(hash_HASH_SIZE).asOpaque(),
+        segmentTreeRoot: bytes(hash_HASH_SIZE).asOpaque(),
     });
     constructor(
     /** Hash of the described work package. */
@@ -9628,13 +9531,13 @@ class RefineContext extends WithDebug {
     lookupAnchor;
     lookupAnchorSlot;
     prerequisites;
-    static Codec = codec_codec.Class(RefineContext, {
-        anchor: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        stateRoot: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        beefyRoot: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        lookupAnchor: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        lookupAnchorSlot: codec_codec.u32.asOpaque(),
-        prerequisites: codec_codec.sequenceVarLen(codec_codec.bytes(hash_HASH_SIZE).asOpaque()),
+    static Codec = Class(RefineContext, {
+        anchor: bytes(hash_HASH_SIZE).asOpaque(),
+        stateRoot: bytes(hash_HASH_SIZE).asOpaque(),
+        beefyRoot: bytes(hash_HASH_SIZE).asOpaque(),
+        lookupAnchor: bytes(hash_HASH_SIZE).asOpaque(),
+        lookupAnchorSlot: u32.asOpaque(),
+        prerequisites: sequenceVarLen(bytes(hash_HASH_SIZE).asOpaque()),
     });
     static create({ anchor, stateRoot, beefyRoot, lookupAnchor, lookupAnchorSlot, prerequisites, }) {
         return new RefineContext(anchor, stateRoot, beefyRoot, lookupAnchor, lookupAnchorSlot, prerequisites);
@@ -9691,9 +9594,9 @@ const tryAsSegmentIndex = (v) => asOpaqueType(tryAsU16(v));
 class ImportSpec extends WithDebug {
     treeRoot;
     index;
-    static Codec = codec_codec.Class(ImportSpec, {
-        treeRoot: codec_codec.bytes(hash_HASH_SIZE),
-        index: codec_codec.u16.asOpaque(),
+    static Codec = Class(ImportSpec, {
+        treeRoot: bytes(hash_HASH_SIZE),
+        index: u16.asOpaque(),
     });
     static create({ treeRoot, index }) {
         return new ImportSpec(treeRoot, index);
@@ -9715,9 +9618,9 @@ class ImportSpec extends WithDebug {
 class WorkItemExtrinsicSpec extends WithDebug {
     hash;
     len;
-    static Codec = codec_codec.Class(WorkItemExtrinsicSpec, {
-        hash: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        len: codec_codec.u32,
+    static Codec = Class(WorkItemExtrinsicSpec, {
+        hash: bytes(hash_HASH_SIZE).asOpaque(),
+        len: u32,
     });
     static create({ hash, len }) {
         return new WorkItemExtrinsicSpec(hash, len);
@@ -9777,19 +9680,19 @@ class work_item_WorkItem extends WithDebug {
     importSegments;
     extrinsic;
     exportCount;
-    static Codec = codec_codec.Class(work_item_WorkItem, {
-        service: codec_codec.u32.asOpaque(),
-        codeHash: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        refineGasLimit: codec_codec.u64.asOpaque(),
-        accumulateGasLimit: codec_codec.u64.asOpaque(),
-        exportCount: codec_codec.u16,
-        payload: codec_codec.blob,
+    static Codec = Class(work_item_WorkItem, {
+        service: u32.asOpaque(),
+        codeHash: bytes(hash_HASH_SIZE).asOpaque(),
+        refineGasLimit: u64.asOpaque(),
+        accumulateGasLimit: u64.asOpaque(),
+        exportCount: u16,
+        payload: blob,
         importSegments: codecKnownSizeArray(ImportSpec.Codec, {
             minLength: 0,
             maxLength: MAX_NUMBER_OF_SEGMENTS,
             typicalLength: MAX_NUMBER_OF_SEGMENTS,
         }),
-        extrinsic: codec_codec.sequenceVarLen(WorkItemExtrinsicSpec.Codec),
+        extrinsic: sequenceVarLen(WorkItemExtrinsicSpec.Codec),
     });
     static create({ service, codeHash, payload, refineGasLimit, accumulateGasLimit, importSegments, extrinsic, exportCount, }) {
         return new work_item_WorkItem(service, codeHash, payload, refineGasLimit, accumulateGasLimit, importSegments, extrinsic, exportCount);
@@ -9862,13 +9765,13 @@ class work_package_WorkPackage extends WithDebug {
     parametrization;
     context;
     items;
-    static Codec = codec_codec.Class(work_package_WorkPackage, {
-        authCodeHost: codec_codec.u32.asOpaque(),
-        authCodeHash: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
+    static Codec = Class(work_package_WorkPackage, {
+        authCodeHost: u32.asOpaque(),
+        authCodeHash: bytes(hash_HASH_SIZE).asOpaque(),
         context: RefineContext.Codec,
-        authorization: codec_codec.blob,
-        parametrization: codec_codec.blob,
-        items: codec_codec.sequenceVarLen(work_item_WorkItem.Codec).convert((x) => x, (items) => FixedSizeArray.new(items, tryAsWorkItemsCount(items.length))),
+        authorization: blob,
+        parametrization: blob,
+        items: sequenceVarLen(work_item_WorkItem.Codec).convert((x) => x, (items) => FixedSizeArray.new(items, tryAsWorkItemsCount(items.length))),
     });
     static create({ authorization, authCodeHost, authCodeHash, parametrization, context, items, }) {
         return new work_package_WorkPackage(authorization, authCodeHost, authCodeHash, parametrization, context, items);
@@ -9928,22 +9831,30 @@ var WorkExecResultKind;
 class WorkExecResult extends WithDebug {
     kind;
     okBlob;
-    static Codec = codec_codec
-        .union("WorkExecResult", {
-        [WorkExecResultKind.ok]: codec_codec.object({ okBlob: codec_codec.blob }),
-        [WorkExecResultKind.outOfGas]: codec_codec.object({}),
-        [WorkExecResultKind.panic]: codec_codec.object({}),
-        [WorkExecResultKind.incorrectNumberOfExports]: codec_codec.object({}),
-        [WorkExecResultKind.digestTooBig]: codec_codec.object({}),
-        [WorkExecResultKind.badCode]: codec_codec.object({}),
-        [WorkExecResultKind.codeOversize]: codec_codec.object({}),
-    })
-        .convert((x) => {
-        if (x.kind === WorkExecResultKind.ok) {
-            return { kind: WorkExecResultKind.ok, okBlob: x.okBlob ?? bytes_BytesBlob.empty() };
-        }
-        return { kind: x.kind };
-    }, (x) => new WorkExecResult(x.kind, x.kind === WorkExecResultKind.ok ? x.okBlob : null));
+    static Codec = custom({
+        name: "WorkExecResult",
+        sizeHint: { bytes: 1, isExact: false },
+    }, (e, x) => {
+        e.varU32(numbers_tryAsU32(x.kind));
+        if (x.kind === WorkExecResultKind.ok && x.okBlob !== null) {
+            e.bytesBlob(x.okBlob);
+        }
+    }, (d) => {
+        const kind = d.varU32();
+        if (kind === WorkExecResultKind.ok) {
+            const blob = d.bytesBlob();
+            return new WorkExecResult(kind, blob);
+        }
+        if (kind > WorkExecResultKind.codeOversize) {
+            throw new Error(`Invalid WorkExecResultKind: ${kind}`);
+        }
+        return new WorkExecResult(kind);
+    }, (s) => {
+        const kind = s.decoder.varU32();
+        if (kind === WorkExecResultKind.ok) {
+            s.bytesBlob();
+        }
+    });
     constructor(
     /** The execution result tag. */
     kind, 
@@ -9967,12 +9878,12 @@ class WorkRefineLoad extends WithDebug {
     extrinsicCount;
     extrinsicSize;
     exportedSegments;
-    static Codec = codec_codec.Class(WorkRefineLoad, {
-        gasUsed: codec_codec.varU64.asOpaque(),
-        importedSegments: codec_codec.varU32,
-        extrinsicCount: codec_codec.varU32,
-        extrinsicSize: codec_codec.varU32,
-        exportedSegments: codec_codec.varU32,
+    static Codec = Class(WorkRefineLoad, {
+        gasUsed: varU64.asOpaque(),
+        importedSegments: varU32,
+        extrinsicCount: varU32,
+        extrinsicSize: varU32,
+        exportedSegments: varU32,
     });
     static create({ gasUsed, importedSegments, extrinsicCount, extrinsicSize, exportedSegments, }) {
         return new WorkRefineLoad(gasUsed, importedSegments, extrinsicCount, extrinsicSize, exportedSegments);
@@ -10008,11 +9919,11 @@ class WorkResult {
     gas;
     result;
     load;
-    static Codec = codec_codec.Class(WorkResult, {
-        serviceId: codec_codec.u32.asOpaque(),
-        codeHash: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        payloadHash: codec_codec.bytes(hash_HASH_SIZE),
-        gas: codec_codec.u64.asOpaque(),
+    static Codec = Class(WorkResult, {
+        serviceId: u32.asOpaque(),
+        codeHash: bytes(hash_HASH_SIZE).asOpaque(),
+        payloadHash: bytes(hash_HASH_SIZE),
+        gas: u64.asOpaque(),
         result: WorkExecResult.Codec,
         load: WorkRefineLoad.Codec,
     });
@@ -10079,12 +9990,12 @@ class WorkPackageSpec extends WithDebug {
     erasureRoot;
     exportsRoot;
     exportsCount;
-    static Codec = codec_codec.Class(WorkPackageSpec, {
-        hash: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        length: codec_codec.u32,
-        erasureRoot: codec_codec.bytes(hash_HASH_SIZE),
-        exportsRoot: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        exportsCount: codec_codec.u16,
+    static Codec = Class(WorkPackageSpec, {
+        hash: bytes(hash_HASH_SIZE).asOpaque(),
+        length: u32,
+        erasureRoot: bytes(hash_HASH_SIZE),
+        exportsRoot: bytes(hash_HASH_SIZE).asOpaque(),
+        exportsCount: u16,
     });
     static create({ hash, length, erasureRoot, exportsRoot, exportsCount }) {
         return new WorkPackageSpec(hash, length, erasureRoot, exportsRoot, exportsCount);
@@ -10122,20 +10033,20 @@ class WorkReport extends WithDebug {
     segmentRootLookup;
     results;
     authorizationGasUsed;
-    static Codec = codec_codec.Class(WorkReport, {
+    static Codec = Class(WorkReport, {
         workPackageSpec: WorkPackageSpec.Codec,
         context: RefineContext.Codec,
-        coreIndex: codec_codec.varU32.convert((o) => numbers_tryAsU32(o), (i) => {
+        coreIndex: varU32.convert((o) => numbers_tryAsU32(o), (i) => {
             if (!isU16(i)) {
                 throw new Error(`Core index exceeds U16: ${i}`);
             }
             return tryAsCoreIndex(i);
         }),
-        authorizerHash: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        authorizationGasUsed: codec_codec.varU64.asOpaque(),
-        authorizationOutput: codec_codec.blob,
-        segmentRootLookup: codec_codec.readonlyArray(codec_codec.sequenceVarLen(WorkPackageInfo.Codec)),
-        results: codec_codec.sequenceVarLen(WorkResult.Codec).convert((x) => x, (items) => FixedSizeArray.new(items, tryAsWorkItemsCount(items.length))),
+        authorizerHash: bytes(hash_HASH_SIZE).asOpaque(),
+        authorizationGasUsed: varU64.asOpaque(),
+        authorizationOutput: blob,
+        segmentRootLookup: readonlyArray(sequenceVarLen(WorkPackageInfo.Codec)),
+        results: sequenceVarLen(WorkResult.Codec).convert((x) => x, (items) => FixedSizeArray.new(items, tryAsWorkItemsCount(items.length))),
     });
     static create({ workPackageSpec, context, coreIndex, authorizerHash, authorizationOutput, segmentRootLookup, results, authorizationGasUsed, }) {
         return new WorkReport(workPackageSpec, context, coreIndex, authorizerHash, authorizationOutput, segmentRootLookup, results, authorizationGasUsed);
@@ -10183,9 +10094,9 @@ const REQUIRED_CREDENTIALS_RANGE = [2, 3];
 class Credential extends WithDebug {
     validatorIndex;
     signature;
-    static Codec = codec_codec.Class(Credential, {
-        validatorIndex: codec_codec.u16.asOpaque(),
-        signature: codec_codec.bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
+    static Codec = Class(Credential, {
+        validatorIndex: u16.asOpaque(),
+        signature: bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
     });
     static create({ validatorIndex, signature }) {
         return new Credential(validatorIndex, signature);
@@ -10209,9 +10120,9 @@ class ReportGuarantee extends WithDebug {
     report;
     slot;
     credentials;
-    static Codec = codec_codec.Class(ReportGuarantee, {
+    static Codec = Class(ReportGuarantee, {
         report: WorkReport.Codec,
-        slot: codec_codec.u32.asOpaque(),
+        slot: u32.asOpaque(),
         credentials: codecKnownSizeArray(Credential.Codec, {
             minLength: REQUIRED_CREDENTIALS_RANGE[0],
             maxLength: REQUIRED_CREDENTIALS_RANGE[1],
@@ -10261,10 +10172,10 @@ function tryAsTicketAttempt(x) {
 class SignedTicket extends WithDebug {
     attempt;
     signature;
-    static Codec = codec_codec.Class(SignedTicket, {
+    static Codec = Class(SignedTicket, {
         // TODO [ToDr] we should verify that attempt is either 0|1|2.
-        attempt: codec_codec.u8.asOpaque(),
-        signature: codec_codec.bytes(BANDERSNATCH_PROOF_BYTES).asOpaque(),
+        attempt: u8.asOpaque(),
+        signature: bytes(BANDERSNATCH_PROOF_BYTES).asOpaque(),
     });
     static create({ attempt, signature }) {
         return new SignedTicket(attempt, signature);
@@ -10283,10 +10194,10 @@ class SignedTicket extends WithDebug {
 class Ticket extends WithDebug {
     id;
     attempt;
-    static Codec = codec_codec.Class(Ticket, {
-        id: codec_codec.bytes(hash_HASH_SIZE),
+    static Codec = Class(Ticket, {
+        id: bytes(hash_HASH_SIZE),
         // TODO [ToDr] we should verify that attempt is either 0|1|2.
-        attempt: codec_codec.u8.asOpaque(),
+        attempt: u8.asOpaque(),
     });
     static create({ id, attempt }) {
         return new Ticket(id, attempt);
@@ -10338,9 +10249,9 @@ const ticketsExtrinsicCodec = codecWithContext((context) => {
 class ValidatorKeys extends WithDebug {
     bandersnatch;
     ed25519;
-    static Codec = codec_codec.Class(ValidatorKeys, {
-        bandersnatch: codec_codec.bytes(BANDERSNATCH_KEY_BYTES).asOpaque(),
-        ed25519: codec_codec.bytes(ED25519_KEY_BYTES).asOpaque(),
+    static Codec = Class(ValidatorKeys, {
+        bandersnatch: bytes(BANDERSNATCH_KEY_BYTES).asOpaque(),
+        ed25519: bytes(ED25519_KEY_BYTES).asOpaque(),
     });
     static create({ bandersnatch, ed25519 }) {
         return new ValidatorKeys(bandersnatch, ed25519);
@@ -10357,7 +10268,7 @@ class ValidatorKeys extends WithDebug {
 }
 class TicketsMarker extends WithDebug {
     tickets;
-    static Codec = codec_codec.Class(TicketsMarker, {
+    static Codec = Class(TicketsMarker, {
         tickets: codecPerEpochBlock(Ticket.Codec),
     });
     static create({ tickets }) {
@@ -10379,9 +10290,9 @@ class EpochMarker extends WithDebug {
     entropy;
     ticketsEntropy;
     validators;
-    static Codec = codec_codec.Class(EpochMarker, {
-        entropy: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        ticketsEntropy: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
+    static Codec = Class(EpochMarker, {
+        entropy: bytes(hash_HASH_SIZE).asOpaque(),
+        ticketsEntropy: bytes(hash_HASH_SIZE).asOpaque(),
         validators: codecPerValidator(ValidatorKeys.Codec),
     });
     static create({ entropy, ticketsEntropy, validators }) {
@@ -10418,17 +10329,17 @@ const encodeUnsealedHeader = (view) => {
  * https://graypaper.fluffylabs.dev/#/ab2cdbd/0c66000c7200?v=0.7.2
  */
 class header_Header extends WithDebug {
-    static Codec = codec_codec.Class(header_Header, {
-        parentHeaderHash: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        priorStateRoot: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        extrinsicHash: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        timeSlotIndex: codec_codec.u32.asOpaque(),
-        epochMarker: codec_codec.optional(EpochMarker.Codec),
-        ticketsMarker: codec_codec.optional(TicketsMarker.Codec),
-        bandersnatchBlockAuthorIndex: codec_codec.u16.asOpaque(),
-        entropySource: codec_codec.bytes(bandersnatch_BANDERSNATCH_VRF_SIGNATURE_BYTES).asOpaque(),
-        offendersMarker: codec_codec.sequenceVarLen(codec_codec.bytes(ED25519_KEY_BYTES).asOpaque()),
-        seal: codec_codec.bytes(bandersnatch_BANDERSNATCH_VRF_SIGNATURE_BYTES).asOpaque(),
+    static Codec = Class(header_Header, {
+        parentHeaderHash: bytes(hash_HASH_SIZE).asOpaque(),
+        priorStateRoot: bytes(hash_HASH_SIZE).asOpaque(),
+        extrinsicHash: bytes(hash_HASH_SIZE).asOpaque(),
+        timeSlotIndex: u32.asOpaque(),
+        epochMarker: optional(EpochMarker.Codec),
+        ticketsMarker: optional(TicketsMarker.Codec),
+        bandersnatchBlockAuthorIndex: u16.asOpaque(),
+        entropySource: bytes(bandersnatch_BANDERSNATCH_VRF_SIGNATURE_BYTES).asOpaque(),
+        offendersMarker: sequenceVarLen(bytes(ED25519_KEY_BYTES).asOpaque()),
+        seal: bytes(bandersnatch_BANDERSNATCH_VRF_SIGNATURE_BYTES).asOpaque(),
     });
     static create(h) {
         return Object.assign(header_Header.empty(), h);
@@ -10483,8 +10394,8 @@ class header_Header extends WithDebug {
  * `DescriptorRecord` or `CodecRecord` for some reason.
  */
 class HeaderViewWithHash extends WithHash {
-    static Codec = codec_codec.Class(HeaderViewWithHash, {
-        hash: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
+    static Codec = Class(HeaderViewWithHash, {
+        hash: bytes(hash_HASH_SIZE).asOpaque(),
         data: header_Header.Codec.View,
     });
     static create({ hash, data }) {
@@ -10505,9 +10416,9 @@ const headerViewWithHashCodec = HeaderViewWithHash.Codec;
 class Preimage extends WithDebug {
     requester;
     blob;
-    static Codec = codec_codec.Class(Preimage, {
-        requester: codec_codec.u32.asOpaque(),
-        blob: codec_codec.blob,
+    static Codec = Class(Preimage, {
+        requester: u32.asOpaque(),
+        blob: blob,
     });
     static create({ requester, blob }) {
         return new Preimage(requester, blob);
@@ -10522,7 +10433,7 @@ class Preimage extends WithDebug {
         this.blob = blob;
     }
 }
-const preimagesExtrinsicCodec = codec_codec.sequenceVarLen(Preimage.Codec);
+const preimagesExtrinsicCodec = sequenceVarLen(Preimage.Codec);
 
 ;// CONCATENATED MODULE: ./packages/jam/block/block.ts
 
@@ -10548,7 +10459,7 @@ class Extrinsic extends WithDebug {
     guarantees;
     assurances;
     disputes;
-    static Codec = codec_codec.Class(Extrinsic, {
+    static Codec = Class(Extrinsic, {
         tickets: ticketsExtrinsicCodec,
         preimages: preimagesExtrinsicCodec,
         guarantees: guaranteesExtrinsicCodec,
@@ -10601,7 +10512,7 @@ class Extrinsic extends WithDebug {
 class Block extends WithDebug {
     header;
     extrinsic;
-    static Codec = codec_codec.Class(Block, {
+    static Codec = Class(Block, {
         header: header_Header.Codec,
         extrinsic: Extrinsic.Codec,
     });
@@ -11582,10 +11493,10 @@ class Version extends WithDebug {
     major;
     minor;
     patch;
-    static Codec = codec_codec.Class(Version, {
-        major: codec_codec.u8,
-        minor: codec_codec.u8,
-        patch: codec_codec.u8,
+    static Codec = Class(Version, {
+        major: u8,
+        minor: u8,
+        patch: u8,
     });
     static tryFromString(str) {
         const parse = (v) => tryAsU8(Number(v));
@@ -11637,12 +11548,12 @@ class PeerInfo extends WithDebug {
     jamVersion;
     appVersion;
     name;
-    static Codec = codec_codec.Class(PeerInfo, {
-        fuzzVersion: codec_codec.u8,
-        features: codec_codec.u32,
+    static Codec = Class(PeerInfo, {
+        fuzzVersion: u8,
+        features: u32,
         jamVersion: Version.Codec,
         appVersion: Version.Codec,
-        name: codec_codec.string,
+        name: string,
     });
     static create({ fuzzVersion, features, appVersion, jamVersion, name }) {
         return new PeerInfo(fuzzVersion, features, jamVersion, appVersion, name);
@@ -11665,9 +11576,9 @@ class PeerInfo extends WithDebug {
 class AncestryItem extends WithDebug {
     slot;
     headerHash;
-    static Codec = codec_codec.Class(AncestryItem, {
-        slot: codec_codec.u32.asOpaque(),
-        headerHash: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
+    static Codec = Class(AncestryItem, {
+        slot: u32.asOpaque(),
+        headerHash: bytes(hash_HASH_SIZE).asOpaque(),
     });
     static create({ slot, headerHash }) {
         return new AncestryItem(slot, headerHash);
@@ -11687,9 +11598,9 @@ class AncestryItem extends WithDebug {
 class KeyValue extends WithDebug {
     key;
     value;
-    static Codec = codec_codec.Class(KeyValue, {
-        key: codec_codec.bytes(TRUNCATED_HASH_SIZE),
-        value: codec_codec.blob,
+    static Codec = Class(KeyValue, {
+        key: bytes(TRUNCATED_HASH_SIZE),
+        value: blob,
     });
     static create({ key, value }) {
         return new KeyValue(key, value);
@@ -11701,12 +11612,12 @@ class KeyValue extends WithDebug {
     }
 }
 /** State ::= SEQUENCE OF KeyValue */
-const stateCodec = codec_codec.sequenceVarLen(KeyValue.Codec);
+const stateCodec = sequenceVarLen(KeyValue.Codec);
 /**
  * Ancestry ::= SEQUENCE (SIZE(0..24)) OF AncestryItem
  * Empty when `feature-ancestry` is not supported by both parties
  */
-const ancestryCodec = codec_codec.sequenceVarLen(AncestryItem.Codec, {
+const ancestryCodec = sequenceVarLen(AncestryItem.Codec, {
     minLength: 0,
     maxLength: 24,
 });
@@ -11721,7 +11632,7 @@ class Initialize extends WithDebug {
     header;
     keyvals;
     ancestry;
-    static Codec = codec_codec.Class(Initialize, {
+    static Codec = Class(Initialize, {
         header: header_Header.Codec,
         keyvals: stateCodec,
         ancestry: ancestryCodec,
@@ -11737,14 +11648,14 @@ class Initialize extends WithDebug {
     }
 }
 /** GetState ::= HeaderHash */
-const getStateCodec = codec_codec.bytes(hash_HASH_SIZE).asOpaque();
+const getStateCodec = bytes(hash_HASH_SIZE).asOpaque();
 /** StateRoot ::= StateRootHash */
-const stateRootCodec = codec_codec.bytes(hash_HASH_SIZE).asOpaque();
+const stateRootCodec = bytes(hash_HASH_SIZE).asOpaque();
 /** Error ::= UTF8String */
 class ErrorMessage extends WithDebug {
     message;
-    static Codec = codec_codec.Class(ErrorMessage, {
-        message: codec_codec.string,
+    static Codec = Class(ErrorMessage, {
+        message: string,
     });
     static create({ message }) {
         return new ErrorMessage(message);
@@ -11776,7 +11687,7 @@ var types_MessageType;
  *     error         [255] Error
  * }
  */
-const types_messageCodec = codec_codec.custom({
+const types_messageCodec = custom({
     name: "Message",
     sizeHint: { bytes: 1, isExact: false },
 }, (e, msg) => {
@@ -12142,9 +12053,9 @@ function getRegisters(argsLength) {
 class AccumulationOutput {
     serviceId;
     output;
-    static Codec = codec_codec.Class(AccumulationOutput, {
-        serviceId: codec_codec.u32.asOpaque(),
-        output: codec_codec.bytes(hash_HASH_SIZE),
+    static Codec = Class(AccumulationOutput, {
+        serviceId: u32.asOpaque(),
+        output: bytes(hash_HASH_SIZE),
     });
     static create(a) {
         return new AccumulationOutput(a.serviceId, a.output);
@@ -12235,9 +12146,9 @@ const MAX_REPORT_DEPENDENCIES = 8;
 class NotYetAccumulatedReport extends WithDebug {
     report;
     dependencies;
-    static Codec = codec_codec.Class(NotYetAccumulatedReport, {
+    static Codec = Class(NotYetAccumulatedReport, {
         report: WorkReport.Codec,
-        dependencies: codecKnownSizeArray(codec_codec.bytes(hash_HASH_SIZE).asOpaque(), {
+        dependencies: codecKnownSizeArray(bytes(hash_HASH_SIZE).asOpaque(), {
             typicalLength: MAX_REPORT_DEPENDENCIES / 2,
             maxLength: MAX_REPORT_DEPENDENCIES,
             minLength: 0,
@@ -12264,7 +12175,7 @@ class NotYetAccumulatedReport extends WithDebug {
         this.dependencies = dependencies;
     }
 }
-const accumulationQueueCodec = codecPerEpochBlock(codec_codec.readonlyArray(codec_codec.sequenceVarLen(NotYetAccumulatedReport.Codec)));
+const accumulationQueueCodec = codecPerEpochBlock(readonlyArray(sequenceVarLen(NotYetAccumulatedReport.Codec)));
 
 ;// CONCATENATED MODULE: ./packages/jam/state/common.ts
 
@@ -12297,9 +12208,9 @@ const codecPerCore = (val) => codecWithContext((context) => {
 class AvailabilityAssignment extends WithDebug {
     workReport;
     timeout;
-    static Codec = codec_codec.Class(AvailabilityAssignment, {
+    static Codec = Class(AvailabilityAssignment, {
         workReport: WorkReport.Codec,
-        timeout: codec_codec.u32.asOpaque(),
+        timeout: u32.asOpaque(),
     });
     static create({ workReport, timeout }) {
         return new AvailabilityAssignment(workReport, timeout);
@@ -12314,7 +12225,7 @@ class AvailabilityAssignment extends WithDebug {
         this.timeout = timeout;
     }
 }
-const availabilityAssignmentsCodec = codecPerCore(codec_codec.optional(AvailabilityAssignment.Codec));
+const availabilityAssignmentsCodec = codecPerCore(optional(AvailabilityAssignment.Codec));
 
 ;// CONCATENATED MODULE: ./packages/jam/state/auth.ts
 
@@ -12326,18 +12237,18 @@ const availabilityAssignmentsCodec = codecPerCore(codec_codec.optional(Availabil
 const MAX_AUTH_POOL_SIZE = O;
 /** `Q`: Size of the authorization queue. */
 const AUTHORIZATION_QUEUE_SIZE = Q;
-const authPoolsCodec = codecPerCore(codecKnownSizeArray(codec_codec.bytes(hash_HASH_SIZE).asOpaque(), {
+const authPoolsCodec = codecPerCore(codecKnownSizeArray(bytes(hash_HASH_SIZE).asOpaque(), {
     minLength: 0,
     maxLength: MAX_AUTH_POOL_SIZE,
     typicalLength: MAX_AUTH_POOL_SIZE,
 }));
-const authQueuesCodec = codecPerCore(codecFixedSizeArray(codec_codec.bytes(hash_HASH_SIZE).asOpaque(), AUTHORIZATION_QUEUE_SIZE));
+const authQueuesCodec = codecPerCore(codecFixedSizeArray(bytes(hash_HASH_SIZE).asOpaque(), AUTHORIZATION_QUEUE_SIZE));
 
 ;// CONCATENATED MODULE: ./packages/jam/state/disputes.ts
 
 
 
-const sortedSetCodec = () => codec_codec.readonlyArray(codec_codec.sequenceVarLen(codec_codec.bytes(hash_HASH_SIZE))).convert((input) => input.array, (output) => {
+const sortedSetCodec = () => readonlyArray(sequenceVarLen(bytes(hash_HASH_SIZE))).convert((input) => input.array, (output) => {
     const typed = output.map((x) => x.asOpaque());
     return SortedSet.fromSortedArray(hashComparator, typed);
 });
@@ -12352,7 +12263,7 @@ class DisputesRecords {
     badSet;
     wonkySet;
     punishSet;
-    static Codec = codec_codec.Class(DisputesRecords, {
+    static Codec = Class(DisputesRecords, {
         goodSet: workReportsSortedSetCodec,
         badSet: workReportsSortedSetCodec,
         wonkySet: workReportsSortedSetCodec,
@@ -12425,10 +12336,10 @@ class BlockState extends WithDebug {
     accumulationResult;
     postStateRoot;
     reported;
-    static Codec = codec_codec.Class(BlockState, {
-        headerHash: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        accumulationResult: codec_codec.bytes(hash_HASH_SIZE),
-        postStateRoot: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
+    static Codec = Class(BlockState, {
+        headerHash: bytes(hash_HASH_SIZE).asOpaque(),
+        accumulationResult: bytes(hash_HASH_SIZE),
+        postStateRoot: bytes(hash_HASH_SIZE).asOpaque(),
         reported: codecHashDictionary(WorkPackageInfo.Codec, (x) => x.workPackageHash),
     });
     static create({ headerHash, accumulationResult, postStateRoot, reported }) {
@@ -12458,14 +12369,14 @@ class BlockState extends WithDebug {
 class RecentBlocks extends WithDebug {
     blocks;
     accumulationLog;
-    static Codec = codec_codec.Class(RecentBlocks, {
+    static Codec = Class(RecentBlocks, {
         blocks: codecKnownSizeArray(BlockState.Codec, {
             minLength: 0,
             maxLength: MAX_RECENT_HISTORY,
             typicalLength: MAX_RECENT_HISTORY,
         }),
-        accumulationLog: codec_codec.object({
-            peaks: codec_codec.readonlyArray(codec_codec.sequenceVarLen(codec_codec.optional(codec_codec.bytes(hash_HASH_SIZE)))),
+        accumulationLog: object({
+            peaks: readonlyArray(sequenceVarLen(optional(bytes(hash_HASH_SIZE)))),
         }),
     });
     static empty() {
@@ -12498,7 +12409,7 @@ class RecentBlocks extends WithDebug {
 
 
 
-const recentlyAccumulatedCodec = codecPerEpochBlock(codec_codec.sequenceVarLen(codec_codec.bytes(hash_HASH_SIZE).asOpaque()).convert((x) => Array.from(x), (x) => HashSet.from(x)));
+const recentlyAccumulatedCodec = codecPerEpochBlock(sequenceVarLen(bytes(hash_HASH_SIZE).asOpaque()).convert((x) => Array.from(x), (x) => HashSet.from(x)));
 
 ;// CONCATENATED MODULE: ./packages/jam/state/validator-data.ts
 
@@ -12521,11 +12432,11 @@ class ValidatorData extends WithDebug {
     ed25519;
     bls;
     metadata;
-    static Codec = codec_codec.Class(ValidatorData, {
-        bandersnatch: codec_codec.bytes(BANDERSNATCH_KEY_BYTES).asOpaque(),
-        ed25519: codec_codec.bytes(ED25519_KEY_BYTES).asOpaque(),
-        bls: codec_codec.bytes(BLS_KEY_BYTES).asOpaque(),
-        metadata: codec_codec.bytes(VALIDATOR_META_BYTES),
+    static Codec = Class(ValidatorData, {
+        bandersnatch: bytes(BANDERSNATCH_KEY_BYTES).asOpaque(),
+        ed25519: bytes(ED25519_KEY_BYTES).asOpaque(),
+        bls: bytes(BLS_KEY_BYTES).asOpaque(),
+        metadata: bytes(VALIDATOR_META_BYTES),
     });
     static create({ ed25519, bandersnatch, bls, metadata }) {
         return new ValidatorData(bandersnatch, ed25519, bls, metadata);
@@ -12558,31 +12469,53 @@ const validatorsDataCodec = codecPerValidator(ValidatorData.Codec);
 
 
 
+
+
 var SafroleSealingKeysKind;
 (function (SafroleSealingKeysKind) {
     SafroleSealingKeysKind[SafroleSealingKeysKind["Tickets"] = 0] = "Tickets";
     SafroleSealingKeysKind[SafroleSealingKeysKind["Keys"] = 1] = "Keys";
 })(SafroleSealingKeysKind || (SafroleSealingKeysKind = {}));
-const codecBandersnatchKey = codec_codec.bytes(BANDERSNATCH_KEY_BYTES).asOpaque();
+const codecBandersnatchKey = bytes(BANDERSNATCH_KEY_BYTES).asOpaque();
 class SafroleSealingKeysData extends WithDebug {
     kind;
     keys;
     tickets;
     static Codec = codecWithContext((context) => {
-        const keysCodec = codec_codec
-            .sequenceFixLen(codecBandersnatchKey, context.epochLength)
-            .convert((keys) => Array.from(keys), (keys) => tryAsPerEpochBlock(keys, context));
-        const ticketsCodec = codec_codec.sequenceFixLen(Ticket.Codec, context.epochLength).convert((tickets) => Array.from(tickets), (tickets) => tryAsPerEpochBlock(tickets, context));
-        return codec_codec
-            .union("SafroleSealingKeys", {
-            [SafroleSealingKeysKind.Keys]: codec_codec.object({ keys: keysCodec }),
-            [SafroleSealingKeysKind.Tickets]: codec_codec.object({ tickets: ticketsCodec }),
-        })
-            .convert((x) => x, (x) => {
+        return custom({
+            name: "SafroleSealingKeys",
+            sizeHint: { bytes: 1 + hash_HASH_SIZE * context.epochLength, isExact: false },
+        }, (e, x) => {
+            e.varU32(numbers_tryAsU32(x.kind));
             if (x.kind === SafroleSealingKeysKind.Keys) {
-                return SafroleSealingKeysData.keys(x.keys);
+                e.sequenceFixLen(codecBandersnatchKey, x.keys);
+            }
+            else {
+                e.sequenceFixLen(Ticket.Codec, x.tickets);
+            }
+        }, (d) => {
+            const epochLength = context.epochLength;
+            const kind = d.varU32();
+            if (kind === SafroleSealingKeysKind.Keys) {
+                const keys = d.sequenceFixLen(codecBandersnatchKey, epochLength);
+                return SafroleSealingKeysData.keys(tryAsPerEpochBlock(keys, context));
+            }
+            if (kind === SafroleSealingKeysKind.Tickets) {
+                const tickets = d.sequenceFixLen(Ticket.Codec, epochLength);
+                return SafroleSealingKeysData.tickets(tryAsPerEpochBlock(tickets, context));
+            }
+            throw new Error(`Unexpected safrole sealing keys kind: ${kind}`);
+        }, (s) => {
+            const kind = s.decoder.varU32();
+            if (kind === SafroleSealingKeysKind.Keys) {
+                s.sequenceFixLen(codecBandersnatchKey, context.epochLength);
+                return;
+            }
+            if (kind === SafroleSealingKeysKind.Tickets) {
+                s.sequenceFixLen(Ticket.Codec, context.epochLength);
+                return;
             }
-            return SafroleSealingKeysData.tickets(x.tickets);
+            throw new Error(`Unexpected safrole sealing keys kind: ${kind}`);
         });
     });
     static keys(keys) {
@@ -12603,11 +12536,11 @@ class safrole_data_SafroleData {
     epochRoot;
     sealingKeySeries;
     ticketsAccumulator;
-    static Codec = codec_codec.Class(safrole_data_SafroleData, {
+    static Codec = Class(safrole_data_SafroleData, {
         nextValidatorData: codecPerValidator(ValidatorData.Codec),
-        epochRoot: codec_codec.bytes(BANDERSNATCH_RING_ROOT_BYTES).asOpaque(),
+        epochRoot: bytes(BANDERSNATCH_RING_ROOT_BYTES).asOpaque(),
         sealingKeySeries: SafroleSealingKeysData.Codec,
-        ticketsAccumulator: codec_codec.readonlyArray(codec_codec.sequenceVarLen(Ticket.Codec)).convert(seeThrough, sized_array_asKnownSize),
+        ticketsAccumulator: readonlyArray(sequenceVarLen(Ticket.Codec)).convert(seeThrough, sized_array_asKnownSize),
     });
     static create({ nextValidatorData, epochRoot, sealingKeySeries, ticketsAccumulator }) {
         return new safrole_data_SafroleData(nextValidatorData, epochRoot, sealingKeySeries, ticketsAccumulator);
@@ -12692,17 +12625,17 @@ class ServiceAccountInfo extends WithDebug {
     created;
     lastAccumulation;
     parentService;
-    static Codec = codec_codec.Class(ServiceAccountInfo, {
-        codeHash: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        balance: codec_codec.u64,
-        accumulateMinGas: codec_codec.u64.convert((x) => x, tryAsServiceGas),
-        onTransferMinGas: codec_codec.u64.convert((x) => x, tryAsServiceGas),
-        storageUtilisationBytes: codec_codec.u64,
-        gratisStorage: codec_codec.u64,
-        storageUtilisationCount: codec_codec.u32,
-        created: codec_codec.u32.convert((x) => x, common_tryAsTimeSlot),
-        lastAccumulation: codec_codec.u32.convert((x) => x, common_tryAsTimeSlot),
-        parentService: codec_codec.u32.convert((x) => x, tryAsServiceId),
+    static Codec = Class(ServiceAccountInfo, {
+        codeHash: bytes(hash_HASH_SIZE).asOpaque(),
+        balance: u64,
+        accumulateMinGas: u64.convert((x) => x, tryAsServiceGas),
+        onTransferMinGas: u64.convert((x) => x, tryAsServiceGas),
+        storageUtilisationBytes: u64,
+        gratisStorage: u64,
+        storageUtilisationCount: u32,
+        created: u32.convert((x) => x, common_tryAsTimeSlot),
+        lastAccumulation: u32.convert((x) => x, common_tryAsTimeSlot),
+        parentService: u32.convert((x) => x, tryAsServiceId),
     });
     static create(a) {
         return new ServiceAccountInfo(a.codeHash, a.balance, a.accumulateMinGas, a.onTransferMinGas, a.storageUtilisationBytes, a.gratisStorage, a.storageUtilisationCount, a.created, a.lastAccumulation, a.parentService);
@@ -12758,9 +12691,9 @@ class ServiceAccountInfo extends WithDebug {
 class PreimageItem extends WithDebug {
     hash;
     blob;
-    static Codec = codec_codec.Class(PreimageItem, {
-        hash: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        blob: codec_codec.blob,
+    static Codec = Class(PreimageItem, {
+        hash: bytes(hash_HASH_SIZE).asOpaque(),
+        blob: blob,
     });
     static create({ hash, blob }) {
         return new PreimageItem(hash, blob);
@@ -12774,9 +12707,9 @@ class PreimageItem extends WithDebug {
 class StorageItem extends WithDebug {
     key;
     value;
-    static Codec = codec_codec.Class(StorageItem, {
-        key: codec_codec.blob.convert((i) => i, (o) => opaque_asOpaqueType(o)),
-        value: codec_codec.blob,
+    static Codec = Class(StorageItem, {
+        key: blob.convert((i) => i, (o) => opaque_asOpaqueType(o)),
+        value: blob,
     });
     static create({ key, value }) {
         return new StorageItem(key, value);
@@ -12837,13 +12770,13 @@ class ValidatorStatistics {
     preImagesSize;
     guarantees;
     assurances;
-    static Codec = codec_codec.Class(ValidatorStatistics, {
-        blocks: codec_codec.u32,
-        tickets: codec_codec.u32,
-        preImages: codec_codec.u32,
-        preImagesSize: codec_codec.u32,
-        guarantees: codec_codec.u32,
-        assurances: codec_codec.u32,
+    static Codec = Class(ValidatorStatistics, {
+        blocks: u32,
+        tickets: u32,
+        preImages: u32,
+        preImagesSize: u32,
+        guarantees: u32,
+        assurances: u32,
     });
     static create({ blocks, tickets, preImages, preImagesSize, guarantees, assurances, }) {
         return new ValidatorStatistics(blocks, tickets, preImages, preImagesSize, guarantees, assurances);
@@ -12873,9 +12806,9 @@ class ValidatorStatistics {
         return new ValidatorStatistics(zero, zero, zero, zero, zero, zero);
     }
 }
-const codecVarU16 = codec_codec.varU32.convert((i) => numbers_tryAsU32(i), (o) => numbers_tryAsU16(o));
+const codecVarU16 = varU32.convert((i) => numbers_tryAsU32(i), (o) => numbers_tryAsU16(o));
 /** Encode/decode unsigned gas. */
-const codecVarGas = codec_codec.varU64.convert((g) => numbers_tryAsU64(g), (i) => tryAsServiceGas(i));
+const codecVarGas = varU64.convert((g) => numbers_tryAsU64(g), (i) => tryAsServiceGas(i));
 /**
  * Single core statistics.
  * Updated per block, based on incoming work reports (`w`).
@@ -12892,14 +12825,14 @@ class CoreStatistics {
     extrinsicCount;
     bundleSize;
     gasUsed;
-    static Codec = codec_codec.Class(CoreStatistics, {
-        dataAvailabilityLoad: codec_codec.varU32,
+    static Codec = Class(CoreStatistics, {
+        dataAvailabilityLoad: varU32,
         popularity: codecVarU16,
         imports: codecVarU16,
         extrinsicCount: codecVarU16,
-        extrinsicSize: codec_codec.varU32,
+        extrinsicSize: varU32,
         exports: codecVarU16,
-        bundleSize: codec_codec.varU32,
+        bundleSize: varU32,
         gasUsed: codecVarGas,
     });
     static create(v) {
@@ -12958,31 +12891,31 @@ class ServiceStatistics {
     onTransfersCount;
     onTransfersGasUsed;
     static Codec = Compatibility.selectIfGreaterOrEqual({
-        fallback: codec_codec.Class(ServiceStatistics, {
+        fallback: Class(ServiceStatistics, {
             providedCount: codecVarU16,
-            providedSize: codec_codec.varU32,
-            refinementCount: codec_codec.varU32,
+            providedSize: varU32,
+            refinementCount: varU32,
             refinementGasUsed: codecVarGas,
             imports: codecVarU16,
             extrinsicCount: codecVarU16,
-            extrinsicSize: codec_codec.varU32,
+            extrinsicSize: varU32,
             exports: codecVarU16,
-            accumulateCount: codec_codec.varU32,
+            accumulateCount: varU32,
             accumulateGasUsed: codecVarGas,
-            onTransfersCount: codec_codec.varU32,
+            onTransfersCount: varU32,
             onTransfersGasUsed: codecVarGas,
         }),
         versions: {
-            [GpVersion.V0_7_1]: codec_codec.Class(ServiceStatistics, {
+            [GpVersion.V0_7_1]: Class(ServiceStatistics, {
                 providedCount: codecVarU16,
-                providedSize: codec_codec.varU32,
-                refinementCount: codec_codec.varU32,
+                providedSize: varU32,
+                refinementCount: varU32,
                 refinementGasUsed: codecVarGas,
                 imports: codecVarU16,
                 extrinsicCount: codecVarU16,
-                extrinsicSize: codec_codec.varU32,
+                extrinsicSize: varU32,
                 exports: codecVarU16,
-                accumulateCount: codec_codec.varU32,
+                accumulateCount: varU32,
                 accumulateGasUsed: codecVarGas,
                 onTransfersCount: ignoreValueWithDefault(numbers_tryAsU32(0)),
                 onTransfersGasUsed: ignoreValueWithDefault(tryAsServiceGas(0)),
@@ -13043,11 +12976,11 @@ class StatisticsData {
     previous;
     cores;
     services;
-    static Codec = codec_codec.Class(StatisticsData, {
+    static Codec = Class(StatisticsData, {
         current: codecPerValidator(ValidatorStatistics.Codec),
         previous: codecPerValidator(ValidatorStatistics.Codec),
         cores: codecPerCore(CoreStatistics.Codec),
-        services: codec_codec.dictionary(codec_codec.u32.asOpaque(), ServiceStatistics.Codec, {
+        services: dictionary(u32.asOpaque(), ServiceStatistics.Codec, {
             sortKeys: (a, b) => a - b,
         }),
     });
@@ -13146,14 +13079,14 @@ class PrivilegedServices {
     assigners;
     autoAccumulateServices;
     /** https://graypaper.fluffylabs.dev/#/ab2cdbd/3bbd023bcb02?v=0.7.2 */
-    static Codec = codec_codec.Class(PrivilegedServices, {
-        manager: codec_codec.u32.asOpaque(),
-        assigners: codecPerCore(codec_codec.u32.asOpaque()),
-        delegator: codec_codec.u32.asOpaque(),
+    static Codec = Class(PrivilegedServices, {
+        manager: u32.asOpaque(),
+        assigners: codecPerCore(u32.asOpaque()),
+        delegator: u32.asOpaque(),
         registrar: Compatibility.isGreaterOrEqual(GpVersion.V0_7_1)
-            ? codec_codec.u32.asOpaque()
+            ? u32.asOpaque()
             : ignoreValueWithDefault(tryAsServiceId(2 ** 32 - 1)),
-        autoAccumulateServices: codec_codec.dictionary(codec_codec.u32.asOpaque(), codec_codec.u64.asOpaque(), {
+        autoAccumulateServices: dictionary(u32.asOpaque(), u64.asOpaque(), {
             sortKeys: (a, b) => a - b,
         }),
     });
@@ -13826,15 +13759,15 @@ class InMemoryState extends WithDebug {
         });
     }
 }
-const serviceEntriesCodec = codec_codec.object({
-    storageKeys: codec_codec.sequenceVarLen(codec_codec.blob.convert((i) => i, (o) => opaque_asOpaqueType(o))),
-    preimages: codec_codec.sequenceVarLen(codec_codec.bytes(hash_HASH_SIZE).asOpaque()),
-    lookupHistory: codec_codec.sequenceVarLen(codec_codec.object({
-        hash: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        length: codec_codec.u32,
+const serviceEntriesCodec = object({
+    storageKeys: sequenceVarLen(blob.convert((i) => i, (o) => opaque_asOpaqueType(o))),
+    preimages: sequenceVarLen(bytes(hash_HASH_SIZE).asOpaque()),
+    lookupHistory: sequenceVarLen(object({
+        hash: bytes(hash_HASH_SIZE).asOpaque(),
+        length: u32,
     })),
 });
-const serviceDataCodec = codec_codec.dictionary(codec_codec.u32.asOpaque(), serviceEntriesCodec, {
+const serviceDataCodec = dictionary(u32.asOpaque(), serviceEntriesCodec, {
     sortKeys: (a, b) => a - b,
 });
 
@@ -14552,7 +14485,7 @@ var serialize_serialize;
     /** C(6): https://graypaper.fluffylabs.dev/#/7e6ff6a/3bf3013bf301?v=0.6.7 */
     serialize.entropy = {
         key: stateKeys.index(StateKeyIdx.Eta),
-        Codec: codecFixedSizeArray(codec_codec.bytes(hash_HASH_SIZE).asOpaque(), ENTROPY_ENTRIES),
+        Codec: codecFixedSizeArray(bytes(hash_HASH_SIZE).asOpaque(), ENTROPY_ENTRIES),
         extract: (s) => s.entropy,
     };
     /** C(7): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b00023b0002?v=0.6.7 */
@@ -14582,7 +14515,7 @@ var serialize_serialize;
     /** C(11): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b3e023b3e02?v=0.6.7 */
     serialize.timeslot = {
         key: stateKeys.index(StateKeyIdx.Tau),
-        Codec: codec_codec.u32.asOpaque(),
+        Codec: u32.asOpaque(),
         extract: (s) => s.timeslot,
     };
     /** C(12): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b4c023b4c02?v=0.6.7 */
@@ -14612,7 +14545,7 @@ var serialize_serialize;
     /** C(16): https://graypaper.fluffylabs.dev/#/38c4e62/3b46033b4603?v=0.7.0 */
     serialize.accumulationOutputLog = {
         key: stateKeys.index(StateKeyIdx.Theta),
-        Codec: codec_codec.sequenceVarLen(AccumulationOutput.Codec).convert((i) => i.array, (o) => SortedArray.fromSortedArray(accumulationOutputComparator, o)),
+        Codec: sequenceVarLen(AccumulationOutput.Codec).convert((i) => i.array, (o) => SortedArray.fromSortedArray(accumulationOutputComparator, o)),
         extract: (s) => s.accumulationOutputLog,
     };
     /** C(255, s): https://graypaper.fluffylabs.dev/#/85129da/383103383103?v=0.6.3 */
@@ -14635,7 +14568,7 @@ var serialize_serialize;
     /** https://graypaper.fluffylabs.dev/#/85129da/387603387603?v=0.6.3 */
     serialize.serviceLookupHistory = (blake2b, serviceId, hash, len) => ({
         key: stateKeys.serviceLookupHistory(blake2b, serviceId, hash, len),
-        Codec: codec_codec.readonlyArray(codec_codec.sequenceVarLen(codec_codec.u32)),
+        Codec: readonlyArray(sequenceVarLen(u32)),
     });
 })(serialize_serialize || (serialize_serialize = {}));
 /**
@@ -15762,7 +15695,7 @@ function getSafroleData(nextValidatorData, epochRoot, sealingKeySeries, ticketsA
 
 const TYPICAL_STATE_ITEMS = 50;
 const TYPICAL_STATE_ITEM_LEN = 50;
-const stateEntriesSequenceCodec = codec_codec.sequenceVarLen(codec_codec.pair(codec_codec.bytes(TRUNCATED_HASH_SIZE), codec_codec.blob));
+const stateEntriesSequenceCodec = sequenceVarLen(pair(bytes(TRUNCATED_HASH_SIZE), blob));
 /**
  * Full, in-memory state represented as serialized entries dictionary.
  *
@@ -15770,7 +15703,7 @@ const stateEntriesSequenceCodec = codec_codec.sequenceVarLen(codec_codec.pair(co
  */
 class state_entries_StateEntries {
     dictionary;
-    static Codec = codec_codec.custom({
+    static Codec = custom({
         name: "StateEntries",
         sizeHint: {
             isExact: false,
@@ -15962,7 +15895,7 @@ function loadState(spec, blake2b, entries) {
 
 
 /** Codec for a map with string keys. */
-const codecMap = (value, extractKey, { typicalLength = codec_codec.TYPICAL_DICTIONARY_LENGTH, compare = (a, b) => {
+const codecMap = (value, extractKey, { typicalLength = TYPICAL_DICTIONARY_LENGTH, compare = (a, b) => {
     const keyA = extractKey(a);
     const keyB = extractKey(b);
     if (keyA < keyB) {
@@ -16005,19 +15938,17 @@ const codecMap = (value, extractKey, { typicalLength = codec_codec.TYPICAL_DICTI
         s.sequenceFixLen(value, len);
     });
 };
-const lookupHistoryItemCodec = codec_codec.object({
-    hash: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
-    length: codec_codec.u32,
-    slots: codec_codec
-        .readonlyArray(codec_codec.sequenceVarLen(codec_codec.u32.asOpaque()))
+const lookupHistoryItemCodec = object({
+    hash: bytes(hash_HASH_SIZE).asOpaque(),
+    length: u32,
+    slots: readonlyArray(sequenceVarLen(u32.asOpaque()))
         .convert(seeThrough, service_tryAsLookupHistorySlots),
 }, "LookupHistoryItem", ({ hash, length, slots }) => new LookupHistoryItem(hash, length, slots));
-const lookupHistoryEntryCodec = codec_codec.object({
-    key: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
-    data: codec_codec.sequenceVarLen(lookupHistoryItemCodec),
+const lookupHistoryEntryCodec = object({
+    key: bytes(hash_HASH_SIZE).asOpaque(),
+    data: sequenceVarLen(lookupHistoryItemCodec),
 });
-const lookupHistoryCodec = codec_codec
-    .sequenceVarLen(lookupHistoryEntryCodec)
+const lookupHistoryCodec = sequenceVarLen(lookupHistoryEntryCodec)
     .convert((dict) => {
     const entries = [];
     for (const [key, data] of dict) {
@@ -16037,9 +15968,9 @@ const lookupHistoryCodec = codec_codec
     return dict;
 });
 class ServiceWithCodec extends InMemoryService {
-    static Codec = codec_codec.Class(ServiceWithCodec, {
-        serviceId: codec_codec.u32.asOpaque(),
-        data: codec_codec.object({
+    static Codec = Class(ServiceWithCodec, {
+        serviceId: u32.asOpaque(),
+        data: object({
             info: ServiceAccountInfo.Codec,
             preimages: codecHashDictionary(PreimageItem.Codec, (x) => x.hash),
             lookupHistory: lookupHistoryCodec,
@@ -16053,7 +15984,7 @@ class ServiceWithCodec extends InMemoryService {
         return new ServiceWithCodec(serviceId, data);
     }
 }
-const inMemoryStateCodec = (spec) => codec_codec.Class(class State extends InMemoryState {
+const inMemoryStateCodec = (spec) => Class(class State extends InMemoryState {
     static create(data) {
         return InMemoryState.new(spec, data);
     }
@@ -16067,12 +15998,11 @@ const inMemoryStateCodec = (spec) => codec_codec.Class(class State extends InMem
     // gamma_k
     nextValidatorData: codecPerValidator(ValidatorData.Codec),
     // gamma_z
-    epochRoot: codec_codec.bytes(BANDERSNATCH_RING_ROOT_BYTES).asOpaque(),
+    epochRoot: bytes(BANDERSNATCH_RING_ROOT_BYTES).asOpaque(),
     // gamma_s
     sealingKeySeries: SafroleSealingKeysData.Codec,
     // gamma_a
-    ticketsAccumulator: codec_codec
-        .readonlyArray(codec_codec.sequenceVarLen(Ticket.Codec))
+    ticketsAccumulator: readonlyArray(sequenceVarLen(Ticket.Codec))
         .convert((x) => x, sized_array_asKnownSize),
     // psi
     disputesRecords: serialize_serialize.disputesRecords.Codec,
@@ -16099,7 +16029,7 @@ const inMemoryStateCodec = (spec) => codec_codec.Class(class State extends InMem
     // theta
     accumulationOutputLog: serialize_serialize.accumulationOutputLog.Codec,
     // delta
-    services: codec_codec.dictionary(codec_codec.u32.asOpaque(), ServiceWithCodec.Codec, {
+    services: dictionary(u32.asOpaque(), ServiceWithCodec.Codec, {
         sortKeys: (a, b) => a - b,
     }),
 });
@@ -16124,11 +16054,11 @@ class TestState {
         state_root: fromJson.bytes32(),
         keyvals: json.array(StateKeyVal.fromJson),
     };
-    static Codec = codec_codec.object({
-        state_root: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        keyvals: codec_codec.sequenceVarLen(codec_codec.object({
-            key: codec_codec.bytes(TRUNCATED_HASH_SIZE),
-            value: codec_codec.blob,
+    static Codec = object({
+        state_root: bytes(hash_HASH_SIZE).asOpaque(),
+        keyvals: sequenceVarLen(object({
+            key: bytes(TRUNCATED_HASH_SIZE),
+            value: blob,
         })),
     });
     state_root;
@@ -16139,7 +16069,7 @@ class StateTransitionGenesis {
         header: headerFromJson,
         state: TestState.fromJson,
     };
-    static Codec = codec_codec.object({
+    static Codec = object({
         header: header_Header.Codec,
         state: TestState.Codec,
     });
@@ -16152,7 +16082,7 @@ class StateTransition {
         post_state: TestState.fromJson,
         block: blockFromJson(chain_spec_tinyChainSpec),
     };
-    static Codec = codec_codec.object({
+    static Codec = object({
         pre_state: TestState.Codec,
         block: Block.Codec,
         post_state: TestState.Codec,
@@ -20229,7 +20159,7 @@ const SUPPORTED_TYPES = [
                 if (option === "as-hash") {
                     return looseType({
                         value: blake2b.hashBytes(encoder_Encoder.encodeObject(header_Header.Codec, header, spec)),
-                        encode: codec_codec.bytes(hash_HASH_SIZE),
+                        encode: bytes(hash_HASH_SIZE),
                     });
                 }
                 throw new Error(`Invalid processing option: ${option}`);
@@ -20283,7 +20213,7 @@ const SUPPORTED_TYPES = [
                 if (option === "as-root-hash") {
                     return looseType({
                         value: state_entries_StateEntries.serializeInMemory(spec, blake2b, state).getRootHash(blake2b),
-                        encode: codec_codec.bytes(hash_HASH_SIZE),
+                        encode: bytes(hash_HASH_SIZE),
                     });
                 }
                 throw new Error(`Invalid processing option: ${option}`);