@typeberry/convert 0.1.2-ef67dce → 0.1.3-6edad4a

package/index.js

@@ -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
@@ -27367,6 +27365,9 @@ function toJson(data) {
         if (value instanceof Map) {
             return Object.fromEntries(value.entries());
         }
+        if (value instanceof ObjectView) {
+            return value.materialize();
+        }
         return value;
     }, 2);
 }