@typeberry/convert 0.5.3 → 0.5.4-ab9c0e1

package/index.js

@@ -4362,7 +4362,6 @@ const env = typeof process === "undefined" ? {} : process.env;
 
 var GpVersion;
 (function (GpVersion) {
-    GpVersion["V0_7_0"] = "0.7.0";
     GpVersion["V0_7_1"] = "0.7.1";
     GpVersion["V0_7_2"] = "0.7.2";
 })(GpVersion || (GpVersion = {}));
@@ -4371,7 +4370,7 @@ var TestSuite;
     TestSuite["W3F_DAVXY"] = "w3f-davxy";
 })(TestSuite || (TestSuite = {}));
 // NOTE: Also acts as a supported versions
-const ALL_VERSIONS_IN_ORDER = [GpVersion.V0_7_0, GpVersion.V0_7_1, GpVersion.V0_7_2];
+const ALL_VERSIONS_IN_ORDER = [GpVersion.V0_7_1, GpVersion.V0_7_2];
 const DEFAULT_SUITE = TestSuite.W3F_DAVXY;
 const DEFAULT_VERSION = GpVersion.V0_7_2;
 let CURRENT_VERSION = parseCurrentVersion(env.GP_VERSION) ?? DEFAULT_VERSION;
@@ -4956,7 +4955,7 @@ function isResult(x) {
 var minimist = __nccwpck_require__(595);
 var minimist_default = /*#__PURE__*/__nccwpck_require__.n(minimist);
 ;// CONCATENATED MODULE: ./bin/convert/package.json
-const package_namespaceObject = {"rE":"0.5.3"};
+const package_namespaceObject = {"rE":"0.5.4"};
 ;// CONCATENATED MODULE: ./packages/core/bytes/bitvec.ts
 
 /**
@@ -5346,7 +5345,7 @@ const bytesBlobComparator = (a, b) => a.compare(b);
 const asTypedNumber = (v) => v;
 const MAX_VALUE_U8 = 0xff;
 const MAX_VALUE_U16 = 0xffff;
-const MAX_VALUE_U32 = 0xffff_ffff;
+const numbers_MAX_VALUE_U32 = 0xffff_ffff;
 const MAX_VALUE_U64 = 0xffffffffffffffffn;
 /** Attempt to cast an input number into U8. */
 const tryAsU8 = (v) => {
@@ -5368,7 +5367,7 @@ const numbers_tryAsU32 = (v) => {
     return asTypedNumber(v);
 };
 /** Check if given number is a valid U32 number. */
-const isU32 = (v) => (v & MAX_VALUE_U32) >>> 0 === v;
+const isU32 = (v) => (v & numbers_MAX_VALUE_U32) >>> 0 === v;
 /** Attempt to cast an input number into U64. */
 const numbers_tryAsU64 = (x) => {
     const v = BigInt(x);
@@ -5850,7 +5849,7 @@ class Skipper {
  *
  * Descriptors can be composed to form more complex typings.
  */
-class Descriptor {
+class descriptor_Descriptor {
     name;
     sizeHint;
     encode;
@@ -5860,11 +5859,11 @@ class Descriptor {
     View;
     /** New descriptor with specialized `View`. */
     static withView(name, sizeHint, encode, decode, skip, view) {
-        return new Descriptor(name, sizeHint, encode, decode, skip, view);
+        return new descriptor_Descriptor(name, sizeHint, encode, decode, skip, view);
     }
     /** Create a new descriptor without a specialized `View`. */
     static new(name, sizeHint, encode, decode, skip) {
-        return new Descriptor(name, sizeHint, encode, decode, skip, null);
+        return new descriptor_Descriptor(name, sizeHint, encode, decode, skip, null);
     }
     constructor(
     /** Descriptive name of the coded data. */
@@ -5901,7 +5900,7 @@ class Descriptor {
     }
     /** Return a new descriptor that converts data into some other type. */
     convert(input, output) {
-        return new Descriptor(this.name, this.sizeHint, (e, elem) => this.encode(e, input(elem)), (d) => output(this.decode(d)), this.skip, this.View);
+        return new descriptor_Descriptor(this.name, this.sizeHint, (e, elem) => this.encode(e, input(elem)), (d) => output(this.decode(d)), this.skip, this.View);
     }
     /** Safely cast the descriptor value to a opaque type. */
     asOpaque() {
@@ -6600,53 +6599,53 @@ const bytes = (() => {
     return (len) => {
         let ret = cache.get(len);
         if (ret === undefined) {
-            ret = Descriptor.new(`Bytes<${len}>`, exactHint(len), (e, v) => e.bytes(v), (d) => d.bytes(len), (s) => s.bytes(len));
+            ret = descriptor_Descriptor.new(`Bytes<${len}>`, exactHint(len), (e, v) => e.bytes(v), (d) => d.bytes(len), (s) => s.bytes(len));
             cache.set(len, ret);
         }
         return ret;
     };
 })();
 /** Zero-size `void` value. */
-const nothing = Descriptor.new("void", { bytes: 0, isExact: true }, (_e, _v) => { }, (_d) => { }, (_s) => { });
+const nothing = descriptor_Descriptor.new("void", { bytes: 0, isExact: true }, (_e, _v) => { }, (_d) => { }, (_s) => { });
 /** Variable-length U32. */
-const varU32 = Descriptor.new("var_u32", { bytes: 4, isExact: false }, (e, v) => e.varU32(v), (d) => d.varU32(), (d) => d.varU32());
+const varU32 = descriptor_Descriptor.new("var_u32", { bytes: 4, isExact: false }, (e, v) => e.varU32(v), (d) => d.varU32(), (d) => d.varU32());
 /** Variable-length U64. */
-const varU64 = Descriptor.new("var_u64", { bytes: 8, isExact: false }, (e, v) => e.varU64(v), (d) => d.varU64(), (d) => d.varU64());
+const varU64 = descriptor_Descriptor.new("var_u64", { bytes: 8, isExact: false }, (e, v) => e.varU64(v), (d) => d.varU64(), (d) => d.varU64());
 /** Unsigned 64-bit number. */
-const u64 = Descriptor.withView("u64", exactHint(8), (e, v) => e.i64(v), (d) => d.u64(), (d) => d.u64(), bytes(8));
+const u64 = descriptor_Descriptor.withView("u64", exactHint(8), (e, v) => e.i64(v), (d) => d.u64(), (d) => d.u64(), bytes(8));
 /** Unsigned 32-bit number. */
-const u32 = Descriptor.withView("u32", exactHint(4), (e, v) => e.i32(v), (d) => d.u32(), (d) => d.u32(), bytes(4));
+const u32 = descriptor_Descriptor.withView("u32", exactHint(4), (e, v) => e.i32(v), (d) => d.u32(), (d) => d.u32(), bytes(4));
 /** Unsigned 24-bit number. */
-const u24 = Descriptor.withView("u24", exactHint(3), (e, v) => e.i24(v), (d) => d.u24(), (d) => d.u24(), bytes(3));
+const u24 = descriptor_Descriptor.withView("u24", exactHint(3), (e, v) => e.i24(v), (d) => d.u24(), (d) => d.u24(), bytes(3));
 /** Unsigned 16-bit number. */
-const u16 = Descriptor.withView("u16", exactHint(2), (e, v) => e.i16(v), (d) => d.u16(), (d) => d.u16(), bytes(2));
+const u16 = descriptor_Descriptor.withView("u16", exactHint(2), (e, v) => e.i16(v), (d) => d.u16(), (d) => d.u16(), bytes(2));
 /** Unsigned 8-bit number. */
-const u8 = Descriptor.new("u8", exactHint(1), (e, v) => e.i8(v), (d) => d.u8(), (d) => d.u8());
+const u8 = descriptor_Descriptor.new("u8", exactHint(1), (e, v) => e.i8(v), (d) => d.u8(), (d) => d.u8());
 /** Signed 64-bit number. */
-const i64 = Descriptor.withView("i64", exactHint(8), (e, v) => e.i64(v), (d) => d.i64(), (s) => s.u64(), bytes(8));
+const i64 = descriptor_Descriptor.withView("i64", exactHint(8), (e, v) => e.i64(v), (d) => d.i64(), (s) => s.u64(), bytes(8));
 /** Signed 32-bit number. */
-const i32 = Descriptor.withView("i32", exactHint(4), (e, v) => e.i32(v), (d) => d.i32(), (s) => s.u32(), bytes(4));
+const i32 = descriptor_Descriptor.withView("i32", exactHint(4), (e, v) => e.i32(v), (d) => d.i32(), (s) => s.u32(), bytes(4));
 /** Signed 24-bit number. */
-const i24 = Descriptor.withView("i24", exactHint(3), (e, v) => e.i24(v), (d) => d.i24(), (s) => s.u24(), bytes(3));
+const i24 = descriptor_Descriptor.withView("i24", exactHint(3), (e, v) => e.i24(v), (d) => d.i24(), (s) => s.u24(), bytes(3));
 /** Signed 16-bit number. */
-const i16 = Descriptor.withView("i16", exactHint(2), (e, v) => e.i16(v), (d) => d.i16(), (s) => s.u16(), bytes(2));
+const i16 = descriptor_Descriptor.withView("i16", exactHint(2), (e, v) => e.i16(v), (d) => d.i16(), (s) => s.u16(), bytes(2));
 /** Signed 8-bit number. */
-const i8 = Descriptor.new("i8", exactHint(1), (e, v) => e.i8(v), (d) => d.i8(), (s) => s.u8());
+const i8 = descriptor_Descriptor.new("i8", exactHint(1), (e, v) => e.i8(v), (d) => d.i8(), (s) => s.u8());
 /** 1-byte boolean value. */
-const bool = Descriptor.new("bool", exactHint(1), (e, v) => e.bool(v), (d) => d.bool(), (s) => s.bool());
+const bool = descriptor_Descriptor.new("bool", exactHint(1), (e, v) => e.bool(v), (d) => d.bool(), (s) => s.bool());
 /** Variable-length bytes blob. */
-const blob = Descriptor.new("BytesBlob", { bytes: TYPICAL_SEQUENCE_LENGTH, isExact: false }, (e, v) => e.bytesBlob(v), (d) => d.bytesBlob(), (s) => s.bytesBlob());
+const blob = descriptor_Descriptor.new("BytesBlob", { bytes: TYPICAL_SEQUENCE_LENGTH, isExact: false }, (e, v) => e.bytesBlob(v), (d) => d.bytesBlob(), (s) => s.bytesBlob());
 /** String encoded as variable-length bytes blob. */
-const string = Descriptor.withView("string", { bytes: TYPICAL_SEQUENCE_LENGTH, isExact: false }, (e, v) => e.bytesBlob(bytes_BytesBlob.blobFrom(new TextEncoder().encode(v))), (d) => new TextDecoder("utf8", { fatal: true }).decode(d.bytesBlob().raw), (s) => s.bytesBlob(), blob);
+const string = descriptor_Descriptor.withView("string", { bytes: TYPICAL_SEQUENCE_LENGTH, isExact: false }, (e, v) => e.bytesBlob(bytes_BytesBlob.blobFrom(new TextEncoder().encode(v))), (d) => new TextDecoder("utf8", { fatal: true }).decode(d.bytesBlob().raw), (s) => s.bytesBlob(), blob);
 /** Variable-length bit vector. */
-const bitVecVarLen = Descriptor.new("BitVec[?]", { bytes: TYPICAL_SEQUENCE_LENGTH >>> 3, isExact: false }, (e, v) => e.bitVecVarLen(v), (d) => d.bitVecVarLen(), (s) => s.bitVecVarLen());
+const bitVecVarLen = descriptor_Descriptor.new("BitVec[?]", { bytes: TYPICAL_SEQUENCE_LENGTH >>> 3, isExact: false }, (e, v) => e.bitVecVarLen(v), (d) => d.bitVecVarLen(), (s) => s.bitVecVarLen());
 /** Fixed-length bit vector. */
-const bitVecFixLen = (bitLen) => Descriptor.new(`BitVec[${bitLen}]`, exactHint(bitLen >>> 3), (e, v) => e.bitVecFixLen(v), (d) => d.bitVecFixLen(bitLen), (s) => s.bitVecFixLen(bitLen));
+const bitVecFixLen = (bitLen) => descriptor_Descriptor.new(`BitVec[${bitLen}]`, exactHint(bitLen >>> 3), (e, v) => e.bitVecFixLen(v), (d) => d.bitVecFixLen(bitLen), (s) => s.bitVecFixLen(bitLen));
 /** Optionality wrapper for given type. */
 const optional = (type) => {
-    const self = Descriptor.new(`Optional<${type.name}>`, addSizeHints({ bytes: 1, isExact: false }, type.sizeHint), (e, v) => e.optional(type, v), (d) => d.optional(type), (s) => s.optional(type));
+    const self = descriptor_Descriptor.new(`Optional<${type.name}>`, addSizeHints({ bytes: 1, isExact: false }, type.sizeHint), (e, v) => e.optional(type, v), (d) => d.optional(type), (s) => s.optional(type));
     if (hasUniqueView(type)) {
-        return Descriptor.withView(self.name, self.sizeHint, self.encode, self.decode, self.skip, optional(type.View));
+        return descriptor_Descriptor.withView(self.name, self.sizeHint, self.encode, self.decode, self.skip, optional(type.View));
     }
     return self;
 };
@@ -6657,7 +6656,7 @@ const sequenceVarLen = (type, options = {
 }) => {
     const name = `Sequence<${type.name}>[?]`;
     const typicalLength = options.typicalLength ?? TYPICAL_SEQUENCE_LENGTH;
-    return Descriptor.withView(name, { bytes: typicalLength * type.sizeHint.bytes, isExact: false }, (e, v) => {
+    return descriptor_Descriptor.withView(name, { bytes: typicalLength * type.sizeHint.bytes, isExact: false }, (e, v) => {
         validateLength(options, v.length, name);
         e.sequenceVarLen(type, v);
     }, (d) => {
@@ -6671,10 +6670,10 @@ const sequenceVarLen = (type, options = {
     }, sequenceViewVarLen(type, options));
 };
 /** Fixed-length sequence of given type. */
-const sequenceFixLen = (type, len) => Descriptor.withView(`Sequence<${type.name}>[${len}]`, { bytes: len * type.sizeHint.bytes, isExact: type.sizeHint.isExact }, (e, v) => e.sequenceFixLen(type, v), (d) => d.sequenceFixLen(type, len), (s) => s.sequenceFixLen(type, len), sequenceViewFixLen(type, { fixedLength: len }));
+const sequenceFixLen = (type, len) => descriptor_Descriptor.withView(`Sequence<${type.name}>[${len}]`, { bytes: len * type.sizeHint.bytes, isExact: type.sizeHint.isExact }, (e, v) => e.sequenceFixLen(type, v), (d) => d.sequenceFixLen(type, len), (s) => s.sequenceFixLen(type, len), sequenceViewFixLen(type, { fixedLength: len }));
 /** Small dictionary codec. */
 const dictionary = (key, value, { sortKeys, fixedLength, }) => {
-    const self = Descriptor.new(`Dictionary<${key.name}, ${value.name}>[${fixedLength ?? "?"}]`, {
+    const self = descriptor_Descriptor.new(`Dictionary<${key.name}, ${value.name}>[${fixedLength ?? "?"}]`, {
         bytes: fixedLength !== undefined
             ? fixedLength * addSizeHints(key.sizeHint, value.sizeHint).bytes
             : TYPICAL_DICTIONARY_LENGTH * (addSizeHints(key.sizeHint, value.sizeHint).bytes ?? 0),
@@ -6713,13 +6712,13 @@ const dictionary = (key, value, { sortKeys, fixedLength, }) => {
         s.sequenceFixLen(value, len);
     });
     if (hasUniqueView(value)) {
-        return Descriptor.withView(self.name, self.sizeHint, self.encode, self.decode, self.skip, dictionary(key, value.View, { sortKeys, fixedLength }));
+        return descriptor_Descriptor.withView(self.name, self.sizeHint, self.encode, self.decode, self.skip, dictionary(key, value.View, { sortKeys, fixedLength }));
     }
     return self;
 };
 /** Encoding of pair of two values. */
 const pair = (a, b) => {
-    const self = Descriptor.new(`Pair<${a.name}, ${b.name}>`, addSizeHints(a.sizeHint, b.sizeHint), (e, elem) => {
+    const self = descriptor_Descriptor.new(`Pair<${a.name}, ${b.name}>`, addSizeHints(a.sizeHint, b.sizeHint), (e, elem) => {
         a.encode(e, elem[0]);
         b.encode(e, elem[1]);
     }, (d) => {
@@ -6731,12 +6730,12 @@ const pair = (a, b) => {
         b.skip(s);
     });
     if (hasUniqueView(a) && hasUniqueView(b)) {
-        return Descriptor.withView(self.name, self.sizeHint, self.encode, self.decode, self.skip, pair(a.View, b.View));
+        return descriptor_Descriptor.withView(self.name, self.sizeHint, self.encode, self.decode, self.skip, pair(a.View, b.View));
     }
     return self;
 };
 /** Custom encoding / decoding logic. */
-const custom = ({ name, sizeHint = { bytes: 0, isExact: false }, }, encode, decode, skip) => Descriptor.new(name, sizeHint, encode, decode, skip);
+const custom = ({ name, sizeHint = { bytes: 0, isExact: false }, }, encode, decode, skip) => descriptor_Descriptor.new(name, sizeHint, encode, decode, skip);
 /** Tagged union type encoding. */
 const union = (name, variants) => {
     const keys = Object.keys(variants).map(Number);
@@ -6777,12 +6776,12 @@ const union = (name, variants) => {
         const codec = variants[kind];
         codec.skip(s);
     };
-    return Descriptor.new(name, sizeHint, encode, decode, skip);
+    return descriptor_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);
-    return Descriptor.withView(name, sizeHint, (e, x) => chooser(e.getContext()).encode(e, x), (d) => chooser(d.getContext()).decode(d), (s) => chooser(s.decoder.getContext()).skip(s), hasUniqueView(Self)
+    return descriptor_Descriptor.withView(name, sizeHint, (e, x) => chooser(e.getContext()).encode(e, x), (d) => chooser(d.getContext()).decode(d), (s) => chooser(s.decoder.getContext()).skip(s), hasUniqueView(Self)
         ? descriptors_select({
             name: Self.View.name,
             sizeHint: Self.View.sizeHint,
@@ -6825,7 +6824,7 @@ const Class = (Class, descriptors) => {
     };
     const view = objectView(Class, descriptors, sizeHint, skipper);
     // and create the descriptor for the entire class.
-    return Descriptor.withView(Class.name, sizeHint, (e, t) => {
+    return descriptor_Descriptor.withView(Class.name, sizeHint, (e, t) => {
         forEachDescriptor(descriptors, (key, descriptor) => {
             const value = t[key];
             descriptor.encode(e, value);
@@ -6878,7 +6877,7 @@ function objectView(Class, descriptors, sizeHint, skipper) {
             });
         }
     });
-    return Descriptor.new(`View<${Class.name}>`, sizeHint, (e, t) => {
+    return descriptor_Descriptor.new(`View<${Class.name}>`, sizeHint, (e, t) => {
         const encoded = t.encoded();
         e.bytes(bytes_Bytes.fromBlob(encoded.raw, encoded.length));
     }, (d) => {
@@ -6897,7 +6896,7 @@ function sequenceViewVarLen(type, options) {
         validateLength(options, length, name);
         return s.sequenceFixLen(type, length);
     };
-    return Descriptor.new(name, sizeHint, (e, t) => {
+    return descriptor_Descriptor.new(name, sizeHint, (e, t) => {
         validateLength(options, t.length, name);
         const encoded = t.encoded();
         e.bytes(bytes_Bytes.fromBlob(encoded.raw, encoded.length));
@@ -6913,7 +6912,7 @@ function sequenceViewFixLen(type, { fixedLength }) {
     const skipper = (s) => s.sequenceFixLen(type, fixedLength);
     const view = type.name !== type.View.name ? `, ${type.View.name}` : "";
     const name = `SeqView<${type.name}${view}>[${fixedLength}]`;
-    return Descriptor.new(name, sizeHint, (e, t) => {
+    return descriptor_Descriptor.new(name, sizeHint, (e, t) => {
         const encoded = t.encoded();
         e.bytes(bytes_Bytes.fromBlob(encoded.raw, encoded.length));
     }, (d) => {
@@ -7743,6 +7742,7 @@ const ZERO_HASH = bytes_Bytes.zero(hash_HASH_SIZE);
 class WithHash extends WithDebug {
     hash;
     data;
+    // TODO [ToDr] use static method and make constructor private
     constructor(hash, data) {
         super();
         this.hash = hash;
@@ -9176,7 +9176,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)), } = {}) => {
-    return Descriptor.new(`HashDictionary<${value.name}>[?]`, {
+    return descriptor_Descriptor.new(`HashDictionary<${value.name}>[?]`, {
         bytes: typicalLength * value.sizeHint.bytes,
         isExact: false,
     }, (e, v) => {
@@ -9751,14 +9751,18 @@ class work_item_WorkItem extends WithDebug {
 
 
 
-/** Verify the value is within the `WorkItemsCount` bounds. */
+/** Convert the value to `WorkItemsCount` bounds. */
 function tryAsWorkItemsCount(len) {
     debug_check `
-    ${len >= MIN_NUMBER_OF_WORK_ITEMS && len <= work_package_MAX_NUMBER_OF_WORK_ITEMS}
+    ${isWorkItemsCount(len)}
     WorkItemsCount: Expected '${MIN_NUMBER_OF_WORK_ITEMS} <= count <= ${work_package_MAX_NUMBER_OF_WORK_ITEMS}' got ${len}
   `;
     return tryAsU8(len);
 }
+/** Verify the value is within the `WorkItemsCount` bounds. */
+function isWorkItemsCount(len) {
+    return len >= MIN_NUMBER_OF_WORK_ITEMS && len <= work_package_MAX_NUMBER_OF_WORK_ITEMS;
+}
 /** Minimal number of work items in the work package or results in work report. */
 const MIN_NUMBER_OF_WORK_ITEMS = 1;
 /** `I`: Maximal number of work items in the work package or results in work report. */
@@ -9859,6 +9863,12 @@ class WorkExecResult extends WithDebug {
         }
         return { kind: x.kind };
     }, (x) => new WorkExecResult(x.kind, x.kind === WorkExecResultKind.ok ? x.okBlob : null));
+    static ok(blob) {
+        return new WorkExecResult(WorkExecResultKind.ok, blob);
+    }
+    static error(kind) {
+        return new WorkExecResult(kind, null);
+    }
     constructor(
     /** The execution result tag. */
     kind, 
@@ -10949,22 +10959,22 @@ const workExecResultFromJson = json.object({
 }, (val) => {
     const { ok, out_of_gas, panic, bad_code, code_oversize, output_oversize } = val;
     if (ok !== undefined) {
-        return new WorkExecResult(numbers_tryAsU32(WorkExecResultKind.ok), ok);
+        return WorkExecResult.ok(ok);
     }
     if (out_of_gas === null) {
-        return new WorkExecResult(numbers_tryAsU32(WorkExecResultKind.outOfGas));
+        return WorkExecResult.error(WorkExecResultKind.outOfGas);
     }
     if (panic === null) {
-        return new WorkExecResult(numbers_tryAsU32(WorkExecResultKind.panic));
+        return WorkExecResult.error(WorkExecResultKind.panic);
     }
     if (bad_code === null) {
-        return new WorkExecResult(numbers_tryAsU32(WorkExecResultKind.badCode));
+        return WorkExecResult.error(WorkExecResultKind.badCode);
     }
     if (code_oversize === null) {
-        return new WorkExecResult(numbers_tryAsU32(WorkExecResultKind.codeOversize));
+        return WorkExecResult.error(WorkExecResultKind.codeOversize);
     }
     if (output_oversize === null) {
-        return new WorkExecResult(numbers_tryAsU32(WorkExecResultKind.digestTooBig));
+        return WorkExecResult.error(WorkExecResultKind.digestTooBig);
     }
     throw new Error("Invalid WorkExecResult");
 });
@@ -11162,6 +11172,13 @@ const blockFromJson = (spec) => json.object({
     header: headerFromJson,
     extrinsic: getExtrinsicFromJson(spec),
 }, ({ header, extrinsic }) => Block.create({ header, extrinsic }));
+const blockViewFromJson = (spec) => {
+    const parseBlock = blockFromJson(spec);
+    return json.fromAny((p) => {
+        const block = parse_parseFromJson(p, parseBlock);
+        return reencodeAsView(Block.Codec, block, spec);
+    });
+};
 
 ;// CONCATENATED MODULE: ./packages/jam/block-json/index.ts
 
@@ -11656,13 +11673,13 @@ const getStateCodec = codec_codec.bytes(hash_HASH_SIZE).asOpaque();
 /** StateRoot ::= StateRootHash */
 const stateRootCodec = codec_codec.bytes(hash_HASH_SIZE).asOpaque();
 /** Error ::= UTF8String */
-class ErrorMessage extends WithDebug {
+class types_ErrorMessage extends WithDebug {
     message;
-    static Codec = codec_codec.Class(ErrorMessage, {
+    static Codec = codec_codec.Class(types_ErrorMessage, {
         message: codec_codec.string,
     });
     static create({ message }) {
-        return new ErrorMessage(message);
+        return new types_ErrorMessage(message);
     }
     constructor(message) {
         super();
@@ -11716,7 +11733,7 @@ const types_messageCodec = codec_codec.custom({
             stateCodec.encode(e, msg.value);
             break;
         case types_MessageType.Error:
-            ErrorMessage.Codec.encode(e, msg.value);
+            types_ErrorMessage.Codec.encode(e, msg.value);
             break;
         default:
             throw new Error(`Unknown message type: ${msg}`);
@@ -11737,7 +11754,7 @@ const types_messageCodec = codec_codec.custom({
         case types_MessageType.State:
             return { type: types_MessageType.State, value: stateCodec.decode(d) };
         case types_MessageType.Error:
-            return { type: types_MessageType.Error, value: ErrorMessage.Codec.decode(d) };
+            return { type: types_MessageType.Error, value: types_ErrorMessage.Codec.decode(d) };
         default:
             throw new Error(`Unknown message type: ${type}`);
     }
@@ -11763,7 +11780,7 @@ const types_messageCodec = codec_codec.custom({
             stateCodec.View.skip(s);
             break;
         case types_MessageType.Error:
-            ErrorMessage.Codec.View.skip(s);
+            types_ErrorMessage.Codec.View.skip(s);
             break;
         default:
             throw new Error(`Unknown message type: ${type}`);
@@ -11826,35 +11843,59 @@ class FuzzTarget {
                 break;
             }
             case MessageType.Initialize: {
-                const stateRoot = await this.msgHandler.initialize(message.value);
-                response = {
-                    type: MessageType.StateRoot,
-                    value: stateRoot,
-                };
-                break;
-            }
-            case MessageType.ImportBlock: {
-                const result = await this.msgHandler.importBlock(message.value);
-                if (result.isOk) {
+                try {
+                    const stateRoot = await this.msgHandler.initialize(message.value);
                     response = {
                         type: MessageType.StateRoot,
-                        value: result.ok,
+                        value: stateRoot,
                     };
                 }
-                else {
+                catch (e) {
+                    response = {
+                        type: MessageType.Error,
+                        value: ErrorMessage.create({ message: `initialize error: ${e}` }),
+                    };
+                }
+                break;
+            }
+            case MessageType.ImportBlock: {
+                try {
+                    const result = await this.msgHandler.importBlock(message.value);
+                    if (result.isOk) {
+                        response = {
+                            type: MessageType.StateRoot,
+                            value: result.ok,
+                        };
+                    }
+                    else {
+                        response = {
+                            type: MessageType.Error,
+                            value: result.error,
+                        };
+                    }
+                }
+                catch (e) {
                     response = {
                         type: MessageType.Error,
-                        value: result.error,
+                        value: ErrorMessage.create({ message: `importBlock error: ${e}` }),
                     };
                 }
                 break;
             }
             case MessageType.GetState: {
-                const state = await this.msgHandler.getSerializedState(message.value);
-                response = {
-                    type: MessageType.State,
-                    value: state,
-                };
+                try {
+                    const state = await this.msgHandler.getSerializedState(message.value);
+                    response = {
+                        type: MessageType.State,
+                        value: state,
+                    };
+                }
+                catch (e) {
+                    response = {
+                        type: MessageType.Error,
+                        value: ErrorMessage.create({ message: `getState error: ${e}` }),
+                    };
+                }
                 break;
             }
             case MessageType.StateRoot: {
@@ -12314,13 +12355,6 @@ function hashComparator(a, b) {
     return a.compare(b);
 }
 
-;// CONCATENATED MODULE: ./packages/core/pvm-interpreter/ops/math-consts.ts
-const math_consts_MAX_VALUE = 4294967295;
-const math_consts_MAX_VALUE_U64 = (/* unused pure expression or super */ null && (2n ** 63n));
-const math_consts_MIN_VALUE = (/* unused pure expression or super */ null && (-(2 ** 31)));
-const math_consts_MAX_SHIFT_U32 = 32;
-const math_consts_MAX_SHIFT_U64 = 64n;
-
 ;// CONCATENATED MODULE: ./packages/jam/state/recent-blocks.ts
 
 
@@ -12575,7 +12609,7 @@ const zeroSizeHint = {
 /** 0-byte read, return given default value */
 const ignoreValueWithDefault = (defaultValue) => Descriptor.new("ignoreValue", zeroSizeHint, (_e, _v) => { }, (_d) => defaultValue, (_s) => { });
 /** Encode and decode object with leading version number. */
-const codecWithVersion = (val) => Descriptor.new("withVersion", {
+const codecWithVersion = (val) => descriptor_Descriptor.new("withVersion", {
     bytes: val.sizeHint.bytes + 8,
     isExact: false,
 }, (e, v) => {
@@ -12738,8 +12772,6 @@ class LookupHistoryItem {
 
 
 
-
-
 /**
  * Activity Record of a single validator.
  *
@@ -12870,42 +12902,20 @@ class ServiceStatistics {
     extrinsicCount;
     accumulateCount;
     accumulateGasUsed;
-    onTransfersCount;
-    onTransfersGasUsed;
-    static Codec = Compatibility.selectIfGreaterOrEqual({
-        fallback: codec_codec.Class(ServiceStatistics, {
-            providedCount: codecVarU16,
-            providedSize: codec_codec.varU32,
-            refinementCount: codec_codec.varU32,
-            refinementGasUsed: codecVarGas,
-            imports: codecVarU16,
-            extrinsicCount: codecVarU16,
-            extrinsicSize: codec_codec.varU32,
-            exports: codecVarU16,
-            accumulateCount: codec_codec.varU32,
-            accumulateGasUsed: codecVarGas,
-            onTransfersCount: codec_codec.varU32,
-            onTransfersGasUsed: codecVarGas,
-        }),
-        versions: {
-            [GpVersion.V0_7_1]: codec_codec.Class(ServiceStatistics, {
-                providedCount: codecVarU16,
-                providedSize: codec_codec.varU32,
-                refinementCount: codec_codec.varU32,
-                refinementGasUsed: codecVarGas,
-                imports: codecVarU16,
-                extrinsicCount: codecVarU16,
-                extrinsicSize: codec_codec.varU32,
-                exports: codecVarU16,
-                accumulateCount: codec_codec.varU32,
-                accumulateGasUsed: codecVarGas,
-                onTransfersCount: ignoreValueWithDefault(numbers_tryAsU32(0)),
-                onTransfersGasUsed: ignoreValueWithDefault(tryAsServiceGas(0)),
-            }),
-        },
+    static Codec = codec_codec.Class(ServiceStatistics, {
+        providedCount: codecVarU16,
+        providedSize: codec_codec.varU32,
+        refinementCount: codec_codec.varU32,
+        refinementGasUsed: codecVarGas,
+        imports: codecVarU16,
+        extrinsicCount: codecVarU16,
+        extrinsicSize: codec_codec.varU32,
+        exports: codecVarU16,
+        accumulateCount: codec_codec.varU32,
+        accumulateGasUsed: codecVarGas,
     });
     static create(v) {
-        return new ServiceStatistics(v.providedCount, v.providedSize, v.refinementCount, v.refinementGasUsed, v.imports, v.exports, v.extrinsicSize, v.extrinsicCount, v.accumulateCount, v.accumulateGasUsed, v.onTransfersCount, v.onTransfersGasUsed);
+        return new ServiceStatistics(v.providedCount, v.providedSize, v.refinementCount, v.refinementGasUsed, v.imports, v.exports, v.extrinsicSize, v.extrinsicCount, v.accumulateCount, v.accumulateGasUsed);
     }
     constructor(
     /** `p.0` */
@@ -12927,11 +12937,7 @@ class ServiceStatistics {
     /** `a.0` */
     accumulateCount, 
     /** `a.1` */
-    accumulateGasUsed, 
-    /** `t.0` @deprecated since 0.7.1 */
-    onTransfersCount, 
-    /** `t.1` @deprecated since 0.7.1 */
-    onTransfersGasUsed) {
+    accumulateGasUsed) {
         this.providedCount = providedCount;
         this.providedSize = providedSize;
         this.refinementCount = refinementCount;
@@ -12942,14 +12948,12 @@ class ServiceStatistics {
         this.extrinsicCount = extrinsicCount;
         this.accumulateCount = accumulateCount;
         this.accumulateGasUsed = accumulateGasUsed;
-        this.onTransfersCount = onTransfersCount;
-        this.onTransfersGasUsed = onTransfersGasUsed;
     }
     static empty() {
         const zero = numbers_tryAsU32(0);
         const zero16 = numbers_tryAsU16(0);
         const zeroGas = tryAsServiceGas(0);
-        return new ServiceStatistics(zero16, zero, zero, zeroGas, zero16, zero16, zero, zero16, zero, zeroGas, zero, zeroGas);
+        return new ServiceStatistics(zero16, zero, zero, zeroGas, zero16, zero16, zero, zero16, zero, zeroGas);
     }
 }
 /** `pi`: Statistics of each validator, cores statistics and services statistics. */
@@ -13048,9 +13052,6 @@ class InMemoryStateView {
 ;// CONCATENATED MODULE: ./packages/jam/state/privileged-services.ts
 
 
-
-
-
 /**
  * https://graypaper.fluffylabs.dev/#/ab2cdbd/114402114402?v=0.7.2
  */
@@ -13065,9 +13066,7 @@ class PrivilegedServices {
         manager: codec_codec.u32.asOpaque(),
         assigners: codecPerCore(codec_codec.u32.asOpaque()),
         delegator: codec_codec.u32.asOpaque(),
-        registrar: Compatibility.isGreaterOrEqual(GpVersion.V0_7_1)
-            ? codec_codec.u32.asOpaque()
-            : ignoreValueWithDefault(tryAsServiceId(2 ** 32 - 1)),
+        registrar: codec_codec.u32.asOpaque(),
         autoAccumulateServices: codec_codec.dictionary(codec_codec.u32.asOpaque(), codec_codec.u64.asOpaque(), {
             sortKeys: (a, b) => a - b,
         }),
@@ -13300,7 +13299,6 @@ class UpdateStorage {
 
 
 
-
 
 
 var UpdateError;
@@ -13733,7 +13731,7 @@ class InMemoryState extends WithDebug {
                 manager: tryAsServiceId(0),
                 assigners: tryAsPerCore(new Array(spec.coresCount).fill(tryAsServiceId(0)), spec),
                 delegator: tryAsServiceId(0),
-                registrar: tryAsServiceId(math_consts_MAX_VALUE),
+                registrar: tryAsServiceId(numbers_MAX_VALUE_U32),
                 autoAccumulateServices: new Map(),
             }),
             accumulationOutputLog: SortedArray.fromArray(accumulationOutputComparator, []),
@@ -13783,7 +13781,7 @@ const serviceDataCodec = codec_codec.dictionary(codec_codec.u32.asOpaque(), serv
 
 class JsonServiceInfo {
     static fromJson = json.object({
-        ...(Compatibility.isGreaterOrEqual(GpVersion.V0_7_1) ? { version: "number" } : {}),
+        version: "number",
         code_hash: fromJson.bytes32(),
         balance: json.fromNumber((x) => numbers_tryAsU64(x)),
         min_item_gas: json.fromNumber((x) => tryAsServiceGas(x)),
@@ -13836,33 +13834,61 @@ class JsonStorageItem {
     key;
     value;
 }
-const lookupMetaFromJson = json.object({
+const preimageStatusFromJson = json.object({
     key: {
         hash: fromJson.bytes32(),
         length: "number",
     },
     value: json.array("number"),
-}, ({ key, value }) => new LookupHistoryItem(key.hash, key.length, value));
-const preimageStatusFromJson = json.object({
+}, ({ key, value }) => new LookupHistoryItem(key.hash, numbers_tryAsU32(key.length), value));
+class JsonService {
+    static fromJson = json.object({
+        id: "number",
+        data: {
+            service: JsonServiceInfo.fromJson,
+            storage: json.optional(json.array(JsonStorageItem.fromJson)),
+            preimage_blobs: json.optional(json.array(JsonPreimageItem.fromJson)),
+            preimage_requests: json.optional(json.array(preimageStatusFromJson)),
+        },
+    }, ({ id, data }) => {
+        const preimages = HashDictionary.fromEntries((data.preimage_blobs ?? []).map((x) => [x.hash, x]));
+        const lookupHistory = HashDictionary.new();
+        for (const item of data.preimage_requests ?? []) {
+            const data = lookupHistory.get(item.hash) ?? [];
+            data.push(item);
+            lookupHistory.set(item.hash, data);
+        }
+        const storage = new Map();
+        const entries = (data.storage ?? []).map(({ key, value }) => {
+            const opaqueKey = opaque_asOpaqueType(key);
+            return [opaqueKey, StorageItem.create({ key: opaqueKey, value })];
+        });
+        for (const [key, item] of entries) {
+            storage.set(key.toString(), item);
+        }
+        return new InMemoryService(id, {
+            info: data.service,
+            preimages,
+            storage,
+            lookupHistory,
+        });
+    });
+    id;
+    data;
+}
+const preimageStatusFromJson072 = json.object({
     hash: fromJson.bytes32(),
     status: json.array("number"),
 }, ({ hash, status }) => new LookupHistoryItem(hash, numbers_tryAsU32(0), status));
-class JsonService {
+class JsonServicePre072 {
     static fromJson = json.object({
         id: "number",
-        data: Compatibility.isGreaterOrEqual(GpVersion.V0_7_1)
-            ? {
-                service: JsonServiceInfo.fromJson,
-                storage: json.optional(json.array(JsonStorageItem.fromJson)),
-                preimages_blob: json.optional(json.array(JsonPreimageItem.fromJson)),
-                preimages_status: json.optional(json.array(preimageStatusFromJson)),
-            }
-            : {
-                service: JsonServiceInfo.fromJson,
-                preimages: json.optional(json.array(JsonPreimageItem.fromJson)),
-                storage: json.optional(json.array(JsonStorageItem.fromJson)),
-                lookup_meta: json.optional(json.array(lookupMetaFromJson)),
-            },
+        data: {
+            service: JsonServiceInfo.fromJson,
+            storage: json.optional(json.array(JsonStorageItem.fromJson)),
+            preimages_blob: json.optional(json.array(JsonPreimageItem.fromJson)),
+            preimages_status: json.optional(json.array(preimageStatusFromJson072)),
+        },
     }, ({ id, data }) => {
         const preimages = HashDictionary.fromEntries((data.preimages ?? data.preimages_blob ?? []).map((x) => [x.hash, x]));
         const lookupHistory = HashDictionary.new();
@@ -14021,8 +14047,6 @@ class TicketsOrKeys {
 
 
 
-
-
 class JsonValidatorStatistics {
     static fromJson = json.object({
         blocks: "number",
@@ -14091,13 +14115,7 @@ class JsonServiceStatistics {
         extrinsic_count: "number",
         accumulate_count: "number",
         accumulate_gas_used: json.fromBigInt(tryAsServiceGas),
-        ...(Compatibility.isGreaterOrEqual(GpVersion.V0_7_1)
-            ? {}
-            : {
-                on_transfers_count: "number",
-                on_transfers_gas_used: json.fromBigInt(tryAsServiceGas),
-            }),
-    }, ({ provided_count, provided_size, refinement_count, refinement_gas_used, imports, exports, extrinsic_size, extrinsic_count, accumulate_count, accumulate_gas_used, on_transfers_count, on_transfers_gas_used, }) => {
+    }, ({ provided_count, provided_size, refinement_count, refinement_gas_used, imports, exports, extrinsic_size, extrinsic_count, accumulate_count, accumulate_gas_used, }) => {
         return ServiceStatistics.create({
             providedCount: provided_count,
             providedSize: provided_size,
@@ -14109,8 +14127,6 @@ class JsonServiceStatistics {
             extrinsicCount: extrinsic_count,
             accumulateCount: accumulate_count,
             accumulateGasUsed: accumulate_gas_used,
-            onTransfersCount: on_transfers_count ?? numbers_tryAsU32(0),
-            onTransfersGasUsed: on_transfers_gas_used ?? tryAsServiceGas(0),
         });
     });
     provided_count;
@@ -14123,8 +14139,6 @@ class JsonServiceStatistics {
     extrinsic_count;
     accumulate_count;
     accumulate_gas_used;
-    on_transfers_count;
-    on_transfers_gas_used;
 }
 const serviceStatisticsEntryFromJson = {
     id: "number",
@@ -14183,7 +14197,6 @@ const validatorDataFromJson = json.object({
 
 
 
-
 const fullStateDumpFromJson = (spec) => json.object({
     alpha: json.array(json.array(fromJson.bytes32())),
     varphi: json.array(json.array(fromJson.bytes32())),
@@ -14205,18 +14218,15 @@ const fullStateDumpFromJson = (spec) => json.object({
         chi_m: "number",
         chi_a: json.array("number"),
         chi_v: "number",
-        chi_r: json.optional("number"),
+        chi_r: "number",
         chi_g: json.nullable(json.map("number", json.fromNumber((v) => tryAsServiceGas(v)))),
     },
     pi: JsonStatisticsData.fromJson,
     omega: json.array(json.array(notYetAccumulatedFromJson)),
     xi: json.array(json.array(fromJson.bytes32())),
     theta: json.nullable(json.array(accumulationOutput)),
-    accounts: json.array(JsonService.fromJson),
+    accounts: json.array(JsonServicePre072.fromJson),
 }, ({ alpha, varphi, beta, gamma, psi, eta, iota, kappa, lambda, rho, tau, chi, pi, omega, xi, theta, accounts, }) => {
-    if (Compatibility.isGreaterOrEqual(GpVersion.V0_7_1) && chi.chi_r === undefined) {
-        throw new Error("Registrar is required in Privileges GP ^0.7.1");
-    }
     return InMemoryState.new(spec, {
         authPools: tryAsPerCore(alpha.map((perCore) => {
             if (perCore.length > MAX_AUTH_POOL_SIZE) {
@@ -14246,7 +14256,7 @@ const fullStateDumpFromJson = (spec) => json.object({
             manager: chi.chi_m,
             assigners: chi.chi_a,
             delegator: chi.chi_v,
-            registrar: chi.chi_r ?? tryAsServiceId(2 ** 32 - 1),
+            registrar: chi.chi_r,
             autoAccumulateServices: chi.chi_g ?? new Map(),
         }),
         statistics: JsonStatisticsData.toStatisticsData(spec, pi),
@@ -14422,7 +14432,6 @@ function legacyServiceNested(serviceId, hash) {
 
 
 
-
 /** Serialization for particular state entries. */
 var serialize_serialize;
 (function (serialize) {
@@ -14530,24 +14539,22 @@ var serialize_serialize;
         Codec: codec_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 */
+    /** C(255, s): https://graypaper.fluffylabs.dev/#/ab2cdbd/3b7d033b7d03?v=0.7.2 */
     serialize.serviceData = (serviceId) => ({
         key: stateKeys.serviceInfo(serviceId),
-        Codec: Compatibility.isGreaterOrEqual(GpVersion.V0_7_1)
-            ? codecWithVersion(ServiceAccountInfo.Codec)
-            : ServiceAccountInfo.Codec,
+        Codec: codecWithVersion(ServiceAccountInfo.Codec),
     });
-    /** https://graypaper.fluffylabs.dev/#/85129da/384803384803?v=0.6.3 */
+    /** https://graypaper.fluffylabs.dev/#/ab2cdbd/3bac033bac03?v=0.7.2 */
     serialize.serviceStorage = (blake2b, serviceId, key) => ({
         key: stateKeys.serviceStorage(blake2b, serviceId, key),
         Codec: dumpCodec,
     });
-    /** https://graypaper.fluffylabs.dev/#/85129da/385b03385b03?v=0.6.3 */
+    /** https://graypaper.fluffylabs.dev/#/ab2cdbd/3bc9033bc903?v=0.7.2 */
     serialize.servicePreimages = (blake2b, serviceId, hash) => ({
         key: stateKeys.servicePreimage(blake2b, serviceId, hash),
         Codec: dumpCodec,
     });
-    /** https://graypaper.fluffylabs.dev/#/85129da/387603387603?v=0.6.3 */
+    /** https://graypaper.fluffylabs.dev/#/ab2cdbd/3bea033b0904?v=0.7.2 */
     serialize.serviceLookupHistory = (blake2b, serviceId, hash, len) => ({
         key: stateKeys.serviceLookupHistory(blake2b, serviceId, hash, len),
         Codec: codec_codec.readonlyArray(codec_codec.sequenceVarLen(codec_codec.u32)),
@@ -14560,7 +14567,7 @@ var serialize_serialize;
  * determine the boundary of the bytes, so it can only be used
  * as the last element of the codec and can't be used in sequences!
  */
-const dumpCodec = Descriptor.new("Dump", { bytes: 64, isExact: false }, (e, v) => e.bytes(bytes_Bytes.fromBlob(v.raw, v.raw.length)), (d) => bytes_BytesBlob.blobFrom(d.bytes(d.source.length - d.bytesRead()).raw), (s) => s.bytes(s.decoder.source.length - s.decoder.bytesRead()));
+const dumpCodec = descriptor_Descriptor.new("Dump", { bytes: 64, isExact: false }, (e, v) => e.bytes(bytes_Bytes.fromBlob(v.raw, v.raw.length)), (d) => bytes_BytesBlob.blobFrom(d.bytes(d.source.length - d.bytesRead()).raw), (s) => s.bytes(s.decoder.source.length - s.decoder.bytesRead()));
 
 ;// CONCATENATED MODULE: ./packages/jam/state-merkleization/serialized-state-view.ts
 
@@ -15888,7 +15895,7 @@ const codecMap = (value, extractKey, { typicalLength = codec_codec.TYPICAL_DICTI
     }
     return Ordering.Equal;
 }, } = {}) => {
-    return Descriptor.new(`Map<${value.name}>[?]`, {
+    return descriptor_Descriptor.new(`Map<${value.name}>[?]`, {
         bytes: typicalLength * value.sizeHint.bytes,
         isExact: false,
     }, (e, v) => {
@@ -16065,11 +16072,11 @@ class StateTransition {
     static fromJson = {
         pre_state: TestState.fromJson,
         post_state: TestState.fromJson,
-        block: blockFromJson(chain_spec_tinyChainSpec),
+        block: blockViewFromJson(chain_spec_tinyChainSpec),
     };
     static Codec = codec_codec.object({
         pre_state: TestState.Codec,
-        block: Block.Codec,
+        block: Block.Codec.View,
         post_state: TestState.Codec,
     });
     pre_state;
@@ -16147,41 +16154,21 @@ async function runWorkItemTest(test, { path }) {
 
 
 
-
-const authorizerFromJson = {
-    code_hash: fromJson.bytes32(),
-    params: json.fromString(bytes_BytesBlob.parseBlob),
-};
-const workPackageFromJson = Compatibility.isGreaterOrEqual(GpVersion.V0_7_1)
-    ? json.object({
-        authorization: json.fromString(bytes_BytesBlob.parseBlob),
-        auth_code_host: "number",
-        auth_code_hash: fromJson.bytes32(),
-        authorizer_config: json.fromString(bytes_BytesBlob.parseBlob),
-        context: refineContextFromJson,
-        items: json.array(workItemFromJson),
-    }, ({ authorization, auth_code_host, auth_code_hash, authorizer_config, context, items }) => work_package_WorkPackage.create({
-        authorization,
-        authCodeHost: auth_code_host,
-        authCodeHash: auth_code_hash,
-        parametrization: authorizer_config,
-        context,
-        items: FixedSizeArray.new(items, tryAsWorkItemsCount(items.length)),
-    }))
-    : json.object({
-        authorization: json.fromString(bytes_BytesBlob.parseBlob),
-        auth_code_host: "number",
-        authorizer: authorizerFromJson,
-        context: refineContextFromJson,
-        items: json.array(workItemFromJson),
-    }, ({ authorization, auth_code_host, authorizer, context, items }) => work_package_WorkPackage.create({
-        authorization,
-        authCodeHost: auth_code_host,
-        authCodeHash: authorizer.code_hash,
-        parametrization: authorizer.params,
-        context,
-        items: FixedSizeArray.new(items, tryAsWorkItemsCount(items.length)),
-    }));
+const workPackageFromJson = json.object({
+    authorization: json.fromString(bytes_BytesBlob.parseBlob),
+    auth_code_host: "number",
+    auth_code_hash: fromJson.bytes32(),
+    authorizer_config: json.fromString(bytes_BytesBlob.parseBlob),
+    context: refineContextFromJson,
+    items: json.array(workItemFromJson),
+}, ({ authorization, auth_code_host, auth_code_hash, authorizer_config, context, items }) => work_package_WorkPackage.create({
+    authorization,
+    authCodeHost: auth_code_host,
+    authCodeHash: auth_code_hash,
+    parametrization: authorizer_config,
+    context,
+    items: FixedSizeArray.new(items, tryAsWorkItemsCount(items.length)),
+}));
 async function runWorkPackageTest(test, { path: file }) {
     runCodecTest(WorkPackage.Codec, test, file);
 }
@@ -17893,22 +17880,22 @@ class memory_builder_MemoryBuilder {
  * Overflowing addition for two-complement representation of 32-bit signed numbers.
  */
 function math_utils_addWithOverflowU32(a, b) {
-    if (a > MAX_VALUE - b) {
+    if (a > MAX_VALUE_U32 - b) {
         /**
-         * MAX_VALUE is equal to 2 ** 32 - 1
-         * MAX_VALUE - ( (MAX_VALUE - a) + (MAX_VALUE - b) ) - 1
-         * = MAX_VALUE - (2MAX_VALUE - a - b) -1
-         * = MAX_VALUE - 2MAX_VALUE + a + b - 1
-         * = a + b - MAX_VALUE - 1
+         * MAX_VALUE_U32 is equal to 2 ** 32 - 1
+         * MAX_VALUE_U32 - ( (MAX_VALUE_U32 - a) + (MAX_VALUE_U32 - b) ) - 1
+         * = MAX_VALUE_U32 - (2MAX_VALUE_U32 - a - b) -1
+         * = MAX_VALUE_U32 - 2MAX_VALUE_U32 + a + b - 1
+         * = a + b - MAX_VALUE_U32 - 1
          * = a + b - 2 ** 32
-         * but we know that 2MAX_VALUE > a + b > MAX_VALUE so in this case:
+         * but we know that 2MAX_VALUE_U32 > a + b > MAX_VALUE_U32 so in this case:
          * a + b - 2 ** 32 <=> (a + b) % 2 ** 32
-         * = (a + b) % (MAX_VALUE + 1)
+         * = (a + b) % (MAX_VALUE_U32 + 1)
          */
-        const spaceToMaxA = MAX_VALUE - a;
-        const spaceToMaxB = MAX_VALUE - b;
+        const spaceToMaxA = MAX_VALUE_U32 - a;
+        const spaceToMaxB = MAX_VALUE_U32 - b;
         const overflowSum = spaceToMaxA + spaceToMaxB;
-        return MAX_VALUE - overflowSum - 1;
+        return MAX_VALUE_U32 - overflowSum - 1;
     }
     return a + b;
 }
@@ -17923,7 +17910,7 @@ function math_utils_addWithOverflowU64(a, b) {
  */
 function math_utils_subU32(a, b) {
     if (b > a) {
-        return MAX_VALUE - b + a + 1;
+        return MAX_VALUE_U32 - b + a + 1;
     }
     return a - b;
 }
@@ -18509,7 +18496,7 @@ class math_ops_MathOps {
         if (this.regs.getLowerU32(secondIndex) === 0) {
             this.regs.setU64(resultIndex, 2n ** 64n - 1n);
         }
-        else if (this.regs.getLowerI32(secondIndex) === -1 && this.regs.getLowerI32(firstIndex) === MIN_VALUE) {
+        else if (this.regs.getLowerI32(secondIndex) === -1 && this.regs.getLowerI32(firstIndex) === MIN_VALUE_I32) {
             this.regs.setU64(resultIndex, signExtend32To64(this.regs.getLowerU32(firstIndex)));
         }
         else {
@@ -18547,7 +18534,7 @@ class math_ops_MathOps {
         if (this.regs.getLowerU32(secondIndex) === 0) {
             this.regs.setU64(resultIndex, BigInt(this.regs.getLowerI32(firstIndex)));
         }
-        else if (this.regs.getLowerI32(secondIndex) === -1 && this.regs.getLowerI32(firstIndex) === MIN_VALUE) {
+        else if (this.regs.getLowerI32(secondIndex) === -1 && this.regs.getLowerI32(firstIndex) === MIN_VALUE_I32) {
             this.regs.setU64(resultIndex, 0n);
         }
         else {
@@ -20273,7 +20260,7 @@ const SUPPORTED_TYPES = [
                 if (option === "as-block") {
                     return looseType({
                         encode: Block.Codec,
-                        value: test.block,
+                        value: test.block.materialize(),
                     });
                 }
                 if (option === "as-fuzz-message") {
@@ -20281,11 +20268,9 @@ const SUPPORTED_TYPES = [
                     console.warn("⚠️  Warning: 'as-fuzz-message' is deprecated and will be removed in version 0.6.0. Use 'as-block-fuzz-message' instead.");
                 }
                 if (option === "as-block-fuzz-message" || option === "as-fuzz-message") {
-                    const encoded = encoder_Encoder.encodeObject(Block.Codec, test.block, spec);
-                    const blockView = decoder_Decoder.decodeObject(Block.Codec.View, encoded, spec);
                     const msg = {
                         type: types_MessageType.ImportBlock,
-                        value: blockView,
+                        value: test.block,
                     };
                     return looseType({
                         value: msg,
@@ -20293,13 +20278,14 @@ const SUPPORTED_TYPES = [
                     });
                 }
                 if (option === "as-state-fuzz-message") {
+                    const blockHeader = test.block.header.materialize();
                     const init = Initialize.create({
                         header: header_Header.empty(),
                         keyvals: test.pre_state.keyvals,
                         ancestry: [
                             AncestryItem.create({
-                                headerHash: test.block.header.parentHeaderHash,
-                                slot: common_tryAsTimeSlot(Math.max(0, test.block.header.timeSlotIndex - 1)),
+                                headerHash: blockHeader.parentHeaderHash,
+                                slot: common_tryAsTimeSlot(Math.max(0, blockHeader.timeSlotIndex - 1)),
                             }),
                         ],
                     });