@typeberry/convert 0.1.2-ced735c9 → 0.1.3-135961b

package/index.js

@@ -4695,8 +4695,8 @@ function print(level, levelAndName, strings, data) {
         return;
     }
     const lvlText = Level[level].padEnd(5);
-    const val = strings.map((v, idx) => `${v}${data[idx]}`);
-    const msg = `${lvlText} [${levelAndName[1]}] ${val}`;
+    const val = strings.map((v, idx) => `${v}${idx < data.length ? data[idx] : ""}`);
+    const msg = `${lvlText} [${levelAndName[1]}] ${val.join("")}`;
     if (level === Level.WARN) {
         console.warn(msg);
     }
@@ -5511,7 +5511,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.1.2"};
+const package_namespaceObject = {"rE":"0.1.3"};
 ;// CONCATENATED MODULE: ./packages/core/bytes/bitvec.ts
 
 /**
@@ -6867,13 +6867,15 @@ function validateLength(range, length, context) {
 
 /** A caching wrapper for either object or sequence item. */
 class ViewField {
+    name;
     getView;
     getValue;
     getEncoded;
     cachedValue;
     cachedView;
     cachedBlob;
-    constructor(getView, getValue, getEncoded) {
+    constructor(name, getView, getValue, getEncoded) {
+        this.name = name;
         this.getView = getView;
         this.getValue = getValue;
         this.getEncoded = getEncoded;
@@ -6899,6 +6901,9 @@ class ViewField {
         }
         return this.cachedBlob;
     }
+    toString() {
+        return `ViewField<${this.name}>`;
+    }
 }
 /**
  * A base class for all the lazy views.
@@ -6973,7 +6978,7 @@ class ObjectView {
             const fieldDecoder = skipper.decoder.clone();
             const field = this.descriptorsKeys[i];
             const type = this.descriptors[field];
-            lastItem = new ViewField(() => type.View.decode(fieldDecoder.clone()), () => type.decode(fieldDecoder.clone()), () => type.skipEncoded(fieldDecoder.clone()));
+            lastItem = new ViewField(`${this.toString()}.${String(field)}`, () => type.View.decode(fieldDecoder.clone()), () => type.decode(fieldDecoder.clone()), () => type.skipEncoded(fieldDecoder.clone()));
             // skip the field
             type.skip(skipper);
             // cache data
@@ -6985,6 +6990,9 @@ class ObjectView {
         }
         return lastItem;
     }
+    toString() {
+        return `View<${this.materializedConstructor.name}>(cache: ${this.cache.size})`;
+    }
 }
 /**
  * A lazy-evaluated decoder of a sequence.
@@ -7073,7 +7081,7 @@ class SequenceView {
             // create new cached prop
             const fieldDecoder = skipper.decoder.clone();
             const type = this.descriptor;
-            lastItem = new ViewField(() => type.View.decode(fieldDecoder.clone()), () => type.decode(fieldDecoder.clone()), () => type.skipEncoded(fieldDecoder.clone()));
+            lastItem = new ViewField(`${this.toString()}[${index}]`, () => type.View.decode(fieldDecoder.clone()), () => type.decode(fieldDecoder.clone()), () => type.skipEncoded(fieldDecoder.clone()));
             // skip the field
             type.skip(skipper);
             // cache data
@@ -7085,6 +7093,9 @@ class SequenceView {
         }
         return lastItem;
     }
+    toString() {
+        return `SequenceView<${this.descriptor.name}>(cache: ${this.cache.size})`;
+    }
 }
 
 ;// CONCATENATED MODULE: ./packages/core/codec/descriptors.ts
@@ -11498,15 +11509,12 @@ function loadConfig(configPath) {
 
 
 
-;// CONCATENATED MODULE: ./packages/extensions/ipc/fuzz/v0/types.ts
+;// CONCATENATED MODULE: ./packages/jam/fuzz-proto/v1/types.ts
 
 
 
 
 
-/**
- * Reference: https://github.com/davxy/jam-conformance/blob/7c6a371a966c6446564f91676e7a2afdec5fa3da/fuzz-proto/fuzz.asn
- */
 /**
  * Version ::= SEQUENCE {
  *     major INTEGER (0..255),
@@ -11547,190 +11555,17 @@ class Version extends WithDebug {
         this.patch = patch;
     }
 }
-/**
- * PeerInfo ::= SEQUENCE {
- *     name         UTF8String,
- *     app-version  Version,
- *     jam-version  Version
- * }
- */
-class PeerInfo extends WithDebug {
-    name;
-    appVersion;
-    jamVersion;
-    static Codec = descriptors_codec.Class(PeerInfo, {
-        name: descriptors_codec.string,
-        appVersion: Version.Codec,
-        jamVersion: Version.Codec,
-    });
-    static create({ name, appVersion, jamVersion }) {
-        return new PeerInfo(name, appVersion, jamVersion);
-    }
-    constructor(name, appVersion, jamVersion) {
-        super();
-        this.name = name;
-        this.appVersion = appVersion;
-        this.jamVersion = jamVersion;
-    }
-}
-/**
- * KeyValue ::= SEQUENCE {
- *     key     TrieKey,
- *     value   OCTET STRING
- * }
- */
-class KeyValue extends WithDebug {
-    key;
-    value;
-    static Codec = descriptors_codec.Class(KeyValue, {
-        key: descriptors_codec.bytes(TRUNCATED_HASH_SIZE),
-        value: descriptors_codec.blob,
-    });
-    static create({ key, value }) {
-        return new KeyValue(key, value);
-    }
-    constructor(key, value) {
-        super();
-        this.key = key;
-        this.value = value;
-    }
-}
-/** State ::= SEQUENCE OF KeyValue */
-const stateCodec = descriptors_codec.sequenceVarLen(KeyValue.Codec);
-/**
- * SetState ::= SEQUENCE {
- *     header  Header,
- *     state   State
- * }
- */
-class SetState extends WithDebug {
-    header;
-    state;
-    static Codec = descriptors_codec.Class(SetState, {
-        header: header_Header.Codec,
-        state: descriptors_codec.sequenceVarLen(KeyValue.Codec),
-    });
-    static create({ header, state }) {
-        return new SetState(header, state);
-    }
-    constructor(header, state) {
-        super();
-        this.header = header;
-        this.state = state;
-    }
-}
-/** GetState ::= HeaderHash */
-const getStateCodec = descriptors_codec.bytes(hash_HASH_SIZE).asOpaque();
-/** StateRoot ::= StateRootHash */
-const stateRootCodec = descriptors_codec.bytes(hash_HASH_SIZE).asOpaque();
-/** Message choice type tags */
-var MessageType;
-(function (MessageType) {
-    MessageType[MessageType["PeerInfo"] = 0] = "PeerInfo";
-    MessageType[MessageType["ImportBlock"] = 1] = "ImportBlock";
-    MessageType[MessageType["SetState"] = 2] = "SetState";
-    MessageType[MessageType["GetState"] = 3] = "GetState";
-    MessageType[MessageType["State"] = 4] = "State";
-    MessageType[MessageType["StateRoot"] = 5] = "StateRoot";
-})(MessageType || (MessageType = {}));
-/**
- * Message ::= CHOICE {
- *     peer-info    [0] PeerInfo,
- *     import-block [1] ImportBlock,
- *     set-state    [2] SetState,
- *     get-state    [3] GetState,
- *     state        [4] State,
- *     state-root   [5] StateRoot
- * }
- */
-const messageCodec = descriptors_codec.custom({
-    name: "Message",
-    sizeHint: { bytes: 1, isExact: false },
-}, (e, msg) => {
-    e.i8(msg.type);
-    switch (msg.type) {
-        case MessageType.PeerInfo:
-            PeerInfo.Codec.encode(e, msg.value);
-            break;
-        case MessageType.ImportBlock:
-            block_Block.Codec.View.encode(e, msg.value);
-            break;
-        case MessageType.SetState:
-            SetState.Codec.encode(e, msg.value);
-            break;
-        case MessageType.GetState:
-            getStateCodec.encode(e, msg.value);
-            break;
-        case MessageType.State:
-            stateCodec.encode(e, msg.value);
-            break;
-        case MessageType.StateRoot:
-            stateRootCodec.encode(e, msg.value);
-            break;
-        default:
-            throw new Error(`Unknown message type: ${msg}`);
-    }
-}, (d) => {
-    const type = d.u8();
-    switch (type) {
-        case MessageType.PeerInfo:
-            return { type: MessageType.PeerInfo, value: PeerInfo.Codec.decode(d) };
-        case MessageType.ImportBlock:
-            return { type: MessageType.ImportBlock, value: block_Block.Codec.View.decode(d) };
-        case MessageType.SetState:
-            return { type: MessageType.SetState, value: SetState.Codec.decode(d) };
-        case MessageType.GetState:
-            return { type: MessageType.GetState, value: getStateCodec.decode(d) };
-        case MessageType.State:
-            return { type: MessageType.State, value: stateCodec.decode(d) };
-        case MessageType.StateRoot:
-            return { type: MessageType.StateRoot, value: stateRootCodec.decode(d) };
-        default:
-            throw new Error(`Unknown message type: ${type}`);
-    }
-}, (s) => {
-    const type = s.decoder.u8();
-    switch (type) {
-        case MessageType.PeerInfo:
-            PeerInfo.Codec.View.skip(s);
-            break;
-        case MessageType.ImportBlock:
-            block_Block.Codec.View.skip(s);
-            break;
-        case MessageType.SetState:
-            SetState.Codec.View.skip(s);
-            break;
-        case MessageType.GetState:
-            getStateCodec.View.skip(s);
-            break;
-        case MessageType.State:
-            stateCodec.View.skip(s);
-            break;
-        case MessageType.StateRoot:
-            stateRootCodec.View.skip(s);
-            break;
-        default:
-            throw new Error(`Unknown message type: ${type}`);
-    }
-});
-
-;// CONCATENATED MODULE: ./packages/extensions/ipc/fuzz/v1/types.ts
-
-
-
-
-
 /**
  * Fuzzer Protocol V1
  * Reference: https://github.com/davxy/jam-conformance/blob/main/fuzz-proto/fuzz.asn
  */
 // Feature bit constants
-var Features;
+var types_Features;
 (function (Features) {
     Features[Features["Ancestry"] = 1] = "Ancestry";
     Features[Features["Fork"] = 2] = "Fork";
     Features[Features["Reserved"] = 2147483648] = "Reserved";
-})(Features || (Features = {}));
+})(types_Features || (types_Features = {}));
 /**
  * PeerInfo ::= SEQUENCE {
  *     fuzz-version U8,
@@ -11740,13 +11575,13 @@ var Features;
  *     name         UTF8String
  * }
  */
-class types_PeerInfo extends WithDebug {
+class PeerInfo extends WithDebug {
     fuzzVersion;
     features;
     jamVersion;
     appVersion;
     name;
-    static Codec = descriptors_codec.Class(types_PeerInfo, {
+    static Codec = descriptors_codec.Class(PeerInfo, {
         fuzzVersion: descriptors_codec.u8,
         features: descriptors_codec.u32,
         jamVersion: Version.Codec,
@@ -11754,7 +11589,7 @@ class types_PeerInfo extends WithDebug {
         name: descriptors_codec.string,
     });
     static create({ fuzzVersion, features, appVersion, jamVersion, name }) {
-        return new types_PeerInfo(fuzzVersion, features, jamVersion, appVersion, name);
+        return new PeerInfo(fuzzVersion, features, jamVersion, appVersion, name);
     }
     constructor(fuzzVersion, features, jamVersion, appVersion, name) {
         super();
@@ -11787,6 +11622,30 @@ class AncestryItem extends WithDebug {
         this.headerHash = headerHash;
     }
 }
+/**
+ * KeyValue ::= SEQUENCE {
+ *     key     TrieKey,
+ *     value   OCTET STRING
+ * }
+ */
+class KeyValue extends WithDebug {
+    key;
+    value;
+    static Codec = descriptors_codec.Class(KeyValue, {
+        key: descriptors_codec.bytes(TRUNCATED_HASH_SIZE),
+        value: descriptors_codec.blob,
+    });
+    static create({ key, value }) {
+        return new KeyValue(key, value);
+    }
+    constructor(key, value) {
+        super();
+        this.key = key;
+        this.value = value;
+    }
+}
+/** State ::= SEQUENCE OF KeyValue */
+const stateCodec = descriptors_codec.sequenceVarLen(KeyValue.Codec);
 /**
  * Ancestry ::= SEQUENCE (SIZE(0..24)) OF AncestryItem
  * Empty when `feature-ancestry` is not supported by both parties
@@ -11822,9 +11681,9 @@ class Initialize extends WithDebug {
     }
 }
 /** GetState ::= HeaderHash */
-const types_getStateCodec = descriptors_codec.bytes(hash_HASH_SIZE).asOpaque();
+const getStateCodec = descriptors_codec.bytes(hash_HASH_SIZE).asOpaque();
 /** StateRoot ::= StateRootHash */
-const types_stateRootCodec = descriptors_codec.bytes(hash_HASH_SIZE).asOpaque();
+const stateRootCodec = descriptors_codec.bytes(hash_HASH_SIZE).asOpaque();
 /** Error ::= UTF8String */
 class ErrorMessage extends WithDebug {
     message;
@@ -11868,19 +11727,19 @@ const types_messageCodec = descriptors_codec.custom({
     e.i8(msg.type);
     switch (msg.type) {
         case types_MessageType.PeerInfo:
-            types_PeerInfo.Codec.encode(e, msg.value);
+            PeerInfo.Codec.encode(e, msg.value);
             break;
         case types_MessageType.Initialize:
             Initialize.Codec.encode(e, msg.value);
             break;
         case types_MessageType.StateRoot:
-            types_stateRootCodec.encode(e, msg.value);
+            stateRootCodec.encode(e, msg.value);
             break;
         case types_MessageType.ImportBlock:
             block_Block.Codec.View.encode(e, msg.value);
             break;
         case types_MessageType.GetState:
-            types_getStateCodec.encode(e, msg.value);
+            getStateCodec.encode(e, msg.value);
             break;
         case types_MessageType.State:
             stateCodec.encode(e, msg.value);
@@ -11895,15 +11754,15 @@ const types_messageCodec = descriptors_codec.custom({
     const type = d.u8();
     switch (type) {
         case types_MessageType.PeerInfo:
-            return { type: types_MessageType.PeerInfo, value: types_PeerInfo.Codec.decode(d) };
+            return { type: types_MessageType.PeerInfo, value: PeerInfo.Codec.decode(d) };
         case types_MessageType.Initialize:
             return { type: types_MessageType.Initialize, value: Initialize.Codec.decode(d) };
         case types_MessageType.StateRoot:
-            return { type: types_MessageType.StateRoot, value: types_stateRootCodec.decode(d) };
+            return { type: types_MessageType.StateRoot, value: stateRootCodec.decode(d) };
         case types_MessageType.ImportBlock:
             return { type: types_MessageType.ImportBlock, value: block_Block.Codec.View.decode(d) };
         case types_MessageType.GetState:
-            return { type: types_MessageType.GetState, value: types_getStateCodec.decode(d) };
+            return { type: types_MessageType.GetState, value: getStateCodec.decode(d) };
         case types_MessageType.State:
             return { type: types_MessageType.State, value: stateCodec.decode(d) };
         case types_MessageType.Error:
@@ -11915,19 +11774,19 @@ const types_messageCodec = descriptors_codec.custom({
     const type = s.decoder.u8();
     switch (type) {
         case types_MessageType.PeerInfo:
-            types_PeerInfo.Codec.View.skip(s);
+            PeerInfo.Codec.View.skip(s);
             break;
         case types_MessageType.Initialize:
             Initialize.Codec.View.skip(s);
             break;
         case types_MessageType.StateRoot:
-            types_stateRootCodec.View.skip(s);
+            stateRootCodec.View.skip(s);
             break;
         case types_MessageType.ImportBlock:
             block_Block.Codec.View.skip(s);
             break;
         case types_MessageType.GetState:
-            types_getStateCodec.View.skip(s);
+            getStateCodec.View.skip(s);
             break;
         case types_MessageType.State:
             stateCodec.View.skip(s);
@@ -11940,6 +11799,145 @@ const types_messageCodec = descriptors_codec.custom({
     }
 });
 
+;// CONCATENATED MODULE: ./packages/jam/fuzz-proto/v1/handler.ts
+
+
+
+
+const handler_logger = Logger.new(import.meta.filename, "ext-ipc-fuzz-v1");
+class FuzzTarget {
+    msgHandler;
+    sender;
+    spec;
+    sessionFeatures = 0;
+    constructor(msgHandler, sender, spec) {
+        this.msgHandler = msgHandler;
+        this.sender = sender;
+        this.spec = spec;
+    }
+    async onSocketMessage(msg) {
+        // attempt to decode the messsage
+        try {
+            const message = Decoder.decodeObject(messageCodec, msg, this.spec);
+            handler_logger.log `[${message.type}] incoming message`;
+            await this.processAndRespond(message);
+        }
+        catch (e) {
+            handler_logger.error `Error while processing fuzz v1 message: ${e}`;
+            handler_logger.error `${e}`;
+            if (e instanceof Error) {
+                handler_logger.error `${e.stack ?? ""}`;
+            }
+            this.sender.close();
+        }
+    }
+    async processAndRespond(message) {
+        let response = null;
+        switch (message.type) {
+            case MessageType.PeerInfo: {
+                // only support V1
+                if (message.value.fuzzVersion !== 1) {
+                    handler_logger.warn `Unsupported fuzzer protocol version: ${message.value.fuzzVersion}. Closing`;
+                    this.sender.close();
+                    return;
+                }
+                // Handle handshake
+                const ourPeerInfo = await this.msgHandler.getPeerInfo(message.value);
+                // Calculate session features (intersection of both peer features)
+                this.sessionFeatures = message.value.features & ourPeerInfo.features;
+                handler_logger.info `Handshake completed. Shared features: 0b${this.sessionFeatures.toString(2)}`;
+                handler_logger.log `Feature ancestry: ${(this.sessionFeatures & Features.Ancestry) !== 0}`;
+                handler_logger.log `Feature fork: ${(this.sessionFeatures & Features.Fork) !== 0}`;
+                response = {
+                    type: MessageType.PeerInfo,
+                    value: ourPeerInfo,
+                };
+                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) {
+                    response = {
+                        type: MessageType.StateRoot,
+                        value: result.ok,
+                    };
+                }
+                else {
+                    response = {
+                        type: MessageType.Error,
+                        value: result.error,
+                    };
+                }
+                break;
+            }
+            case MessageType.GetState: {
+                const state = await this.msgHandler.getSerializedState(message.value);
+                response = {
+                    type: MessageType.State,
+                    value: state,
+                };
+                break;
+            }
+            case MessageType.StateRoot: {
+                handler_logger.log `--> Received unexpected 'StateRoot' message from the fuzzer. Closing.`;
+                this.sender.close();
+                return;
+            }
+            case MessageType.State: {
+                handler_logger.log `--> Received unexpected 'State' message from the fuzzer. Closing.`;
+                this.sender.close();
+                return;
+            }
+            case MessageType.Error: {
+                handler_logger.log `--> Received unexpected 'Error' message from the fuzzer. Closing.`;
+                this.sender.close();
+                return;
+            }
+            default: {
+                handler_logger.log `--> Received unexpected message type ${JSON.stringify(message)} from the fuzzer. Closing.`;
+                this.sender.close();
+                try {
+                    assertNever(message);
+                }
+                catch {
+                    return;
+                }
+            }
+        }
+        if (response !== null) {
+            handler_logger.trace `<-- responding with: ${response.type}`;
+            const encoded = Encoder.encodeObject(messageCodec, response, this.spec);
+            this.sender.send(encoded);
+        }
+        else {
+            handler_logger.warn `<-- no response generated for: ${message.type}`;
+        }
+    }
+    onClose({ error }) {
+        handler_logger.log `Closing the v1 handler. Reason: ${error !== undefined ? error.message : "close"}.`;
+    }
+    /** Check if a specific feature is enabled in the session */
+    hasFeature(feature) {
+        return (this.sessionFeatures & feature) !== 0;
+    }
+}
+
+;// CONCATENATED MODULE: ./packages/jam/fuzz-proto/v1/index.ts
+
+
+
+;// CONCATENATED MODULE: ./packages/jam/fuzz-proto/index.ts
+
+
+
 ;// CONCATENATED MODULE: ./packages/core/pvm-spi-decoder/memory-conts.ts
 // GP reference: https://graypaper.fluffylabs.dev/#/7e6ff6a/2d32002d3200?v=0.6.7
 const memory_conts_PAGE_SIZE = 2 ** 12; // Z_P from GP
@@ -12192,6 +12190,10 @@ class disputes_DisputesRecords {
     static create({ goodSet, badSet, wonkySet, punishSet }) {
         return new disputes_DisputesRecords(goodSet, badSet, wonkySet, punishSet);
     }
+    goodSetDict;
+    badSetDict;
+    wonkySetDict;
+    punishSetDict;
     constructor(
     /** `goodSet`: all work-reports hashes which were judged to be correct */
     goodSet, 
@@ -12205,6 +12207,18 @@ class disputes_DisputesRecords {
         this.badSet = badSet;
         this.wonkySet = wonkySet;
         this.punishSet = punishSet;
+        this.goodSetDict = hash_set_HashSet.from(goodSet.array);
+        this.badSetDict = hash_set_HashSet.from(badSet.array);
+        this.wonkySetDict = hash_set_HashSet.from(wonkySet.array);
+        this.punishSetDict = hash_set_HashSet.from(punishSet.array);
+    }
+    asDictionaries() {
+        return {
+            goodSet: this.goodSetDict,
+            badSet: this.badSetDict,
+            wonkySet: this.wonkySetDict,
+            punishSet: this.punishSetDict,
+        };
     }
     static fromSortedArrays({ goodSet, badSet, wonkySet, punishSet, }) {
         return new disputes_DisputesRecords(sorted_set_SortedSet.fromSortedArray(disputes_hashComparator, goodSet), sorted_set_SortedSet.fromSortedArray(disputes_hashComparator, badSet), sorted_set_SortedSet.fromSortedArray(disputes_hashComparator, wonkySet), sorted_set_SortedSet.fromSortedArray(disputes_hashComparator, punishSet));
@@ -16249,10 +16263,16 @@ function registers_signExtend32To64(value) {
 
 /** Attempt to convert a number into `HostCallIndex`. */
 const host_call_handler_tryAsHostCallIndex = (v) => opaque_asOpaqueType(numbers_tryAsU32(v));
+/**
+ * Host-call exit reason.
+ *
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/24a30124a501?v=0.7.2
+ */
 var host_call_handler_PvmExecution;
 (function (PvmExecution) {
     PvmExecution[PvmExecution["Halt"] = 0] = "Halt";
     PvmExecution[PvmExecution["Panic"] = 1] = "Panic";
+    PvmExecution[PvmExecution["OOG"] = 2] = "OOG";
 })(host_call_handler_PvmExecution || (host_call_handler_PvmExecution = {}));
 /** A utility function to easily trace a bunch of registers. */
 function host_call_handler_traceRegisters(...regs) {
@@ -17473,6 +17493,17 @@ class page_range_PageRange {
         }
         return new page_range_PageRange(start, length);
     }
+    /** Returns true if the page range is wrapped (`start` >= `end`) and is not empty */
+    isWrapped() {
+        return this.start >= this.end && !this.isEmpty();
+    }
+    /** Checks if given page number is within the range */
+    isInRange(page) {
+        if (this.isWrapped()) {
+            return page >= this.start || page < this.end;
+        }
+        return page >= this.start && page < this.end;
+    }
     /** Checks if a range is empty (`length === 0`) */
     isEmpty() {
         return this.length === 0;
@@ -17852,10 +17883,11 @@ class memory_builder_MemoryBuilder {
       startHeapIndex (${startHeapIndex}) has to be less than or equal to endHeapIndex (${endHeapIndex})
     `;
         this.ensureNotFinalized();
-        const range = MemoryRange.fromStartAndLength(startHeapIndex, endHeapIndex - startHeapIndex);
-        const pages = PageRange.fromMemoryRange(range);
-        for (const pageNumber of pages) {
-            if (this.initialMemory.has(pageNumber)) {
+        const heapRange = MemoryRange.fromStartAndLength(startHeapIndex, endHeapIndex - startHeapIndex);
+        const heapPagesRange = PageRange.fromMemoryRange(heapRange);
+        const initializedPageNumbers = Array.from(this.initialMemory.keys());
+        for (const pageNumber of initializedPageNumbers) {
+            if (heapPagesRange.isInRange(pageNumber)) {
                 throw new IncorrectSbrkIndex();
             }
         }
@@ -19857,8 +19889,9 @@ class host_calls_HostCalls {
             const index = tryAsHostCallIndex(hostCallIndex);
             const hostCall = this.hostCalls.get(index);
             const gasBefore = gas.get();
-            const gasCost = typeof hostCall.gasCost === "number" ? hostCall.gasCost : hostCall.gasCost(regs);
-            const underflow = gas.sub(gasCost);
+            // NOTE: `basicGasCost(regs)` function is for compatibility reasons: pre GP 0.7.2
+            const basicGasCost = typeof hostCall.basicGasCost === "number" ? hostCall.basicGasCost : hostCall.basicGasCost(regs);
+            const underflow = gas.sub(basicGasCost);
             const pcLog = `[PC: ${pvmInstance.getPC()}]`;
             if (underflow) {
                 this.hostCalls.traceHostCall(`${pcLog} OOG`, index, hostCall, regs, gas.get());
@@ -19875,6 +19908,10 @@ class host_calls_HostCalls {
                 status = Status.PANIC;
                 return this.getReturnValue(status, pvmInstance);
             }
+            if (result === PvmExecution.OOG) {
+                status = Status.OOG;
+                return this.getReturnValue(status, pvmInstance);
+            }
             if (result === undefined) {
                 pvmInstance.runProgram();
                 status = pvmInstance.getStatus();
@@ -19933,7 +19970,7 @@ class host_calls_manager_HostCallsManager {
 }
 class NoopMissing {
     index = tryAsHostCallIndex(2 ** 32 - 1);
-    gasCost = tryAsSmallGas(0);
+    basicGasCost = tryAsSmallGas(0);
     currentServiceId = tryAsU32(0);
     tracedRegisters = [];
     async execute() {
@@ -20047,7 +20084,7 @@ function utils_clampU64ToU32(value) {
 
 class missing_Missing {
     index = tryAsHostCallIndex(2 ** 32 - 1);
-    gasCost = tryAsSmallGas(10);
+    basicGasCost = tryAsSmallGas(10);
     currentServiceId = CURRENT_SERVICE_ID;
     tracedRegisters = traceRegisters(7);
     execute(_gas, regs, _memory) {
@@ -20424,7 +20461,7 @@ class disputes_Disputes {
             const { key, workReportHash } = disputes.culprits[i];
             // check if some offenders weren't reported earlier
             // https://graypaper.fluffylabs.dev/#/579bd12/125501125501
-            const isInPunishSet = this.state.disputesRecords.punishSet.findExact(key) !== undefined;
+            const isInPunishSet = this.state.disputesRecords.asDictionaries().punishSet.has(key);
             if (isInPunishSet) {
                 return Result.error(DisputesErrorCode.OffenderAlreadyReported);
             }
@@ -20435,8 +20472,8 @@ class disputes_Disputes {
             }
             // verify if the culprit will be in new bad set
             // https://graypaper.fluffylabs.dev/#/579bd12/124601124601
-            const isInNewBadSet = newItems.toAddToBadSet.findExact(workReportHash);
-            if (isInNewBadSet === undefined) {
+            const isInNewBadSet = newItems.asDictionaries().badSet.has(workReportHash);
+            if (!isInNewBadSet) {
                 return Result.error(DisputesErrorCode.CulpritsVerdictNotBad);
             }
             // verify culprit signature
@@ -20459,7 +20496,7 @@ class disputes_Disputes {
             const { key, workReportHash, wasConsideredValid } = disputes.faults[i];
             // check if some offenders weren't reported earlier
             // https://graypaper.fluffylabs.dev/#/579bd12/12a20112a201
-            const isInPunishSet = this.state.disputesRecords.punishSet.findExact(key) !== undefined;
+            const isInPunishSet = this.state.disputesRecords.asDictionaries().punishSet.has(key);
             if (isInPunishSet) {
                 return Result.error(DisputesErrorCode.OffenderAlreadyReported);
             }
@@ -20474,9 +20511,10 @@ class disputes_Disputes {
             // but it does not pass the tests
             // https://graypaper.fluffylabs.dev/#/579bd12/128a01129601
             if (wasConsideredValid) {
-                const isInNewGoodSet = newItems.toAddToGoodSet.findExact(workReportHash);
-                const isInNewBadSet = newItems.toAddToBadSet.findExact(workReportHash);
-                if (isInNewGoodSet !== undefined || isInNewBadSet === undefined) {
+                const { goodSet, badSet } = newItems.asDictionaries();
+                const isInNewGoodSet = goodSet.has(workReportHash);
+                const isInNewBadSet = badSet.has(workReportHash);
+                if (isInNewGoodSet || !isInNewBadSet) {
                     return Result.error(DisputesErrorCode.FaultVerdictWrong);
                 }
             }
@@ -20529,10 +20567,11 @@ class disputes_Disputes {
         for (const verdict of disputes.verdicts) {
             // current verdicts should not be reported earlier
             // https://graypaper.fluffylabs.dev/#/579bd12/122202122202
-            const isInGoodSet = this.state.disputesRecords.goodSet.findExact(verdict.workReportHash);
-            const isInBadSet = this.state.disputesRecords.badSet.findExact(verdict.workReportHash);
-            const isInWonkySet = this.state.disputesRecords.wonkySet.findExact(verdict.workReportHash);
-            if (isInGoodSet !== undefined || isInBadSet !== undefined || isInWonkySet !== undefined) {
+            const { goodSet, badSet, wonkySet } = this.state.disputesRecords.asDictionaries();
+            const isInGoodSet = goodSet.has(verdict.workReportHash);
+            const isInBadSet = badSet.has(verdict.workReportHash);
+            const isInWonkySet = wonkySet.has(verdict.workReportHash);
+            if (isInGoodSet || isInBadSet || isInWonkySet) {
                 return Result.error(DisputesErrorCode.AlreadyJudged);
             }
         }
@@ -20602,11 +20641,12 @@ class disputes_Disputes {
                 toAddToWonkySet.push(r);
             }
         }
-        return {
-            toAddToGoodSet: SortedSet.fromArrayUnique(hashComparator, toAddToGoodSet),
-            toAddToBadSet: SortedSet.fromArrayUnique(hashComparator, toAddToBadSet),
-            toAddToWonkySet: SortedSet.fromArrayUnique(hashComparator, toAddToWonkySet),
-        };
+        return DisputesRecords.create({
+            goodSet: SortedSet.fromArrayUnique(hashComparator, toAddToGoodSet),
+            badSet: SortedSet.fromArrayUnique(hashComparator, toAddToBadSet),
+            wonkySet: SortedSet.fromArrayUnique(hashComparator, toAddToWonkySet),
+            punishSet: SortedSet.fromArray(hashComparator, []),
+        });
     }
     getClearedCoreAssignment(v) {
         /**
@@ -20641,9 +20681,9 @@ class disputes_Disputes {
         const toAddToPunishSet = SortedArray.fromArray(hashComparator, Array.from(offenders));
         return DisputesRecords.create({
             // https://graypaper.fluffylabs.dev/#/579bd12/12690312bc03
-            goodSet: SortedSet.fromTwoSortedCollections(this.state.disputesRecords.goodSet, newItems.toAddToGoodSet),
-            badSet: SortedSet.fromTwoSortedCollections(this.state.disputesRecords.badSet, newItems.toAddToBadSet),
-            wonkySet: SortedSet.fromTwoSortedCollections(this.state.disputesRecords.wonkySet, newItems.toAddToWonkySet),
+            goodSet: SortedSet.fromTwoSortedCollections(this.state.disputesRecords.goodSet, newItems.goodSet),
+            badSet: SortedSet.fromTwoSortedCollections(this.state.disputesRecords.badSet, newItems.badSet),
+            wonkySet: SortedSet.fromTwoSortedCollections(this.state.disputesRecords.wonkySet, newItems.wonkySet),
             punishSet: SortedSet.fromTwoSortedCollections(this.state.disputesRecords.punishSet, toAddToPunishSet),
         });
     }
@@ -23027,7 +23067,7 @@ class Assign {
     partialState;
     chainSpec;
     index = host_call_handler_tryAsHostCallIndex(15);
-    gasCost = gas_tryAsSmallGas(10);
+    basicGasCost = gas_tryAsSmallGas(10);
     tracedRegisters = host_call_handler_traceRegisters(IN_OUT_REG, 8);
     constructor(currentServiceId, partialState, chainSpec) {
         this.currentServiceId = currentServiceId;
@@ -23105,7 +23145,7 @@ class Bless {
     partialState;
     chainSpec;
     index = host_call_handler_tryAsHostCallIndex(14);
-    gasCost = gas_tryAsSmallGas(10);
+    basicGasCost = gas_tryAsSmallGas(10);
     tracedRegisters = host_call_handler_traceRegisters(bless_IN_OUT_REG, 8, 9, 10, 11);
     constructor(currentServiceId, partialState, chainSpec) {
         this.currentServiceId = currentServiceId;
@@ -23190,7 +23230,7 @@ class Bless {
 class gas_GasHostCall {
     currentServiceId;
     index = host_call_handler_tryAsHostCallIndex(0);
-    gasCost = gas_tryAsSmallGas(10);
+    basicGasCost = gas_tryAsSmallGas(10);
     tracedRegisters = host_call_handler_traceRegisters(7);
     constructor(currentServiceId) {
         this.currentServiceId = currentServiceId;
@@ -23217,7 +23257,7 @@ class Checkpoint {
     currentServiceId;
     partialState;
     index = host_call_handler_tryAsHostCallIndex(17);
-    gasCost = gas_tryAsSmallGas(10);
+    basicGasCost = gas_tryAsSmallGas(10);
     tracedRegisters;
     gasHostCall;
     constructor(currentServiceId, partialState) {
@@ -23254,7 +23294,7 @@ class Designate {
     partialState;
     chainSpec;
     index = host_call_handler_tryAsHostCallIndex(16);
-    gasCost = gas_tryAsSmallGas(10);
+    basicGasCost = gas_tryAsSmallGas(10);
     tracedRegisters = host_call_handler_traceRegisters(designate_IN_OUT_REG);
     constructor(currentServiceId, partialState, chainSpec) {
         this.currentServiceId = currentServiceId;
@@ -23305,7 +23345,7 @@ class Eject {
     currentServiceId;
     partialState;
     index = host_call_handler_tryAsHostCallIndex(21);
-    gasCost = gas_tryAsSmallGas(10);
+    basicGasCost = gas_tryAsSmallGas(10);
     tracedRegisters = host_call_handler_traceRegisters(eject_IN_OUT_REG, 8);
     constructor(currentServiceId, partialState) {
         this.currentServiceId = currentServiceId;
@@ -23367,7 +23407,7 @@ class Forget {
     currentServiceId;
     partialState;
     index = host_call_handler_tryAsHostCallIndex(24);
-    gasCost = gas_tryAsSmallGas(10);
+    basicGasCost = gas_tryAsSmallGas(10);
     tracedRegisters = host_call_handler_traceRegisters(forget_IN_OUT_REG, 8);
     constructor(currentServiceId, partialState) {
         this.currentServiceId = currentServiceId;
@@ -23417,7 +23457,7 @@ class New {
     currentServiceId;
     partialState;
     index = host_call_handler_tryAsHostCallIndex(18);
-    gasCost = gas_tryAsSmallGas(10);
+    basicGasCost = gas_tryAsSmallGas(10);
     tracedRegisters = host_call_handler_traceRegisters(new_IN_OUT_REG, 8, 9, 10, 11);
     constructor(currentServiceId, partialState) {
         this.currentServiceId = currentServiceId;
@@ -23480,7 +23520,7 @@ class Provide {
     currentServiceId;
     partialState;
     index = host_call_handler_tryAsHostCallIndex(26);
-    gasCost = gas_tryAsSmallGas(10);
+    basicGasCost = gas_tryAsSmallGas(10);
     tracedRegisters = host_call_handler_traceRegisters(provide_IN_OUT_REG, 8, 9);
     constructor(currentServiceId, partialState) {
         this.currentServiceId = currentServiceId;
@@ -23541,7 +23581,7 @@ class Query {
     currentServiceId;
     partialState;
     index = host_call_handler_tryAsHostCallIndex(22);
-    gasCost = gas_tryAsSmallGas(10);
+    basicGasCost = gas_tryAsSmallGas(10);
     tracedRegisters = host_call_handler_traceRegisters(IN_OUT_REG_1, IN_OUT_REG_2);
     constructor(currentServiceId, partialState) {
         this.currentServiceId = currentServiceId;
@@ -23607,7 +23647,7 @@ class Solicit {
     currentServiceId;
     partialState;
     index = host_call_handler_tryAsHostCallIndex(23);
-    gasCost = gas_tryAsSmallGas(10);
+    basicGasCost = gas_tryAsSmallGas(10);
     tracedRegisters = host_call_handler_traceRegisters(solicit_IN_OUT_REG, 8);
     constructor(currentServiceId, partialState) {
         this.currentServiceId = currentServiceId;
@@ -23655,12 +23695,12 @@ class Solicit {
 
 const transfer_IN_OUT_REG = 7; // `d`
 const AMOUNT_REG = 8; // `a`
-const ON_TRANSFER_GAS_REG = 9; // `l`
+const TRANSFER_GAS_FEE_REG = 9; // `l`
 const MEMO_START_REG = 10; // `o`
 /**
  * Transfer balance from one service account to another.
  *
- * https://graypaper.fluffylabs.dev/#/7e6ff6a/373b00373b00?v=0.6.7
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/373f00373f00?v=0.7.2
  */
 class Transfer {
     currentServiceId;
@@ -23672,38 +23712,50 @@ class Transfer {
         },
     }));
     /**
-     * `g = 10 + ω9`
-     * https://graypaper.fluffylabs.dev/#/7e6ff6a/373d00373d00?v=0.6.7
+     * `g = 10 + t`
+     *
+     * `t` has positive value, only when status of a transfer is `OK`
+     * `0` otherwise
+     *
+     * Pre0.7.2: `g = 10 + ω9`
+     *
+     * https://graypaper.fluffylabs.dev/#/ab2cdbd/373f00373f00?v=0.7.2
      */
-    gasCost = (regs) => {
-        const gas = 10n + regs.get(ON_TRANSFER_GAS_REG);
-        return gas_tryAsGas(gas);
-    };
-    tracedRegisters = host_call_handler_traceRegisters(transfer_IN_OUT_REG, AMOUNT_REG, ON_TRANSFER_GAS_REG, MEMO_START_REG);
+    basicGasCost = compatibility_Compatibility.isGreaterOrEqual(compatibility_GpVersion.V0_7_2)
+        ? gas_tryAsSmallGas(10)
+        : (regs) => gas_tryAsGas(10n + regs.get(TRANSFER_GAS_FEE_REG));
+    tracedRegisters = host_call_handler_traceRegisters(transfer_IN_OUT_REG, AMOUNT_REG, TRANSFER_GAS_FEE_REG, MEMO_START_REG);
     constructor(currentServiceId, partialState) {
         this.currentServiceId = currentServiceId;
         this.partialState = partialState;
     }
-    async execute(_gas, regs, memory) {
+    async execute(gas, regs, memory) {
         // `d`: destination
         const destination = getServiceId(regs.get(transfer_IN_OUT_REG));
         // `a`: amount
         const amount = regs.get(AMOUNT_REG);
         // `l`: gas
-        const onTransferGas = common_tryAsServiceGas(regs.get(ON_TRANSFER_GAS_REG));
+        const transferGasFee = common_tryAsServiceGas(regs.get(TRANSFER_GAS_FEE_REG));
         // `o`: transfer memo
         const memoStart = regs.get(MEMO_START_REG);
         const memo = bytes_Bytes.zero(TRANSFER_MEMO_BYTES);
         const memoryReadResult = memory.loadInto(memo.raw, memoStart);
         // page fault while reading the memory.
         if (memoryReadResult.isError) {
-            logger_logger.trace `TRANSFER(${destination}, ${amount}, ${onTransferGas}, ${memo}) <- PANIC`;
+            logger_logger.trace `TRANSFER(${destination}, ${amount}, ${transferGasFee}, ${memo}) <- PANIC`;
             return host_call_handler_PvmExecution.Panic;
         }
-        const transferResult = this.partialState.transfer(destination, amount, onTransferGas, memo);
-        logger_logger.trace `TRANSFER(${destination}, ${amount}, ${onTransferGas}, ${memo}) <- ${result_resultToString(transferResult)}`;
+        const transferResult = this.partialState.transfer(destination, amount, transferGasFee, memo);
+        logger_logger.trace `TRANSFER(${destination}, ${amount}, ${transferGasFee}, ${memo}) <- ${result_resultToString(transferResult)}`;
         // All good!
         if (transferResult.isOk) {
+            if (compatibility_Compatibility.isGreaterOrEqual(compatibility_GpVersion.V0_7_2)) {
+                // substracting value `t`
+                const underflow = gas.sub(gas_tryAsGas(transferGasFee));
+                if (underflow) {
+                    return host_call_handler_PvmExecution.OOG;
+                }
+            }
             regs.set(transfer_IN_OUT_REG, results_HostCallResult.OK);
             return;
         }
@@ -23743,7 +23795,7 @@ class Upgrade {
     currentServiceId;
     partialState;
     index = host_call_handler_tryAsHostCallIndex(19);
-    gasCost = gas_tryAsSmallGas(10);
+    basicGasCost = gas_tryAsSmallGas(10);
     tracedRegisters = host_call_handler_traceRegisters(upgrade_IN_OUT_REG, GAS_REG, ALLOWANCE_REG);
     constructor(currentServiceId, partialState) {
         this.currentServiceId = currentServiceId;
@@ -23786,7 +23838,7 @@ class Yield {
     currentServiceId;
     partialState;
     index = host_call_handler_tryAsHostCallIndex(25);
-    gasCost = gas_tryAsSmallGas(10);
+    basicGasCost = gas_tryAsSmallGas(10);
     tracedRegisters = host_call_handler_traceRegisters(yield_IN_OUT_REG);
     constructor(currentServiceId, partialState) {
         this.currentServiceId = currentServiceId;
@@ -23822,7 +23874,7 @@ class fetch_Fetch {
     currentServiceId;
     fetch;
     index = tryAsHostCallIndex(1);
-    gasCost = tryAsSmallGas(10);
+    basicGasCost = tryAsSmallGas(10);
     tracedRegisters = traceRegisters(fetch_IN_OUT_REG, 8, 9, 10, 11, 12);
     constructor(currentServiceId, fetch) {
         this.currentServiceId = currentServiceId;
@@ -23979,7 +24031,7 @@ class info_Info {
     currentServiceId;
     account;
     index = tryAsHostCallIndex(5);
-    gasCost = tryAsSmallGas(10);
+    basicGasCost = tryAsSmallGas(10);
     tracedRegisters = traceRegisters(info_IN_OUT_REG, 8, OFFSET_REG, LEN_REG);
     constructor(currentServiceId, account) {
         this.currentServiceId = currentServiceId;
@@ -24054,7 +24106,7 @@ const decoder = new TextDecoder("utf8");
 class log_LogHostCall {
     currentServiceId;
     index = tryAsHostCallIndex(100);
-    gasCost = tryAsSmallGas(0);
+    basicGasCost = tryAsSmallGas(0);
     // intentionally not tracing anything here, since the message will be printed anyway.
     tracedRegisters = traceRegisters();
     constructor(currentServiceId) {
@@ -24096,7 +24148,7 @@ class lookup_Lookup {
     currentServiceId;
     account;
     index = tryAsHostCallIndex(2);
-    gasCost = tryAsSmallGas(10);
+    basicGasCost = tryAsSmallGas(10);
     tracedRegisters = traceRegisters(lookup_IN_OUT_REG, 8, 9, 10, 11);
     constructor(currentServiceId, account) {
         this.currentServiceId = currentServiceId;
@@ -24159,7 +24211,7 @@ class read_Read {
     currentServiceId;
     account;
     index = tryAsHostCallIndex(3);
-    gasCost = tryAsSmallGas(10);
+    basicGasCost = tryAsSmallGas(10);
     tracedRegisters = traceRegisters(read_IN_OUT_REG, 8, 9, 10, 11, 12);
     constructor(currentServiceId, account) {
         this.currentServiceId = currentServiceId;
@@ -24229,7 +24281,7 @@ class write_Write {
     currentServiceId;
     account;
     index = tryAsHostCallIndex(4);
-    gasCost = tryAsSmallGas(10);
+    basicGasCost = tryAsSmallGas(10);
     tracedRegisters = traceRegisters(write_IN_OUT_REG, 8, 9, 10);
     constructor(currentServiceId, account) {
         this.currentServiceId = currentServiceId;
@@ -26809,6 +26861,12 @@ async function runPvmTest(testContent) {
 
 
 
+function looseType(output) {
+    return {
+        value: output.value,
+        encode: output.encode,
+    };
+}
 const SUPPORTED_TYPES = [
     {
         name: "block",
@@ -26826,8 +26884,12 @@ const SUPPORTED_TYPES = [
             run(spec, data, option) {
                 const header = data;
                 if (option === "as-hash") {
-                    return hashBytes(encoder_Encoder.encodeObject(header_Header.Codec, header, spec));
+                    return looseType({
+                        value: hashBytes(encoder_Encoder.encodeObject(header_Header.Codec, header, spec)),
+                        encode: descriptors_codec.bytes(hash_HASH_SIZE),
+                    });
                 }
+                throw new Error(`Invalid processing option: ${option}`);
             },
         },
     },
@@ -26871,11 +26933,17 @@ const SUPPORTED_TYPES = [
             run(spec, data, option) {
                 const state = data;
                 if (option === "as-entries") {
-                    return Object.fromEntries(state_entries_StateEntries.serializeInMemory(spec, state));
+                    return looseType({
+                        value: Object.fromEntries(state_entries_StateEntries.serializeInMemory(spec, state)),
+                    });
                 }
                 if (option === "as-root-hash") {
-                    return state_entries_StateEntries.serializeInMemory(spec, state).getRootHash();
+                    return looseType({
+                        value: state_entries_StateEntries.serializeInMemory(spec, state).getRootHash(),
+                        encode: descriptors_codec.bytes(hash_HASH_SIZE),
+                    });
                 }
+                throw new Error(`Invalid processing option: ${option}`);
             },
         },
     },
@@ -26885,19 +26953,39 @@ const SUPPORTED_TYPES = [
         decode: StateTransitionGenesis.Codec,
         json: () => StateTransitionGenesis.fromJson,
         process: {
-            options: ["as-state", "as-jip4"],
+            options: ["as-state", "as-jip4", "as-fuzz-message"],
             run(spec, data, option) {
                 const test = data;
                 if (option === "as-state") {
-                    return stateFromKeyvals(spec, test.state);
+                    return looseType({
+                        value: stateFromKeyvals(spec, test.state),
+                    });
                 }
                 if (option === "as-jip4") {
                     const genesisState = new Map(test.state.keyvals.map((x) => [x.key, x.value]));
-                    return JipChainSpec.create({
-                        genesisHeader: encoder_Encoder.encodeObject(header_Header.Codec, test.header, spec),
-                        genesisState,
+                    return looseType({
+                        value: JipChainSpec.create({
+                            genesisHeader: encoder_Encoder.encodeObject(header_Header.Codec, test.header, spec),
+                            genesisState,
+                        }),
+                    });
+                }
+                if (option === "as-fuzz-message") {
+                    const init = Initialize.create({
+                        header: test.header,
+                        keyvals: test.state.keyvals,
+                        ancestry: [],
+                    });
+                    const msg = {
+                        type: types_MessageType.Initialize,
+                        value: init,
+                    };
+                    return looseType({
+                        value: msg,
+                        encode: types_messageCodec,
                     });
                 }
+                throw new Error(`Invalid processing option: ${option}`);
             },
         },
     },
@@ -26907,15 +26995,32 @@ const SUPPORTED_TYPES = [
         decode: StateTransition.Codec,
         json: () => StateTransition.fromJson,
         process: {
-            options: ["as-pre-state", "as-post-state"],
+            options: ["as-pre-state", "as-post-state", "as-fuzz-message"],
             run(spec, data, option) {
                 const test = data;
                 if (option === "as-pre-state") {
-                    return stateFromKeyvals(spec, test.pre_state);
+                    return looseType({
+                        value: stateFromKeyvals(spec, test.pre_state),
+                    });
                 }
                 if (option === "as-post-state") {
-                    return stateFromKeyvals(spec, test.post_state);
+                    return looseType({
+                        value: stateFromKeyvals(spec, test.post_state),
+                    });
+                }
+                if (option === "as-fuzz-message") {
+                    const encoded = encoder_Encoder.encodeObject(block_Block.Codec, test.block, spec);
+                    const blockView = decoder_Decoder.decodeObject(block_Block.Codec.View, encoded, spec);
+                    const msg = {
+                        type: types_MessageType.ImportBlock,
+                        value: blockView,
+                    };
+                    return looseType({
+                        value: msg,
+                        encode: types_messageCodec,
+                    });
                 }
+                throw new Error(`Invalid processing option: ${option}`);
             },
         },
     },
@@ -26938,7 +27043,7 @@ const HELP = `
 @typeberry/convert ${package_namespaceObject.rE} by Fluffy Labs.
 
 Usage:
-  @typeberry/convert [options] <bin-hex-or-json-input-file> <type> [process] [output-format]
+  @typeberry/convert [options] <bin-hex-or-json-input-file> <type> [process] [output-format] [output-file]
 
 Attempts to read provided input file as 'type' and output in requested 'output-format'.
 For some 'type's it's additionally possible to process the data before outputting it.
@@ -26947,6 +27052,7 @@ The input type is detected from file extension ('.bin', '.hex' or '.json').
 Example usage:
   @typeberry/convert ./genesis-header.json header to-hex
   @typeberry/convert ./state-snapshot.json state-dump as-entries to-json
+  @typeberry/convert ./state-snapshot.json stf-vector as-fuzz-message to-bin msg0.bin
 
 Options:
   --flavor    - chain spec flavor, either 'full' or 'tiny'.
@@ -26956,6 +27062,7 @@ Output formats:
   to-print       - Print the object to the console
   to-json        - JSON format (when supported)
   to-hex         - JAM-codec hex-encoded string (when supported)
+  to-bin         - JAM-codec binary data (when supported)
   to-repl        - Start a JavaScript REPL with the data loaded into a variable
 
 Input types:
@@ -26978,6 +27085,7 @@ var OutputFormat;
     OutputFormat["Print"] = "to-print";
     OutputFormat["Json"] = "to-json";
     OutputFormat["Hex"] = "to-hex";
+    OutputFormat["Bin"] = "to-bin";
     OutputFormat["Repl"] = "to-repl";
 })(OutputFormat || (OutputFormat = {}));
 function parseArgs(cliInput, withRelPath) {
@@ -26999,14 +27107,16 @@ function parseArgs(cliInput, withRelPath) {
     const type = parseType(args._.shift());
     const maybeProcess = args._.shift();
     const maybeOutputFormat = args._.shift();
+    const maybeDestination = args._.shift();
     assertNoMoreArgs(args);
-    const { process, format } = getProcessAndOutput(type, maybeProcess, maybeOutputFormat);
+    const { process, format, destination } = getProcessFormatAndDestination(type, maybeProcess, maybeOutputFormat, maybeDestination);
     return {
         flavor: chainSpec.flavor,
         type,
         process,
         inputPath: withRelPath(input),
         outputFormat: format,
+        destination,
     };
 }
 function parseType(type) {
@@ -27032,10 +27142,21 @@ function parseOutputFormat(output) {
             return OutputFormat.Json;
         case OutputFormat.Repl:
             return OutputFormat.Repl;
+        case OutputFormat.Bin:
+            return OutputFormat.Bin;
         default:
             throw new Error(`Invalid output format: '${output}'.`);
     }
 }
+function parseProcess(processOptions, maybeProcess) {
+    if (maybeProcess === undefined) {
+        return null;
+    }
+    if (!processOptions.includes(maybeProcess)) {
+        throw new Error(`Incorrect processing option: ${maybeProcess}. Expected one of: ${processOptions}.`);
+    }
+    return maybeProcess;
+}
 // TODO [ToDr] Consider sharing that?
 function parseOption(args, option, parser, defaultValue) {
     if (args[option] === undefined) {
@@ -27071,33 +27192,64 @@ function assertNoMoreArgs(args) {
         throw new Error(`Unrecognized options: '${keysLeft}'`);
     }
 }
-function getProcessAndOutput(type, maybeProcess, maybeOutputFormat) {
+function getProcessFormatAndDestination(type, maybeProcess, maybeOutputFormat, maybeDestination) {
+    const defaultProcess = "";
     const defaultFormat = parseOutputFormat(undefined);
-    const options = type.process?.options ?? [];
-    // we have both options, so we expect them in the right order.
-    if (maybeProcess !== undefined && maybeOutputFormat !== undefined) {
+    const processOptions = type.process?.options ?? [];
+    // we have all three so it must be in order
+    if (maybeProcess !== undefined && maybeOutputFormat !== undefined && maybeDestination !== undefined) {
         const format = parseOutputFormat(maybeOutputFormat);
-        if (!options.includes(maybeProcess)) {
-            throw new Error(`Incorrect processing option: ${maybeProcess}. Expected one of: ${options}.`);
-        }
-        return { process: maybeProcess, format };
+        const process = parseProcess(processOptions, maybeProcess) ?? defaultProcess;
+        const destination = maybeDestination;
+        throwIfDumpNotSupported(format, destination);
+        return { process, format, destination };
+    }
+    // we have either:
+    // 1. process + format
+    // 2. format + destination
+    if (maybeProcess !== undefined && maybeOutputFormat !== undefined) {
+        // we've got processing first, so easy-peasy
+        if (processOptions.includes(maybeProcess)) {
+            const format = parseOutputFormat(maybeOutputFormat);
+            throwIfDumpNotSupported(format, null);
+            return { process: maybeProcess, format, destination: null };
+        }
+        // first one has to be format then.
+        const format = parseOutputFormat(maybeProcess);
+        const destination = maybeOutputFormat;
+        throwIfDumpNotSupported(format, destination);
+        return { process: defaultProcess, format, destination };
     }
     // only one parameter, but it can be either output or processing.
+    const destination = null;
     if (maybeProcess !== undefined) {
-        if (options.includes(maybeProcess)) {
-            return { process: maybeProcess, format: defaultFormat };
+        if (processOptions.includes(maybeProcess)) {
+            return { process: maybeProcess, format: defaultFormat, destination };
         }
         // now it should be output format, but we want to give a better error message,
         // if user mispelled processing.
         try {
             const format = parseOutputFormat(maybeProcess);
-            return { process: "", format };
+            throwIfDumpNotSupported(format, destination);
+            return { process: defaultProcess, format, destination };
         }
         catch {
             throw new Error(`'${maybeProcess}' is neither output format nor processing parameter.`);
         }
     }
-    return { process: "", format: defaultFormat };
+    return { process: defaultProcess, format: defaultFormat, destination };
+}
+function throwIfDumpNotSupported(format, destination) {
+    if (destination !== null) {
+        if (format === OutputFormat.Print || format === OutputFormat.Repl) {
+            throw new Error(`Dumping to file is not supported for ${format}`);
+        }
+    }
+    else {
+        if (format === OutputFormat.Bin) {
+            throw new Error(`${format} requires destination file`);
+        }
+    }
 }
 
 // EXTERNAL MODULE: ./node_modules/json-bigint-patch/dist/index.js
@@ -27157,9 +27309,13 @@ function loadInputFile(file, withRelPath) {
     throw new Error("Input file format unsupported.");
 }
 function dumpOutput(spec, data, type, outputFormat, args, withRelPath) {
+    const { destination } = args;
+    const dump = destination !== null
+        ? (v) => external_node_fs_default().writeFileSync(withRelPath(destination), v)
+        : (v) => console.info(v);
     switch (outputFormat) {
         case OutputFormat.Print: {
-            console.info(`${debug_inspect(data)}`);
+            dump(`${debug_inspect(data)}`);
             return;
         }
         case OutputFormat.Hex: {
@@ -27167,13 +27323,24 @@ function dumpOutput(spec, data, type, outputFormat, args, withRelPath) {
                 throw new Error(`${type.name} does not support encoding to JAM codec.`);
             }
             const encoded = encoder_Encoder.encodeObject(type.encode, data, spec);
-            console.info(`${encoded}`);
+            dump(`${encoded}`);
+            return;
+        }
+        case OutputFormat.Bin: {
+            if (type.encode === undefined) {
+                throw new Error(`${type.name} does not support encoding to JAM codec.`);
+            }
+            if (destination === null) {
+                throw new Error(`${OutputFormat.Bin} requires destination file.`);
+            }
+            const encoded = encoder_Encoder.encodeObject(type.encode, data, spec);
+            dump(encoded.raw);
             return;
         }
         case OutputFormat.Json: {
             // TODO [ToDr] this will probably not work for all cases,
             // but for now may be good enough.
-            console.info(toJson(data));
+            dump(toJson(data));
             return;
         }
         case OutputFormat.Repl: {
@@ -27240,6 +27407,9 @@ function toJson(data) {
         if (value instanceof Map) {
             return Object.fromEntries(value.entries());
         }
+        if (value instanceof ObjectView) {
+            return value.materialize();
+        }
         return value;
     }, 2);
 }
@@ -27250,12 +27420,14 @@ function processOutput(spec, data, type, process) {
     if (type.process === undefined || !type.process.options.includes(process)) {
         throw new Error(`Unsupported processing: '${process}' for '${type.name}'`);
     }
+    const processed = type.process.run(spec, data, process);
     return {
-        processed: type.process.run(spec, data, process),
+        processed: processed.value,
         type: {
             ...type,
-            // disable encoding, since it won't match
-            encode: undefined,
+            name: `${type.name}(${process})`,
+            // use encoding from processed type
+            encode: processed.encode,
         },
     };
 }