@typeberry/lib 0.1.2-ef67dce → 0.1.3-135961b

package/index.cjs

@@ -563,7 +563,7 @@ function isResult(x) {
  * as an afterthought.
  */
 
-var index$s = /*#__PURE__*/Object.freeze({
+var index$u = /*#__PURE__*/Object.freeze({
   __proto__: null,
   get CURRENT_SUITE () { return CURRENT_SUITE; },
   get CURRENT_VERSION () { return CURRENT_VERSION; },
@@ -717,7 +717,7 @@ class Ordering {
     }
 }
 
-var index$r = /*#__PURE__*/Object.freeze({
+var index$t = /*#__PURE__*/Object.freeze({
   __proto__: null,
   Ordering: Ordering
 });
@@ -968,7 +968,7 @@ function u8ArraySameLengthEqual(self, other) {
 }
 const bytesBlobComparator = (a, b) => a.compare(b);
 
-var index$q = /*#__PURE__*/Object.freeze({
+var index$s = /*#__PURE__*/Object.freeze({
   __proto__: null,
   BitVec: BitVec,
   Bytes: Bytes,
@@ -1070,7 +1070,7 @@ const minU64 = (a, ...values) => values.reduce((min, value) => (value > min ? mi
 /** Get the biggest value between U64 a and values given as input parameters. */
 const maxU64 = (a, ...values) => values.reduce((max, value) => (value < max ? max : value), a);
 
-var index$p = /*#__PURE__*/Object.freeze({
+var index$r = /*#__PURE__*/Object.freeze({
   __proto__: null,
   isU16: isU16,
   isU32: isU32,
@@ -1947,13 +1947,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;
@@ -1979,6 +1981,9 @@ class ViewField {
         }
         return this.cachedBlob;
     }
+    toString() {
+        return `ViewField<${this.name}>`;
+    }
 }
 /**
  * A base class for all the lazy views.
@@ -2053,7 +2058,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
@@ -2065,6 +2070,9 @@ class ObjectView {
         }
         return lastItem;
     }
+    toString() {
+        return `View<${this.materializedConstructor.name}>(cache: ${this.cache.size})`;
+    }
 }
 /**
  * A lazy-evaluated decoder of a sequence.
@@ -2153,7 +2161,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
@@ -2165,6 +2173,9 @@ class SequenceView {
         }
         return lastItem;
     }
+    toString() {
+        return `SequenceView<${this.descriptor.name}>(cache: ${this.cache.size})`;
+    }
 }
 
 /**
@@ -2480,7 +2491,7 @@ function sequenceViewFixLen(type, { fixedLength }) {
     }, skipper);
 }
 
-var index$o = /*#__PURE__*/Object.freeze({
+var index$q = /*#__PURE__*/Object.freeze({
   __proto__: null,
   Decoder: Decoder,
   Descriptor: Descriptor,
@@ -4919,7 +4930,7 @@ var keccak = /*#__PURE__*/Object.freeze({
   hashBlobs: hashBlobs
 });
 
-var index$n = /*#__PURE__*/Object.freeze({
+var index$p = /*#__PURE__*/Object.freeze({
   __proto__: null,
   HASH_SIZE: HASH_SIZE,
   PageAllocator: PageAllocator,
@@ -4985,7 +4996,7 @@ var keyDerivation = /*#__PURE__*/Object.freeze({
   trivialSeed: trivialSeed
 });
 
-var index$m = /*#__PURE__*/Object.freeze({
+var index$o = /*#__PURE__*/Object.freeze({
   __proto__: null,
   BANDERSNATCH_KEY_BYTES: BANDERSNATCH_KEY_BYTES,
   BANDERSNATCH_PROOF_BYTES: BANDERSNATCH_PROOF_BYTES,
@@ -5589,7 +5600,7 @@ class TruncatedHashDictionary {
     }
 }
 
-var index$l = /*#__PURE__*/Object.freeze({
+var index$n = /*#__PURE__*/Object.freeze({
   __proto__: null,
   FixedSizeArray: FixedSizeArray,
   HashDictionary: HashDictionary,
@@ -5784,7 +5795,7 @@ class Bootnode {
     }
 }
 
-var index$k = /*#__PURE__*/Object.freeze({
+var index$m = /*#__PURE__*/Object.freeze({
   __proto__: null,
   Bootnode: Bootnode,
   ChainSpec: ChainSpec,
@@ -7279,7 +7290,7 @@ function emptyBlock(slot = tryAsTimeSlot(0)) {
     });
 }
 
-var index$j = /*#__PURE__*/Object.freeze({
+var index$l = /*#__PURE__*/Object.freeze({
   __proto__: null,
   Block: Block,
   EpochMarker: EpochMarker,
@@ -7535,7 +7546,7 @@ var json;
     json.object = object;
 })(json || (json = {}));
 
-var index$i = /*#__PURE__*/Object.freeze({
+var index$k = /*#__PURE__*/Object.freeze({
   __proto__: null,
   get json () { return json; },
   parseFromJson: parseFromJson
@@ -7805,7 +7816,7 @@ const blockFromJson = (spec) => json.object({
     extrinsic: getExtrinsicFromJson(spec),
 }, ({ header, extrinsic }) => Block.create({ header, extrinsic }));
 
-var index$h = /*#__PURE__*/Object.freeze({
+var index$j = /*#__PURE__*/Object.freeze({
   __proto__: null,
   blockFromJson: blockFromJson,
   disputesExtrinsicFromJson: disputesExtrinsicFromJson,
@@ -8303,7 +8314,7 @@ class Logger {
     }
 }
 
-var index$g = /*#__PURE__*/Object.freeze({
+var index$i = /*#__PURE__*/Object.freeze({
   __proto__: null,
   get Level () { return Level; },
   Logger: Logger,
@@ -8326,7 +8337,7 @@ class AuthorshipOptions {
     }
 }
 
-const logger$4 = Logger.new(undefined, "config");
+const logger$5 = Logger.new(undefined, "config");
 /** Development config. Will accept unsealed blocks for now. */
 const DEV_CONFIG = "dev";
 /** Default config file. */
@@ -8385,15 +8396,15 @@ class NodeConfiguration {
 }
 function loadConfig(configPath) {
     if (configPath === DEFAULT_CONFIG) {
-        logger$4.log `🔧 Loading DEFAULT config`;
+        logger$5.log `🔧 Loading DEFAULT config`;
         return parseFromJson(configs.default, NodeConfiguration.fromJson);
     }
     if (configPath === DEV_CONFIG) {
-        logger$4.log `🔧 Loading DEV config`;
+        logger$5.log `🔧 Loading DEV config`;
         return parseFromJson(configs.dev, NodeConfiguration.fromJson);
     }
     try {
-        logger$4.log `🔧 Loading config from ${configPath}`;
+        logger$5.log `🔧 Loading config from ${configPath}`;
         const configFile = fs.readFileSync(configPath, "utf8");
         const parsed = JSON.parse(configFile);
         return parseFromJson(parsed, NodeConfiguration.fromJson);
@@ -8403,7 +8414,7 @@ function loadConfig(configPath) {
     }
 }
 
-var index$f = /*#__PURE__*/Object.freeze({
+var index$h = /*#__PURE__*/Object.freeze({
   __proto__: null,
   DEFAULT_CONFIG: DEFAULT_CONFIG,
   DEV_CONFIG: DEV_CONFIG,
@@ -8720,6 +8731,10 @@ class DisputesRecords {
     static create({ goodSet, badSet, wonkySet, punishSet }) {
         return new DisputesRecords(goodSet, badSet, wonkySet, punishSet);
     }
+    goodSetDict;
+    badSetDict;
+    wonkySetDict;
+    punishSetDict;
     constructor(
     /** `goodSet`: all work-reports hashes which were judged to be correct */
     goodSet, 
@@ -8733,6 +8748,18 @@ class DisputesRecords {
         this.badSet = badSet;
         this.wonkySet = wonkySet;
         this.punishSet = punishSet;
+        this.goodSetDict = HashSet.from(goodSet.array);
+        this.badSetDict = HashSet.from(badSet.array);
+        this.wonkySetDict = HashSet.from(wonkySet.array);
+        this.punishSetDict = 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 DisputesRecords(SortedSet.fromSortedArray(hashComparator, goodSet), SortedSet.fromSortedArray(hashComparator, badSet), SortedSet.fromSortedArray(hashComparator, wonkySet), SortedSet.fromSortedArray(hashComparator, punishSet));
@@ -10069,7 +10096,7 @@ const serviceDataCodec = codec$1.dictionary(codec$1.u32.asOpaque(), serviceEntri
     sortKeys: (a, b) => a - b,
 });
 
-var index$e = /*#__PURE__*/Object.freeze({
+var index$g = /*#__PURE__*/Object.freeze({
   __proto__: null,
   AccumulationOutput: AccumulationOutput,
   AutoAccumulate: AutoAccumulate,
@@ -11079,7 +11106,7 @@ const bitLookup = [
     [0b00000000, 8],
 ];
 
-var index$d = /*#__PURE__*/Object.freeze({
+var index$f = /*#__PURE__*/Object.freeze({
   __proto__: null,
   BranchNode: BranchNode,
   InMemoryTrie: InMemoryTrie,
@@ -11425,7 +11452,7 @@ function loadState(spec, entries) {
  *        hashmap of `key -> value` entries.
  */
 
-var index$c = /*#__PURE__*/Object.freeze({
+var index$e = /*#__PURE__*/Object.freeze({
   __proto__: null,
   SerializedService: SerializedService,
   SerializedState: SerializedState,
@@ -11711,7 +11738,7 @@ class InMemoryStates {
     }
 }
 
-var index$b = /*#__PURE__*/Object.freeze({
+var index$d = /*#__PURE__*/Object.freeze({
   __proto__: null,
   InMemoryBlocks: InMemoryBlocks,
   InMemoryStates: InMemoryStates,
@@ -12073,7 +12100,7 @@ const initEc = async () => {
     await init.reedSolomon();
 };
 
-var index$a = /*#__PURE__*/Object.freeze({
+var index$c = /*#__PURE__*/Object.freeze({
   __proto__: null,
   N_CHUNKS_REDUNDANCY: N_CHUNKS_REDUNDANCY,
   N_CHUNKS_REQUIRED: N_CHUNKS_REQUIRED,
@@ -12097,6 +12124,439 @@ var index$a = /*#__PURE__*/Object.freeze({
   unzip: unzip
 });
 
+/**
+ * Version ::= SEQUENCE {
+ *     major INTEGER (0..255),
+ *     minor INTEGER (0..255),
+ *     patch INTEGER (0..255)
+ * }
+ */
+class Version extends WithDebug {
+    major;
+    minor;
+    patch;
+    static Codec = codec$1.Class(Version, {
+        major: codec$1.u8,
+        minor: codec$1.u8,
+        patch: codec$1.u8,
+    });
+    static tryFromString(str) {
+        const parse = (v) => tryAsU8(Number(v));
+        try {
+            const [major, minor, patch] = str.trim().split(".").map(parse);
+            return Version.create({
+                major,
+                minor,
+                patch,
+            });
+        }
+        catch (e) {
+            throw new Error(`Unable to parse ${str} as Version: ${e}`);
+        }
+    }
+    static create({ major, minor, patch }) {
+        return new Version(major, minor, patch);
+    }
+    constructor(major, minor, patch) {
+        super();
+        this.major = major;
+        this.minor = minor;
+        this.patch = patch;
+    }
+}
+/**
+ * Fuzzer Protocol V1
+ * Reference: https://github.com/davxy/jam-conformance/blob/main/fuzz-proto/fuzz.asn
+ */
+// Feature bit constants
+var Features;
+(function (Features) {
+    Features[Features["Ancestry"] = 1] = "Ancestry";
+    Features[Features["Fork"] = 2] = "Fork";
+    Features[Features["Reserved"] = 2147483648] = "Reserved";
+})(Features || (Features = {}));
+/**
+ * PeerInfo ::= SEQUENCE {
+ *     fuzz-version U8,
+ *     features     Features,
+ *     jam-version  Version,
+ *     app-version  Version,
+ *     name         UTF8String
+ * }
+ */
+class PeerInfo extends WithDebug {
+    fuzzVersion;
+    features;
+    jamVersion;
+    appVersion;
+    name;
+    static Codec = codec$1.Class(PeerInfo, {
+        fuzzVersion: codec$1.u8,
+        features: codec$1.u32,
+        jamVersion: Version.Codec,
+        appVersion: Version.Codec,
+        name: codec$1.string,
+    });
+    static create({ fuzzVersion, features, appVersion, jamVersion, name }) {
+        return new PeerInfo(fuzzVersion, features, jamVersion, appVersion, name);
+    }
+    constructor(fuzzVersion, features, jamVersion, appVersion, name) {
+        super();
+        this.fuzzVersion = fuzzVersion;
+        this.features = features;
+        this.jamVersion = jamVersion;
+        this.appVersion = appVersion;
+        this.name = name;
+    }
+}
+/**
+ * AncestryItem ::= SEQUENCE {
+ *     slot TimeSlot,
+ *     header-hash HeaderHash
+ * }
+ */
+class AncestryItem extends WithDebug {
+    slot;
+    headerHash;
+    static Codec = codec$1.Class(AncestryItem, {
+        slot: codec$1.u32.asOpaque(),
+        headerHash: codec$1.bytes(HASH_SIZE).asOpaque(),
+    });
+    static create({ slot, headerHash }) {
+        return new AncestryItem(slot, headerHash);
+    }
+    constructor(slot, headerHash) {
+        super();
+        this.slot = slot;
+        this.headerHash = headerHash;
+    }
+}
+/**
+ * KeyValue ::= SEQUENCE {
+ *     key     TrieKey,
+ *     value   OCTET STRING
+ * }
+ */
+class KeyValue extends WithDebug {
+    key;
+    value;
+    static Codec = codec$1.Class(KeyValue, {
+        key: codec$1.bytes(TRUNCATED_HASH_SIZE),
+        value: codec$1.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 = codec$1.sequenceVarLen(KeyValue.Codec);
+/**
+ * Ancestry ::= SEQUENCE (SIZE(0..24)) OF AncestryItem
+ * Empty when `feature-ancestry` is not supported by both parties
+ */
+const ancestryCodec = codec$1.sequenceVarLen(AncestryItem.Codec, {
+    minLength: 0,
+    maxLength: 24,
+});
+/**
+ * Initialize ::= SEQUENCE {
+ *     header Header,
+ *     keyvals State,
+ *     ancestry Ancestry
+ * }
+ */
+class Initialize extends WithDebug {
+    header;
+    keyvals;
+    ancestry;
+    static Codec = codec$1.Class(Initialize, {
+        header: Header.Codec,
+        keyvals: stateCodec,
+        ancestry: ancestryCodec,
+    });
+    static create({ header, keyvals, ancestry }) {
+        return new Initialize(header, keyvals, ancestry);
+    }
+    constructor(header, keyvals, ancestry) {
+        super();
+        this.header = header;
+        this.keyvals = keyvals;
+        this.ancestry = ancestry;
+    }
+}
+/** GetState ::= HeaderHash */
+const getStateCodec = codec$1.bytes(HASH_SIZE).asOpaque();
+/** StateRoot ::= StateRootHash */
+const stateRootCodec = codec$1.bytes(HASH_SIZE).asOpaque();
+/** Error ::= UTF8String */
+class ErrorMessage extends WithDebug {
+    message;
+    static Codec = codec$1.Class(ErrorMessage, {
+        message: codec$1.string,
+    });
+    static create({ message }) {
+        return new ErrorMessage(message);
+    }
+    constructor(message) {
+        super();
+        this.message = message;
+    }
+}
+/** Message choice type tags */
+var MessageType;
+(function (MessageType) {
+    MessageType[MessageType["PeerInfo"] = 0] = "PeerInfo";
+    MessageType[MessageType["Initialize"] = 1] = "Initialize";
+    MessageType[MessageType["StateRoot"] = 2] = "StateRoot";
+    MessageType[MessageType["ImportBlock"] = 3] = "ImportBlock";
+    MessageType[MessageType["GetState"] = 4] = "GetState";
+    MessageType[MessageType["State"] = 5] = "State";
+    MessageType[MessageType["Error"] = 255] = "Error";
+})(MessageType || (MessageType = {}));
+/**
+ * Message ::= CHOICE {
+ *     peer-info     [0] PeerInfo,
+ *     initialize    [1] Initialize,
+ *     state-root    [2] StateRoot,
+ *     import-block  [3] ImportBlock,
+ *     get-state     [4] GetState,
+ *     state         [5] State,
+ *     error         [255] Error
+ * }
+ */
+const messageCodec = codec$1.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.Initialize:
+            Initialize.Codec.encode(e, msg.value);
+            break;
+        case MessageType.StateRoot:
+            stateRootCodec.encode(e, msg.value);
+            break;
+        case MessageType.ImportBlock:
+            Block.Codec.View.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.Error:
+            ErrorMessage.Codec.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.Initialize:
+            return { type: MessageType.Initialize, value: Initialize.Codec.decode(d) };
+        case MessageType.StateRoot:
+            return { type: MessageType.StateRoot, value: stateRootCodec.decode(d) };
+        case MessageType.ImportBlock:
+            return { type: MessageType.ImportBlock, value: Block.Codec.View.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.Error:
+            return { type: MessageType.Error, value: ErrorMessage.Codec.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.Initialize:
+            Initialize.Codec.View.skip(s);
+            break;
+        case MessageType.StateRoot:
+            stateRootCodec.View.skip(s);
+            break;
+        case MessageType.ImportBlock:
+            Block.Codec.View.skip(s);
+            break;
+        case MessageType.GetState:
+            getStateCodec.View.skip(s);
+            break;
+        case MessageType.State:
+            stateCodec.View.skip(s);
+            break;
+        case MessageType.Error:
+            ErrorMessage.Codec.View.skip(s);
+            break;
+        default:
+            throw new Error(`Unknown message type: ${type}`);
+    }
+});
+
+const logger$4 = Logger.new(undefined, "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);
+            logger$4.log `[${message.type}] incoming message`;
+            await this.processAndRespond(message);
+        }
+        catch (e) {
+            logger$4.error `Error while processing fuzz v1 message: ${e}`;
+            logger$4.error `${e}`;
+            if (e instanceof Error) {
+                logger$4.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) {
+                    logger$4.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;
+                logger$4.info `Handshake completed. Shared features: 0b${this.sessionFeatures.toString(2)}`;
+                logger$4.log `Feature ancestry: ${(this.sessionFeatures & Features.Ancestry) !== 0}`;
+                logger$4.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: {
+                logger$4.log `--> Received unexpected 'StateRoot' message from the fuzzer. Closing.`;
+                this.sender.close();
+                return;
+            }
+            case MessageType.State: {
+                logger$4.log `--> Received unexpected 'State' message from the fuzzer. Closing.`;
+                this.sender.close();
+                return;
+            }
+            case MessageType.Error: {
+                logger$4.log `--> Received unexpected 'Error' message from the fuzzer. Closing.`;
+                this.sender.close();
+                return;
+            }
+            default: {
+                logger$4.log `--> Received unexpected message type ${JSON.stringify(message)} from the fuzzer. Closing.`;
+                this.sender.close();
+                try {
+                    assertNever(message);
+                }
+                catch {
+                    return;
+                }
+            }
+        }
+        if (response !== null) {
+            logger$4.trace `<-- responding with: ${response.type}`;
+            const encoded = Encoder.encodeObject(messageCodec, response, this.spec);
+            this.sender.send(encoded);
+        }
+        else {
+            logger$4.warn `<-- no response generated for: ${message.type}`;
+        }
+    }
+    onClose({ error }) {
+        logger$4.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;
+    }
+}
+
+var index$b = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  AncestryItem: AncestryItem,
+  ErrorMessage: ErrorMessage,
+  get Features () { return Features; },
+  FuzzTarget: FuzzTarget,
+  Initialize: Initialize,
+  KeyValue: KeyValue,
+  get MessageType () { return MessageType; },
+  PeerInfo: PeerInfo,
+  Version: Version,
+  ancestryCodec: ancestryCodec,
+  getStateCodec: getStateCodec,
+  messageCodec: messageCodec,
+  stateCodec: stateCodec,
+  stateRootCodec: stateRootCodec
+});
+
+var index$a = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  v1: index$b
+});
+
 /** Size of the transfer memo. */
 const TRANSFER_MEMO_BYTES = W_T;
 /**
@@ -12883,10 +13343,16 @@ function signExtend32To64(value) {
 
 /** Attempt to convert a number into `HostCallIndex`. */
 const tryAsHostCallIndex = (v) => asOpaqueType(tryAsU32(v));
+/**
+ * Host-call exit reason.
+ *
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/24a30124a501?v=0.7.2
+ */
 var PvmExecution;
 (function (PvmExecution) {
     PvmExecution[PvmExecution["Halt"] = 0] = "Halt";
     PvmExecution[PvmExecution["Panic"] = 1] = "Panic";
+    PvmExecution[PvmExecution["OOG"] = 2] = "OOG";
 })(PvmExecution || (PvmExecution = {}));
 /** A utility function to easily trace a bunch of registers. */
 function traceRegisters(...regs) {
@@ -16521,8 +16987,9 @@ class 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());
@@ -16539,6 +17006,10 @@ class 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();
@@ -16939,8 +17410,8 @@ var index$3 = /*#__PURE__*/Object.freeze({
   asOpaqueType: asOpaqueType,
   assertEmpty: assertEmpty,
   assertNever: assertNever,
-  block: index$j,
-  bytes: index$q,
+  block: index$l,
+  bytes: index$s,
   check: check,
   clampU64ToU32: clampU64ToU32,
   createResults: createResults,
@@ -16948,13 +17419,13 @@ var index$3 = /*#__PURE__*/Object.freeze({
   extractCodeAndMetadata: extractCodeAndMetadata,
   getServiceId: getServiceId,
   getServiceIdOrCurrent: getServiceIdOrCurrent,
-  hash: index$n,
+  hash: index$p,
   inspect: inspect,
   instructionArgumentTypeMap: instructionArgumentTypeMap,
   interpreter: index$7,
   isBrowser: isBrowser,
   measure: measure,
-  numbers: index$p,
+  numbers: index$r,
   resultToString: resultToString,
   seeThrough: seeThrough,
   slotsToPreimageStatus: slotsToPreimageStatus,
@@ -17528,7 +17999,7 @@ class Preimages {
 
 class Missing {
     index = tryAsHostCallIndex(2 ** 32 - 1);
-    gasCost = tryAsSmallGas(10);
+    basicGasCost = tryAsSmallGas(10);
     currentServiceId = CURRENT_SERVICE_ID;
     tracedRegisters = traceRegisters(7);
     execute(_gas, regs, _memory) {
@@ -17668,32 +18139,33 @@ var index = /*#__PURE__*/Object.freeze({
   WorkPackageExecutor: WorkPackageExecutor
 });
 
-exports.block = index$j;
-exports.block_json = index$h;
-exports.bytes = index$q;
-exports.codec = index$o;
-exports.collections = index$l;
-exports.config = index$k;
-exports.config_node = index$f;
-exports.crypto = index$m;
-exports.database = index$b;
-exports.erasure_coding = index$a;
-exports.hash = index$n;
+exports.block = index$l;
+exports.block_json = index$j;
+exports.bytes = index$s;
+exports.codec = index$q;
+exports.collections = index$n;
+exports.config = index$m;
+exports.config_node = index$h;
+exports.crypto = index$o;
+exports.database = index$d;
+exports.erasure_coding = index$c;
+exports.fuzz_proto = index$a;
+exports.hash = index$p;
 exports.jam_host_calls = index$9;
-exports.json_parser = index$i;
-exports.logger = index$g;
+exports.json_parser = index$k;
+exports.logger = index$i;
 exports.mmr = index$8;
-exports.numbers = index$p;
-exports.ordering = index$r;
+exports.numbers = index$r;
+exports.ordering = index$t;
 exports.pvm = index$3;
 exports.pvm_host_calls = index$6;
 exports.pvm_interpreter = index$7;
 exports.pvm_program = index$4;
 exports.pvm_spi_decoder = index$5;
 exports.shuffling = index$2;
-exports.state = index$e;
+exports.state = index$g;
 exports.state_json = index$1;
-exports.state_merkleization = index$c;
+exports.state_merkleization = index$e;
 exports.transition = index;
-exports.trie = index$d;
-exports.utils = index$s;
+exports.trie = index$f;
+exports.utils = index$u;