@typeberry/jam 0.4.1-9e565b9 → 0.4.1-bb6dbac

package/bootstrap-network.mjs

@@ -15433,6 +15433,349 @@ exports.fromBER = fromBER;
 exports.verifySchema = verifySchema;
 
 
+/***/ }),
+
+/***/ 952:
+/***/ ((module) => {
+
+
+
+var has = Object.prototype.hasOwnProperty
+  , prefix = '~';
+
+/**
+ * Constructor to create a storage for our `EE` objects.
+ * An `Events` instance is a plain object whose properties are event names.
+ *
+ * @constructor
+ * @private
+ */
+function Events() {}
+
+//
+// We try to not inherit from `Object.prototype`. In some engines creating an
+// instance in this way is faster than calling `Object.create(null)` directly.
+// If `Object.create(null)` is not supported we prefix the event names with a
+// character to make sure that the built-in object properties are not
+// overridden or used as an attack vector.
+//
+if (Object.create) {
+  Events.prototype = Object.create(null);
+
+  //
+  // This hack is needed because the `__proto__` property is still inherited in
+  // some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5.
+  //
+  if (!new Events().__proto__) prefix = false;
+}
+
+/**
+ * Representation of a single event listener.
+ *
+ * @param {Function} fn The listener function.
+ * @param {*} context The context to invoke the listener with.
+ * @param {Boolean} [once=false] Specify if the listener is a one-time listener.
+ * @constructor
+ * @private
+ */
+function EE(fn, context, once) {
+  this.fn = fn;
+  this.context = context;
+  this.once = once || false;
+}
+
+/**
+ * Add a listener for a given event.
+ *
+ * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
+ * @param {(String|Symbol)} event The event name.
+ * @param {Function} fn The listener function.
+ * @param {*} context The context to invoke the listener with.
+ * @param {Boolean} once Specify if the listener is a one-time listener.
+ * @returns {EventEmitter}
+ * @private
+ */
+function addListener(emitter, event, fn, context, once) {
+  if (typeof fn !== 'function') {
+    throw new TypeError('The listener must be a function');
+  }
+
+  var listener = new EE(fn, context || emitter, once)
+    , evt = prefix ? prefix + event : event;
+
+  if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;
+  else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
+  else emitter._events[evt] = [emitter._events[evt], listener];
+
+  return emitter;
+}
+
+/**
+ * Clear event by name.
+ *
+ * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
+ * @param {(String|Symbol)} evt The Event name.
+ * @private
+ */
+function clearEvent(emitter, evt) {
+  if (--emitter._eventsCount === 0) emitter._events = new Events();
+  else delete emitter._events[evt];
+}
+
+/**
+ * Minimal `EventEmitter` interface that is molded against the Node.js
+ * `EventEmitter` interface.
+ *
+ * @constructor
+ * @public
+ */
+function EventEmitter() {
+  this._events = new Events();
+  this._eventsCount = 0;
+}
+
+/**
+ * Return an array listing the events for which the emitter has registered
+ * listeners.
+ *
+ * @returns {Array}
+ * @public
+ */
+EventEmitter.prototype.eventNames = function eventNames() {
+  var names = []
+    , events
+    , name;
+
+  if (this._eventsCount === 0) return names;
+
+  for (name in (events = this._events)) {
+    if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
+  }
+
+  if (Object.getOwnPropertySymbols) {
+    return names.concat(Object.getOwnPropertySymbols(events));
+  }
+
+  return names;
+};
+
+/**
+ * Return the listeners registered for a given event.
+ *
+ * @param {(String|Symbol)} event The event name.
+ * @returns {Array} The registered listeners.
+ * @public
+ */
+EventEmitter.prototype.listeners = function listeners(event) {
+  var evt = prefix ? prefix + event : event
+    , handlers = this._events[evt];
+
+  if (!handlers) return [];
+  if (handlers.fn) return [handlers.fn];
+
+  for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
+    ee[i] = handlers[i].fn;
+  }
+
+  return ee;
+};
+
+/**
+ * Return the number of listeners listening to a given event.
+ *
+ * @param {(String|Symbol)} event The event name.
+ * @returns {Number} The number of listeners.
+ * @public
+ */
+EventEmitter.prototype.listenerCount = function listenerCount(event) {
+  var evt = prefix ? prefix + event : event
+    , listeners = this._events[evt];
+
+  if (!listeners) return 0;
+  if (listeners.fn) return 1;
+  return listeners.length;
+};
+
+/**
+ * Calls each of the listeners registered for a given event.
+ *
+ * @param {(String|Symbol)} event The event name.
+ * @returns {Boolean} `true` if the event had listeners, else `false`.
+ * @public
+ */
+EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+  var evt = prefix ? prefix + event : event;
+
+  if (!this._events[evt]) return false;
+
+  var listeners = this._events[evt]
+    , len = arguments.length
+    , args
+    , i;
+
+  if (listeners.fn) {
+    if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);
+
+    switch (len) {
+      case 1: return listeners.fn.call(listeners.context), true;
+      case 2: return listeners.fn.call(listeners.context, a1), true;
+      case 3: return listeners.fn.call(listeners.context, a1, a2), true;
+      case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;
+      case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+      case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+    }
+
+    for (i = 1, args = new Array(len -1); i < len; i++) {
+      args[i - 1] = arguments[i];
+    }
+
+    listeners.fn.apply(listeners.context, args);
+  } else {
+    var length = listeners.length
+      , j;
+
+    for (i = 0; i < length; i++) {
+      if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);
+
+      switch (len) {
+        case 1: listeners[i].fn.call(listeners[i].context); break;
+        case 2: listeners[i].fn.call(listeners[i].context, a1); break;
+        case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break;
+        case 4: listeners[i].fn.call(listeners[i].context, a1, a2, a3); break;
+        default:
+          if (!args) for (j = 1, args = new Array(len -1); j < len; j++) {
+            args[j - 1] = arguments[j];
+          }
+
+          listeners[i].fn.apply(listeners[i].context, args);
+      }
+    }
+  }
+
+  return true;
+};
+
+/**
+ * Add a listener for a given event.
+ *
+ * @param {(String|Symbol)} event The event name.
+ * @param {Function} fn The listener function.
+ * @param {*} [context=this] The context to invoke the listener with.
+ * @returns {EventEmitter} `this`.
+ * @public
+ */
+EventEmitter.prototype.on = function on(event, fn, context) {
+  return addListener(this, event, fn, context, false);
+};
+
+/**
+ * Add a one-time listener for a given event.
+ *
+ * @param {(String|Symbol)} event The event name.
+ * @param {Function} fn The listener function.
+ * @param {*} [context=this] The context to invoke the listener with.
+ * @returns {EventEmitter} `this`.
+ * @public
+ */
+EventEmitter.prototype.once = function once(event, fn, context) {
+  return addListener(this, event, fn, context, true);
+};
+
+/**
+ * Remove the listeners of a given event.
+ *
+ * @param {(String|Symbol)} event The event name.
+ * @param {Function} fn Only remove the listeners that match this function.
+ * @param {*} context Only remove the listeners that have this context.
+ * @param {Boolean} once Only remove one-time listeners.
+ * @returns {EventEmitter} `this`.
+ * @public
+ */
+EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
+  var evt = prefix ? prefix + event : event;
+
+  if (!this._events[evt]) return this;
+  if (!fn) {
+    clearEvent(this, evt);
+    return this;
+  }
+
+  var listeners = this._events[evt];
+
+  if (listeners.fn) {
+    if (
+      listeners.fn === fn &&
+      (!once || listeners.once) &&
+      (!context || listeners.context === context)
+    ) {
+      clearEvent(this, evt);
+    }
+  } else {
+    for (var i = 0, events = [], length = listeners.length; i < length; i++) {
+      if (
+        listeners[i].fn !== fn ||
+        (once && !listeners[i].once) ||
+        (context && listeners[i].context !== context)
+      ) {
+        events.push(listeners[i]);
+      }
+    }
+
+    //
+    // Reset the array, or remove it completely if we have no more listeners.
+    //
+    if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
+    else clearEvent(this, evt);
+  }
+
+  return this;
+};
+
+/**
+ * Remove all listeners, or those of the specified event.
+ *
+ * @param {(String|Symbol)} [event] The event name.
+ * @returns {EventEmitter} `this`.
+ * @public
+ */
+EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
+  var evt;
+
+  if (event) {
+    evt = prefix ? prefix + event : event;
+    if (this._events[evt]) clearEvent(this, evt);
+  } else {
+    this._events = new Events();
+    this._eventsCount = 0;
+  }
+
+  return this;
+};
+
+//
+// Alias methods names because people roll like that.
+//
+EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+EventEmitter.prototype.addListener = EventEmitter.prototype.on;
+
+//
+// Expose the prefix.
+//
+EventEmitter.prefixed = prefix;
+
+//
+// Allow `EventEmitter` to be imported as module namespace.
+//
+EventEmitter.EventEmitter = EventEmitter;
+
+//
+// Expose the module.
+//
+if (true) {
+  module.exports = EventEmitter;
+}
+
+
 /***/ }),
 
 /***/ 1681:
@@ -24027,7 +24370,11 @@ __nccwpck_require__.d(__webpack_exports__, {
   TB: () => (/* reexport */ protocol)
 });
 
+;// CONCATENATED MODULE: ./packages/core/utils/env.ts
+const env = typeof process === "undefined" ? {} : process.env;
+
 ;// CONCATENATED MODULE: ./packages/core/utils/compatibility.ts
+
 var GpVersion;
 (function (GpVersion) {
     GpVersion["V0_6_7"] = "0.6.7";
@@ -24047,7 +24394,6 @@ const DEFAULT_SUITE = TestSuite.W3F_DAVXY;
  * Since we are currently at 0.7.1 not 0.7.2, we set our default version accordingly.
  */
 const DEFAULT_VERSION = GpVersion.V0_7_1;
-const env = typeof process === "undefined" ? {} : process.env;
 let CURRENT_VERSION = parseCurrentVersion(env.GP_VERSION) ?? DEFAULT_VERSION;
 let CURRENT_SUITE = parseCurrentSuite(env.TEST_SUITE) ?? DEFAULT_SUITE;
 function parseCurrentVersion(env) {
@@ -24240,7 +24586,7 @@ function lazyInspect(obj) {
 }
 
 ;// CONCATENATED MODULE: ./packages/core/utils/dev.ts
-const dev_env = typeof process === "undefined" ? {} : process.env;
+
 /**
  * The function will produce relative path resolver that is adjusted
  * for package location within the workspace.
@@ -24258,7 +24604,7 @@ const dev_env = typeof process === "undefined" ? {} : process.env;
  * NOTE: the translation happens only for development build! When
  * we build a single library from our project, we no longer mangle the paths.
  */
-const workspacePathFix = dev_env.NODE_ENV === "development"
+const workspacePathFix = env.NODE_ENV === "development"
     ? (workspacePath) => (p) => {
         if (p.startsWith("/")) {
             return p;
@@ -26239,7 +26585,7 @@ const TYPICAL_SEQUENCE_LENGTH = 64;
  * For the size hint for encoding typical dictionaries.
  * TODO [ToDr] [opti] This value should be updated when we run some real-data bechmarks.
  */
-const descriptors_TYPICAL_DICTIONARY_LENGTH = 32;
+const TYPICAL_DICTIONARY_LENGTH = 32;
 /**
  * Convert a descriptor for regular array into readonly one.
  *
@@ -26265,213 +26611,209 @@ function exactHint(bytes) {
         isExact: true,
     };
 }
-/** Descriptors for data types that can be read/written from/to codec. */
-var descriptors_codec;
-(function (codec) {
-    /** Fixed-length bytes sequence. */
-    codec.bytes = (() => {
-        const cache = new Map();
-        return (len) => {
-            let ret = cache.get(len);
-            if (ret === undefined) {
-                ret = descriptor_Descriptor.new(`Bytes<${len}>`, exactHint(len), (e, v) => e.bytes(v), (d) => d.bytes(len), (s) => s.bytes(len));
-                cache.set(len, ret);
-            }
-            return ret;
-        };
-    })();
-    /** Zero-size `void` value. */
-    codec.nothing = descriptor_Descriptor.new("void", { bytes: 0, isExact: true }, (_e, _v) => { }, (_d) => { }, (_s) => { });
-    /** Variable-length U32. */
-    codec.varU32 = descriptor_Descriptor.new("var_u32", { bytes: 4, isExact: false }, (e, v) => e.varU32(v), (d) => d.varU32(), (d) => d.varU32());
-    /** Variable-length U64. */
-    codec.varU64 = descriptor_Descriptor.new("var_u64", { bytes: 8, isExact: false }, (e, v) => e.varU64(v), (d) => d.varU64(), (d) => d.varU64());
-    /** Unsigned 64-bit number. */
-    codec.u64 = descriptor_Descriptor.withView("u64", exactHint(8), (e, v) => e.i64(v), (d) => d.u64(), (d) => d.u64(), codec.bytes(8));
-    /** Unsigned 32-bit number. */
-    codec.u32 = descriptor_Descriptor.withView("u32", exactHint(4), (e, v) => e.i32(v), (d) => d.u32(), (d) => d.u32(), codec.bytes(4));
-    /** Unsigned 24-bit number. */
-    codec.u24 = descriptor_Descriptor.withView("u24", exactHint(3), (e, v) => e.i24(v), (d) => d.u24(), (d) => d.u24(), codec.bytes(3));
-    /** Unsigned 16-bit number. */
-    codec.u16 = descriptor_Descriptor.withView("u16", exactHint(2), (e, v) => e.i16(v), (d) => d.u16(), (d) => d.u16(), codec.bytes(2));
-    /** Unsigned 8-bit number. */
-    codec.u8 = descriptor_Descriptor.new("u8", exactHint(1), (e, v) => e.i8(v), (d) => d.u8(), (d) => d.u8());
-    /** Signed 64-bit number. */
-    codec.i64 = descriptor_Descriptor.withView("u64", exactHint(8), (e, v) => e.i64(v), (d) => d.i64(), (s) => s.u64(), codec.bytes(8));
-    /** Signed 32-bit number. */
-    codec.i32 = descriptor_Descriptor.withView("i32", exactHint(4), (e, v) => e.i32(v), (d) => d.i32(), (s) => s.u32(), codec.bytes(4));
-    /** Signed 24-bit number. */
-    codec.i24 = descriptor_Descriptor.withView("i24", exactHint(3), (e, v) => e.i24(v), (d) => d.i24(), (s) => s.u24(), codec.bytes(3));
-    /** Signed 16-bit number. */
-    codec.i16 = descriptor_Descriptor.withView("i16", exactHint(2), (e, v) => e.i16(v), (d) => d.i16(), (s) => s.u16(), codec.bytes(2));
-    /** Signed 8-bit number. */
-    codec.i8 = descriptor_Descriptor.new("i8", exactHint(1), (e, v) => e.i8(v), (d) => d.i8(), (s) => s.u8());
-    /** 1-byte boolean value. */
-    codec.bool = descriptor_Descriptor.new("bool", exactHint(1), (e, v) => e.bool(v), (d) => d.bool(), (s) => s.bool());
-    /** Variable-length bytes blob. */
-    codec.blob = descriptor_Descriptor.new("BytesBlob", { bytes: TYPICAL_SEQUENCE_LENGTH, isExact: false }, (e, v) => e.bytesBlob(v), (d) => d.bytesBlob(), (s) => s.bytesBlob());
-    /** String encoded as variable-length bytes blob. */
-    codec.string = descriptor_Descriptor.withView("string", { bytes: TYPICAL_SEQUENCE_LENGTH, isExact: false }, (e, v) => e.bytesBlob(bytes_BytesBlob.blobFrom(new TextEncoder().encode(v))), (d) => new TextDecoder("utf8", { fatal: true }).decode(d.bytesBlob().raw), (s) => s.bytesBlob(), codec.blob);
-    /** Variable-length bit vector. */
-    codec.bitVecVarLen = descriptor_Descriptor.new("BitVec[?]", { bytes: TYPICAL_SEQUENCE_LENGTH >>> 3, isExact: false }, (e, v) => e.bitVecVarLen(v), (d) => d.bitVecVarLen(), (s) => s.bitVecVarLen());
-    /** Fixed-length bit vector. */
-    codec.bitVecFixLen = (bitLen) => descriptor_Descriptor.new(`BitVec[${bitLen}]`, exactHint(bitLen >>> 3), (e, v) => e.bitVecFixLen(v), (d) => d.bitVecFixLen(bitLen), (s) => s.bitVecFixLen(bitLen));
-    /** Optionality wrapper for given type. */
-    codec.optional = (type) => {
-        const self = descriptor_Descriptor.new(`Optional<${type.name}>`, addSizeHints({ bytes: 1, isExact: false }, type.sizeHint), (e, v) => e.optional(type, v), (d) => d.optional(type), (s) => s.optional(type));
-        if (hasUniqueView(type)) {
-            return descriptor_Descriptor.withView(self.name, self.sizeHint, self.encode, self.decode, self.skip, codec.optional(type.View));
-        }
-        return self;
-    };
-    /** Variable-length sequence of given type. */
-    codec.sequenceVarLen = (type, options = {
-        minLength: 0,
-        maxLength: 2 ** 32 - 1,
-    }) => {
-        const name = `Sequence<${type.name}>[?]`;
-        const typicalLength = options.typicalLength ?? TYPICAL_SEQUENCE_LENGTH;
-        return descriptor_Descriptor.withView(name, { bytes: typicalLength * type.sizeHint.bytes, isExact: false }, (e, v) => {
-            validateLength(options, v.length, name);
-            e.sequenceVarLen(type, v);
-        }, (d) => {
-            const len = d.varU32();
-            validateLength(options, len, name);
-            return d.sequenceFixLen(type, len);
-        }, (s) => {
-            const len = s.decoder.varU32();
-            validateLength(options, len, name);
-            return s.sequenceFixLen(type, len);
-        }, sequenceViewVarLen(type, options));
-    };
-    /** Fixed-length sequence of given type. */
-    codec.sequenceFixLen = (type, len) => descriptor_Descriptor.withView(`Sequence<${type.name}>[${len}]`, { bytes: len * type.sizeHint.bytes, isExact: type.sizeHint.isExact }, (e, v) => e.sequenceFixLen(type, v), (d) => d.sequenceFixLen(type, len), (s) => s.sequenceFixLen(type, len), sequenceViewFixLen(type, { fixedLength: len }));
-    /** Small dictionary codec. */
-    codec.dictionary = (key, value, { sortKeys, fixedLength, }) => {
-        const self = descriptor_Descriptor.new(`Dictionary<${key.name}, ${value.name}>[${fixedLength ?? "?"}]`, {
-            bytes: fixedLength !== undefined
-                ? fixedLength * addSizeHints(key.sizeHint, value.sizeHint).bytes
-                : descriptors_TYPICAL_DICTIONARY_LENGTH * (addSizeHints(key.sizeHint, value.sizeHint).bytes ?? 0),
-            isExact: fixedLength !== undefined ? key.sizeHint.isExact && value.sizeHint.isExact : false,
-        }, (e, v) => {
-            const data = Array.from(v.entries());
-            data.sort((a, b) => sortKeys(a[0], b[0]));
-            // length prefix
-            if (fixedLength === undefined || fixedLength === 0) {
-                e.varU32(numbers_tryAsU32(data.length));
-            }
-            for (const [k, v] of data) {
-                key.encode(e, k);
-                value.encode(e, v);
-            }
-        }, (d) => {
-            const map = new Map();
-            const len = fixedLength ?? d.varU32();
-            let prevKey = null;
-            for (let i = 0; i < len; i += 1) {
-                const k = key.decode(d);
-                const v = value.decode(d);
-                if (map.has(k)) {
-                    throw new Error(`Duplicate item in the dictionary encoding: "${k}"!`);
-                }
-                if (prevKey !== null && sortKeys(prevKey, k) >= 0) {
-                    throw new Error(`The keys in dictionary encoding are not sorted "${prevKey}" >= "${k}"!`);
-                }
-                map.set(k, v);
-                prevKey = k;
-            }
-            return map;
-        }, (s) => {
-            const len = fixedLength ?? s.decoder.varU32();
-            s.sequenceFixLen(key, len);
-            s.sequenceFixLen(value, len);
-        });
-        if (hasUniqueView(value)) {
-            return descriptor_Descriptor.withView(self.name, self.sizeHint, self.encode, self.decode, self.skip, codec.dictionary(key, value.View, { sortKeys, fixedLength }));
+/** Fixed-length bytes sequence. */
+const bytes = (() => {
+    const cache = new Map();
+    return (len) => {
+        let ret = cache.get(len);
+        if (ret === undefined) {
+            ret = descriptor_Descriptor.new(`Bytes<${len}>`, exactHint(len), (e, v) => e.bytes(v), (d) => d.bytes(len), (s) => s.bytes(len));
+            cache.set(len, ret);
         }
-        return self;
+        return ret;
     };
-    /** Encoding of pair of two values. */
-    codec.pair = (a, b) => {
-        const self = descriptor_Descriptor.new(`Pair<${a.name}, ${b.name}>`, addSizeHints(a.sizeHint, b.sizeHint), (e, elem) => {
-            a.encode(e, elem[0]);
-            b.encode(e, elem[1]);
-        }, (d) => {
-            const aValue = a.decode(d);
-            const bValue = b.decode(d);
-            return [aValue, bValue];
-        }, (s) => {
-            a.skip(s);
-            b.skip(s);
-        });
-        if (hasUniqueView(a) && hasUniqueView(b)) {
-            return descriptor_Descriptor.withView(self.name, self.sizeHint, self.encode, self.decode, self.skip, codec.pair(a.View, b.View));
+})();
+/** Zero-size `void` value. */
+const nothing = descriptor_Descriptor.new("void", { bytes: 0, isExact: true }, (_e, _v) => { }, (_d) => { }, (_s) => { });
+/** Variable-length U32. */
+const varU32 = descriptor_Descriptor.new("var_u32", { bytes: 4, isExact: false }, (e, v) => e.varU32(v), (d) => d.varU32(), (d) => d.varU32());
+/** Variable-length U64. */
+const varU64 = descriptor_Descriptor.new("var_u64", { bytes: 8, isExact: false }, (e, v) => e.varU64(v), (d) => d.varU64(), (d) => d.varU64());
+/** Unsigned 64-bit number. */
+const u64 = descriptor_Descriptor.withView("u64", exactHint(8), (e, v) => e.i64(v), (d) => d.u64(), (d) => d.u64(), bytes(8));
+/** Unsigned 32-bit number. */
+const u32 = descriptor_Descriptor.withView("u32", exactHint(4), (e, v) => e.i32(v), (d) => d.u32(), (d) => d.u32(), bytes(4));
+/** Unsigned 24-bit number. */
+const u24 = descriptor_Descriptor.withView("u24", exactHint(3), (e, v) => e.i24(v), (d) => d.u24(), (d) => d.u24(), bytes(3));
+/** Unsigned 16-bit number. */
+const u16 = descriptor_Descriptor.withView("u16", exactHint(2), (e, v) => e.i16(v), (d) => d.u16(), (d) => d.u16(), bytes(2));
+/** Unsigned 8-bit number. */
+const u8 = descriptor_Descriptor.new("u8", exactHint(1), (e, v) => e.i8(v), (d) => d.u8(), (d) => d.u8());
+/** Signed 64-bit number. */
+const i64 = descriptor_Descriptor.withView("i64", exactHint(8), (e, v) => e.i64(v), (d) => d.i64(), (s) => s.u64(), bytes(8));
+/** Signed 32-bit number. */
+const i32 = descriptor_Descriptor.withView("i32", exactHint(4), (e, v) => e.i32(v), (d) => d.i32(), (s) => s.u32(), bytes(4));
+/** Signed 24-bit number. */
+const i24 = descriptor_Descriptor.withView("i24", exactHint(3), (e, v) => e.i24(v), (d) => d.i24(), (s) => s.u24(), bytes(3));
+/** Signed 16-bit number. */
+const i16 = descriptor_Descriptor.withView("i16", exactHint(2), (e, v) => e.i16(v), (d) => d.i16(), (s) => s.u16(), bytes(2));
+/** Signed 8-bit number. */
+const i8 = descriptor_Descriptor.new("i8", exactHint(1), (e, v) => e.i8(v), (d) => d.i8(), (s) => s.u8());
+/** 1-byte boolean value. */
+const bool = descriptor_Descriptor.new("bool", exactHint(1), (e, v) => e.bool(v), (d) => d.bool(), (s) => s.bool());
+/** Variable-length bytes blob. */
+const blob = descriptor_Descriptor.new("BytesBlob", { bytes: TYPICAL_SEQUENCE_LENGTH, isExact: false }, (e, v) => e.bytesBlob(v), (d) => d.bytesBlob(), (s) => s.bytesBlob());
+/** String encoded as variable-length bytes blob. */
+const string = descriptor_Descriptor.withView("string", { bytes: TYPICAL_SEQUENCE_LENGTH, isExact: false }, (e, v) => e.bytesBlob(bytes_BytesBlob.blobFrom(new TextEncoder().encode(v))), (d) => new TextDecoder("utf8", { fatal: true }).decode(d.bytesBlob().raw), (s) => s.bytesBlob(), blob);
+/** Variable-length bit vector. */
+const bitVecVarLen = descriptor_Descriptor.new("BitVec[?]", { bytes: TYPICAL_SEQUENCE_LENGTH >>> 3, isExact: false }, (e, v) => e.bitVecVarLen(v), (d) => d.bitVecVarLen(), (s) => s.bitVecVarLen());
+/** Fixed-length bit vector. */
+const bitVecFixLen = (bitLen) => descriptor_Descriptor.new(`BitVec[${bitLen}]`, exactHint(bitLen >>> 3), (e, v) => e.bitVecFixLen(v), (d) => d.bitVecFixLen(bitLen), (s) => s.bitVecFixLen(bitLen));
+/** Optionality wrapper for given type. */
+const optional = (type) => {
+    const self = descriptor_Descriptor.new(`Optional<${type.name}>`, addSizeHints({ bytes: 1, isExact: false }, type.sizeHint), (e, v) => e.optional(type, v), (d) => d.optional(type), (s) => s.optional(type));
+    if (hasUniqueView(type)) {
+        return descriptor_Descriptor.withView(self.name, self.sizeHint, self.encode, self.decode, self.skip, optional(type.View));
+    }
+    return self;
+};
+/** Variable-length sequence of given type. */
+const sequenceVarLen = (type, options = {
+    minLength: 0,
+    maxLength: 2 ** 32 - 1,
+}) => {
+    const name = `Sequence<${type.name}>[?]`;
+    const typicalLength = options.typicalLength ?? TYPICAL_SEQUENCE_LENGTH;
+    return descriptor_Descriptor.withView(name, { bytes: typicalLength * type.sizeHint.bytes, isExact: false }, (e, v) => {
+        validateLength(options, v.length, name);
+        e.sequenceVarLen(type, v);
+    }, (d) => {
+        const len = d.varU32();
+        validateLength(options, len, name);
+        return d.sequenceFixLen(type, len);
+    }, (s) => {
+        const len = s.decoder.varU32();
+        validateLength(options, len, name);
+        return s.sequenceFixLen(type, len);
+    }, sequenceViewVarLen(type, options));
+};
+/** Fixed-length sequence of given type. */
+const sequenceFixLen = (type, len) => descriptor_Descriptor.withView(`Sequence<${type.name}>[${len}]`, { bytes: len * type.sizeHint.bytes, isExact: type.sizeHint.isExact }, (e, v) => e.sequenceFixLen(type, v), (d) => d.sequenceFixLen(type, len), (s) => s.sequenceFixLen(type, len), sequenceViewFixLen(type, { fixedLength: len }));
+/** Small dictionary codec. */
+const dictionary = (key, value, { sortKeys, fixedLength, }) => {
+    const self = descriptor_Descriptor.new(`Dictionary<${key.name}, ${value.name}>[${fixedLength ?? "?"}]`, {
+        bytes: fixedLength !== undefined
+            ? fixedLength * addSizeHints(key.sizeHint, value.sizeHint).bytes
+            : TYPICAL_DICTIONARY_LENGTH * (addSizeHints(key.sizeHint, value.sizeHint).bytes ?? 0),
+        isExact: fixedLength !== undefined ? key.sizeHint.isExact && value.sizeHint.isExact : false,
+    }, (e, v) => {
+        const data = Array.from(v.entries());
+        data.sort((a, b) => sortKeys(a[0], b[0]));
+        // length prefix
+        if (fixedLength === undefined) {
+            e.varU32(numbers_tryAsU32(data.length));
+        }
+        for (const [k, v] of data) {
+            key.encode(e, k);
+            value.encode(e, v);
         }
-        return self;
-    };
-    /** Custom encoding / decoding logic. */
-    codec.custom = ({ name, sizeHint = { bytes: 0, isExact: false }, }, encode, decode, skip) => descriptor_Descriptor.new(name, sizeHint, encode, decode, skip);
-    /** Choose a descriptor depending on the encoding/decoding context. */
-    codec.select = ({ name, sizeHint, }, chooser) => {
-        const Self = chooser(null);
-        return descriptor_Descriptor.withView(name, sizeHint, (e, x) => chooser(e.getContext()).encode(e, x), (d) => chooser(d.getContext()).decode(d), (s) => chooser(s.decoder.getContext()).skip(s), hasUniqueView(Self)
-            ? codec.select({
-                name: Self.View.name,
-                sizeHint: Self.View.sizeHint,
-            }, (ctx) => chooser(ctx).View)
-            : Self.View);
-    };
-    /**
-     * A descriptor for a more complex POJO.
-     *
-     * This descriptor is very similar to `Class`, but it DOES NOT maintain the
-     * prototype chain of the resulting object - we only care about the shape of
-     * the object here.
-     */
-    codec.object = (descriptors, name = "object", create = (o) => o) => {
-        return codec.Class({ name, create }, descriptors);
-    };
-    /**
-     * A descriptor for a more complex class type.
-     *
-     * The resulting descriptor is able to encode & decode all of the public fields of
-     * the class, given the map of descriptors for each one of them.
-     *
-     * The resulting decoded object will be an instance of given `Class` unlike simpler,
-     * shape-based `object` method.
-     */
-    codec.Class = (Class, descriptors) => {
-        // Calculate a size hint for this class.
-        let sizeHint = exactHint(0);
-        forEachDescriptor(descriptors, (_k, val) => {
-            sizeHint = addSizeHints(sizeHint, val.sizeHint);
-        });
-        const skipper = (s) => {
-            // optimized case for fixed size complex values.
-            if (sizeHint.isExact) {
-                return s.decoder.skip(sizeHint.bytes);
+    }, (d) => {
+        const map = new Map();
+        const len = fixedLength ?? d.varU32();
+        let prevKey = null;
+        for (let i = 0; i < len; i += 1) {
+            const k = key.decode(d);
+            const v = value.decode(d);
+            if (map.has(k)) {
+                throw new Error(`Duplicate item in the dictionary encoding: "${k}"!`);
             }
-            forEachDescriptor(descriptors, (_key, descriptor) => {
-                descriptor.skip(s);
-            });
-        };
-        const view = objectView(Class, descriptors, sizeHint, skipper);
-        // and create the descriptor for the entire class.
-        return descriptor_Descriptor.withView(Class.name, sizeHint, (e, t) => {
-            forEachDescriptor(descriptors, (key, descriptor) => {
-                const value = t[key];
-                descriptor.encode(e, value);
-            });
-        }, (d) => {
-            const constructorParams = {};
-            forEachDescriptor(descriptors, (key, descriptor) => {
-                const value = descriptor.decode(d);
-                constructorParams[key] = value;
-            });
-            return Class.create(constructorParams);
-        }, skipper, view);
+            if (prevKey !== null && sortKeys(prevKey, k) >= 0) {
+                throw new Error(`The keys in dictionary encoding are not sorted "${prevKey}" >= "${k}"!`);
+            }
+            map.set(k, v);
+            prevKey = k;
+        }
+        return map;
+    }, (s) => {
+        const len = fixedLength ?? s.decoder.varU32();
+        s.sequenceFixLen(key, len);
+        s.sequenceFixLen(value, len);
+    });
+    if (hasUniqueView(value)) {
+        return descriptor_Descriptor.withView(self.name, self.sizeHint, self.encode, self.decode, self.skip, dictionary(key, value.View, { sortKeys, fixedLength }));
+    }
+    return self;
+};
+/** Encoding of pair of two values. */
+const pair = (a, b) => {
+    const self = descriptor_Descriptor.new(`Pair<${a.name}, ${b.name}>`, addSizeHints(a.sizeHint, b.sizeHint), (e, elem) => {
+        a.encode(e, elem[0]);
+        b.encode(e, elem[1]);
+    }, (d) => {
+        const aValue = a.decode(d);
+        const bValue = b.decode(d);
+        return [aValue, bValue];
+    }, (s) => {
+        a.skip(s);
+        b.skip(s);
+    });
+    if (hasUniqueView(a) && hasUniqueView(b)) {
+        return descriptor_Descriptor.withView(self.name, self.sizeHint, self.encode, self.decode, self.skip, pair(a.View, b.View));
+    }
+    return self;
+};
+/** Custom encoding / decoding logic. */
+const custom = ({ name, sizeHint = { bytes: 0, isExact: false }, }, encode, decode, skip) => descriptor_Descriptor.new(name, sizeHint, encode, decode, skip);
+/** Choose a descriptor depending on the encoding/decoding context. */
+const descriptors_select = ({ name, sizeHint, }, chooser) => {
+    const Self = chooser(null);
+    return descriptor_Descriptor.withView(name, sizeHint, (e, x) => chooser(e.getContext()).encode(e, x), (d) => chooser(d.getContext()).decode(d), (s) => chooser(s.decoder.getContext()).skip(s), hasUniqueView(Self)
+        ? descriptors_select({
+            name: Self.View.name,
+            sizeHint: Self.View.sizeHint,
+        }, (ctx) => chooser(ctx).View)
+        : Self.View);
+};
+/**
+ * A descriptor for a more complex POJO.
+ *
+ * This descriptor is very similar to `Class`, but it DOES NOT maintain the
+ * prototype chain of the resulting object - we only care about the shape of
+ * the object here.
+ */
+const object = (descriptors, name = "object", create = (o) => o) => {
+    return Class({ name, create }, descriptors);
+};
+/**
+ * A descriptor for a more complex class type.
+ *
+ * The resulting descriptor is able to encode & decode all of the public fields of
+ * the class, given the map of descriptors for each one of them.
+ *
+ * The resulting decoded object will be an instance of given `Class` unlike simpler,
+ * shape-based `object` method.
+ */
+const Class = (Class, descriptors) => {
+    // Calculate a size hint for this class.
+    let sizeHint = exactHint(0);
+    forEachDescriptor(descriptors, (_k, val) => {
+        sizeHint = addSizeHints(sizeHint, val.sizeHint);
+    });
+    const skipper = (s) => {
+        // optimized case for fixed size complex values.
+        if (sizeHint.isExact) {
+            return s.decoder.skip(sizeHint.bytes);
+        }
+        forEachDescriptor(descriptors, (_key, descriptor) => {
+            descriptor.skip(s);
+        });
     };
-})(descriptors_codec || (descriptors_codec = {}));
+    const view = objectView(Class, descriptors, sizeHint, skipper);
+    // and create the descriptor for the entire class.
+    return descriptor_Descriptor.withView(Class.name, sizeHint, (e, t) => {
+        forEachDescriptor(descriptors, (key, descriptor) => {
+            const value = t[key];
+            descriptor.encode(e, value);
+        });
+    }, (d) => {
+        const constructorParams = {};
+        forEachDescriptor(descriptors, (key, descriptor) => {
+            const value = descriptor.decode(d);
+            constructorParams[key] = value;
+        });
+        return Class.create(constructorParams);
+    }, skipper, view);
+};
 /** Typesafe iteration of every descriptor in the record object. */
 function forEachDescriptor(descriptors, f) {
     for (const key in descriptors) {
@@ -27978,9 +28320,438 @@ class ArrayView {
     }
 }
 
+;// CONCATENATED MODULE: ./packages/core/collections/blob-dictionary.ts
+
+
+/** A map which uses byte blobs as keys */
+class BlobDictionary extends WithDebug {
+    mapNodeThreshold;
+    /**
+     * The root node of the dictionary.
+     *
+     * This is the main internal data structure that organizes entries
+     * in a tree-like fashion (array-based nodes up to `mapNodeThreshold`,
+     * map-based nodes beyond it). All insertions, updates, and deletions
+     * operate through this structure.
+     */
+    root = Node.withList();
+    /**
+     * Auxiliary map that stores references to the original keys and their values.
+     *
+     * - Overriding a value in the main structure does not replace the original key reference.
+     * - Used for efficient iteration over `keys()`, `values()`, `entries()`, and computing `size`.
+     */
+    keyvals = new Map();
+    /**
+     * Protected constructor used internally by `BlobDictionary.new`
+     * and `BlobDictionary.fromEntries`.
+     *
+     * This enforces controlled instantiation — users should create instances
+     * through the provided static factory methods instead of calling the
+     * constructor directly.
+     *
+     * @param mapNodeThreshold - The threshold that determines when the dictionary
+     * switches from using an array-based (`ListChildren`) node to a map-based (`MapChildren`) node for storing entries.
+     */
+    constructor(mapNodeThreshold) {
+        super();
+        this.mapNodeThreshold = mapNodeThreshold;
+    }
+    /**
+     * Returns the number of entries in the dictionary.
+     *
+     * The count is derived from the auxiliary `keyvals` map, which stores
+     * all original key references and their associated values. This ensures
+     * that the `size` reflects the actual number of entries, independent of
+     * internal overrides in the main `root` structure.
+     *
+     * @returns The total number of entries in the dictionary.
+     */
+    get size() {
+        return this.keyvals.size;
+    }
+    [TEST_COMPARE_USING]() {
+        const vals = Array.from(this);
+        vals.sort((a, b) => a[0].compare(b[0]).value);
+        return vals;
+    }
+    /**
+     * Creates an empty `BlobDictionary`.
+     *
+     * @param mapNodeThreshold - The threshold that determines when the dictionary
+     * switches from using an array-based (`ListChildren`) node to a map-based (`MapChildren`) node for storing entries.
+     * Defaults to `0`.
+     *
+     * @returns A new, empty `BlobDictionary` instance.
+     */
+    static new(mapNodeThreshold = 0) {
+        return new BlobDictionary(mapNodeThreshold);
+    }
+    /**
+     * Creates a new `BlobDictionary` initialized with the given entries.
+     *
+     * @param entries - An array of `[key, value]` pairs used to populate the dictionary.
+     * @param mapNodeThreshold - The threshold that determines when the dictionary
+     * switches from using an array-based (`ListChildren`) node to a map-based (`MapChildren`) node for storing entries.
+     * Defaults to `0`.
+     *
+     * @returns A new `BlobDictionary` containing the provided entries.
+     */
+    static fromEntries(entries, mapNodeThreshold) {
+        const dict = BlobDictionary.new(mapNodeThreshold);
+        for (const [key, value] of entries) {
+            dict.set(key, value);
+        }
+        return dict;
+    }
+    /**
+     * Internal helper that inserts, updates or deletes an entry in the dictionary.
+     *
+     * Behaviour details:
+     * - Passing `undefined` as `value` indicates a deletion. (E.g. `delete` uses `internalSet(key, undefined)`.)
+     * - When an add (new entry) or a delete actually changes the structure, the method returns the affected leaf node.
+     * - When the call only overrides an existing value (no structural add/delete), the method returns `null`.
+     *
+     * This method is intended for internal use by the dictionary implementation and allows `undefined` as a
+     * sentinel value to signal removals.
+     *
+     * @param key - The key to insert, update or remove.
+     * @param value - The value to associate with the key, or `undefined` to remove the key.
+     * @returns The leaf node created or removed on add/delete, or `null` if the operation only overwrote an existing value.
+     */
+    internalSet(key, value) {
+        let node = this.root;
+        const keyChunkGenerator = key.chunks(CHUNK_SIZE);
+        let depth = 0;
+        for (;;) {
+            const maybeKeyChunk = keyChunkGenerator.next().value;
+            if (maybeKeyChunk === undefined) {
+                if (value === undefined) {
+                    return node.remove(key);
+                }
+                return node.set(key, value);
+            }
+            const keyChunk = opaque_asOpaqueType(maybeKeyChunk);
+            if (node.children instanceof ListChildren) {
+                const subkey = bytes_BytesBlob.blobFrom(key.raw.subarray(CHUNK_SIZE * depth));
+                const leaf = value !== undefined ? node.children.insert(subkey, { key, value }) : node.children.remove(subkey);
+                if (subkey.length > CHUNK_SIZE && node.children.children.length > this.mapNodeThreshold) {
+                    node.convertListChildrenToMap();
+                }
+                return leaf;
+            }
+            depth += 1;
+            const children = node.children;
+            if (children instanceof ListChildren) {
+                throw new Error("We handle list node earlier. If we fall through, we know it's for the `Map` case.");
+            }
+            if (children instanceof MapChildren) {
+                const maybeNode = children.getChild(keyChunk);
+                if (maybeNode !== undefined) {
+                    // simply go one level deeper
+                    node = maybeNode;
+                }
+                else {
+                    // we are trying to remove an item, but it does not exist
+                    if (value === undefined) {
+                        return null;
+                    }
+                    // no more child nodes, we insert a new one.
+                    const newNode = Node.withList();
+                    children.setChild(keyChunk, newNode);
+                    node = newNode;
+                }
+                continue;
+            }
+            assertNever(children);
+        }
+    }
+    /**
+     * Adds a new entry to the dictionary or updates the value of an existing key.
+     *
+     * If an entry with the given key already exists, its value is replaced
+     * with the new one.
+     *
+     * @param key - The key to add or update in the dictionary.
+     * @param value - The value to associate with the specified key.
+     * @returns Nothing (`void`).
+     */
+    set(key, value) {
+        const leaf = this.internalSet(key, value);
+        if (leaf !== null) {
+            this.keyvals.set(leaf.key, leaf);
+        }
+    }
+    /**
+     * Retrieves the value associated with the given key from the dictionary.
+     *
+     * If the key does not exist, this method returns `undefined`.
+     *
+     * @param key - The key whose associated value should be retrieved.
+     * @returns The value associated with the specified key, or `undefined` if the key is not present.
+     */
+    get(key) {
+        let node = this.root;
+        const pathChunksGenerator = key.chunks(CHUNK_SIZE);
+        let depth = 0;
+        while (node !== undefined) {
+            const maybePathChunk = pathChunksGenerator.next().value;
+            if (node.children instanceof ListChildren) {
+                const subkey = bytes_BytesBlob.blobFrom(key.raw.subarray(depth * CHUNK_SIZE));
+                const child = node.children.find(subkey);
+                if (child !== null) {
+                    return child.value;
+                }
+            }
+            if (maybePathChunk === undefined) {
+                return node.getLeaf()?.value;
+            }
+            if (node.children instanceof MapChildren) {
+                const pathChunk = opaque_asOpaqueType(maybePathChunk);
+                node = node.children.getChild(pathChunk);
+                depth += 1;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Checks whether the dictionary contains an entry for the given key.
+     *
+     * ⚠️ **Note:** Avoid using `has(...)` together with `get(...)` in a pattern like this:
+     *
+     * ```ts
+     * if (dict.has(key)) {
+     *   const value = dict.get(key);
+     *   ...
+     * }
+     * ```
+     *
+     * This approach performs two lookups for the same key.
+     *
+     * Instead, prefer the following pattern, which retrieves the value once:
+     *
+     * ```ts
+     * const value = dict.get(key);
+     * if (value !== undefined) {
+     *   ...
+     * }
+     * ```
+     *
+     * @param key - The key to check for.
+     * @returns `true` if the dictionary contains an entry for the given key, otherwise `false`.
+     */
+    has(key) {
+        return this.get(key) !== undefined;
+    }
+    /**
+     * Removes an entry with the specified key from the dictionary.
+     *
+     * Internally, this calls {@link internalSet} with `undefined` to mark the entry as deleted.
+     *
+     * @param key - The key of the entry to remove.
+     * @returns `true` if an entry was removed (i.e. the key existed), otherwise `false`.
+     */
+    delete(key) {
+        const leaf = this.internalSet(key, undefined);
+        if (leaf !== null) {
+            this.keyvals.delete(leaf.key);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Returns an iterator over the keys in the dictionary.
+     *
+     * The iterator yields each key in insertion order.
+     *
+     * @returns An iterator over all keys in the dictionary.
+     */
+    keys() {
+        return this.keyvals.keys();
+    }
+    /**
+     * Returns an iterator over the values in the dictionary.
+     *
+     * The iterator yields each value in insertion order.
+     *
+     * @returns An iterator over all values in the dictionary.
+     */
+    *values() {
+        for (const leaf of this.keyvals.values()) {
+            yield leaf.value;
+        }
+    }
+    /**
+     * Returns an iterator over the `[key, value]` pairs in the dictionary.
+     *
+     * The iterator yields entries in insertion order.
+     *
+     * @returns An iterator over `[key, value]` tuples for each entry in the dictionary.
+     */
+    *entries() {
+        for (const leaf of this.keyvals.values()) {
+            yield [leaf.key, leaf.value];
+        }
+    }
+    /**
+     * Default iterator for the dictionary.
+     *
+     * Equivalent to calling {@link entries}.
+     * Enables iteration with `for...of`:
+     *
+     * ```ts
+     * for (const [key, value] of dict) {
+     *   ...
+     * }
+     * ```
+     *
+     * @returns An iterator over `[key, value]` pairs.
+     */
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    /**
+     * Creates a new sorted array of values, ordered by their corresponding keys.
+     *
+     * Iterates over all entries in the dictionary and sorts them according
+     * to the provided comparator function applied to the keys.
+     *
+     * @param comparator - A comparator function that can compare two keys.
+     *
+     * @returns A new array containing all values from the dictionary,
+     * sorted according to their keys.
+     */
+    toSortedArray(comparator) {
+        const vals = Array.from(this);
+        vals.sort((a, b) => comparator(a[0], b[0]).value);
+        return vals.map((x) => x[1]);
+    }
+}
+const CHUNK_SIZE = 6;
+/**
+ * A function to transform a bytes chunk (up to 6 bytes into U48 number)
+ *
+ * Note that it uses 3 additional bits to store length(`value * 8 + len;`),
+ * It is needed to distinguish shorter chunks that have 0s at the end, for example: [1, 2] and [1, 2, 0]
+ * */
+function bytesAsU48(bytes) {
+    const len = bytes.length;
+    debug_check `${len <= CHUNK_SIZE} Length has to be <= ${CHUNK_SIZE}, got: ${len}`;
+    let value = bytes[3] | (bytes[2] << 8) | (bytes[1] << 16) | (bytes[0] << 24);
+    for (let i = 4; i < bytes.length; i++) {
+        value = value * 256 + bytes[i];
+    }
+    return value * 8 + len;
+}
+class Node {
+    leaf;
+    children;
+    convertListChildrenToMap() {
+        if (!(this.children instanceof ListChildren)) {
+            return;
+        }
+        this.children = MapChildren.fromListNode(this.children);
+    }
+    static withList() {
+        return new Node(undefined, ListChildren.new());
+    }
+    static withMap() {
+        return new Node(undefined, MapChildren.new());
+    }
+    constructor(leaf, children) {
+        this.leaf = leaf;
+        this.children = children;
+    }
+    getLeaf() {
+        return this.leaf;
+    }
+    remove(_key) {
+        if (this.leaf === undefined) {
+            return null;
+        }
+        const removedLeaf = this.leaf;
+        this.leaf = undefined;
+        return removedLeaf;
+    }
+    set(key, value) {
+        if (this.leaf === undefined) {
+            this.leaf = { key, value };
+            return this.leaf;
+        }
+        this.leaf.value = value;
+        return null;
+    }
+}
+class ListChildren {
+    children = [];
+    constructor() { }
+    find(key) {
+        const result = this.children.find((item) => item[0].isEqualTo(key));
+        if (result !== undefined) {
+            return result[1];
+        }
+        return null;
+    }
+    remove(key) {
+        const existingIndex = this.children.findIndex((item) => item[0].isEqualTo(key));
+        if (existingIndex >= 0) {
+            const ret = this.children.splice(existingIndex, 1);
+            return ret[0][1];
+        }
+        return null;
+    }
+    insert(key, leaf) {
+        const existingIndex = this.children.findIndex((item) => item[0].isEqualTo(key));
+        if (existingIndex >= 0) {
+            const existing = this.children[existingIndex];
+            existing[1].value = leaf.value;
+            return null;
+        }
+        this.children.push([key, leaf]);
+        return leaf;
+    }
+    static new() {
+        return new ListChildren();
+    }
+}
+class MapChildren {
+    children = new Map();
+    constructor() { }
+    static new() {
+        return new MapChildren();
+    }
+    static fromListNode(node) {
+        const mapNode = new MapChildren();
+        for (const [key, leaf] of node.children) {
+            const currentKeyChunk = opaque_asOpaqueType(bytes_BytesBlob.blobFrom(key.raw.subarray(0, CHUNK_SIZE)));
+            const subKey = bytes_BytesBlob.blobFrom(key.raw.subarray(CHUNK_SIZE));
+            let child = mapNode.getChild(currentKeyChunk);
+            if (child === undefined) {
+                child = Node.withList();
+                mapNode.setChild(currentKeyChunk, child);
+            }
+            const children = child.children;
+            children.insert(subKey, leaf);
+        }
+        return mapNode;
+    }
+    getChild(keyChunk) {
+        const chunkAsNumber = bytesAsU48(keyChunk.raw);
+        return this.children.get(chunkAsNumber);
+    }
+    setChild(keyChunk, node) {
+        const chunkAsNumber = bytesAsU48(keyChunk.raw);
+        this.children.set(chunkAsNumber, node);
+    }
+}
+
 ;// CONCATENATED MODULE: ./packages/core/collections/hash-dictionary.ts
-/** A map which uses hashes as keys. */
-class hash_dictionary_HashDictionary {
+/**
+ * A map which uses hashes as keys.
+ *
+ * @deprecated
+ * */
+class StringHashDictionary {
     // TODO [ToDr] [crit] We can't use `TrieHash` directly in the map,
     // because of the way it's being compared. Hence having `string` here.
     // This has to be benchmarked and re-written to a custom map most likely.
@@ -28046,6 +28817,17 @@ class hash_dictionary_HashDictionary {
     }
 }
 
+/**
+ * A value that indicates when `BlobDictionary` transforms Array nodes into Map nodes.
+ * In practice, it doesn't matter much because, in real life, arrays in this structure usually have a length close to 1.
+ */
+const BLOB_DICTIONARY_THRESHOLD = 5;
+class hash_dictionary_HashDictionary extends BlobDictionary {
+    constructor() {
+        super(BLOB_DICTIONARY_THRESHOLD);
+    }
+}
+
 ;// CONCATENATED MODULE: ./packages/core/collections/hash-set.ts
 
 /** A set specialized for storing hashes. */
@@ -28510,6 +29292,18 @@ class SortedSet extends (/* unused pure expression or super */ null && (SortedAr
 
 
 
+function getTruncatedKey(key) {
+    // Always return exactly TRUNCATED_HASH_SIZE bytes.
+    if (key.length === TRUNCATED_HASH_SIZE) {
+        return key;
+    }
+    return bytes_Bytes.fromBlob(key.raw.subarray(0, TRUNCATED_HASH_SIZE), TRUNCATED_HASH_SIZE);
+}
+/**
+ * A value that indicates when `BlobDictionary` transforms Array nodes into Map nodes.
+ * In practice, it doesn't matter much because, in real life, arrays in this structure usually have a length close to 1.
+ */
+const truncated_hash_dictionary_BLOB_DICTIONARY_THRESHOLD = 5;
 /**
  * A collection of hash-based keys (likely `StateKey`s) which ignores
  * differences on the last byte.
@@ -28522,48 +29316,37 @@ class TruncatedHashDictionary {
      * Each key will be copied and have the last byte replace with a 0.
      */
     static fromEntries(entries) {
-        /** Copy key bytes of an entry and replace the last one with 0. */
-        const mapped = Array.from(entries).map(([key, value]) => {
-            const newKey = bytes_Bytes.zero(hash_HASH_SIZE).asOpaque();
-            newKey.raw.set(key.raw.subarray(0, TRUNCATED_HASH_SIZE));
-            return [newKey, value];
-        });
-        return new TruncatedHashDictionary(hash_dictionary_HashDictionary.fromEntries(mapped));
+        return new TruncatedHashDictionary(BlobDictionary.fromEntries(Array.from(entries).map(([key, value]) => [getTruncatedKey(key), value]), truncated_hash_dictionary_BLOB_DICTIONARY_THRESHOLD));
     }
-    /** A truncated key which we re-use to query the dictionary. */
-    truncatedKey = bytes_Bytes.zero(hash_HASH_SIZE).asOpaque();
     constructor(dict) {
         this.dict = dict;
     }
     [TEST_COMPARE_USING]() {
-        return this.dict;
+        return Array.from(this.dict);
     }
     /** Return number of items in the dictionary. */
     get size() {
         return this.dict.size;
     }
     /** Retrieve a value that matches the key on `TRUNCATED_HASH_SIZE`. */
-    get(fullKey) {
-        this.truncatedKey.raw.set(fullKey.raw.subarray(0, TRUNCATED_HASH_SIZE));
-        return this.dict.get(this.truncatedKey);
+    get(key) {
+        const truncatedKey = getTruncatedKey(key);
+        return this.dict.get(truncatedKey);
     }
     /** Return true if the key is present in the dictionary */
-    has(fullKey) {
-        this.truncatedKey.raw.set(fullKey.raw.subarray(0, TRUNCATED_HASH_SIZE));
-        return this.dict.has(this.truncatedKey);
+    has(key) {
+        const truncatedKey = getTruncatedKey(key);
+        return this.dict.has(truncatedKey);
     }
     /** Set or update a value that matches the key on `TRUNCATED_HASH_SIZE`. */
-    set(fullKey, value) {
-        // NOTE we can't use the the shared key here, since the collection will
-        // store the key for us, hence the copy.
-        const key = bytes_Bytes.zero(hash_HASH_SIZE);
-        key.raw.set(fullKey.raw.subarray(0, TRUNCATED_HASH_SIZE));
-        this.dict.set(key.asOpaque(), value);
+    set(key, value) {
+        const truncatedKey = getTruncatedKey(key);
+        this.dict.set(truncatedKey, value);
     }
     /** Remove a value that matches the key on `TRUNCATED_HASH_SIZE`. */
-    delete(fullKey) {
-        this.truncatedKey.raw.set(fullKey.raw.subarray(0, TRUNCATED_HASH_SIZE));
-        this.dict.delete(this.truncatedKey);
+    delete(key) {
+        const truncatedKey = getTruncatedKey(key);
+        this.dict.delete(truncatedKey);
     }
     /** Iterator over values of the dictionary. */
     values() {
@@ -28571,9 +29354,7 @@ class TruncatedHashDictionary {
     }
     /** Iterator over entries of the dictionary (with truncated keys) */
     *entries() {
-        for (const [key, value] of this.dict.entries()) {
-            yield [bytes_Bytes.fromBlob(key.raw.subarray(0, TRUNCATED_HASH_SIZE), TRUNCATED_HASH_SIZE).asOpaque(), value];
-        }
+        yield* this.dict.entries();
     }
     [Symbol.iterator]() {
         return this.entries();
@@ -28590,6 +29371,7 @@ class TruncatedHashDictionary {
 
 
 
+
 ;// CONCATENATED MODULE: ./packages/jam/config/chain-spec.ts
 
 
@@ -28774,7 +29556,7 @@ var PvmBackend;
 
 
 
-;// CONCATENATED MODULE: ./packages/jam/block/codec.ts
+;// CONCATENATED MODULE: ./packages/jam/block/codec-utils.ts
 
 
 
@@ -28789,7 +29571,7 @@ function codecWithContext(chooser) {
     const defaultContext = fullChainSpec;
     const { name, sizeHint } = chooser(defaultContext);
     const cache = new Map();
-    return descriptors_codec.select({
+    return descriptors_select({
         name,
         sizeHint: { bytes: sizeHint.bytes, isExact: false },
     }, (context) => {
@@ -28816,9 +29598,9 @@ function codecWithContext(chooser) {
 /** Codec for a known-size array with length validation. */
 const codecKnownSizeArray = (val, options, _id) => {
     if ("fixedLength" in options) {
-        return readonlyArray(descriptors_codec.sequenceFixLen(val, options.fixedLength)).convert(seeThrough, sized_array_asKnownSize);
+        return readonlyArray(sequenceFixLen(val, options.fixedLength)).convert(seeThrough, sized_array_asKnownSize);
     }
-    return readonlyArray(descriptors_codec.sequenceVarLen(val, options)).convert(seeThrough, sized_array_asKnownSize);
+    return readonlyArray(sequenceVarLen(val, options)).convert(seeThrough, sized_array_asKnownSize);
 };
 /** Codec for a fixed-size array with length validation. */
 const codecFixedSizeArray = (val, len) => {
@@ -28836,7 +29618,7 @@ const codecFixedSizeArray = (val, len) => {
     });
 };
 /** Codec for a hash-dictionary. */
-const codecHashDictionary = (value, extractKey, { typicalLength = TYPICAL_DICTIONARY_LENGTH, compare = (a, b) => extractKey(a).compare(extractKey(b)), } = {}) => {
+const codecHashDictionary = (value, extractKey, { typicalLength = codec.TYPICAL_DICTIONARY_LENGTH, compare = (a, b) => extractKey(a).compare(extractKey(b)), } = {}) => {
     return Descriptor.new(`HashDictionary<${value.name}>[?]`, {
         bytes: typicalLength * value.sizeHint.bytes,
         isExact: false,
@@ -28888,13 +29670,13 @@ class assurances_AvailabilityAssurance extends WithDebug {
     bitfield;
     validatorIndex;
     signature;
-    static Codec = descriptors_codec.Class(assurances_AvailabilityAssurance, {
-        anchor: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
+    static Codec = Class(assurances_AvailabilityAssurance, {
+        anchor: bytes(hash_HASH_SIZE).asOpaque(),
         bitfield: codecWithContext((context) => {
-            return descriptors_codec.bitVecFixLen(context.coresCount);
+            return bitVecFixLen(context.coresCount);
         }),
-        validatorIndex: descriptors_codec.u16.asOpaque(),
-        signature: descriptors_codec.bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
+        validatorIndex: u16.asOpaque(),
+        signature: bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
     });
     static create({ anchor, bitfield, validatorIndex, signature }) {
         return new assurances_AvailabilityAssurance(anchor, bitfield, validatorIndex, signature);
@@ -29186,10 +29968,10 @@ function tryAsTicketAttempt(x) {
 class SignedTicket extends WithDebug {
     attempt;
     signature;
-    static Codec = descriptors_codec.Class(SignedTicket, {
+    static Codec = Class(SignedTicket, {
         // TODO [ToDr] we should verify that attempt is either 0|1|2.
-        attempt: descriptors_codec.u8.asOpaque(),
-        signature: descriptors_codec.bytes(BANDERSNATCH_PROOF_BYTES).asOpaque(),
+        attempt: u8.asOpaque(),
+        signature: bytes(BANDERSNATCH_PROOF_BYTES).asOpaque(),
     });
     static create({ attempt, signature }) {
         return new SignedTicket(attempt, signature);
@@ -29208,10 +29990,10 @@ class SignedTicket extends WithDebug {
 class Ticket extends WithDebug {
     id;
     attempt;
-    static Codec = descriptors_codec.Class(Ticket, {
-        id: descriptors_codec.bytes(hash_HASH_SIZE),
+    static Codec = Class(Ticket, {
+        id: bytes(hash_HASH_SIZE),
         // TODO [ToDr] we should verify that attempt is either 0|1|2.
-        attempt: descriptors_codec.u8.asOpaque(),
+        attempt: u8.asOpaque(),
     });
     static create({ id, attempt }) {
         return new Ticket(id, attempt);
@@ -29357,11 +30139,11 @@ class Fault extends WithDebug {
     wasConsideredValid;
     key;
     signature;
-    static Codec = descriptors_codec.Class(Fault, {
-        workReportHash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        wasConsideredValid: descriptors_codec.bool,
-        key: descriptors_codec.bytes(ED25519_KEY_BYTES).asOpaque(),
-        signature: descriptors_codec.bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
+    static Codec = Class(Fault, {
+        workReportHash: bytes(hash_HASH_SIZE).asOpaque(),
+        wasConsideredValid: bool,
+        key: bytes(ED25519_KEY_BYTES).asOpaque(),
+        signature: bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
     });
     static create({ workReportHash, wasConsideredValid, key, signature }) {
         return new Fault(workReportHash, wasConsideredValid, key, signature);
@@ -29389,10 +30171,10 @@ class Culprit extends WithDebug {
     workReportHash;
     key;
     signature;
-    static Codec = descriptors_codec.Class(Culprit, {
-        workReportHash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        key: descriptors_codec.bytes(ED25519_KEY_BYTES).asOpaque(),
-        signature: descriptors_codec.bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
+    static Codec = Class(Culprit, {
+        workReportHash: bytes(hash_HASH_SIZE).asOpaque(),
+        key: bytes(ED25519_KEY_BYTES).asOpaque(),
+        signature: bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
     });
     static create({ workReportHash, key, signature }) {
         return new Culprit(workReportHash, key, signature);
@@ -29417,10 +30199,10 @@ class Judgement extends WithDebug {
     isWorkReportValid;
     index;
     signature;
-    static Codec = descriptors_codec.Class(Judgement, {
-        isWorkReportValid: descriptors_codec.bool,
-        index: descriptors_codec.u16.asOpaque(),
-        signature: descriptors_codec.bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
+    static Codec = Class(Judgement, {
+        isWorkReportValid: bool,
+        index: u16.asOpaque(),
+        signature: bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
     });
     static create({ isWorkReportValid, index, signature }) {
         return new Judgement(isWorkReportValid, index, signature);
@@ -29449,11 +30231,12 @@ class Verdict extends WithDebug {
     workReportHash;
     votesEpoch;
     votes;
-    static Codec = descriptors_codec.Class(Verdict, {
-        workReportHash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        votesEpoch: descriptors_codec.u32.asOpaque(),
+    static Codec = Class(Verdict, {
+        workReportHash: bytes(hash_HASH_SIZE).asOpaque(),
+        votesEpoch: u32.asOpaque(),
         votes: codecWithContext((context) => {
-            return readonlyArray(descriptors_codec.sequenceFixLen(Judgement.Codec, context.validatorsSuperMajority)).convert(seeThrough, sized_array_asKnownSize);
+            return readonlyArray(sequenceFixLen(Judgement.Codec, context.validatorsSuperMajority))
+                .convert(seeThrough, sized_array_asKnownSize);
         }),
     });
     static create({ workReportHash, votesEpoch, votes }) {
@@ -29494,10 +30277,10 @@ class DisputesExtrinsic extends WithDebug {
     verdicts;
     culprits;
     faults;
-    static Codec = descriptors_codec.Class(DisputesExtrinsic, {
-        verdicts: descriptors_codec.sequenceVarLen(Verdict.Codec),
-        culprits: descriptors_codec.sequenceVarLen(Culprit.Codec),
-        faults: descriptors_codec.sequenceVarLen(Fault.Codec),
+    static Codec = Class(DisputesExtrinsic, {
+        verdicts: sequenceVarLen(Verdict.Codec),
+        culprits: sequenceVarLen(Culprit.Codec),
+        faults: sequenceVarLen(Fault.Codec),
     });
     static create({ verdicts, culprits, faults }) {
         return new DisputesExtrinsic(verdicts, culprits, faults);
@@ -29543,9 +30326,9 @@ class DisputesExtrinsic extends WithDebug {
 class WorkPackageInfo extends WithDebug {
     workPackageHash;
     segmentTreeRoot;
-    static Codec = descriptors_codec.Class(WorkPackageInfo, {
-        workPackageHash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        segmentTreeRoot: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
+    static Codec = Class(WorkPackageInfo, {
+        workPackageHash: bytes(hash_HASH_SIZE).asOpaque(),
+        segmentTreeRoot: bytes(hash_HASH_SIZE).asOpaque(),
     });
     constructor(
     /** Hash of the described work package. */
@@ -29573,13 +30356,13 @@ class RefineContext extends WithDebug {
     lookupAnchor;
     lookupAnchorSlot;
     prerequisites;
-    static Codec = descriptors_codec.Class(RefineContext, {
-        anchor: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        stateRoot: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        beefyRoot: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        lookupAnchor: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        lookupAnchorSlot: descriptors_codec.u32.asOpaque(),
-        prerequisites: descriptors_codec.sequenceVarLen(descriptors_codec.bytes(hash_HASH_SIZE).asOpaque()),
+    static Codec = Class(RefineContext, {
+        anchor: bytes(hash_HASH_SIZE).asOpaque(),
+        stateRoot: bytes(hash_HASH_SIZE).asOpaque(),
+        beefyRoot: bytes(hash_HASH_SIZE).asOpaque(),
+        lookupAnchor: bytes(hash_HASH_SIZE).asOpaque(),
+        lookupAnchorSlot: u32.asOpaque(),
+        prerequisites: sequenceVarLen(bytes(hash_HASH_SIZE).asOpaque()),
     });
     static create({ anchor, stateRoot, beefyRoot, lookupAnchor, lookupAnchorSlot, prerequisites, }) {
         return new RefineContext(anchor, stateRoot, beefyRoot, lookupAnchor, lookupAnchorSlot, prerequisites);
@@ -29636,9 +30419,9 @@ const tryAsSegmentIndex = (v) => asOpaqueType(tryAsU16(v));
 class ImportSpec extends WithDebug {
     treeRoot;
     index;
-    static Codec = descriptors_codec.Class(ImportSpec, {
-        treeRoot: descriptors_codec.bytes(hash_HASH_SIZE),
-        index: descriptors_codec.u16.asOpaque(),
+    static Codec = Class(ImportSpec, {
+        treeRoot: bytes(hash_HASH_SIZE),
+        index: u16.asOpaque(),
     });
     static create({ treeRoot, index }) {
         return new ImportSpec(treeRoot, index);
@@ -29660,9 +30443,9 @@ class ImportSpec extends WithDebug {
 class WorkItemExtrinsicSpec extends WithDebug {
     hash;
     len;
-    static Codec = descriptors_codec.Class(WorkItemExtrinsicSpec, {
-        hash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        len: descriptors_codec.u32,
+    static Codec = Class(WorkItemExtrinsicSpec, {
+        hash: bytes(hash_HASH_SIZE).asOpaque(),
+        len: u32,
     });
     static create({ hash, len }) {
         return new WorkItemExtrinsicSpec(hash, len);
@@ -29723,33 +30506,33 @@ class WorkItem extends WithDebug {
     extrinsic;
     exportCount;
     static Codec = Compatibility.isGreaterOrEqual(GpVersion.V0_7_0)
-        ? descriptors_codec.Class(WorkItem, {
-            service: descriptors_codec.u32.asOpaque(),
-            codeHash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-            refineGasLimit: descriptors_codec.u64.asOpaque(),
-            accumulateGasLimit: descriptors_codec.u64.asOpaque(),
-            exportCount: descriptors_codec.u16,
-            payload: descriptors_codec.blob,
+        ? Class(WorkItem, {
+            service: u32.asOpaque(),
+            codeHash: bytes(hash_HASH_SIZE).asOpaque(),
+            refineGasLimit: u64.asOpaque(),
+            accumulateGasLimit: u64.asOpaque(),
+            exportCount: u16,
+            payload: blob,
             importSegments: codecKnownSizeArray(ImportSpec.Codec, {
                 minLength: 0,
                 maxLength: MAX_NUMBER_OF_SEGMENTS,
                 typicalLength: MAX_NUMBER_OF_SEGMENTS,
             }),
-            extrinsic: descriptors_codec.sequenceVarLen(WorkItemExtrinsicSpec.Codec),
+            extrinsic: sequenceVarLen(WorkItemExtrinsicSpec.Codec),
         })
-        : descriptors_codec.Class(WorkItem, {
-            service: descriptors_codec.u32.asOpaque(),
-            codeHash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-            payload: descriptors_codec.blob,
-            refineGasLimit: descriptors_codec.u64.asOpaque(),
-            accumulateGasLimit: descriptors_codec.u64.asOpaque(),
+        : Class(WorkItem, {
+            service: u32.asOpaque(),
+            codeHash: bytes(hash_HASH_SIZE).asOpaque(),
+            payload: blob,
+            refineGasLimit: u64.asOpaque(),
+            accumulateGasLimit: u64.asOpaque(),
             importSegments: codecKnownSizeArray(ImportSpec.Codec, {
                 minLength: 0,
                 maxLength: MAX_NUMBER_OF_SEGMENTS,
                 typicalLength: MAX_NUMBER_OF_SEGMENTS,
             }),
-            extrinsic: descriptors_codec.sequenceVarLen(WorkItemExtrinsicSpec.Codec),
-            exportCount: descriptors_codec.u16,
+            extrinsic: sequenceVarLen(WorkItemExtrinsicSpec.Codec),
+            exportCount: u16,
         });
     static create({ service, codeHash, payload, refineGasLimit, accumulateGasLimit, importSegments, extrinsic, exportCount, }) {
         return new WorkItem(service, codeHash, payload, refineGasLimit, accumulateGasLimit, importSegments, extrinsic, exportCount);
@@ -29823,21 +30606,21 @@ class WorkPackage extends WithDebug {
     context;
     items;
     static Codec = Compatibility.isGreaterOrEqual(GpVersion.V0_7_0)
-        ? descriptors_codec.Class(WorkPackage, {
-            authCodeHost: descriptors_codec.u32.asOpaque(),
-            authCodeHash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
+        ? Class(WorkPackage, {
+            authCodeHost: u32.asOpaque(),
+            authCodeHash: bytes(hash_HASH_SIZE).asOpaque(),
             context: RefineContext.Codec,
-            authorization: descriptors_codec.blob,
-            parametrization: descriptors_codec.blob,
-            items: descriptors_codec.sequenceVarLen(WorkItem.Codec).convert((x) => x, (items) => sized_array_FixedSizeArray.new(items, tryAsWorkItemsCount(items.length))),
+            authorization: blob,
+            parametrization: blob,
+            items: sequenceVarLen(WorkItem.Codec).convert((x) => x, (items) => sized_array_FixedSizeArray.new(items, tryAsWorkItemsCount(items.length))),
         })
-        : descriptors_codec.Class(WorkPackage, {
-            authorization: descriptors_codec.blob,
-            authCodeHost: descriptors_codec.u32.asOpaque(),
-            authCodeHash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-            parametrization: descriptors_codec.blob,
+        : Class(WorkPackage, {
+            authorization: blob,
+            authCodeHost: u32.asOpaque(),
+            authCodeHash: bytes(hash_HASH_SIZE).asOpaque(),
+            parametrization: blob,
             context: RefineContext.Codec,
-            items: descriptors_codec.sequenceVarLen(WorkItem.Codec).convert((x) => x, (items) => sized_array_FixedSizeArray.new(items, tryAsWorkItemsCount(items.length))),
+            items: sequenceVarLen(WorkItem.Codec).convert((x) => x, (items) => sized_array_FixedSizeArray.new(items, tryAsWorkItemsCount(items.length))),
         });
     static create({ authorization, authCodeHost, authCodeHash, parametrization, context, items, }) {
         return new WorkPackage(authorization, authCodeHost, authCodeHash, parametrization, context, items);
@@ -29897,7 +30680,7 @@ var WorkExecResultKind;
 class WorkExecResult extends WithDebug {
     kind;
     okBlob;
-    static Codec = descriptors_codec.custom({
+    static Codec = custom({
         name: "WorkExecResult",
         sizeHint: { bytes: 1, isExact: false },
     }, (e, x) => {
@@ -29944,12 +30727,12 @@ class WorkRefineLoad extends WithDebug {
     extrinsicCount;
     extrinsicSize;
     exportedSegments;
-    static Codec = descriptors_codec.Class(WorkRefineLoad, {
-        gasUsed: descriptors_codec.varU64.asOpaque(),
-        importedSegments: descriptors_codec.varU32,
-        extrinsicCount: descriptors_codec.varU32,
-        extrinsicSize: descriptors_codec.varU32,
-        exportedSegments: descriptors_codec.varU32,
+    static Codec = Class(WorkRefineLoad, {
+        gasUsed: varU64.asOpaque(),
+        importedSegments: varU32,
+        extrinsicCount: varU32,
+        extrinsicSize: varU32,
+        exportedSegments: varU32,
     });
     static create({ gasUsed, importedSegments, extrinsicCount, extrinsicSize, exportedSegments, }) {
         return new WorkRefineLoad(gasUsed, importedSegments, extrinsicCount, extrinsicSize, exportedSegments);
@@ -29985,11 +30768,11 @@ class WorkResult {
     gas;
     result;
     load;
-    static Codec = descriptors_codec.Class(WorkResult, {
-        serviceId: descriptors_codec.u32.asOpaque(),
-        codeHash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        payloadHash: descriptors_codec.bytes(hash_HASH_SIZE),
-        gas: descriptors_codec.u64.asOpaque(),
+    static Codec = Class(WorkResult, {
+        serviceId: u32.asOpaque(),
+        codeHash: bytes(hash_HASH_SIZE).asOpaque(),
+        payloadHash: bytes(hash_HASH_SIZE),
+        gas: u64.asOpaque(),
         result: WorkExecResult.Codec,
         load: WorkRefineLoad.Codec,
     });
@@ -30056,12 +30839,12 @@ class WorkPackageSpec extends WithDebug {
     erasureRoot;
     exportsRoot;
     exportsCount;
-    static Codec = descriptors_codec.Class(WorkPackageSpec, {
-        hash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        length: descriptors_codec.u32,
-        erasureRoot: descriptors_codec.bytes(hash_HASH_SIZE),
-        exportsRoot: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        exportsCount: descriptors_codec.u16,
+    static Codec = Class(WorkPackageSpec, {
+        hash: bytes(hash_HASH_SIZE).asOpaque(),
+        length: u32,
+        erasureRoot: bytes(hash_HASH_SIZE),
+        exportsRoot: bytes(hash_HASH_SIZE).asOpaque(),
+        exportsCount: u16,
     });
     static create({ hash, length, erasureRoot, exportsRoot, exportsCount }) {
         return new WorkPackageSpec(hash, length, erasureRoot, exportsRoot, exportsCount);
@@ -30133,35 +30916,35 @@ class WorkReportNoCodec extends WithDebug {
         this.authorizationGasUsed = authorizationGasUsed;
     }
 }
-const WorkReportCodec = descriptors_codec.Class(WorkReportNoCodec, {
+const WorkReportCodec = Class(WorkReportNoCodec, {
     workPackageSpec: WorkPackageSpec.Codec,
     context: RefineContext.Codec,
-    coreIndex: descriptors_codec.varU32.convert((o) => numbers_tryAsU32(o), (i) => {
+    coreIndex: varU32.convert((o) => numbers_tryAsU32(o), (i) => {
         if (!isU16(i)) {
             throw new Error(`Core index exceeds U16: ${i}`);
         }
         return tryAsCoreIndex(i);
     }),
-    authorizerHash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-    authorizationGasUsed: descriptors_codec.varU64.asOpaque(),
-    authorizationOutput: descriptors_codec.blob,
-    segmentRootLookup: readonlyArray(descriptors_codec.sequenceVarLen(WorkPackageInfo.Codec)),
-    results: descriptors_codec.sequenceVarLen(WorkResult.Codec).convert((x) => x, (items) => sized_array_FixedSizeArray.new(items, tryAsWorkItemsCount(items.length))),
+    authorizerHash: bytes(hash_HASH_SIZE).asOpaque(),
+    authorizationGasUsed: varU64.asOpaque(),
+    authorizationOutput: blob,
+    segmentRootLookup: readonlyArray(sequenceVarLen(WorkPackageInfo.Codec)),
+    results: sequenceVarLen(WorkResult.Codec).convert((x) => x, (items) => sized_array_FixedSizeArray.new(items, tryAsWorkItemsCount(items.length))),
 });
-const WorkReportCodecPre070 = descriptors_codec.Class(WorkReportNoCodec, {
+const WorkReportCodecPre070 = Class(WorkReportNoCodec, {
     workPackageSpec: WorkPackageSpec.Codec,
     context: RefineContext.Codec,
-    coreIndex: descriptors_codec.varU32.convert((o) => numbers_tryAsU32(o), (i) => {
+    coreIndex: varU32.convert((o) => numbers_tryAsU32(o), (i) => {
         if (!isU16(i)) {
             throw new Error(`Core index exceeds U16: ${i}`);
         }
         return tryAsCoreIndex(i);
     }),
-    authorizerHash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-    authorizationOutput: descriptors_codec.blob,
-    segmentRootLookup: readonlyArray(descriptors_codec.sequenceVarLen(WorkPackageInfo.Codec)),
-    results: descriptors_codec.sequenceVarLen(WorkResult.Codec).convert((x) => x, (items) => sized_array_FixedSizeArray.new(items, tryAsWorkItemsCount(items.length))),
-    authorizationGasUsed: descriptors_codec.varU64.asOpaque(),
+    authorizerHash: bytes(hash_HASH_SIZE).asOpaque(),
+    authorizationOutput: blob,
+    segmentRootLookup: readonlyArray(sequenceVarLen(WorkPackageInfo.Codec)),
+    results: sequenceVarLen(WorkResult.Codec).convert((x) => x, (items) => sized_array_FixedSizeArray.new(items, tryAsWorkItemsCount(items.length))),
+    authorizationGasUsed: varU64.asOpaque(),
 });
 class WorkReport extends WorkReportNoCodec {
     static Codec = Compatibility.isGreaterOrEqual(GpVersion.V0_7_0)
@@ -30180,9 +30963,9 @@ const REQUIRED_CREDENTIALS_RANGE = [2, 3];
 class Credential extends WithDebug {
     validatorIndex;
     signature;
-    static Codec = descriptors_codec.Class(Credential, {
-        validatorIndex: descriptors_codec.u16.asOpaque(),
-        signature: descriptors_codec.bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
+    static Codec = Class(Credential, {
+        validatorIndex: u16.asOpaque(),
+        signature: bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
     });
     static create({ validatorIndex, signature }) {
         return new Credential(validatorIndex, signature);
@@ -30206,9 +30989,9 @@ class ReportGuarantee extends WithDebug {
     report;
     slot;
     credentials;
-    static Codec = descriptors_codec.Class(ReportGuarantee, {
+    static Codec = Class(ReportGuarantee, {
         report: WorkReport.Codec,
-        slot: descriptors_codec.u32.asOpaque(),
+        slot: u32.asOpaque(),
         credentials: codecKnownSizeArray(Credential.Codec, {
             minLength: REQUIRED_CREDENTIALS_RANGE[0],
             maxLength: REQUIRED_CREDENTIALS_RANGE[1],
@@ -30260,9 +31043,9 @@ const guaranteesExtrinsicCodec = codecWithContext((context) => codecKnownSizeArr
 class ValidatorKeys extends WithDebug {
     bandersnatch;
     ed25519;
-    static Codec = descriptors_codec.Class(ValidatorKeys, {
-        bandersnatch: descriptors_codec.bytes(BANDERSNATCH_KEY_BYTES).asOpaque(),
-        ed25519: descriptors_codec.bytes(ED25519_KEY_BYTES).asOpaque(),
+    static Codec = Class(ValidatorKeys, {
+        bandersnatch: bytes(BANDERSNATCH_KEY_BYTES).asOpaque(),
+        ed25519: bytes(ED25519_KEY_BYTES).asOpaque(),
     });
     static create({ bandersnatch, ed25519 }) {
         return new ValidatorKeys(bandersnatch, ed25519);
@@ -30279,7 +31062,7 @@ class ValidatorKeys extends WithDebug {
 }
 class TicketsMarker extends WithDebug {
     tickets;
-    static Codec = descriptors_codec.Class(TicketsMarker, {
+    static Codec = Class(TicketsMarker, {
         tickets: codecPerEpochBlock(Ticket.Codec),
     });
     static create({ tickets }) {
@@ -30301,9 +31084,9 @@ class EpochMarker extends WithDebug {
     entropy;
     ticketsEntropy;
     validators;
-    static Codec = descriptors_codec.Class(EpochMarker, {
-        entropy: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        ticketsEntropy: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
+    static Codec = Class(EpochMarker, {
+        entropy: bytes(hash_HASH_SIZE).asOpaque(),
+        ticketsEntropy: bytes(hash_HASH_SIZE).asOpaque(),
         validators: codecPerValidator(ValidatorKeys.Codec),
     });
     static create({ entropy, ticketsEntropy, validators }) {
@@ -30338,16 +31121,16 @@ const encodeUnsealedHeader = (view) => {
  * Codec descriptor with pre 0.7.0 encoding order
  */
 const legacyDescriptor = {
-    parentHeaderHash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-    priorStateRoot: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-    extrinsicHash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-    timeSlotIndex: descriptors_codec.u32.asOpaque(),
-    epochMarker: descriptors_codec.optional(EpochMarker.Codec),
-    ticketsMarker: descriptors_codec.optional(TicketsMarker.Codec),
-    offendersMarker: descriptors_codec.sequenceVarLen(descriptors_codec.bytes(ED25519_KEY_BYTES).asOpaque()),
-    bandersnatchBlockAuthorIndex: descriptors_codec.u16.asOpaque(),
-    entropySource: descriptors_codec.bytes(bandersnatch_BANDERSNATCH_VRF_SIGNATURE_BYTES).asOpaque(),
-    seal: descriptors_codec.bytes(bandersnatch_BANDERSNATCH_VRF_SIGNATURE_BYTES).asOpaque(),
+    parentHeaderHash: bytes(hash_HASH_SIZE).asOpaque(),
+    priorStateRoot: bytes(hash_HASH_SIZE).asOpaque(),
+    extrinsicHash: bytes(hash_HASH_SIZE).asOpaque(),
+    timeSlotIndex: u32.asOpaque(),
+    epochMarker: optional(EpochMarker.Codec),
+    ticketsMarker: optional(TicketsMarker.Codec),
+    offendersMarker: sequenceVarLen(bytes(ED25519_KEY_BYTES).asOpaque()),
+    bandersnatchBlockAuthorIndex: u16.asOpaque(),
+    entropySource: bytes(bandersnatch_BANDERSNATCH_VRF_SIGNATURE_BYTES).asOpaque(),
+    seal: bytes(bandersnatch_BANDERSNATCH_VRF_SIGNATURE_BYTES).asOpaque(),
 };
 /**
  * The header of the JAM block.
@@ -30355,19 +31138,19 @@ const legacyDescriptor = {
  * https://graypaper.fluffylabs.dev/#/579bd12/0c66000c7200
  */
 class header_Header extends WithDebug {
-    static Codec = descriptors_codec.Class(header_Header, Compatibility.isLessThan(GpVersion.V0_7_0)
+    static Codec = Class(header_Header, Compatibility.isLessThan(GpVersion.V0_7_0)
         ? legacyDescriptor
         : {
-            parentHeaderHash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-            priorStateRoot: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-            extrinsicHash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-            timeSlotIndex: descriptors_codec.u32.asOpaque(),
-            epochMarker: descriptors_codec.optional(EpochMarker.Codec),
-            ticketsMarker: descriptors_codec.optional(TicketsMarker.Codec),
-            bandersnatchBlockAuthorIndex: descriptors_codec.u16.asOpaque(),
-            entropySource: descriptors_codec.bytes(bandersnatch_BANDERSNATCH_VRF_SIGNATURE_BYTES).asOpaque(),
-            offendersMarker: descriptors_codec.sequenceVarLen(descriptors_codec.bytes(ED25519_KEY_BYTES).asOpaque()),
-            seal: descriptors_codec.bytes(bandersnatch_BANDERSNATCH_VRF_SIGNATURE_BYTES).asOpaque(),
+            parentHeaderHash: bytes(hash_HASH_SIZE).asOpaque(),
+            priorStateRoot: bytes(hash_HASH_SIZE).asOpaque(),
+            extrinsicHash: bytes(hash_HASH_SIZE).asOpaque(),
+            timeSlotIndex: u32.asOpaque(),
+            epochMarker: optional(EpochMarker.Codec),
+            ticketsMarker: optional(TicketsMarker.Codec),
+            bandersnatchBlockAuthorIndex: u16.asOpaque(),
+            entropySource: bytes(bandersnatch_BANDERSNATCH_VRF_SIGNATURE_BYTES).asOpaque(),
+            offendersMarker: sequenceVarLen(bytes(ED25519_KEY_BYTES).asOpaque()),
+            seal: bytes(bandersnatch_BANDERSNATCH_VRF_SIGNATURE_BYTES).asOpaque(),
         });
     static create(h) {
         return Object.assign(header_Header.empty(), h);
@@ -30422,8 +31205,8 @@ class header_Header extends WithDebug {
  * `DescriptorRecord` or `CodecRecord` for some reason.
  */
 class HeaderViewWithHash extends WithHash {
-    static Codec = descriptors_codec.Class(HeaderViewWithHash, {
-        hash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
+    static Codec = Class(HeaderViewWithHash, {
+        hash: bytes(hash_HASH_SIZE).asOpaque(),
         data: header_Header.Codec.View,
     });
     static create({ hash, data }) {
@@ -30444,9 +31227,9 @@ const headerViewWithHashCodec = HeaderViewWithHash.Codec;
 class Preimage extends WithDebug {
     requester;
     blob;
-    static Codec = descriptors_codec.Class(Preimage, {
-        requester: descriptors_codec.u32.asOpaque(),
-        blob: descriptors_codec.blob,
+    static Codec = Class(Preimage, {
+        requester: u32.asOpaque(),
+        blob: blob,
     });
     static create({ requester, blob }) {
         return new Preimage(requester, blob);
@@ -30461,7 +31244,7 @@ class Preimage extends WithDebug {
         this.blob = blob;
     }
 }
-const preimagesExtrinsicCodec = descriptors_codec.sequenceVarLen(Preimage.Codec);
+const preimagesExtrinsicCodec = sequenceVarLen(Preimage.Codec);
 
 ;// CONCATENATED MODULE: ./packages/jam/block/block.ts
 
@@ -30487,7 +31270,7 @@ class block_Extrinsic extends WithDebug {
     guarantees;
     assurances;
     disputes;
-    static Codec = descriptors_codec.Class(block_Extrinsic, {
+    static Codec = Class(block_Extrinsic, {
         tickets: ticketsExtrinsicCodec,
         preimages: preimagesExtrinsicCodec,
         guarantees: guaranteesExtrinsicCodec,
@@ -30540,7 +31323,7 @@ class block_Extrinsic extends WithDebug {
 class block_Block extends WithDebug {
     header;
     extrinsic;
-    static Codec = descriptors_codec.Class(block_Block, {
+    static Codec = Class(block_Block, {
         header: header_Header.Codec,
         extrinsic: block_Extrinsic.Codec,
     });
@@ -33079,9 +33862,9 @@ class BlockRequest extends WithDebug {
     headerHash;
     direction;
     maxBlocks;
-    static Codec = descriptors_codec.Class(BlockRequest, {
-        headerHash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        direction: descriptors_codec.u8.convert((i) => tryAsU8(i), (i) => {
+    static Codec = Class(BlockRequest, {
+        headerHash: bytes(hash_HASH_SIZE).asOpaque(),
+        direction: u8.convert((i) => tryAsU8(i), (i) => {
             switch (i) {
                 case Direction.AscExcl:
                     return Direction.AscExcl;
@@ -33091,7 +33874,7 @@ class BlockRequest extends WithDebug {
                     throw new Error(`Invalid 'Direction' value: ${i}`);
             }
         }),
-        maxBlocks: descriptors_codec.u32,
+        maxBlocks: u32,
     });
     static create({ headerHash, direction, maxBlocks }) {
         return new BlockRequest(headerHash, direction, maxBlocks);
@@ -33116,7 +33899,7 @@ class ServerHandler {
         const request = decoder_Decoder.decodeObject(BlockRequest.Codec, message);
         ce_128_block_request_logger.log `[${sender.streamId}] Client has requested: ${request}`;
         const blocks = this.getBlockSequence(sender.streamId, request.headerHash, request.direction, request.maxBlocks);
-        sender.bufferAndSend(encoder_Encoder.encodeObject(descriptors_codec.sequenceFixLen(block_Block.Codec.View, blocks.length), blocks, this.chainSpec));
+        sender.bufferAndSend(encoder_Encoder.encodeObject(sequenceFixLen(block_Block.Codec.View, blocks.length), blocks, this.chainSpec));
         sender.close();
     }
     onClose() { }
@@ -33439,13 +34222,13 @@ class LeafNode {
  */
 const ce_129_state_request_STREAM_KIND = tryAsStreamKind(129);
 const ce_129_state_request_TRIE_NODE_BYTES = 64;
-const trieNodeCodec = descriptors_codec.bytes(ce_129_state_request_TRIE_NODE_BYTES).convert((i) => bytes_Bytes.fromBlob(i.raw, ce_129_state_request_TRIE_NODE_BYTES), (i) => new TrieNode(i.raw));
+const trieNodeCodec = bytes(ce_129_state_request_TRIE_NODE_BYTES).convert((i) => bytes_Bytes.fromBlob(i.raw, ce_129_state_request_TRIE_NODE_BYTES), (i) => new TrieNode(i.raw));
 class KeyValuePair extends WithDebug {
     key;
     value;
-    static Codec = descriptors_codec.Class(KeyValuePair, {
-        key: descriptors_codec.bytes(TRUNCATED_KEY_BYTES),
-        value: descriptors_codec.blob,
+    static Codec = Class(KeyValuePair, {
+        key: bytes(TRUNCATED_KEY_BYTES),
+        value: blob,
     });
     static create({ key, value }) {
         return new KeyValuePair(key, value);
@@ -33458,8 +34241,8 @@ class KeyValuePair extends WithDebug {
 }
 class StateResponse extends WithDebug {
     keyValuePairs;
-    static Codec = descriptors_codec.Class(StateResponse, {
-        keyValuePairs: descriptors_codec.sequenceVarLen(KeyValuePair.Codec),
+    static Codec = Class(StateResponse, {
+        keyValuePairs: sequenceVarLen(KeyValuePair.Codec),
     });
     static create({ keyValuePairs }) {
         return new StateResponse(keyValuePairs);
@@ -33474,11 +34257,11 @@ class StateRequest extends WithDebug {
     startKey;
     endKey;
     maximumSize;
-    static Codec = descriptors_codec.Class(StateRequest, {
-        headerHash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        startKey: descriptors_codec.bytes(TRUNCATED_KEY_BYTES),
-        endKey: descriptors_codec.bytes(TRUNCATED_KEY_BYTES),
-        maximumSize: descriptors_codec.u32,
+    static Codec = Class(StateRequest, {
+        headerHash: bytes(hash_HASH_SIZE).asOpaque(),
+        startKey: bytes(TRUNCATED_KEY_BYTES),
+        endKey: bytes(TRUNCATED_KEY_BYTES),
+        maximumSize: u32,
     });
     static create({ headerHash, startKey, endKey, maximumSize }) {
         return new StateRequest(headerHash, startKey, endKey, maximumSize);
@@ -33562,8 +34345,8 @@ const STREAM_KIND_PROXY_TO_ALL = tryAsStreamKind(132);
 class TicketDistributionRequest extends WithDebug {
     epochIndex;
     ticket;
-    static Codec = descriptors_codec.Class(TicketDistributionRequest, {
-        epochIndex: descriptors_codec.u32.asOpaque(),
+    static Codec = Class(TicketDistributionRequest, {
+        epochIndex: u32.asOpaque(),
         ticket: SignedTicket.Codec,
     });
     static create({ epochIndex, ticket }) {
@@ -33626,8 +34409,8 @@ const ce_133_work_package_submission_STREAM_KIND = tryAsStreamKind(133);
 class CoreWorkPackage extends WithDebug {
     coreIndex;
     workPackage;
-    static Codec = descriptors_codec.Class(CoreWorkPackage, {
-        coreIndex: descriptors_codec.u16.asOpaque(),
+    static Codec = Class(CoreWorkPackage, {
+        coreIndex: u16.asOpaque(),
         workPackage: WorkPackage.Codec,
     });
     static create({ coreIndex, workPackage }) {
@@ -33693,14 +34476,14 @@ class ce_133_work_package_submission_ClientHandler {
 
 
 
-const WorkPackageBundleCodec = descriptors_codec.blob;
+const WorkPackageBundleCodec = blob;
 const ce_134_work_package_sharing_STREAM_KIND = tryAsStreamKind(134);
 class WorkPackageSharingRequest extends WithDebug {
     coreIndex;
     segmentsRootMappings;
-    static Codec = descriptors_codec.Class(WorkPackageSharingRequest, {
-        coreIndex: descriptors_codec.u16.asOpaque(),
-        segmentsRootMappings: descriptors_codec.sequenceVarLen(WorkPackageInfo.Codec),
+    static Codec = Class(WorkPackageSharingRequest, {
+        coreIndex: u16.asOpaque(),
+        segmentsRootMappings: sequenceVarLen(WorkPackageInfo.Codec),
     });
     static create({ coreIndex, segmentsRootMappings }) {
         return new WorkPackageSharingRequest(coreIndex, segmentsRootMappings);
@@ -33714,9 +34497,9 @@ class WorkPackageSharingRequest extends WithDebug {
 class WorkPackageSharingResponse extends WithDebug {
     workReportHash;
     signature;
-    static Codec = descriptors_codec.Class(WorkPackageSharingResponse, {
-        workReportHash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        signature: descriptors_codec.bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
+    static Codec = Class(WorkPackageSharingResponse, {
+        workReportHash: bytes(hash_HASH_SIZE).asOpaque(),
+        signature: bytes(ED25519_SIGNATURE_BYTES).asOpaque(),
     });
     static create({ workReportHash, signature }) {
         return new WorkPackageSharingResponse(workReportHash, signature);
@@ -33814,9 +34597,9 @@ class GuaranteedWorkReport extends WithDebug {
     report;
     slot;
     signatures;
-    static Codec = descriptors_codec.Class(GuaranteedWorkReport, {
+    static Codec = Class(GuaranteedWorkReport, {
         report: WorkReport.Codec,
-        slot: descriptors_codec.u32.asOpaque(),
+        slot: u32.asOpaque(),
         signatures: codecWithContext((context) => {
             return codecKnownSizeArray(Credential.Codec, {
                 minLength: 0,
@@ -33888,9 +34671,9 @@ const up_0_block_announcement_STREAM_KIND = tryAsStreamKind(0);
 class HashAndSlot extends WithDebug {
     hash;
     slot;
-    static Codec = descriptors_codec.Class(HashAndSlot, {
-        hash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        slot: descriptors_codec.u32.asOpaque(),
+    static Codec = Class(HashAndSlot, {
+        hash: bytes(hash_HASH_SIZE).asOpaque(),
+        slot: u32.asOpaque(),
     });
     static create({ hash, slot }) {
         return new HashAndSlot(hash, slot);
@@ -33907,9 +34690,9 @@ class HashAndSlot extends WithDebug {
 class Handshake {
     final;
     leafs;
-    static Codec = descriptors_codec.Class(Handshake, {
+    static Codec = Class(Handshake, {
         final: HashAndSlot.Codec,
-        leafs: descriptors_codec.sequenceVarLen(HashAndSlot.Codec),
+        leafs: sequenceVarLen(HashAndSlot.Codec),
     });
     static create({ final, leafs }) {
         return new Handshake(final, leafs);
@@ -33930,7 +34713,7 @@ class Handshake {
 class Announcement extends WithDebug {
     header;
     final;
-    static Codec = descriptors_codec.Class(Announcement, {
+    static Codec = Class(Announcement, {
         header: header_Header.Codec,
         final: HashAndSlot.Codec,
     });
@@ -34416,12 +35199,9 @@ async function main(config, comms) {
     main_logger.info `🛜 Network worker finished. Closing channel.`;
 }
 
-;// CONCATENATED MODULE: external "node:worker_threads"
-const external_node_worker_threads_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:worker_threads");
 ;// CONCATENATED MODULE: ./packages/workers/api/channel.ts
 
 
-
 const channel_logger = Logger.new(import.meta.filename, "workers");
 /**
  * Wraps a protocol definition and a communication port into a properly
@@ -34488,10 +35268,10 @@ class channel_Channel {
             // listen to request incoming to worker
             this.port.on(key, val.request, async ({ responseId, data }) => {
                 try {
-                    console.log(`[${threadId}] handling ${key}. Responseid: ${responseId}`);
+                    console.log(`[${this.port.threadId}] handling ${key}. Responseid: ${responseId}`);
                     // handle them
                     const response = await handler(data);
-                    console.log(`[${threadId}] sending response: ${responseId}`);
+                    console.log(`[${this.port.threadId}] sending response: ${responseId}`);
                     // and send response back on dedicated event
                     this.port.postMessage(responseId, val.response, {
                         responseId,
@@ -34509,14 +35289,14 @@ class channel_Channel {
         return (data) => {
             this.nextResponseId++;
             const responseId = `${key}:${this.nextResponseId}`;
-            console.log(`[${threadId}] will wait for ${key}`);
+            console.log(`[${this.port.threadId}] will wait for ${key}`);
             return new Promise((resolve, reject) => {
                 this.pendingPromises.add(reject);
                 // attach response listener first
                 this.port.once(responseId, val.response, (msg) => {
                     // we got response, so will resolve
                     this.pendingPromises.delete(reject);
-                    console.log(`[${threadId}] got ${key}`);
+                    console.log(`[${this.port.threadId}] got ${key}`);
                     resolve(msg.data);
                 });
                 // send message to the port
@@ -34541,6 +35321,14 @@ function isMessageCodecs(val) {
     return val !== null && typeof val === "object" && "request" in val && "response" in val;
 }
 
+// EXTERNAL MODULE: ./node_modules/eventemitter3/index.js
+var eventemitter3 = __nccwpck_require__(952);
+;// CONCATENATED MODULE: ./node_modules/eventemitter3/index.mjs
+
+
+
+/* harmony default export */ const node_modules_eventemitter3 = ((/* unused pure expression or super */ null && (EventEmitter)));
+
 ;// CONCATENATED MODULE: ./packages/workers/api/port.ts
 
 /**
@@ -34551,6 +35339,7 @@ function isMessageCodecs(val) {
  */
 class port_DirectPort {
     events;
+    threadId = 0;
     /** Create a pair of symmetrical inter-connected ports. */
     static pair() {
         const events = new EventEmitter();
@@ -34628,12 +35417,12 @@ class NetworkingConfig extends WithDebug {
     host;
     port;
     bootnodes;
-    static Codec = descriptors_codec.Class(NetworkingConfig, {
-        genesisHeaderHash: descriptors_codec.bytes(hash_HASH_SIZE).asOpaque(),
-        key: descriptors_codec.bytes(ED25519_PRIV_KEY_BYTES).asOpaque(),
-        host: descriptors_codec.string,
-        port: descriptors_codec.u16,
-        bootnodes: descriptors_codec.sequenceVarLen(descriptors_codec.string),
+    static Codec = Class(NetworkingConfig, {
+        genesisHeaderHash: bytes(hash_HASH_SIZE).asOpaque(),
+        key: bytes(ED25519_PRIV_KEY_BYTES).asOpaque(),
+        host: string,
+        port: u16,
+        bootnodes: sequenceVarLen(string),
     });
     static create({ genesisHeaderHash, key, host, port, bootnodes }) {
         return new NetworkingConfig(genesisHeaderHash, key, host, port, bootnodes);
@@ -34661,17 +35450,17 @@ const protocol = createProtocol("net", {
     toWorker: {
         newHeader: {
             request: headerViewWithHashCodec,
-            response: descriptors_codec.nothing,
+            response: nothing,
         },
         finish: {
-            request: descriptors_codec.nothing,
-            response: descriptors_codec.nothing,
+            request: nothing,
+            response: nothing,
         },
     },
     fromWorker: {
         blocks: {
-            request: descriptors_codec.sequenceVarLen(block_Block.Codec.View),
-            response: descriptors_codec.nothing,
+            request: sequenceVarLen(block_Block.Codec.View),
+            response: nothing,
         },
     },
 });