@typeberry/convert 0.5.3-fb6e98a → 0.5.4-472e282

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
 
 /**
@@ -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) => {
@@ -9177,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) => {
@@ -9752,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. */
@@ -11169,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
 
@@ -11663,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();
@@ -11723,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}`);
@@ -11744,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}`);
     }
@@ -11770,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}`);
@@ -11833,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: result.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: 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: {
@@ -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,
         }),
@@ -13782,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)),
@@ -13835,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();
@@ -14020,8 +14047,6 @@ class TicketsOrKeys {
 
 
 
-
-
 class JsonValidatorStatistics {
     static fromJson = json.object({
         blocks: "number",
@@ -14090,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,
@@ -14108,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;
@@ -14122,8 +14139,6 @@ class JsonServiceStatistics {
     extrinsic_count;
     accumulate_count;
     accumulate_gas_used;
-    on_transfers_count;
-    on_transfers_gas_used;
 }
 const serviceStatisticsEntryFromJson = {
     id: "number",
@@ -14182,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())),
@@ -14204,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) {
@@ -14245,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),
@@ -14421,7 +14432,6 @@ function legacyServiceNested(serviceId, hash) {
 
 
 
-
 /** Serialization for particular state entries. */
 var serialize_serialize;
 (function (serialize) {
@@ -14529,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)),
@@ -14559,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
 
@@ -15887,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) => {
@@ -16064,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;
@@ -16146,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);
 }
@@ -20272,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") {
@@ -20280,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,
@@ -20292,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)),
                             }),
                         ],
                     });