@typeberry/lib 0.1.2-a90b655 → 0.1.2-b25cc82

package/index.js

@@ -560,7 +560,7 @@ function isResult(x) {
  * as an afterthought.
  */
 
-var index$u = /*#__PURE__*/Object.freeze({
+var index$s = /*#__PURE__*/Object.freeze({
   __proto__: null,
   get CURRENT_SUITE () { return CURRENT_SUITE; },
   get CURRENT_VERSION () { return CURRENT_VERSION; },
@@ -714,7 +714,7 @@ class Ordering {
     }
 }
 
-var index$t = /*#__PURE__*/Object.freeze({
+var index$r = /*#__PURE__*/Object.freeze({
   __proto__: null,
   Ordering: Ordering
 });
@@ -965,7 +965,7 @@ function u8ArraySameLengthEqual(self, other) {
 }
 const bytesBlobComparator = (a, b) => a.compare(b);
 
-var index$s = /*#__PURE__*/Object.freeze({
+var index$q = /*#__PURE__*/Object.freeze({
   __proto__: null,
   BitVec: BitVec,
   Bytes: Bytes,
@@ -1067,7 +1067,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$r = /*#__PURE__*/Object.freeze({
+var index$p = /*#__PURE__*/Object.freeze({
   __proto__: null,
   isU16: isU16,
   isU32: isU32,
@@ -2477,7 +2477,7 @@ function sequenceViewFixLen(type, { fixedLength }) {
     }, skipper);
 }
 
-var index$q = /*#__PURE__*/Object.freeze({
+var index$o = /*#__PURE__*/Object.freeze({
   __proto__: null,
   Decoder: Decoder,
   Descriptor: Descriptor,
@@ -4916,7 +4916,7 @@ var keccak = /*#__PURE__*/Object.freeze({
   hashBlobs: hashBlobs
 });
 
-var index$p = /*#__PURE__*/Object.freeze({
+var index$n = /*#__PURE__*/Object.freeze({
   __proto__: null,
   HASH_SIZE: HASH_SIZE,
   PageAllocator: PageAllocator,
@@ -4982,7 +4982,7 @@ var keyDerivation = /*#__PURE__*/Object.freeze({
   trivialSeed: trivialSeed
 });
 
-var index$o = /*#__PURE__*/Object.freeze({
+var index$m = /*#__PURE__*/Object.freeze({
   __proto__: null,
   BANDERSNATCH_KEY_BYTES: BANDERSNATCH_KEY_BYTES,
   BANDERSNATCH_PROOF_BYTES: BANDERSNATCH_PROOF_BYTES,
@@ -5586,7 +5586,7 @@ class TruncatedHashDictionary {
     }
 }
 
-var index$n = /*#__PURE__*/Object.freeze({
+var index$l = /*#__PURE__*/Object.freeze({
   __proto__: null,
   FixedSizeArray: FixedSizeArray,
   HashDictionary: HashDictionary,
@@ -5781,7 +5781,7 @@ class Bootnode {
     }
 }
 
-var index$m = /*#__PURE__*/Object.freeze({
+var index$k = /*#__PURE__*/Object.freeze({
   __proto__: null,
   Bootnode: Bootnode,
   ChainSpec: ChainSpec,
@@ -5954,6 +5954,40 @@ var assurances = /*#__PURE__*/Object.freeze({
   assurancesExtrinsicCodec: assurancesExtrinsicCodec
 });
 
+/** Attempt to convert a number into `TimeSlot`. */
+const tryAsTimeSlot = (v) => asOpaqueType(tryAsU32(v));
+/** Attempt to convert a number into `ValidatorIndex`. */
+const tryAsValidatorIndex = (v) => asOpaqueType(tryAsU16(v));
+/** Attempt to convert a number into `ServiceId`. */
+const tryAsServiceId = (v) => asOpaqueType(tryAsU32(v));
+const tryAsServiceGas = (v) => asOpaqueType(tryAsU64(v));
+/** Attempt to convert a number into `CoreIndex`. */
+const tryAsCoreIndex = (v) => asOpaqueType(tryAsU16(v));
+/** Attempt to convert a number into `Epoch`. */
+const tryAsEpoch = (v) => asOpaqueType(tryAsU32(v));
+function tryAsPerValidator(array, spec) {
+    check `
+    ${array.length === spec.validatorsCount}
+    Invalid per-validator array length. Expected ${spec.validatorsCount}, got: ${array.length}
+  `;
+    return asKnownSize(array);
+}
+const codecPerValidator = (val) => codecWithContext((context) => {
+    return codecKnownSizeArray(val, {
+        fixedLength: context.validatorsCount,
+    });
+});
+function tryAsPerEpochBlock(array, spec) {
+    check `
+    ${array.length === spec.epochLength}
+    Invalid per-epoch-block array length. Expected ${spec.epochLength}, got: ${array.length}
+  `;
+    return asKnownSize(array);
+}
+const codecPerEpochBlock = (val) => codecWithContext((context) => {
+    return codecKnownSizeArray(val, { fixedLength: context.epochLength });
+});
+
 /**
  * Proof of signing a contradictory [`Judgement`] of a work report.
  */
@@ -6145,40 +6179,6 @@ var disputes = /*#__PURE__*/Object.freeze({
   Verdict: Verdict
 });
 
-/** Attempt to convert a number into `TimeSlot`. */
-const tryAsTimeSlot = (v) => asOpaqueType(tryAsU32(v));
-/** Attempt to convert a number into `ValidatorIndex`. */
-const tryAsValidatorIndex = (v) => asOpaqueType(tryAsU16(v));
-/** Attempt to convert a number into `ServiceId`. */
-const tryAsServiceId = (v) => asOpaqueType(tryAsU32(v));
-const tryAsServiceGas = (v) => asOpaqueType(tryAsU64(v));
-/** Attempt to convert a number into `CoreIndex`. */
-const tryAsCoreIndex = (v) => asOpaqueType(tryAsU16(v));
-/** Attempt to convert a number into `Epoch`. */
-const tryAsEpoch = (v) => asOpaqueType(tryAsU32(v));
-function tryAsPerValidator(array, spec) {
-    check `
-    ${array.length === spec.validatorsCount}
-    Invalid per-validator array length. Expected ${spec.validatorsCount}, got: ${array.length}
-  `;
-    return asKnownSize(array);
-}
-const codecPerValidator = (val) => codecWithContext((context) => {
-    return codecKnownSizeArray(val, {
-        fixedLength: context.validatorsCount,
-    });
-});
-function tryAsPerEpochBlock(array, spec) {
-    check `
-    ${array.length === spec.epochLength}
-    Invalid per-epoch-block array length. Expected ${spec.epochLength}, got: ${array.length}
-  `;
-    return asKnownSize(array);
-}
-const codecPerEpochBlock = (val) => codecWithContext((context) => {
-    return codecKnownSizeArray(val, { fixedLength: context.epochLength });
-});
-
 /**
  * Mapping between work package hash and root hash of it's exports.
  *
@@ -7257,8 +7257,26 @@ class Block extends WithDebug {
         this.extrinsic = extrinsic;
     }
 }
+function emptyBlock(slot = tryAsTimeSlot(0)) {
+    const header = Header.empty();
+    header.timeSlotIndex = slot;
+    return Block.create({
+        header,
+        extrinsic: Extrinsic.create({
+            tickets: asKnownSize([]),
+            preimages: [],
+            assurances: asKnownSize([]),
+            guarantees: asKnownSize([]),
+            disputes: {
+                verdicts: [],
+                culprits: [],
+                faults: [],
+            },
+        }),
+    });
+}
 
-var index$l = /*#__PURE__*/Object.freeze({
+var index$j = /*#__PURE__*/Object.freeze({
   __proto__: null,
   Block: Block,
   EpochMarker: EpochMarker,
@@ -7273,6 +7291,7 @@ var index$l = /*#__PURE__*/Object.freeze({
   codecPerValidator: codecPerValidator,
   codecUtils: codec,
   disputes: disputes,
+  emptyBlock: emptyBlock,
   encodeUnsealedHeader: encodeUnsealedHeader,
   guarantees: guarantees,
   headerViewWithHashCodec: headerViewWithHashCodec,
@@ -7513,7 +7532,7 @@ var json;
     json.object = object;
 })(json || (json = {}));
 
-var index$k = /*#__PURE__*/Object.freeze({
+var index$i = /*#__PURE__*/Object.freeze({
   __proto__: null,
   get json () { return json; },
   parseFromJson: parseFromJson
@@ -7783,7 +7802,7 @@ const blockFromJson = (spec) => json.object({
     extrinsic: getExtrinsicFromJson(spec),
 }, ({ header, extrinsic }) => Block.create({ header, extrinsic }));
 
-var index$j = /*#__PURE__*/Object.freeze({
+var index$h = /*#__PURE__*/Object.freeze({
   __proto__: null,
   blockFromJson: blockFromJson,
   disputesExtrinsicFromJson: disputesExtrinsicFromJson,
@@ -8049,8 +8068,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);
     }
@@ -8281,7 +8300,7 @@ class Logger {
     }
 }
 
-var index$i = /*#__PURE__*/Object.freeze({
+var index$g = /*#__PURE__*/Object.freeze({
   __proto__: null,
   get Level () { return Level; },
   Logger: Logger,
@@ -8304,7 +8323,7 @@ class AuthorshipOptions {
     }
 }
 
-const logger$5 = Logger.new(import.meta.filename, "config");
+const logger$4 = Logger.new(import.meta.filename, "config");
 /** Development config. Will accept unsealed blocks for now. */
 const DEV_CONFIG = "dev";
 /** Default config file. */
@@ -8363,15 +8382,15 @@ class NodeConfiguration {
 }
 function loadConfig(configPath) {
     if (configPath === DEFAULT_CONFIG) {
-        logger$5.log `🔧 Loading DEFAULT config`;
+        logger$4.log `🔧 Loading DEFAULT config`;
         return parseFromJson(configs.default, NodeConfiguration.fromJson);
     }
     if (configPath === DEV_CONFIG) {
-        logger$5.log `🔧 Loading DEV config`;
+        logger$4.log `🔧 Loading DEV config`;
         return parseFromJson(configs.dev, NodeConfiguration.fromJson);
     }
     try {
-        logger$5.log `🔧 Loading config from ${configPath}`;
+        logger$4.log `🔧 Loading config from ${configPath}`;
         const configFile = fs.readFileSync(configPath, "utf8");
         const parsed = JSON.parse(configFile);
         return parseFromJson(parsed, NodeConfiguration.fromJson);
@@ -8381,7 +8400,7 @@ function loadConfig(configPath) {
     }
 }
 
-var index$h = /*#__PURE__*/Object.freeze({
+var index$f = /*#__PURE__*/Object.freeze({
   __proto__: null,
   DEFAULT_CONFIG: DEFAULT_CONFIG,
   DEV_CONFIG: DEV_CONFIG,
@@ -10047,7 +10066,7 @@ const serviceDataCodec = codec$1.dictionary(codec$1.u32.asOpaque(), serviceEntri
     sortKeys: (a, b) => a - b,
 });
 
-var index$g = /*#__PURE__*/Object.freeze({
+var index$e = /*#__PURE__*/Object.freeze({
   __proto__: null,
   AccumulationOutput: AccumulationOutput,
   AutoAccumulate: AutoAccumulate,
@@ -11057,7 +11076,7 @@ const bitLookup = [
     [0b00000000, 8],
 ];
 
-var index$f = /*#__PURE__*/Object.freeze({
+var index$d = /*#__PURE__*/Object.freeze({
   __proto__: null,
   BranchNode: BranchNode,
   InMemoryTrie: InMemoryTrie,
@@ -11403,7 +11422,7 @@ function loadState(spec, entries) {
  *        hashmap of `key -> value` entries.
  */
 
-var index$e = /*#__PURE__*/Object.freeze({
+var index$c = /*#__PURE__*/Object.freeze({
   __proto__: null,
   SerializedService: SerializedService,
   SerializedState: SerializedState,
@@ -11689,7 +11708,7 @@ class InMemoryStates {
     }
 }
 
-var index$d = /*#__PURE__*/Object.freeze({
+var index$b = /*#__PURE__*/Object.freeze({
   __proto__: null,
   InMemoryBlocks: InMemoryBlocks,
   InMemoryStates: InMemoryStates,
@@ -12051,7 +12070,7 @@ const initEc = async () => {
     await init.reedSolomon();
 };
 
-var index$c = /*#__PURE__*/Object.freeze({
+var index$a = /*#__PURE__*/Object.freeze({
   __proto__: null,
   N_CHUNKS_REDUNDANCY: N_CHUNKS_REDUNDANCY,
   N_CHUNKS_REQUIRED: N_CHUNKS_REQUIRED,
@@ -12075,439 +12094,6 @@ var index$c = /*#__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(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);
-            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;
 /**
@@ -14555,6 +14141,17 @@ class PageRange {
         }
         return new 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;
@@ -14895,10 +14492,11 @@ class 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();
             }
         }
@@ -17338,8 +16936,8 @@ var index$3 = /*#__PURE__*/Object.freeze({
   asOpaqueType: asOpaqueType,
   assertEmpty: assertEmpty,
   assertNever: assertNever,
-  block: index$l,
-  bytes: index$s,
+  block: index$j,
+  bytes: index$q,
   check: check,
   clampU64ToU32: clampU64ToU32,
   createResults: createResults,
@@ -17347,13 +16945,13 @@ var index$3 = /*#__PURE__*/Object.freeze({
   extractCodeAndMetadata: extractCodeAndMetadata,
   getServiceId: getServiceId,
   getServiceIdOrCurrent: getServiceIdOrCurrent,
-  hash: index$p,
+  hash: index$n,
   inspect: inspect,
   instructionArgumentTypeMap: instructionArgumentTypeMap,
   interpreter: index$7,
   isBrowser: isBrowser,
   measure: measure,
-  numbers: index$r,
+  numbers: index$p,
   resultToString: resultToString,
   seeThrough: seeThrough,
   slotsToPreimageStatus: slotsToPreimageStatus,
@@ -18067,4 +17665,4 @@ var index = /*#__PURE__*/Object.freeze({
   WorkPackageExecutor: WorkPackageExecutor
 });
 
-export { index$l as block, index$j as block_json, index$s as bytes, index$q as codec, index$n as collections, index$m as config, index$h as config_node, index$o as crypto, index$d as database, index$c as erasure_coding, index$a as fuzz_proto, index$p as hash, index$9 as jam_host_calls, index$k as json_parser, index$i as logger, index$8 as mmr, index$r as numbers, index$t as ordering, index$3 as pvm, index$6 as pvm_host_calls, index$7 as pvm_interpreter, index$4 as pvm_program, index$5 as pvm_spi_decoder, index$2 as shuffling, index$g as state, index$1 as state_json, index$e as state_merkleization, index as transition, index$f as trie, index$u as utils };
+export { index$j as block, index$h as block_json, index$q as bytes, index$o as codec, index$l as collections, index$k as config, index$f as config_node, index$m as crypto, index$b as database, index$a as erasure_coding, index$n as hash, index$9 as jam_host_calls, index$i as json_parser, index$g as logger, index$8 as mmr, index$p as numbers, index$r as ordering, index$3 as pvm, index$6 as pvm_host_calls, index$7 as pvm_interpreter, index$4 as pvm_program, index$5 as pvm_spi_decoder, index$2 as shuffling, index$e as state, index$1 as state_json, index$c as state_merkleization, index as transition, index$d as trie, index$s as utils };