@typeberry/lib 0.5.1-1dda9d6 → 0.5.1

package/{index.mjs → index.js}

@@ -2379,48 +2379,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(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 select = ({ name, sizeHint, }, chooser) => {
     const Self = chooser(null);
@@ -2596,59 +2554,24 @@ var descriptors = /*#__PURE__*/Object.freeze({
   u32: u32,
   u64: u64,
   u8: u8,
-  union: union,
   varU32: varU32,
   varU64: varU64
 });
 
-const codec = descriptors;
-
 var index$x = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  Class: Class,
   Decoder: Decoder,
   Descriptor: Descriptor,
   Encoder: Encoder,
   EndOfDataError: EndOfDataError,
   ObjectView: ObjectView,
   SequenceView: SequenceView,
-  TYPICAL_DICTIONARY_LENGTH: TYPICAL_DICTIONARY_LENGTH,
   ViewField: ViewField,
   addSizeHints: addSizeHints,
-  bitVecFixLen: bitVecFixLen,
-  bitVecVarLen: bitVecVarLen,
-  blob: blob,
-  bool: bool,
-  bytes: bytes,
-  codec: codec,
-  custom: custom,
+  codec: descriptors,
   decodeVariableLengthExtraBytes: decodeVariableLengthExtraBytes,
-  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: select,
-  sequenceFixLen: sequenceFixLen,
-  sequenceVarLen: sequenceVarLen,
-  string: string,
   tryAsExactBytes: tryAsExactBytes,
-  u16: u16,
-  u24: u24,
-  u32: u32,
-  u64: u64,
-  u8: u8,
-  union: union,
-  validateLength: validateLength,
-  varU32: varU32,
-  varU64: varU64
+  validateLength: validateLength
 });
 
 //#region rolldown:runtime
@@ -5859,7 +5782,7 @@ function codecWithContext(chooser) {
     const defaultContext = fullChainSpec;
     const { name, sizeHint } = chooser(defaultContext);
     const cache = new Map();
-    return codec.select({
+    return select({
         name,
         sizeHint: { bytes: sizeHint.bytes, isExact: false },
     }, (context) => {
@@ -5886,9 +5809,9 @@ function codecWithContext(chooser) {
 /** Codec for a known-size array with length validation. */
 const codecKnownSizeArray = (val, options, _id) => {
     if ("fixedLength" in options) {
-        return codec.readonlyArray(codec.sequenceFixLen(val, options.fixedLength)).convert(seeThrough, asKnownSize);
+        return readonlyArray(sequenceFixLen(val, options.fixedLength)).convert(seeThrough, asKnownSize);
     }
-    return codec.readonlyArray(codec.sequenceVarLen(val, options)).convert(seeThrough, asKnownSize);
+    return readonlyArray(sequenceVarLen(val, options)).convert(seeThrough, asKnownSize);
 };
 /** Codec for a fixed-size array with length validation. */
 const codecFixedSizeArray = (val, len) => {
@@ -5897,7 +5820,7 @@ const codecFixedSizeArray = (val, len) => {
             throw new Error(`[${val.name}] Invalid size of fixed-size array. Got ${actual}, expected: ${len}`);
         }
     };
-    return codec.sequenceFixLen(val, len).convert((i) => {
+    return sequenceFixLen(val, len).convert((i) => {
         checkLength(i.length);
         return i;
     }, (o) => {
@@ -5906,7 +5829,7 @@ const codecFixedSizeArray = (val, len) => {
     });
 };
 /** Codec for a hash-dictionary. */
-const codecHashDictionary = (value, extractKey, { typicalLength = 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,
@@ -5960,13 +5883,13 @@ class AvailabilityAssurance extends WithDebug {
     bitfield;
     validatorIndex;
     signature;
-    static Codec = codec.Class(AvailabilityAssurance, {
-        anchor: codec.bytes(HASH_SIZE).asOpaque(),
+    static Codec = Class(AvailabilityAssurance, {
+        anchor: bytes(HASH_SIZE).asOpaque(),
         bitfield: codecWithContext((context) => {
-            return codec.bitVecFixLen(context.coresCount);
+            return bitVecFixLen(context.coresCount);
         }),
-        validatorIndex: codec.u16.asOpaque(),
-        signature: 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);
@@ -6051,11 +5974,11 @@ class Fault extends WithDebug {
     wasConsideredValid;
     key;
     signature;
-    static Codec = codec.Class(Fault, {
-        workReportHash: codec.bytes(HASH_SIZE).asOpaque(),
-        wasConsideredValid: codec.bool,
-        key: codec.bytes(ED25519_KEY_BYTES).asOpaque(),
-        signature: codec.bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
+    static Codec = Class(Fault, {
+        workReportHash: bytes(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);
@@ -6083,10 +6006,10 @@ class Culprit extends WithDebug {
     workReportHash;
     key;
     signature;
-    static Codec = codec.Class(Culprit, {
-        workReportHash: codec.bytes(HASH_SIZE).asOpaque(),
-        key: codec.bytes(ED25519_KEY_BYTES).asOpaque(),
-        signature: codec.bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
+    static Codec = Class(Culprit, {
+        workReportHash: bytes(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);
@@ -6111,10 +6034,10 @@ class Judgement extends WithDebug {
     isWorkReportValid;
     index;
     signature;
-    static Codec = codec.Class(Judgement, {
-        isWorkReportValid: codec.bool,
-        index: codec.u16.asOpaque(),
-        signature: 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);
@@ -6143,12 +6066,11 @@ class Verdict extends WithDebug {
     workReportHash;
     votesEpoch;
     votes;
-    static Codec = codec.Class(Verdict, {
-        workReportHash: codec.bytes(HASH_SIZE).asOpaque(),
-        votesEpoch: codec.u32.asOpaque(),
+    static Codec = Class(Verdict, {
+        workReportHash: bytes(HASH_SIZE).asOpaque(),
+        votesEpoch: u32.asOpaque(),
         votes: codecWithContext((context) => {
-            return codec
-                .readonlyArray(codec.sequenceFixLen(Judgement.Codec, context.validatorsSuperMajority))
+            return readonlyArray(sequenceFixLen(Judgement.Codec, context.validatorsSuperMajority))
                 .convert(seeThrough, asKnownSize);
         }),
     });
@@ -6190,10 +6112,10 @@ class DisputesExtrinsic extends WithDebug {
     verdicts;
     culprits;
     faults;
-    static Codec = codec.Class(DisputesExtrinsic, {
-        verdicts: codec.sequenceVarLen(Verdict.Codec),
-        culprits: codec.sequenceVarLen(Culprit.Codec),
-        faults: 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);
@@ -6244,9 +6166,9 @@ var disputes = /*#__PURE__*/Object.freeze({
 class WorkPackageInfo extends WithDebug {
     workPackageHash;
     segmentTreeRoot;
-    static Codec = codec.Class(WorkPackageInfo, {
-        workPackageHash: codec.bytes(HASH_SIZE).asOpaque(),
-        segmentTreeRoot: codec.bytes(HASH_SIZE).asOpaque(),
+    static Codec = Class(WorkPackageInfo, {
+        workPackageHash: bytes(HASH_SIZE).asOpaque(),
+        segmentTreeRoot: bytes(HASH_SIZE).asOpaque(),
     });
     constructor(
     /** Hash of the described work package. */
@@ -6274,13 +6196,13 @@ class RefineContext extends WithDebug {
     lookupAnchor;
     lookupAnchorSlot;
     prerequisites;
-    static Codec = codec.Class(RefineContext, {
-        anchor: codec.bytes(HASH_SIZE).asOpaque(),
-        stateRoot: codec.bytes(HASH_SIZE).asOpaque(),
-        beefyRoot: codec.bytes(HASH_SIZE).asOpaque(),
-        lookupAnchor: codec.bytes(HASH_SIZE).asOpaque(),
-        lookupAnchorSlot: codec.u32.asOpaque(),
-        prerequisites: codec.sequenceVarLen(codec.bytes(HASH_SIZE).asOpaque()),
+    static Codec = Class(RefineContext, {
+        anchor: bytes(HASH_SIZE).asOpaque(),
+        stateRoot: bytes(HASH_SIZE).asOpaque(),
+        beefyRoot: bytes(HASH_SIZE).asOpaque(),
+        lookupAnchor: bytes(HASH_SIZE).asOpaque(),
+        lookupAnchorSlot: u32.asOpaque(),
+        prerequisites: sequenceVarLen(bytes(HASH_SIZE).asOpaque()),
     });
     static create({ anchor, stateRoot, beefyRoot, lookupAnchor, lookupAnchorSlot, prerequisites, }) {
         return new RefineContext(anchor, stateRoot, beefyRoot, lookupAnchor, lookupAnchorSlot, prerequisites);
@@ -6332,9 +6254,9 @@ const tryAsSegmentIndex = (v) => asOpaqueType(tryAsU16(v));
 class ImportSpec extends WithDebug {
     treeRoot;
     index;
-    static Codec = codec.Class(ImportSpec, {
-        treeRoot: codec.bytes(HASH_SIZE),
-        index: codec.u16.asOpaque(),
+    static Codec = Class(ImportSpec, {
+        treeRoot: bytes(HASH_SIZE),
+        index: u16.asOpaque(),
     });
     static create({ treeRoot, index }) {
         return new ImportSpec(treeRoot, index);
@@ -6356,9 +6278,9 @@ class ImportSpec extends WithDebug {
 class WorkItemExtrinsicSpec extends WithDebug {
     hash;
     len;
-    static Codec = codec.Class(WorkItemExtrinsicSpec, {
-        hash: codec.bytes(HASH_SIZE).asOpaque(),
-        len: codec.u32,
+    static Codec = Class(WorkItemExtrinsicSpec, {
+        hash: bytes(HASH_SIZE).asOpaque(),
+        len: u32,
     });
     static create({ hash, len }) {
         return new WorkItemExtrinsicSpec(hash, len);
@@ -6388,7 +6310,7 @@ function workItemExtrinsicsCodec(workItems) {
     if (sum.overflow) {
         throw new Error("Unable to create a decoder, because the length of extrinsics overflows!");
     }
-    return codec.custom({
+    return custom({
         name: "WorkItemExtrinsics",
         sizeHint: { bytes: sum.value, isExact: true },
     }, (e, val) => {
@@ -6418,19 +6340,19 @@ class WorkItem extends WithDebug {
     importSegments;
     extrinsic;
     exportCount;
-    static Codec = codec.Class(WorkItem, {
-        service: codec.u32.asOpaque(),
-        codeHash: codec.bytes(HASH_SIZE).asOpaque(),
-        refineGasLimit: codec.u64.asOpaque(),
-        accumulateGasLimit: codec.u64.asOpaque(),
-        exportCount: codec.u16,
-        payload: codec.blob,
+    static Codec = Class(WorkItem, {
+        service: u32.asOpaque(),
+        codeHash: bytes(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.sequenceVarLen(WorkItemExtrinsicSpec.Codec),
+        extrinsic: sequenceVarLen(WorkItemExtrinsicSpec.Codec),
     });
     static create({ service, codeHash, payload, refineGasLimit, accumulateGasLimit, importSegments, extrinsic, exportCount, }) {
         return new WorkItem(service, codeHash, payload, refineGasLimit, accumulateGasLimit, importSegments, extrinsic, exportCount);
@@ -6503,13 +6425,13 @@ class WorkPackage extends WithDebug {
     parametrization;
     context;
     items;
-    static Codec = codec.Class(WorkPackage, {
-        authCodeHost: codec.u32.asOpaque(),
-        authCodeHash: codec.bytes(HASH_SIZE).asOpaque(),
+    static Codec = Class(WorkPackage, {
+        authCodeHost: u32.asOpaque(),
+        authCodeHash: bytes(HASH_SIZE).asOpaque(),
         context: RefineContext.Codec,
-        authorization: codec.blob,
-        parametrization: codec.blob,
-        items: codec.sequenceVarLen(WorkItem.Codec).convert((x) => x, (items) => FixedSizeArray.new(items, tryAsWorkItemsCount(items.length))),
+        authorization: blob,
+        parametrization: blob,
+        items: sequenceVarLen(WorkItem.Codec).convert((x) => x, (items) => FixedSizeArray.new(items, tryAsWorkItemsCount(items.length))),
     });
     static create({ authorization, authCodeHost, authCodeHash, parametrization, context, items, }) {
         return new WorkPackage(authorization, authCodeHost, authCodeHash, parametrization, context, items);
@@ -6572,22 +6494,30 @@ var WorkExecResultKind;
 class WorkExecResult extends WithDebug {
     kind;
     okBlob;
-    static Codec = codec
-        .union("WorkExecResult", {
-        [WorkExecResultKind.ok]: codec.object({ okBlob: codec.blob }),
-        [WorkExecResultKind.outOfGas]: codec.object({}),
-        [WorkExecResultKind.panic]: codec.object({}),
-        [WorkExecResultKind.incorrectNumberOfExports]: codec.object({}),
-        [WorkExecResultKind.digestTooBig]: codec.object({}),
-        [WorkExecResultKind.badCode]: codec.object({}),
-        [WorkExecResultKind.codeOversize]: codec.object({}),
-    })
-        .convert((x) => {
-        if (x.kind === WorkExecResultKind.ok) {
-            return { kind: WorkExecResultKind.ok, okBlob: x.okBlob ?? 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(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, 
@@ -6611,12 +6541,12 @@ class WorkRefineLoad extends WithDebug {
     extrinsicCount;
     extrinsicSize;
     exportedSegments;
-    static Codec = codec.Class(WorkRefineLoad, {
-        gasUsed: codec.varU64.asOpaque(),
-        importedSegments: codec.varU32,
-        extrinsicCount: codec.varU32,
-        extrinsicSize: codec.varU32,
-        exportedSegments: 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);
@@ -6652,11 +6582,11 @@ class WorkResult {
     gas;
     result;
     load;
-    static Codec = codec.Class(WorkResult, {
-        serviceId: codec.u32.asOpaque(),
-        codeHash: codec.bytes(HASH_SIZE).asOpaque(),
-        payloadHash: codec.bytes(HASH_SIZE),
-        gas: codec.u64.asOpaque(),
+    static Codec = Class(WorkResult, {
+        serviceId: u32.asOpaque(),
+        codeHash: bytes(HASH_SIZE).asOpaque(),
+        payloadHash: bytes(HASH_SIZE),
+        gas: u64.asOpaque(),
         result: WorkExecResult.Codec,
         load: WorkRefineLoad.Codec,
     });
@@ -6721,12 +6651,12 @@ class WorkPackageSpec extends WithDebug {
     erasureRoot;
     exportsRoot;
     exportsCount;
-    static Codec = codec.Class(WorkPackageSpec, {
-        hash: codec.bytes(HASH_SIZE).asOpaque(),
-        length: codec.u32,
-        erasureRoot: codec.bytes(HASH_SIZE),
-        exportsRoot: codec.bytes(HASH_SIZE).asOpaque(),
-        exportsCount: codec.u16,
+    static Codec = Class(WorkPackageSpec, {
+        hash: bytes(HASH_SIZE).asOpaque(),
+        length: u32,
+        erasureRoot: bytes(HASH_SIZE),
+        exportsRoot: bytes(HASH_SIZE).asOpaque(),
+        exportsCount: u16,
     });
     static create({ hash, length, erasureRoot, exportsRoot, exportsCount }) {
         return new WorkPackageSpec(hash, length, erasureRoot, exportsRoot, exportsCount);
@@ -6764,20 +6694,20 @@ class WorkReport extends WithDebug {
     segmentRootLookup;
     results;
     authorizationGasUsed;
-    static Codec = codec.Class(WorkReport, {
+    static Codec = Class(WorkReport, {
         workPackageSpec: WorkPackageSpec.Codec,
         context: RefineContext.Codec,
-        coreIndex: codec.varU32.convert((o) => tryAsU32(o), (i) => {
+        coreIndex: varU32.convert((o) => tryAsU32(o), (i) => {
             if (!isU16(i)) {
                 throw new Error(`Core index exceeds U16: ${i}`);
             }
             return tryAsCoreIndex(i);
         }),
-        authorizerHash: codec.bytes(HASH_SIZE).asOpaque(),
-        authorizationGasUsed: codec.varU64.asOpaque(),
-        authorizationOutput: codec.blob,
-        segmentRootLookup: codec.readonlyArray(codec.sequenceVarLen(WorkPackageInfo.Codec)),
-        results: codec.sequenceVarLen(WorkResult.Codec).convert((x) => x, (items) => FixedSizeArray.new(items, tryAsWorkItemsCount(items.length))),
+        authorizerHash: bytes(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);
@@ -6825,9 +6755,9 @@ const REQUIRED_CREDENTIALS_RANGE = [2, 3];
 class Credential extends WithDebug {
     validatorIndex;
     signature;
-    static Codec = codec.Class(Credential, {
-        validatorIndex: codec.u16.asOpaque(),
-        signature: 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);
@@ -6851,9 +6781,9 @@ class ReportGuarantee extends WithDebug {
     report;
     slot;
     credentials;
-    static Codec = codec.Class(ReportGuarantee, {
+    static Codec = Class(ReportGuarantee, {
         report: WorkReport.Codec,
-        slot: codec.u32.asOpaque(),
+        slot: u32.asOpaque(),
         credentials: codecKnownSizeArray(Credential.Codec, {
             minLength: REQUIRED_CREDENTIALS_RANGE[0],
             maxLength: REQUIRED_CREDENTIALS_RANGE[1],
@@ -6905,10 +6835,10 @@ function tryAsTicketAttempt(x) {
 class SignedTicket extends WithDebug {
     attempt;
     signature;
-    static Codec = codec.Class(SignedTicket, {
+    static Codec = Class(SignedTicket, {
         // TODO [ToDr] we should verify that attempt is either 0|1|2.
-        attempt: codec.u8.asOpaque(),
-        signature: codec.bytes(BANDERSNATCH_PROOF_BYTES).asOpaque(),
+        attempt: u8.asOpaque(),
+        signature: bytes(BANDERSNATCH_PROOF_BYTES).asOpaque(),
     });
     static create({ attempt, signature }) {
         return new SignedTicket(attempt, signature);
@@ -6927,10 +6857,10 @@ class SignedTicket extends WithDebug {
 class Ticket extends WithDebug {
     id;
     attempt;
-    static Codec = codec.Class(Ticket, {
-        id: codec.bytes(HASH_SIZE),
+    static Codec = Class(Ticket, {
+        id: bytes(HASH_SIZE),
         // TODO [ToDr] we should verify that attempt is either 0|1|2.
-        attempt: codec.u8.asOpaque(),
+        attempt: u8.asOpaque(),
     });
     static create({ id, attempt }) {
         return new Ticket(id, attempt);
@@ -6972,9 +6902,9 @@ var tickets = /*#__PURE__*/Object.freeze({
 class ValidatorKeys extends WithDebug {
     bandersnatch;
     ed25519;
-    static Codec = codec.Class(ValidatorKeys, {
-        bandersnatch: codec.bytes(BANDERSNATCH_KEY_BYTES).asOpaque(),
-        ed25519: 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);
@@ -6991,7 +6921,7 @@ class ValidatorKeys extends WithDebug {
 }
 class TicketsMarker extends WithDebug {
     tickets;
-    static Codec = codec.Class(TicketsMarker, {
+    static Codec = Class(TicketsMarker, {
         tickets: codecPerEpochBlock(Ticket.Codec),
     });
     static create({ tickets }) {
@@ -7013,9 +6943,9 @@ class EpochMarker extends WithDebug {
     entropy;
     ticketsEntropy;
     validators;
-    static Codec = codec.Class(EpochMarker, {
-        entropy: codec.bytes(HASH_SIZE).asOpaque(),
-        ticketsEntropy: codec.bytes(HASH_SIZE).asOpaque(),
+    static Codec = Class(EpochMarker, {
+        entropy: bytes(HASH_SIZE).asOpaque(),
+        ticketsEntropy: bytes(HASH_SIZE).asOpaque(),
         validators: codecPerValidator(ValidatorKeys.Codec),
     });
     static create({ entropy, ticketsEntropy, validators }) {
@@ -7052,17 +6982,17 @@ const encodeUnsealedHeader = (view) => {
  * https://graypaper.fluffylabs.dev/#/ab2cdbd/0c66000c7200?v=0.7.2
  */
 class Header extends WithDebug {
-    static Codec = codec.Class(Header, {
-        parentHeaderHash: codec.bytes(HASH_SIZE).asOpaque(),
-        priorStateRoot: codec.bytes(HASH_SIZE).asOpaque(),
-        extrinsicHash: codec.bytes(HASH_SIZE).asOpaque(),
-        timeSlotIndex: codec.u32.asOpaque(),
-        epochMarker: codec.optional(EpochMarker.Codec),
-        ticketsMarker: codec.optional(TicketsMarker.Codec),
-        bandersnatchBlockAuthorIndex: codec.u16.asOpaque(),
-        entropySource: codec.bytes(BANDERSNATCH_VRF_SIGNATURE_BYTES).asOpaque(),
-        offendersMarker: codec.sequenceVarLen(codec.bytes(ED25519_KEY_BYTES).asOpaque()),
-        seal: codec.bytes(BANDERSNATCH_VRF_SIGNATURE_BYTES).asOpaque(),
+    static Codec = Class(Header, {
+        parentHeaderHash: bytes(HASH_SIZE).asOpaque(),
+        priorStateRoot: bytes(HASH_SIZE).asOpaque(),
+        extrinsicHash: bytes(HASH_SIZE).asOpaque(),
+        timeSlotIndex: u32.asOpaque(),
+        epochMarker: optional(EpochMarker.Codec),
+        ticketsMarker: optional(TicketsMarker.Codec),
+        bandersnatchBlockAuthorIndex: u16.asOpaque(),
+        entropySource: bytes(BANDERSNATCH_VRF_SIGNATURE_BYTES).asOpaque(),
+        offendersMarker: sequenceVarLen(bytes(ED25519_KEY_BYTES).asOpaque()),
+        seal: bytes(BANDERSNATCH_VRF_SIGNATURE_BYTES).asOpaque(),
     });
     static create(h) {
         return Object.assign(Header.empty(), h);
@@ -7117,8 +7047,8 @@ class Header extends WithDebug {
  * `DescriptorRecord` or `CodecRecord` for some reason.
  */
 class HeaderViewWithHash extends WithHash {
-    static Codec = codec.Class(HeaderViewWithHash, {
-        hash: codec.bytes(HASH_SIZE).asOpaque(),
+    static Codec = Class(HeaderViewWithHash, {
+        hash: bytes(HASH_SIZE).asOpaque(),
         data: Header.Codec.View,
     });
     static create({ hash, data }) {
@@ -7136,9 +7066,9 @@ const headerViewWithHashCodec = HeaderViewWithHash.Codec;
 class Preimage extends WithDebug {
     requester;
     blob;
-    static Codec = codec.Class(Preimage, {
-        requester: codec.u32.asOpaque(),
-        blob: codec.blob,
+    static Codec = Class(Preimage, {
+        requester: u32.asOpaque(),
+        blob: blob,
     });
     static create({ requester, blob }) {
         return new Preimage(requester, blob);
@@ -7153,7 +7083,7 @@ class Preimage extends WithDebug {
         this.blob = blob;
     }
 }
-const preimagesExtrinsicCodec = codec.sequenceVarLen(Preimage.Codec);
+const preimagesExtrinsicCodec = sequenceVarLen(Preimage.Codec);
 
 var preimage = /*#__PURE__*/Object.freeze({
   __proto__: null,
@@ -7174,7 +7104,7 @@ class Extrinsic extends WithDebug {
     guarantees;
     assurances;
     disputes;
-    static Codec = codec.Class(Extrinsic, {
+    static Codec = Class(Extrinsic, {
         tickets: ticketsExtrinsicCodec,
         preimages: preimagesExtrinsicCodec,
         guarantees: guaranteesExtrinsicCodec,
@@ -7227,7 +7157,7 @@ class Extrinsic extends WithDebug {
 class Block extends WithDebug {
     header;
     extrinsic;
-    static Codec = codec.Class(Block, {
+    static Codec = Class(Block, {
         header: Header.Codec,
         extrinsic: Extrinsic.Codec,
     });
@@ -8725,9 +8655,9 @@ function legacyServiceNested(serviceId, hash) {
 class AccumulationOutput {
     serviceId;
     output;
-    static Codec = codec.Class(AccumulationOutput, {
-        serviceId: codec.u32.asOpaque(),
-        output: codec.bytes(HASH_SIZE),
+    static Codec = Class(AccumulationOutput, {
+        serviceId: u32.asOpaque(),
+        output: bytes(HASH_SIZE),
     });
     static create(a) {
         return new AccumulationOutput(a.serviceId, a.output);
@@ -8803,9 +8733,9 @@ const MAX_REPORT_DEPENDENCIES = 8;
 class NotYetAccumulatedReport extends WithDebug {
     report;
     dependencies;
-    static Codec = codec.Class(NotYetAccumulatedReport, {
+    static Codec = Class(NotYetAccumulatedReport, {
         report: WorkReport.Codec,
-        dependencies: codecKnownSizeArray(codec.bytes(HASH_SIZE).asOpaque(), {
+        dependencies: codecKnownSizeArray(bytes(HASH_SIZE).asOpaque(), {
             typicalLength: MAX_REPORT_DEPENDENCIES / 2,
             maxLength: MAX_REPORT_DEPENDENCIES,
             minLength: 0,
@@ -8832,7 +8762,7 @@ class NotYetAccumulatedReport extends WithDebug {
         this.dependencies = dependencies;
     }
 }
-const accumulationQueueCodec = codecPerEpochBlock(codec.readonlyArray(codec.sequenceVarLen(NotYetAccumulatedReport.Codec)));
+const accumulationQueueCodec = codecPerEpochBlock(readonlyArray(sequenceVarLen(NotYetAccumulatedReport.Codec)));
 
 /** Check if given array has correct length before casting to the opaque type. */
 function tryAsPerCore(array, spec) {
@@ -8857,9 +8787,9 @@ const codecPerCore = (val) => codecWithContext((context) => {
 class AvailabilityAssignment extends WithDebug {
     workReport;
     timeout;
-    static Codec = codec.Class(AvailabilityAssignment, {
+    static Codec = Class(AvailabilityAssignment, {
         workReport: WorkReport.Codec,
-        timeout: codec.u32.asOpaque(),
+        timeout: u32.asOpaque(),
     });
     static create({ workReport, timeout }) {
         return new AvailabilityAssignment(workReport, timeout);
@@ -8874,20 +8804,20 @@ class AvailabilityAssignment extends WithDebug {
         this.timeout = timeout;
     }
 }
-const availabilityAssignmentsCodec = codecPerCore(codec.optional(AvailabilityAssignment.Codec));
+const availabilityAssignmentsCodec = codecPerCore(optional(AvailabilityAssignment.Codec));
 
 /** `O`: Maximal authorization pool size. */
 const MAX_AUTH_POOL_SIZE = O;
 /** `Q`: Size of the authorization queue. */
 const AUTHORIZATION_QUEUE_SIZE = Q;
-const authPoolsCodec = codecPerCore(codecKnownSizeArray(codec.bytes(HASH_SIZE).asOpaque(), {
+const authPoolsCodec = codecPerCore(codecKnownSizeArray(bytes(HASH_SIZE).asOpaque(), {
     minLength: 0,
     maxLength: MAX_AUTH_POOL_SIZE,
     typicalLength: MAX_AUTH_POOL_SIZE,
 }));
-const authQueuesCodec = codecPerCore(codecFixedSizeArray(codec.bytes(HASH_SIZE).asOpaque(), AUTHORIZATION_QUEUE_SIZE));
+const authQueuesCodec = codecPerCore(codecFixedSizeArray(bytes(HASH_SIZE).asOpaque(), AUTHORIZATION_QUEUE_SIZE));
 
-const sortedSetCodec = () => codec.readonlyArray(codec.sequenceVarLen(codec.bytes(HASH_SIZE))).convert((input) => input.array, (output) => {
+const sortedSetCodec = () => readonlyArray(sequenceVarLen(bytes(HASH_SIZE))).convert((input) => input.array, (output) => {
     const typed = output.map((x) => x.asOpaque());
     return SortedSet.fromSortedArray(hashComparator, typed);
 });
@@ -8902,7 +8832,7 @@ class DisputesRecords {
     badSet;
     wonkySet;
     punishSet;
-    static Codec = codec.Class(DisputesRecords, {
+    static Codec = Class(DisputesRecords, {
         goodSet: workReportsSortedSetCodec,
         badSet: workReportsSortedSetCodec,
         wonkySet: workReportsSortedSetCodec,
@@ -8967,10 +8897,10 @@ class BlockState extends WithDebug {
     accumulationResult;
     postStateRoot;
     reported;
-    static Codec = codec.Class(BlockState, {
-        headerHash: codec.bytes(HASH_SIZE).asOpaque(),
-        accumulationResult: codec.bytes(HASH_SIZE),
-        postStateRoot: codec.bytes(HASH_SIZE).asOpaque(),
+    static Codec = Class(BlockState, {
+        headerHash: bytes(HASH_SIZE).asOpaque(),
+        accumulationResult: bytes(HASH_SIZE),
+        postStateRoot: bytes(HASH_SIZE).asOpaque(),
         reported: codecHashDictionary(WorkPackageInfo.Codec, (x) => x.workPackageHash),
     });
     static create({ headerHash, accumulationResult, postStateRoot, reported }) {
@@ -9000,14 +8930,14 @@ class BlockState extends WithDebug {
 class RecentBlocks extends WithDebug {
     blocks;
     accumulationLog;
-    static Codec = codec.Class(RecentBlocks, {
+    static Codec = Class(RecentBlocks, {
         blocks: codecKnownSizeArray(BlockState.Codec, {
             minLength: 0,
             maxLength: MAX_RECENT_HISTORY,
             typicalLength: MAX_RECENT_HISTORY,
         }),
-        accumulationLog: codec.object({
-            peaks: codec.readonlyArray(codec.sequenceVarLen(codec.optional(codec.bytes(HASH_SIZE)))),
+        accumulationLog: object({
+            peaks: readonlyArray(sequenceVarLen(optional(bytes(HASH_SIZE)))),
         }),
     });
     static empty() {
@@ -9035,7 +8965,7 @@ class RecentBlocks extends WithDebug {
     }
 }
 
-const recentlyAccumulatedCodec = codecPerEpochBlock(codec.sequenceVarLen(codec.bytes(HASH_SIZE).asOpaque()).convert((x) => Array.from(x), (x) => HashSet.from(x)));
+const recentlyAccumulatedCodec = codecPerEpochBlock(sequenceVarLen(bytes(HASH_SIZE).asOpaque()).convert((x) => Array.from(x), (x) => HashSet.from(x)));
 
 /**
  * Fixed size of validator metadata.
@@ -9053,11 +8983,11 @@ class ValidatorData extends WithDebug {
     ed25519;
     bls;
     metadata;
-    static Codec = codec.Class(ValidatorData, {
-        bandersnatch: codec.bytes(BANDERSNATCH_KEY_BYTES).asOpaque(),
-        ed25519: codec.bytes(ED25519_KEY_BYTES).asOpaque(),
-        bls: codec.bytes(BLS_KEY_BYTES).asOpaque(),
-        metadata: 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);
@@ -9085,26 +9015,46 @@ var SafroleSealingKeysKind;
     SafroleSealingKeysKind[SafroleSealingKeysKind["Tickets"] = 0] = "Tickets";
     SafroleSealingKeysKind[SafroleSealingKeysKind["Keys"] = 1] = "Keys";
 })(SafroleSealingKeysKind || (SafroleSealingKeysKind = {}));
-const codecBandersnatchKey = 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
-            .sequenceFixLen(codecBandersnatchKey, context.epochLength)
-            .convert((keys) => Array.from(keys), (keys) => tryAsPerEpochBlock(keys, context));
-        const ticketsCodec = codec.sequenceFixLen(Ticket.Codec, context.epochLength).convert((tickets) => Array.from(tickets), (tickets) => tryAsPerEpochBlock(tickets, context));
-        return codec
-            .union("SafroleSealingKeys", {
-            [SafroleSealingKeysKind.Keys]: codec.object({ keys: keysCodec }),
-            [SafroleSealingKeysKind.Tickets]: codec.object({ tickets: ticketsCodec }),
-        })
-            .convert((x) => x, (x) => {
+        return custom({
+            name: "SafroleSealingKeys",
+            sizeHint: { bytes: 1 + HASH_SIZE * context.epochLength, isExact: false },
+        }, (e, x) => {
+            e.varU32(tryAsU32(x.kind));
             if (x.kind === SafroleSealingKeysKind.Keys) {
-                return SafroleSealingKeysData.keys(x.keys);
+                e.sequenceFixLen(codecBandersnatchKey, x.keys);
             }
-            return SafroleSealingKeysData.tickets(x.tickets);
+            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;
+            }
+            throw new Error(`Unexpected safrole sealing keys kind: ${kind}`);
         });
     });
     static keys(keys) {
@@ -9125,11 +9075,11 @@ class SafroleData {
     epochRoot;
     sealingKeySeries;
     ticketsAccumulator;
-    static Codec = codec.Class(SafroleData, {
+    static Codec = Class(SafroleData, {
         nextValidatorData: codecPerValidator(ValidatorData.Codec),
-        epochRoot: codec.bytes(BANDERSNATCH_RING_ROOT_BYTES).asOpaque(),
+        epochRoot: bytes(BANDERSNATCH_RING_ROOT_BYTES).asOpaque(),
         sealingKeySeries: SafroleSealingKeysData.Codec,
-        ticketsAccumulator: codec.readonlyArray(codec.sequenceVarLen(Ticket.Codec)).convert(seeThrough, asKnownSize),
+        ticketsAccumulator: readonlyArray(sequenceVarLen(Ticket.Codec)).convert(seeThrough, asKnownSize),
     });
     static create({ nextValidatorData, epochRoot, sealingKeySeries, ticketsAccumulator }) {
         return new SafroleData(nextValidatorData, epochRoot, sealingKeySeries, ticketsAccumulator);
@@ -9207,17 +9157,17 @@ class ServiceAccountInfo extends WithDebug {
     created;
     lastAccumulation;
     parentService;
-    static Codec = codec.Class(ServiceAccountInfo, {
-        codeHash: codec.bytes(HASH_SIZE).asOpaque(),
-        balance: codec.u64,
-        accumulateMinGas: codec.u64.convert((x) => x, tryAsServiceGas),
-        onTransferMinGas: codec.u64.convert((x) => x, tryAsServiceGas),
-        storageUtilisationBytes: codec.u64,
-        gratisStorage: codec.u64,
-        storageUtilisationCount: codec.u32,
-        created: codec.u32.convert((x) => x, tryAsTimeSlot),
-        lastAccumulation: codec.u32.convert((x) => x, tryAsTimeSlot),
-        parentService: codec.u32.convert((x) => x, tryAsServiceId),
+    static Codec = Class(ServiceAccountInfo, {
+        codeHash: bytes(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, tryAsTimeSlot),
+        lastAccumulation: u32.convert((x) => x, 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);
@@ -9273,9 +9223,9 @@ class ServiceAccountInfo extends WithDebug {
 class PreimageItem extends WithDebug {
     hash;
     blob;
-    static Codec = codec.Class(PreimageItem, {
-        hash: codec.bytes(HASH_SIZE).asOpaque(),
-        blob: codec.blob,
+    static Codec = Class(PreimageItem, {
+        hash: bytes(HASH_SIZE).asOpaque(),
+        blob: blob,
     });
     static create({ hash, blob }) {
         return new PreimageItem(hash, blob);
@@ -9289,9 +9239,9 @@ class PreimageItem extends WithDebug {
 class StorageItem extends WithDebug {
     key;
     value;
-    static Codec = codec.Class(StorageItem, {
-        key: codec.blob.convert((i) => i, (o) => asOpaqueType(o)),
-        value: codec.blob,
+    static Codec = Class(StorageItem, {
+        key: blob.convert((i) => i, (o) => asOpaqueType(o)),
+        value: blob,
     });
     static create({ key, value }) {
         return new StorageItem(key, value);
@@ -9345,13 +9295,13 @@ class ValidatorStatistics {
     preImagesSize;
     guarantees;
     assurances;
-    static Codec = codec.Class(ValidatorStatistics, {
-        blocks: codec.u32,
-        tickets: codec.u32,
-        preImages: codec.u32,
-        preImagesSize: codec.u32,
-        guarantees: codec.u32,
-        assurances: 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);
@@ -9381,9 +9331,9 @@ class ValidatorStatistics {
         return new ValidatorStatistics(zero, zero, zero, zero, zero, zero);
     }
 }
-const codecVarU16 = codec.varU32.convert((i) => tryAsU32(i), (o) => tryAsU16(o));
+const codecVarU16 = varU32.convert((i) => tryAsU32(i), (o) => tryAsU16(o));
 /** Encode/decode unsigned gas. */
-const codecVarGas = codec.varU64.convert((g) => tryAsU64(g), (i) => tryAsServiceGas(i));
+const codecVarGas = varU64.convert((g) => tryAsU64(g), (i) => tryAsServiceGas(i));
 /**
  * Single core statistics.
  * Updated per block, based on incoming work reports (`w`).
@@ -9400,14 +9350,14 @@ class CoreStatistics {
     extrinsicCount;
     bundleSize;
     gasUsed;
-    static Codec = codec.Class(CoreStatistics, {
-        dataAvailabilityLoad: codec.varU32,
+    static Codec = Class(CoreStatistics, {
+        dataAvailabilityLoad: varU32,
         popularity: codecVarU16,
         imports: codecVarU16,
         extrinsicCount: codecVarU16,
-        extrinsicSize: codec.varU32,
+        extrinsicSize: varU32,
         exports: codecVarU16,
-        bundleSize: codec.varU32,
+        bundleSize: varU32,
         gasUsed: codecVarGas,
     });
     static create(v) {
@@ -9466,31 +9416,31 @@ class ServiceStatistics {
     onTransfersCount;
     onTransfersGasUsed;
     static Codec = Compatibility.selectIfGreaterOrEqual({
-        fallback: codec.Class(ServiceStatistics, {
+        fallback: Class(ServiceStatistics, {
             providedCount: codecVarU16,
-            providedSize: codec.varU32,
-            refinementCount: codec.varU32,
+            providedSize: varU32,
+            refinementCount: varU32,
             refinementGasUsed: codecVarGas,
             imports: codecVarU16,
             extrinsicCount: codecVarU16,
-            extrinsicSize: codec.varU32,
+            extrinsicSize: varU32,
             exports: codecVarU16,
-            accumulateCount: codec.varU32,
+            accumulateCount: varU32,
             accumulateGasUsed: codecVarGas,
-            onTransfersCount: codec.varU32,
+            onTransfersCount: varU32,
             onTransfersGasUsed: codecVarGas,
         }),
         versions: {
-            [GpVersion.V0_7_1]: codec.Class(ServiceStatistics, {
+            [GpVersion.V0_7_1]: Class(ServiceStatistics, {
                 providedCount: codecVarU16,
-                providedSize: codec.varU32,
-                refinementCount: codec.varU32,
+                providedSize: varU32,
+                refinementCount: varU32,
                 refinementGasUsed: codecVarGas,
                 imports: codecVarU16,
                 extrinsicCount: codecVarU16,
-                extrinsicSize: codec.varU32,
+                extrinsicSize: varU32,
                 exports: codecVarU16,
-                accumulateCount: codec.varU32,
+                accumulateCount: varU32,
                 accumulateGasUsed: codecVarGas,
                 onTransfersCount: ignoreValueWithDefault(tryAsU32(0)),
                 onTransfersGasUsed: ignoreValueWithDefault(tryAsServiceGas(0)),
@@ -9551,11 +9501,11 @@ class StatisticsData {
     previous;
     cores;
     services;
-    static Codec = codec.Class(StatisticsData, {
+    static Codec = Class(StatisticsData, {
         current: codecPerValidator(ValidatorStatistics.Codec),
         previous: codecPerValidator(ValidatorStatistics.Codec),
         cores: codecPerCore(CoreStatistics.Codec),
-        services: codec.dictionary(codec.u32.asOpaque(), ServiceStatistics.Codec, {
+        services: dictionary(u32.asOpaque(), ServiceStatistics.Codec, {
             sortKeys: (a, b) => a - b,
         }),
     });
@@ -9637,14 +9587,14 @@ class PrivilegedServices {
     assigners;
     autoAccumulateServices;
     /** https://graypaper.fluffylabs.dev/#/ab2cdbd/3bbd023bcb02?v=0.7.2 */
-    static Codec = codec.Class(PrivilegedServices, {
-        manager: codec.u32.asOpaque(),
-        assigners: codecPerCore(codec.u32.asOpaque()),
-        delegator: 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.u32.asOpaque()
+            ? u32.asOpaque()
             : ignoreValueWithDefault(tryAsServiceId(2 ** 32 - 1)),
-        autoAccumulateServices: codec.dictionary(codec.u32.asOpaque(), codec.u64.asOpaque(), {
+        autoAccumulateServices: dictionary(u32.asOpaque(), u64.asOpaque(), {
             sortKeys: (a, b) => a - b,
         }),
     });
@@ -10289,15 +10239,15 @@ class InMemoryState extends WithDebug {
         });
     }
 }
-const serviceEntriesCodec = codec.object({
-    storageKeys: codec.sequenceVarLen(codec.blob.convert((i) => i, (o) => asOpaqueType(o))),
-    preimages: codec.sequenceVarLen(codec.bytes(HASH_SIZE).asOpaque()),
-    lookupHistory: codec.sequenceVarLen(codec.object({
-        hash: codec.bytes(HASH_SIZE).asOpaque(),
-        length: codec.u32,
+const serviceEntriesCodec = object({
+    storageKeys: sequenceVarLen(blob.convert((i) => i, (o) => asOpaqueType(o))),
+    preimages: sequenceVarLen(bytes(HASH_SIZE).asOpaque()),
+    lookupHistory: sequenceVarLen(object({
+        hash: bytes(HASH_SIZE).asOpaque(),
+        length: u32,
     })),
 });
-const serviceDataCodec = codec.dictionary(codec.u32.asOpaque(), serviceEntriesCodec, {
+const serviceDataCodec = dictionary(u32.asOpaque(), serviceEntriesCodec, {
     sortKeys: (a, b) => a - b,
 });
 
@@ -10400,7 +10350,7 @@ var serialize;
     /** C(6): https://graypaper.fluffylabs.dev/#/7e6ff6a/3bf3013bf301?v=0.6.7 */
     serialize.entropy = {
         key: stateKeys.index(StateKeyIdx.Eta),
-        Codec: codecFixedSizeArray(codec.bytes(HASH_SIZE).asOpaque(), ENTROPY_ENTRIES),
+        Codec: codecFixedSizeArray(bytes(HASH_SIZE).asOpaque(), ENTROPY_ENTRIES),
         extract: (s) => s.entropy,
     };
     /** C(7): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b00023b0002?v=0.6.7 */
@@ -10430,7 +10380,7 @@ var serialize;
     /** C(11): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b3e023b3e02?v=0.6.7 */
     serialize.timeslot = {
         key: stateKeys.index(StateKeyIdx.Tau),
-        Codec: codec.u32.asOpaque(),
+        Codec: u32.asOpaque(),
         extract: (s) => s.timeslot,
     };
     /** C(12): https://graypaper.fluffylabs.dev/#/7e6ff6a/3b4c023b4c02?v=0.6.7 */
@@ -10460,7 +10410,7 @@ var serialize;
     /** C(16): https://graypaper.fluffylabs.dev/#/38c4e62/3b46033b4603?v=0.7.0 */
     serialize.accumulationOutputLog = {
         key: stateKeys.index(StateKeyIdx.Theta),
-        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 */
@@ -10483,7 +10433,7 @@ var 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.readonlyArray(codec.sequenceVarLen(codec.u32)),
+        Codec: readonlyArray(sequenceVarLen(u32)),
     });
 })(serialize || (serialize = {}));
 /**
@@ -11577,7 +11527,7 @@ function getSafroleData(nextValidatorData, epochRoot, sealingKeySeries, ticketsA
 
 const TYPICAL_STATE_ITEMS = 50;
 const TYPICAL_STATE_ITEM_LEN = 50;
-const stateEntriesSequenceCodec = codec.sequenceVarLen(codec.pair(codec.bytes(TRUNCATED_HASH_SIZE), codec.blob));
+const stateEntriesSequenceCodec = sequenceVarLen(pair(bytes(TRUNCATED_HASH_SIZE), blob));
 /**
  * Full, in-memory state represented as serialized entries dictionary.
  *
@@ -11585,7 +11535,7 @@ const stateEntriesSequenceCodec = codec.sequenceVarLen(codec.pair(codec.bytes(TR
  */
 class StateEntries {
     dictionary;
-    static Codec = codec.custom({
+    static Codec = custom({
         name: "StateEntries",
         sizeHint: {
             isExact: false,
@@ -12405,10 +12355,10 @@ class Version extends WithDebug {
     major;
     minor;
     patch;
-    static Codec = codec.Class(Version, {
-        major: codec.u8,
-        minor: codec.u8,
-        patch: codec.u8,
+    static Codec = Class(Version, {
+        major: u8,
+        minor: u8,
+        patch: u8,
     });
     static tryFromString(str) {
         const parse = (v) => tryAsU8(Number(v));
@@ -12460,12 +12410,12 @@ class PeerInfo extends WithDebug {
     jamVersion;
     appVersion;
     name;
-    static Codec = codec.Class(PeerInfo, {
-        fuzzVersion: codec.u8,
-        features: codec.u32,
+    static Codec = Class(PeerInfo, {
+        fuzzVersion: u8,
+        features: u32,
         jamVersion: Version.Codec,
         appVersion: Version.Codec,
-        name: codec.string,
+        name: string,
     });
     static create({ fuzzVersion, features, appVersion, jamVersion, name }) {
         return new PeerInfo(fuzzVersion, features, jamVersion, appVersion, name);
@@ -12488,9 +12438,9 @@ class PeerInfo extends WithDebug {
 class AncestryItem extends WithDebug {
     slot;
     headerHash;
-    static Codec = codec.Class(AncestryItem, {
-        slot: codec.u32.asOpaque(),
-        headerHash: codec.bytes(HASH_SIZE).asOpaque(),
+    static Codec = Class(AncestryItem, {
+        slot: u32.asOpaque(),
+        headerHash: bytes(HASH_SIZE).asOpaque(),
     });
     static create({ slot, headerHash }) {
         return new AncestryItem(slot, headerHash);
@@ -12510,9 +12460,9 @@ class AncestryItem extends WithDebug {
 class KeyValue extends WithDebug {
     key;
     value;
-    static Codec = codec.Class(KeyValue, {
-        key: codec.bytes(TRUNCATED_HASH_SIZE),
-        value: codec.blob,
+    static Codec = Class(KeyValue, {
+        key: bytes(TRUNCATED_HASH_SIZE),
+        value: blob,
     });
     static create({ key, value }) {
         return new KeyValue(key, value);
@@ -12524,12 +12474,12 @@ class KeyValue extends WithDebug {
     }
 }
 /** State ::= SEQUENCE OF KeyValue */
-const stateCodec = 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.sequenceVarLen(AncestryItem.Codec, {
+const ancestryCodec = sequenceVarLen(AncestryItem.Codec, {
     minLength: 0,
     maxLength: 24,
 });
@@ -12544,7 +12494,7 @@ class Initialize extends WithDebug {
     header;
     keyvals;
     ancestry;
-    static Codec = codec.Class(Initialize, {
+    static Codec = Class(Initialize, {
         header: Header.Codec,
         keyvals: stateCodec,
         ancestry: ancestryCodec,
@@ -12560,14 +12510,14 @@ class Initialize extends WithDebug {
     }
 }
 /** GetState ::= HeaderHash */
-const getStateCodec = codec.bytes(HASH_SIZE).asOpaque();
+const getStateCodec = bytes(HASH_SIZE).asOpaque();
 /** StateRoot ::= StateRootHash */
-const stateRootCodec = codec.bytes(HASH_SIZE).asOpaque();
+const stateRootCodec = bytes(HASH_SIZE).asOpaque();
 /** Error ::= UTF8String */
 class ErrorMessage extends WithDebug {
     message;
-    static Codec = codec.Class(ErrorMessage, {
-        message: codec.string,
+    static Codec = Class(ErrorMessage, {
+        message: string,
     });
     static create({ message }) {
         return new ErrorMessage(message);
@@ -12599,7 +12549,7 @@ var MessageType;
  *     error         [255] Error
  * }
  */
-const messageCodec = codec.custom({
+const messageCodec = custom({
     name: "Message",
     sizeHint: { bytes: 1, isExact: false },
 }, (e, msg) => {
@@ -18084,7 +18034,7 @@ class Assign {
         // NOTE: Here we know the core index is valid
         const coreIndex = tryAsCoreIndex(Number(maybeCoreIndex));
         const decoder = Decoder.fromBlob(res);
-        const authQueue = decoder.sequenceFixLen(codec.bytes(HASH_SIZE).asOpaque(), AUTHORIZATION_QUEUE_SIZE);
+        const authQueue = decoder.sequenceFixLen(bytes(HASH_SIZE).asOpaque(), AUTHORIZATION_QUEUE_SIZE);
         const fixedSizeAuthQueue = FixedSizeArray.new(authQueue, AUTHORIZATION_QUEUE_SIZE);
         const result = this.partialState.updateAuthorizationQueue(coreIndex, fixedSizeAuthQueue, assigners);
         if (result.isOk) {
@@ -18108,9 +18058,9 @@ class Assign {
 }
 
 const IN_OUT_REG$m = 7;
-const serviceIdAndGasCodec = codec.object({
-    serviceId: codec.u32.convert((i) => i, (o) => asOpaqueType(o)),
-    gas: codec.u64.convert((i) => tryAsU64(i), (o) => tryAsServiceGas(o)),
+const serviceIdAndGasCodec = object({
+    serviceId: u32.convert((i) => i, (o) => asOpaqueType(o)),
+    gas: u64.convert((i) => tryAsU64(i), (o) => tryAsServiceGas(o)),
 });
 /**
  * Modify privileged services and services that auto-accumulate every block.
@@ -18168,7 +18118,7 @@ class Bless {
             memIndex = tryAsU64(memIndex + tryAsU64(decoder.bytesRead()));
         }
         // https://graypaper.fluffylabs.dev/#/7e6ff6a/367200367200?v=0.6.7
-        const res = safeAllocUint8Array(tryAsExactBytes(codec.u32.sizeHint) * this.chainSpec.coresCount);
+        const res = safeAllocUint8Array(tryAsExactBytes(u32.sizeHint) * this.chainSpec.coresCount);
         const authorizersDecoder = Decoder.fromBlob(res);
         const memoryReadResult = memory.loadInto(res, authorization);
         if (memoryReadResult.isError) {
@@ -18176,7 +18126,7 @@ class Bless {
             return PvmExecution.Panic;
         }
         // `a`
-        const authorizers = tryAsPerCore(authorizersDecoder.sequenceFixLen(codec.u32.asOpaque(), this.chainSpec.coresCount), this.chainSpec);
+        const authorizers = tryAsPerCore(authorizersDecoder.sequenceFixLen(u32.asOpaque(), this.chainSpec.coresCount), this.chainSpec);
         const updateResult = this.partialState.updatePrivilegedServices(manager, authorizers, delegator, registrar, autoAccumulate);
         if (updateResult.isOk) {
             logger$7.trace `[${this.currentServiceId}] BLESS(m: ${manager}, a: [${authorizers}], v: ${delegator}, r: ${registrar}, ${lazyInspect(autoAccumulate)}) <- OK`;
@@ -18786,12 +18736,12 @@ class PendingTransfer {
     amount;
     memo;
     gas;
-    static Codec = codec.Class(PendingTransfer, {
-        source: codec.u32.asOpaque(),
-        destination: codec.u32.asOpaque(),
-        amount: codec.u64,
-        memo: codec.bytes(TRANSFER_MEMO_BYTES),
-        gas: codec.u64.asOpaque(),
+    static Codec = Class(PendingTransfer, {
+        source: u32.asOpaque(),
+        destination: u32.asOpaque(),
+        amount: u64,
+        memo: bytes(TRANSFER_MEMO_BYTES),
+        gas: u64.asOpaque(),
     });
     constructor(
     /** `s`: sending service */
@@ -19089,18 +19039,18 @@ class Info {
  *
  * https://graypaper.fluffylabs.dev/#/ab2cdbd/33920033b500?v=0.7.2
  */
-const codecServiceAccountInfoWithThresholdBalance = codec.object({
-    codeHash: codec.bytes(HASH_SIZE),
-    balance: codec.u64,
-    thresholdBalance: codec.u64,
-    accumulateMinGas: codec.u64.convert((i) => i, tryAsServiceGas),
-    onTransferMinGas: codec.u64.convert((i) => i, tryAsServiceGas),
-    storageUtilisationBytes: codec.u64,
-    storageUtilisationCount: codec.u32,
-    gratisStorage: codec.u64,
-    created: codec.u32.convert((x) => x, tryAsTimeSlot),
-    lastAccumulation: codec.u32.convert((x) => x, tryAsTimeSlot),
-    parentService: codec.u32.convert((x) => x, tryAsServiceId),
+const codecServiceAccountInfoWithThresholdBalance = object({
+    codeHash: bytes(HASH_SIZE),
+    balance: u64,
+    thresholdBalance: u64,
+    accumulateMinGas: u64.convert((i) => i, tryAsServiceGas),
+    onTransferMinGas: u64.convert((i) => i, tryAsServiceGas),
+    storageUtilisationBytes: u64,
+    storageUtilisationCount: u32,
+    gratisStorage: u64,
+    created: u32.convert((x) => x, tryAsTimeSlot),
+    lastAccumulation: u32.convert((x) => x, tryAsTimeSlot),
+    parentService: u32.convert((x) => x, tryAsServiceId),
 }, "ServiceAccountInfoWithThresholdBalance");
 
 const decoder = new TextDecoder("utf8");
@@ -19476,9 +19426,9 @@ class HistoricalLookup {
 
 const IN_OUT_REG_1 = 7;
 const IN_OUT_REG_2 = 8;
-const gasAndRegistersCodec = codec.object({
-    gas: codec.i64,
-    registers: codec.bytes(NO_OF_REGISTERS$1 * REGISTER_BYTE_SIZE),
+const gasAndRegistersCodec = object({
+    gas: i64,
+    registers: bytes(NO_OF_REGISTERS$1 * REGISTER_BYTE_SIZE),
 });
 const GAS_REGISTERS_SIZE = tryAsExactBytes(gasAndRegistersCodec.sizeHint);
 /**
@@ -20324,21 +20274,21 @@ const GAS_TO_INVOKE_WORK_REPORT = 10000000n;
  * https://graypaper.fluffylabs.dev/#/ab2cdbd/176b00176b00?v=0.7.2
  */
 class Operand extends WithDebug {
-    static Codec = codec.Class(Operand, {
+    static Codec = Class(Operand, {
         // h
-        hash: codec.bytes(HASH_SIZE).asOpaque(),
+        hash: bytes(HASH_SIZE).asOpaque(),
         // e
-        exportsRoot: codec.bytes(HASH_SIZE).asOpaque(),
+        exportsRoot: bytes(HASH_SIZE).asOpaque(),
         // a
-        authorizerHash: codec.bytes(HASH_SIZE).asOpaque(),
+        authorizerHash: bytes(HASH_SIZE).asOpaque(),
         // y
-        payloadHash: codec.bytes(HASH_SIZE),
+        payloadHash: bytes(HASH_SIZE),
         // g
-        gas: codec.varU64.asOpaque(),
+        gas: varU64.asOpaque(),
         // d
         result: WorkExecResult.Codec,
         // o
-        authorizationOutput: codec.blob,
+        authorizationOutput: blob,
     });
     /**
      * https://graypaper.fluffylabs.dev/#/ab2cdbd/18680118eb01?v=0.7.2
@@ -20609,11 +20559,7 @@ function verifyReportsBasic(input) {
         const authOutputSize = reportView.authorizationOutput.view().length;
         let totalOutputsSize = 0;
         for (const item of reportView.results.view()) {
-            const workItemView = item.view();
-            const result = workItemView.result.materialize();
-            if (result.kind === WorkExecResultKind.ok) {
-                totalOutputsSize += result.okBlob?.raw.length ?? 0;
-            }
+            totalOutputsSize += item.view().result.view().okBlob?.raw.length ?? 0;
         }
         if (authOutputSize + totalOutputsSize > MAX_WORK_REPORT_SIZE_BYTES) {
             return Result$1.error(ReportsError.WorkReportTooBig, () => `Work report at ${reportView.coreIndex.materialize()} too big. Got ${authOutputSize} + ${totalOutputsSize}, max: ${MAX_WORK_REPORT_SIZE_BYTES}`);
@@ -20627,47 +20573,75 @@ var TransferOperandKind;
     TransferOperandKind[TransferOperandKind["OPERAND"] = 0] = "OPERAND";
     TransferOperandKind[TransferOperandKind["TRANSFER"] = 1] = "TRANSFER";
 })(TransferOperandKind || (TransferOperandKind = {}));
-const TRANSFER_OR_OPERAND = codec.union("TransferOrOperand", {
-    [TransferOperandKind.OPERAND]: codec.object({ value: Operand.Codec }),
-    [TransferOperandKind.TRANSFER]: codec.object({ value: PendingTransfer.Codec }),
+const TRANSFER_OR_OPERAND = custom({
+    name: "TransferOrOperand",
+    sizeHint: { bytes: 1, isExact: false },
+}, (e, x) => {
+    e.varU32(tryAsU32(x.kind));
+    if (x.kind === TransferOperandKind.OPERAND) {
+        e.object(Operand.Codec, x.value);
+    }
+    if (x.kind === TransferOperandKind.TRANSFER) {
+        e.object(PendingTransfer.Codec, x.value);
+    }
+}, (d) => {
+    const kind = d.varU32();
+    if (kind === TransferOperandKind.OPERAND) {
+        return {
+            kind: TransferOperandKind.OPERAND,
+            value: d.object(Operand.Codec),
+        };
+    }
+    if (kind === TransferOperandKind.TRANSFER) {
+        return { kind: TransferOperandKind.TRANSFER, value: d.object(PendingTransfer.Codec) };
+    }
+    throw new Error(`Unable to decode TransferOrOperand. Invalid kind: ${kind}.`);
+}, (s) => {
+    const kind = s.decoder.varU32();
+    if (kind === TransferOperandKind.OPERAND) {
+        s.object(Operand.Codec);
+    }
+    if (kind === TransferOperandKind.TRANSFER) {
+        s.object(PendingTransfer.Codec);
+    }
 });
-const TRANSFERS_AND_OPERANDS = codec.sequenceVarLen(TRANSFER_OR_OPERAND);
+const TRANSFERS_AND_OPERANDS = sequenceVarLen(TRANSFER_OR_OPERAND);
 // https://github.com/gavofyork/graypaper/pull/414
 // 0.7.0 encoding is used for prior versions as well.
-const CONSTANTS_CODEC = codec.object({
-    B_I: codec.u64,
-    B_L: codec.u64,
-    B_S: codec.u64,
-    C: codec.u16,
-    D: codec.u32,
-    E: codec.u32,
-    G_A: codec.u64,
-    G_I: codec.u64,
-    G_R: codec.u64,
-    G_T: codec.u64,
-    H: codec.u16,
-    I: codec.u16,
-    J: codec.u16,
-    K: codec.u16,
-    L: codec.u32,
-    N: codec.u16,
-    O: codec.u16,
-    P: codec.u16,
-    Q: codec.u16,
-    R: codec.u16,
-    T: codec.u16,
-    U: codec.u16,
-    V: codec.u16,
-    W_A: codec.u32,
-    W_B: codec.u32,
-    W_C: codec.u32,
-    W_E: codec.u32,
-    W_M: codec.u32,
-    W_P: codec.u32,
-    W_R: codec.u32,
-    W_T: codec.u32,
-    W_X: codec.u32,
-    Y: codec.u32,
+const CONSTANTS_CODEC = object({
+    B_I: u64,
+    B_L: u64,
+    B_S: u64,
+    C: u16,
+    D: u32,
+    E: u32,
+    G_A: u64,
+    G_I: u64,
+    G_R: u64,
+    G_T: u64,
+    H: u16,
+    I: u16,
+    J: u16,
+    K: u16,
+    L: u32,
+    N: u16,
+    O: u16,
+    P: u16,
+    Q: u16,
+    R: u16,
+    T: u16,
+    U: u16,
+    V: u16,
+    W_A: u32,
+    W_B: u32,
+    W_C: u32,
+    W_E: u32,
+    W_M: u32,
+    W_P: u32,
+    W_R: u32,
+    W_T: u32,
+    W_X: u32,
+    Y: u32,
 });
 const encodedConstantsCache = new Map();
 function getEncodedConstants(chainSpec) {
@@ -20780,7 +20754,7 @@ class FetchExternalities {
     allOperands() {
         if (this.fetchData.context === FetchContext.LegacyAccumulate) {
             const operands = this.fetchData.operands;
-            return Encoder.encodeObject(codec.sequenceVarLen(Operand.Codec), operands, this.chainSpec);
+            return Encoder.encodeObject(sequenceVarLen(Operand.Codec), operands, this.chainSpec);
         }
         return null;
     }
@@ -20801,7 +20775,7 @@ class FetchExternalities {
     allTransfers() {
         if (this.fetchData.context === FetchContext.LegacyOnTransfer) {
             const { transfers } = this.fetchData;
-            return Encoder.encodeObject(codec.sequenceVarLen(PendingTransfer.Codec), transfers, this.chainSpec);
+            return Encoder.encodeObject(sequenceVarLen(PendingTransfer.Codec), transfers, this.chainSpec);
         }
         return null;
     }
@@ -21032,10 +21006,10 @@ function getWorkPackageHashes(reports) {
     const workPackageHashes = reports.map((report) => report.workPackageSpec.hash);
     return HashSet.from(workPackageHashes);
 }
-const NEXT_ID_CODEC = codec.object({
-    serviceId: codec.varU32.asOpaque(),
-    entropy: codec.bytes(HASH_SIZE).asOpaque(),
-    timeslot: codec.varU32.asOpaque(),
+const NEXT_ID_CODEC = object({
+    serviceId: varU32.asOpaque(),
+    entropy: bytes(HASH_SIZE).asOpaque(),
+    timeslot: varU32.asOpaque(),
 });
 /**
  * Generate a next service id.
@@ -21433,10 +21407,10 @@ var PvmInvocationError;
     PvmInvocationError[PvmInvocationError["PreimageTooLong"] = 2] = "PreimageTooLong";
 })(PvmInvocationError || (PvmInvocationError = {}));
 const logger$5 = Logger.new(import.meta.filename, "accumulate");
-const ARGS_CODEC$1 = codec.object({
-    slot: codec.varU32.asOpaque(),
-    serviceId: codec.varU32.asOpaque(),
-    argsLength: codec.varU32,
+const ARGS_CODEC$1 = object({
+    slot: varU32.asOpaque(),
+    serviceId: varU32.asOpaque(),
+    argsLength: varU32,
 });
 class Accumulate {
     chainSpec;
@@ -21846,10 +21820,10 @@ class Accumulate {
     }
 }
 
-const ARGS_CODEC = codec.object({
-    timeslot: codec.varU32.asOpaque(),
-    serviceId: codec.varU32.asOpaque(),
-    transfersLength: codec.varU32,
+const ARGS_CODEC = object({
+    timeslot: varU32.asOpaque(),
+    serviceId: varU32.asOpaque(),
+    transfersLength: varU32,
 });
 var DeferredTransfersErrorCode;
 (function (DeferredTransfersErrorCode) {
@@ -24578,7 +24552,7 @@ class TransitionHasher {
     extrinsic(extrinsicView) {
         // https://graypaper.fluffylabs.dev/#/cc517d7/0cfb000cfb00?v=0.6.5
         const guaranteesCount = tryAsU32(extrinsicView.guarantees.view().length);
-        const countEncoded = Encoder.encodeObject(codec.varU32, guaranteesCount);
+        const countEncoded = Encoder.encodeObject(varU32, guaranteesCount);
         const guaranteesBlobs = extrinsicView.guarantees
             .view()
             .map((g) => g.view())
@@ -26292,7 +26266,7 @@ var index$3 = /*#__PURE__*/Object.freeze({
   startSameThread: startSameThread
 });
 
-const importBlockResultCodec = (hashName) => codec.custom({
+const importBlockResultCodec = (hashName) => custom({
     name: `Result<${hashName}, string>`,
     sizeHint: { bytes: 1, isExact: false },
 }, (e, x) => {
@@ -26330,33 +26304,33 @@ const importBlockResultCodec = (hashName) => codec.custom({
 const protocol = createProtocol("importer", {
     toWorker: {
         getStateEntries: {
-            request: codec.bytes(HASH_SIZE).asOpaque(),
-            response: codec.optional(StateEntries.Codec),
+            request: bytes(HASH_SIZE).asOpaque(),
+            response: optional(StateEntries.Codec),
         },
         getBestStateRootHash: {
-            request: codec.nothing,
-            response: codec.bytes(HASH_SIZE).asOpaque(),
+            request: nothing,
+            response: bytes(HASH_SIZE).asOpaque(),
         },
         importBlock: {
             request: Block.Codec.View,
             response: importBlockResultCodec("HeaderHash"),
         },
         finish: {
-            request: codec.nothing,
-            response: codec.nothing,
+            request: nothing,
+            response: nothing,
         },
     },
     fromWorker: {
         bestHeaderAnnouncement: {
             request: headerViewWithHashCodec,
-            response: codec.nothing,
+            response: nothing,
         },
     },
 });
 class ImporterConfig {
     pvm;
-    static Codec = codec.Class(ImporterConfig, {
-        pvm: codec.u8.convert((i) => tryAsU8(i), (o) => {
+    static Codec = Class(ImporterConfig, {
+        pvm: u8.convert((i) => tryAsU8(i), (o) => {
             if (o === PvmBackend.BuiltIn) {
                 return PvmBackend.BuiltIn;
             }
@@ -26374,7 +26348,7 @@ class ImporterConfig {
     }
 }
 
-const WORKER = new URL("./bootstrap-importer.mjs", import.meta.url);
+const WORKER = new URL(import.meta.resolve("./bootstrap-importer.mjs"));
 
 var index$2 = /*#__PURE__*/Object.freeze({
   __proto__: null,
@@ -26821,11 +26795,11 @@ class TestState {
         state_root: fromJson.bytes32(),
         keyvals: json.array(StateKeyVal.fromJson),
     };
-    static Codec = codec.object({
-        state_root: codec.bytes(HASH_SIZE).asOpaque(),
-        keyvals: codec.sequenceVarLen(codec.object({
-            key: codec.bytes(TRUNCATED_HASH_SIZE),
-            value: codec.blob,
+    static Codec = object({
+        state_root: bytes(HASH_SIZE).asOpaque(),
+        keyvals: sequenceVarLen(object({
+            key: bytes(TRUNCATED_HASH_SIZE),
+            value: blob,
         })),
     });
     state_root;
@@ -26836,7 +26810,7 @@ class StateTransitionGenesis {
         header: headerFromJson,
         state: TestState.fromJson,
     };
-    static Codec = codec.object({
+    static Codec = object({
         header: Header.Codec,
         state: TestState.Codec,
     });
@@ -26849,7 +26823,7 @@ class StateTransition {
         post_state: TestState.fromJson,
         block: blockFromJson(tinyChainSpec),
     };
-    static Codec = codec.object({
+    static Codec = object({
         pre_state: TestState.Codec,
         block: Block.Codec,
         post_state: TestState.Codec,