@typeberry/convert 0.5.10 → 0.5.11-10b197e

package/index.js

@@ -4626,7 +4626,7 @@ function seeThrough(v) {
 }
 
 ;// CONCATENATED MODULE: ./packages/core/utils/package.json
-const package_namespaceObject = {"rE":"0.5.10"};
+const package_namespaceObject = {"rE":"0.5.11"};
 ;// CONCATENATED MODULE: ./packages/core/utils/result.ts
 
 /**
@@ -5784,6 +5784,9 @@ class EndOfDataError extends Error {
 /** Wrapper for `Decoder` that can skip bytes of fields in the data buffer instead of decoding them. */
 class Skipper {
     decoder;
+    static new(decoder) {
+        return new Skipper(decoder);
+    }
     constructor(decoder) {
         this.decoder = decoder;
     }
@@ -5906,7 +5909,7 @@ class descriptor_Descriptor {
      */
     skipEncoded(decoder) {
         const initBytes = decoder.bytesRead();
-        this.skip(new Skipper(decoder));
+        this.skip(Skipper.new(decoder));
         const endBytes = decoder.bytesRead();
         return bytes_BytesBlob.blobFrom(decoder.source.subarray(initBytes, endBytes));
     }
@@ -5924,6 +5927,7 @@ class descriptor_Descriptor {
 
 
 
+
 function tryAsExactBytes(a) {
     check `${a.isExact} The value is not exact size estimation!`;
     return a.bytes;
@@ -6073,12 +6077,12 @@ class encoder_Encoder {
         this.offset += 1;
     }
     /**
-     * Encode a single boolean discriminator using variable encoding.
+     * Encode a single boolean discriminator using 1-byte encoding.
      *
      * https://graypaper.fluffylabs.dev/#/579bd12/375300375300
      */
     bool(bool) {
-        this.varU32(numbers_tryAsU32(bool ? 1 : 0));
+        this.i8(tryAsU8(bool ? 1 : 0));
     }
     /**
      * Prepare for encoding of a fixed-bytes number.
@@ -6430,7 +6434,7 @@ class ObjectView {
        is already decoded (${this.lastDecodedFieldIdx}, ${String(lastField)}).
     `;
         let lastItem = this.cache.get(lastField);
-        const skipper = new Skipper(this.decoder);
+        const skipper = Skipper.new(this.decoder);
         // now skip all of the fields and further populate the cache.
         for (let i = this.lastDecodedFieldIdx + 1; i <= index; i++) {
             // create new cached prop
@@ -6537,7 +6541,7 @@ class SequenceView {
       Unjustified call to 'decodeUpTo' - the index (${index}) is already decoded (${this.lastDecodedIdx}).
     `;
         let lastItem = this.cache.get(this.lastDecodedIdx);
-        const skipper = new Skipper(this.decoder);
+        const skipper = Skipper.new(this.decoder);
         // now skip all of the fields and further populate the cache.
         for (let i = this.lastDecodedIdx + 1; i <= index; i++) {
             // create new cached prop
@@ -6874,6 +6878,9 @@ function hasUniqueView(a) {
 function objectView(Class, descriptors, sizeHint, skipper) {
     // Create a View, based on the `AbstractView`.
     class ClassView extends ObjectView {
+        static new(d) {
+            return new ClassView(d);
+        }
         constructor(d) {
             super(d, Class, descriptors);
         }
@@ -6893,8 +6900,8 @@ function objectView(Class, descriptors, sizeHint, skipper) {
         const encoded = t.encoded();
         e.bytes(bytes_Bytes.fromBlob(encoded.raw, encoded.length));
     }, (d) => {
-        const view = new ClassView(d.clone());
-        skipper(new Skipper(d));
+        const view = ClassView.new(d.clone());
+        skipper(Skipper.new(d));
         return view;
     }, skipper);
 }
@@ -6914,7 +6921,7 @@ function sequenceViewVarLen(type, options) {
         e.bytes(bytes_Bytes.fromBlob(encoded.raw, encoded.length));
     }, (d) => {
         const view = new SequenceView(d.clone(), type);
-        skipper(new Skipper(d));
+        skipper(Skipper.new(d));
         return view;
     }, skipper);
 }
@@ -6929,7 +6936,7 @@ function sequenceViewFixLen(type, { fixedLength }) {
         e.bytes(bytes_Bytes.fromBlob(encoded.raw, encoded.length));
     }, (d) => {
         const view = new SequenceView(d.clone(), type, fixedLength);
-        skipper(new Skipper(d));
+        skipper(Skipper.new(d));
         return view;
     }, skipper);
 }
@@ -7617,6 +7624,9 @@ const ED25519_SIGNATURE_BYTES = 64;
 class Ed25519Pair {
     pubKey;
     _privKey;
+    static new(pubKey, _privKey) {
+        return new Ed25519Pair(pubKey, _privKey);
+    }
     constructor(
     /** Public key */
     pubKey, 
@@ -7629,7 +7639,7 @@ class Ed25519Pair {
 /** Create a private key from given raw bytes. */
 async function ed25519_privateKey(privKey) {
     const pubKey = await ed.getPublicKeyAsync(privKey.raw);
-    return new Ed25519Pair(Bytes.fromBlob(pubKey, ED25519_KEY_BYTES).asOpaque(), privKey.asOpaque());
+    return Ed25519Pair.new(Bytes.fromBlob(pubKey, ED25519_KEY_BYTES).asOpaque(), privKey.asOpaque());
 }
 /** Sign given piece of data using provided key pair. */
 async function sign(key, message) {
@@ -7761,7 +7771,9 @@ const ZERO_HASH = bytes_Bytes.zero(hash_HASH_SIZE);
 class WithHash extends WithDebug {
     hash;
     data;
-    // TODO [ToDr] use static method and make constructor private
+    static new(hash, data) {
+        return new WithHash(hash, data);
+    }
     constructor(hash, data) {
         super();
         this.hash = hash;
@@ -7773,6 +7785,9 @@ class WithHash extends WithDebug {
  */
 class WithHashAndBytes extends WithHash {
     encoded;
+    static create(hash, data, encoded) {
+        return new WithHashAndBytes(hash, data, encoded);
+    }
     constructor(hash, data, encoded) {
         super(hash, data);
         this.encoded = encoded;
@@ -8481,6 +8496,9 @@ class MultiMap {
      * Pass the number of keys and optionally mappers from keys to primitive types
      * if needed.
      */
+    static new(keysLength, keyMappers) {
+        return new MultiMap(keysLength, keyMappers);
+    }
     constructor(keysLength, keyMappers) {
         check `${keysLength > 0} Keys cannot be empty.`;
         check `${keyMappers === undefined || keyMappers.length === keysLength} Incorrect number of key mappers given!`;
@@ -9029,6 +9047,9 @@ class ChainSpec extends WithDebug {
     maxRefineGas;
     /** `L`: The maximum age in timeslots of the lookup anchor. */
     maxLookupAnchorAge;
+    static new(data) {
+        return new ChainSpec(data);
+    }
     constructor(data) {
         super();
         this.name = data.name;
@@ -9051,7 +9072,7 @@ class ChainSpec extends WithDebug {
     }
 }
 /** Set of values for "tiny" chain as defined in JAM test vectors. */
-const chain_spec_tinyChainSpec = new ChainSpec({
+const chain_spec_tinyChainSpec = ChainSpec.new({
     name: "tiny",
     validatorsCount: numbers_tryAsU16(6),
     coresCount: numbers_tryAsU16(2),
@@ -9073,7 +9094,7 @@ const chain_spec_tinyChainSpec = new ChainSpec({
  * Set of values for "full" chain as defined in JAM test vectors.
  * Please note that only validatorsCount and epochLength are "full", the rest is copied from "tiny".
  */
-const chain_spec_fullChainSpec = new ChainSpec({
+const chain_spec_fullChainSpec = ChainSpec.new({
     name: "full",
     validatorsCount: numbers_tryAsU16(1023),
     coresCount: numbers_tryAsU16(341),
@@ -9096,6 +9117,9 @@ class Bootnode {
     id;
     ip;
     port;
+    static new(id, ip, port) {
+        return new Bootnode(id, ip, port);
+    }
     constructor(
     /** Network address derived from the node's cryptographic public key (always 53-character?) */
     id, 
@@ -9806,37 +9830,37 @@ const work_package_MAX_NUMBER_OF_WORK_ITEMS = 16;
 /**
  * A piece of work done within a core.
  *
- * `P = (j ∈ Y, h ∈ NS, u ∈ H, p ∈ Y, x ∈ X, w ∈ ⟦I⟧1∶I)
+ * `P = (j ∈ Y, h ∈ NS, u ∈ H, f ∈ Y, x ∈ X, w ∈ ⟦I⟧1∶I)
  *
  * https://graypaper.fluffylabs.dev/#/579bd12/197000197200
  */
 class work_package_WorkPackage extends WithDebug {
-    authorization;
+    authToken;
     authCodeHost;
     authCodeHash;
-    parametrization;
+    authConfiguration;
     context;
     items;
     static Codec = codec_codec.Class(work_package_WorkPackage, {
         authCodeHost: codec_codec.u32.asOpaque(),
         authCodeHash: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
         context: RefineContext.Codec,
-        authorization: codec_codec.blob,
-        parametrization: codec_codec.blob,
+        authToken: codec_codec.blob,
+        authConfiguration: codec_codec.blob,
         items: codec_codec.sequenceVarLen(work_item_WorkItem.Codec).convert((x) => x, (items) => FixedSizeArray.new(items, tryAsWorkItemsCount(items.length))),
     });
-    static create({ authorization, authCodeHost, authCodeHash, parametrization, context, items, }) {
-        return new work_package_WorkPackage(authorization, authCodeHost, authCodeHash, parametrization, context, items);
+    static create({ authToken, authCodeHost, authCodeHash, authConfiguration, context, items, }) {
+        return new work_package_WorkPackage(authToken, authCodeHost, authCodeHash, authConfiguration, context, items);
     }
     constructor(
     /** `j`: simple blob acting as an authorization token */
-    authorization, 
+    authToken, 
     /** `h`: index of the service that hosts the authorization code */
     authCodeHost, 
     /** `u`: authorization code hash */
     authCodeHash, 
-    /** `p`: authorization parametrization blob */
-    parametrization, 
+    /** `f`: authorization configuration blob */
+    authConfiguration, 
     /** `x`: context in which the refine function should run */
     context, 
     /**
@@ -9847,10 +9871,10 @@ class work_package_WorkPackage extends WithDebug {
      */
     items) {
         super();
-        this.authorization = authorization;
+        this.authToken = authToken;
         this.authCodeHost = authCodeHost;
         this.authCodeHash = authCodeHash;
-        this.parametrization = parametrization;
+        this.authConfiguration = authConfiguration;
         this.context = context;
         this.items = items;
     }
@@ -10448,7 +10472,7 @@ class HeaderViewWithHash extends WithHash {
         data: header_Header.Codec.View,
     });
     static create({ hash, data }) {
-        return new WithHash(hash, data);
+        return WithHash.new(hash, data);
     }
 }
 /** Encoding of header + hash. */
@@ -11250,7 +11274,7 @@ function parseBootnode(v) {
         throw new Error(`Invalid port number: "${port}"`);
     }
     // TODO [ToDr] we should probably validate the name!
-    return new Bootnode(opaque_asOpaqueType(name), ip, portNumber);
+    return Bootnode.new(opaque_asOpaqueType(name), ip, portNumber);
 }
 /**
  * Configuration file for any blockchain network built on the JAM protocol
@@ -11833,6 +11857,9 @@ class FuzzTarget {
     sender;
     spec;
     sessionFeatures = 0;
+    static new(msgHandler, sender, spec) {
+        return new FuzzTarget(msgHandler, sender, spec);
+    }
     constructor(msgHandler, sender, spec) {
         this.msgHandler = msgHandler;
         this.sender = sender;
@@ -12017,6 +12044,9 @@ class MemorySegment extends WithDebug {
     end;
     data;
     static from({ start, end, data }) {
+        return MemorySegment.new(start, end, data);
+    }
+    static new(start, end, data) {
         return new MemorySegment(start, end, data);
     }
     constructor(start, end, data) {
@@ -12031,6 +12061,9 @@ class SpiMemory extends WithDebug {
     writeable;
     sbrkIndex;
     heapEnd;
+    static new(readable, writeable, sbrkIndex, heapEnd) {
+        return new SpiMemory(readable, writeable, sbrkIndex, heapEnd);
+    }
     constructor(readable, writeable, sbrkIndex, heapEnd) {
         super();
         this.readable = readable;
@@ -12043,6 +12076,9 @@ class SpiProgram extends WithDebug {
     code;
     memory;
     registers;
+    static new(code, memory, registers) {
+        return new SpiProgram(code, memory, registers);
+    }
     constructor(code, memory, registers) {
         super();
         this.code = code;
@@ -12101,10 +12137,10 @@ function decode_standard_program_decodeStandardProgram(program, args) {
         heapDataEnd < heapZerosEnd && getMemorySegment(heapDataEnd, heapZerosEnd),
         stackStart < stackEnd && getMemorySegment(stackStart, stackEnd),
     ].filter(nonEmpty);
-    return new SpiProgram(code, new SpiMemory(readableMemory, writeableMemory, heapZerosEnd, stackStart), getRegisters(args.length));
+    return SpiProgram.new(code, SpiMemory.new(readableMemory, writeableMemory, heapZerosEnd, stackStart), getRegisters(args.length));
 }
 function getMemorySegment(start, end, data = null) {
-    return new MemorySegment(start, end, data);
+    return MemorySegment.new(start, end, data);
 }
 function getRegisters(argsLength) {
     const regs = new BigUint64Array(decode_standard_program_NO_OF_REGISTERS);
@@ -12784,6 +12820,9 @@ class LookupHistoryItem {
     hash;
     length;
     slots;
+    static new(hash, length, slots) {
+        return new LookupHistoryItem(hash, length, slots);
+    }
     constructor(hash, length, 
     /**
      * Preimage availability history as a sequence of time slots.
@@ -13030,6 +13069,9 @@ class StatisticsData {
 class InMemoryStateView {
     chainSpec;
     state;
+    static new(chainSpec, state) {
+        return new InMemoryStateView(chainSpec, state);
+    }
     constructor(chainSpec, state) {
         this.chainSpec = chainSpec;
         this.state = state;
@@ -13351,6 +13393,10 @@ var UpdateError;
 class InMemoryService extends WithDebug {
     serviceId;
     data;
+    /** Create a new in-memory service wrapping the given id and data. */
+    static new(serviceId, data) {
+        return new InMemoryService(serviceId, data);
+    }
     constructor(
     /** Service id. */
     serviceId, 
@@ -13390,7 +13436,7 @@ class InMemoryService extends WithDebug {
     }
     /** Return identical `InMemoryService` which does not share any references. */
     clone() {
-        return new InMemoryService(this.serviceId, {
+        return InMemoryService.new(this.serviceId, {
             info: ServiceAccountInfo.create(this.data.info),
             preimages: HashDictionary.fromEntries(Array.from(this.data.preimages.entries())),
             lookupHistory: HashDictionary.fromEntries(Array.from(this.data.lookupHistory.entries()).map(([k, v]) => [k, v.slice()])),
@@ -13421,7 +13467,7 @@ class InMemoryService extends WithDebug {
                 throw new Error(`Service ${service.serviceId} is missing expected lookupHistory: ${hash}, ${length}`);
             }
             const items = lookupHistory.get(hash) ?? [];
-            items.push(new LookupHistoryItem(hash, length, slots));
+            items.push(LookupHistoryItem.new(hash, length, slots));
             lookupHistory.set(hash, items);
         }
         // copy storage
@@ -13432,7 +13478,7 @@ class InMemoryService extends WithDebug {
             }
             storage.set(key.toString(), StorageItem.create({ key, value }));
         }
-        return new InMemoryService(service.serviceId, {
+        return InMemoryService.new(service.serviceId, {
             info,
             preimages,
             storage,
@@ -13590,7 +13636,7 @@ class InMemoryState extends WithDebug {
                     if (slot !== null) {
                         const lookupHistory = service.data.lookupHistory.get(preimage.hash);
                         const length = numbers_tryAsU32(preimage.blob.length);
-                        const lookup = new LookupHistoryItem(preimage.hash, length, service_tryAsLookupHistorySlots([slot]));
+                        const lookup = LookupHistoryItem.new(preimage.hash, length, service_tryAsLookupHistorySlots([slot]));
                         if (lookupHistory === undefined) {
                             // no lookup history for that preimage at all (edge case, should be requested)
                             service.data.lookupHistory.set(preimage.hash, [lookup]);
@@ -13637,7 +13683,7 @@ class InMemoryState extends WithDebug {
                 if (this.services.has(serviceId)) {
                     return result_Result.error(UpdateError.DuplicateService, () => `${serviceId} already exists!`);
                 }
-                this.services.set(serviceId, new InMemoryService(serviceId, {
+                this.services.set(serviceId, InMemoryService.new(serviceId, {
                     info: account,
                     preimages: HashDictionary.new(),
                     storage: new Map(),
@@ -13708,7 +13754,7 @@ class InMemoryState extends WithDebug {
         this.services = s.services;
     }
     view() {
-        return new InMemoryStateView(this.chainSpec, this);
+        return InMemoryStateView.new(this.chainSpec, this);
     }
     /**
      * Create an empty and possibly incoherent `InMemoryState`.
@@ -13875,7 +13921,7 @@ const preimageStatusFromJson = json.object({
         length: "number",
     },
     value: json.array("number"),
-}, ({ key, value }) => new LookupHistoryItem(key.hash, numbers_tryAsU32(key.length), value));
+}, ({ key, value }) => LookupHistoryItem.new(key.hash, numbers_tryAsU32(key.length), value));
 class JsonService {
     static fromJson = json.object({
         id: "number",
@@ -13901,7 +13947,7 @@ class JsonService {
         for (const [key, item] of entries) {
             storage.set(key.toString(), item);
         }
-        return new InMemoryService(id, {
+        return InMemoryService.new(id, {
             info: data.service,
             preimages,
             storage,
@@ -13914,7 +13960,7 @@ class JsonService {
 const preimageStatusFromJson072 = json.object({
     hash: fromJson.bytes32(),
     status: json.array("number"),
-}, ({ hash, status }) => new LookupHistoryItem(hash, numbers_tryAsU32(0), status));
+}, ({ hash, status }) => LookupHistoryItem.new(hash, numbers_tryAsU32(0), status));
 class JsonServicePre072 {
     static fromJson = json.object({
         id: "number",
@@ -13930,7 +13976,7 @@ class JsonServicePre072 {
         for (const item of data.lookup_meta ?? data.preimages_status ?? []) {
             const data = lookupHistory.get(item.hash) ?? [];
             const length = numbers_tryAsU32(preimages.get(item.hash)?.blob.length ?? item.length);
-            data.push(new LookupHistoryItem(item.hash, length, item.slots));
+            data.push(LookupHistoryItem.new(item.hash, length, item.slots));
             lookupHistory.set(item.hash, data);
         }
         const storage = new Map();
@@ -13941,7 +13987,7 @@ class JsonServicePre072 {
         for (const [key, item] of entries) {
             storage.set(key.toString(), item);
         }
-        return new InMemoryService(id, {
+        return InMemoryService.new(id, {
             info: data.service,
             preimages,
             storage,
@@ -14612,11 +14658,14 @@ const dumpCodec = descriptor_Descriptor.new("Dump", { bytes: 64, isExact: false
 class SerializedStateView {
     spec;
     backend;
+    /** Best-effort list of recently active services. */
     recentlyUsedServices;
     viewCache;
-    constructor(spec, backend, 
-    /** Best-effort list of recently active services. */
-    recentlyUsedServices, viewCache) {
+    /** Build a new view over an existing serialized-state backend. */
+    static new(args) {
+        return new SerializedStateView(args.spec, args.backend, args.recentlyUsedServices, args.viewCache);
+    }
+    constructor(spec, backend, recentlyUsedServices, viewCache) {
         this.spec = spec;
         this.backend = backend;
         this.recentlyUsedServices = recentlyUsedServices;
@@ -14732,7 +14781,12 @@ class serialized_state_SerializedState {
     }
     /** Return a non-decoding version of the state. */
     view() {
-        return new SerializedStateView(this.spec, this.backend, this.recentlyUsedServices, this.viewCache);
+        return SerializedStateView.new({
+            spec: this.spec,
+            backend: this.backend,
+            recentlyUsedServices: this.recentlyUsedServices,
+            viewCache: this.viewCache,
+        });
     }
     // TODO [ToDr] Temporary method to update the state,
     // without changing references.
@@ -14752,7 +14806,7 @@ class serialized_state_SerializedState {
         if (!this.recentlyUsedServices.includes(id)) {
             this.recentlyUsedServices.push(id);
         }
-        return new SerializedService(this.blake2b, id, serviceData, (key) => this.retrieveOptional(key));
+        return SerializedService.new(this.blake2b, id, serviceData, (key) => this.retrieveOptional(key));
     }
     retrieve(k, description) {
         const data = this.retrieveOptional(k);
@@ -14838,6 +14892,9 @@ class SerializedService {
     serviceId;
     accountInfo;
     retrieveOptional;
+    static new(blake2b, serviceId, accountInfo, retrieveOptional) {
+        return new SerializedService(blake2b, serviceId, accountInfo, retrieveOptional);
+    }
     constructor(blake2b, 
     /** Service id */
     serviceId, accountInfo, retrieveOptional) {
@@ -14952,13 +15009,11 @@ class TrieNode {
     }
     /** View this node as a branch node */
     asBranchNode() {
-        debug_check `${this.getNodeType() === NodeType.Branch} not a branch!`;
-        return new BranchNode(this);
+        return BranchNode.viewOf(this);
     }
     /** View this node as a leaf node */
     asLeafNode() {
-        debug_check `${this.getNodeType() !== NodeType.Branch} not a leaf!`;
-        return new LeafNode(this);
+        return LeafNode.viewOf(this);
     }
     toString() {
         return bytes_BytesBlob.blobFrom(this.raw).toString();
@@ -14978,10 +15033,7 @@ class TrieNode {
  */
 class BranchNode {
     node;
-    // Underlying raw node.
-    constructor(node) {
-        this.node = node;
-    }
+    /** Build a branch node from its left and right sub-node hashes. */
     static fromSubNodes(left, right) {
         const node = new TrieNode();
         node.raw.set(left.raw, 0);
@@ -14990,6 +15042,15 @@ class BranchNode {
         node.raw[0] &= FIRST_BIT_SET_NEG;
         return new BranchNode(node);
     }
+    /** View an existing raw trie node as a branch node (validates node type). */
+    static viewOf(node) {
+        debug_check `${node.getNodeType() === NodeType.Branch} not a branch!`;
+        return new BranchNode(node);
+    }
+    // Underlying raw node.
+    constructor(node) {
+        this.node = node;
+    }
     /** Get the hash of the left sub-trie. */
     getLeft() {
         return bytes_Bytes.fromBlob(this.node.raw.subarray(0, hash_HASH_SIZE), hash_HASH_SIZE).asOpaque();
@@ -15020,9 +15081,6 @@ class BranchNode {
 class LeafNode {
     // Underlying raw node.
     node;
-    constructor(node) {
-        this.node = node;
-    }
     static fromValue(key, value, valueHash) {
         const node = new TrieNode();
         // The value will fit in the leaf itself.
@@ -15042,6 +15100,14 @@ class LeafNode {
         }
         return new LeafNode(node);
     }
+    /** View an existing raw trie node as a leaf node (validates node type). */
+    static viewOf(node) {
+        debug_check `${node.getNodeType() !== NodeType.Branch} not a leaf!`;
+        return new LeafNode(node);
+    }
+    constructor(node) {
+        this.node = node;
+    }
     /** Get the key (truncated to 31 bytes). */
     getKey() {
         return bytes_Bytes.fromBlob(this.node.raw.subarray(1, TRUNCATED_KEY_BYTES + 1), TRUNCATED_KEY_BYTES).asOpaque();
@@ -15089,6 +15155,9 @@ class LeafNode {
 class NodesDb {
     hasher;
     nodes = HashDictionary.new();
+    static new(hasher) {
+        return new NodesDb(hasher);
+    }
     constructor(hasher) {
         this.hasher = hasher;
     }
@@ -15130,6 +15199,9 @@ class NodesDb {
  * A version of `NodesDb` augmented with mutating methods.
  */
 class WriteableNodesDb extends NodesDb {
+    static new(hasher) {
+        return new WriteableNodesDb(hasher);
+    }
     remove(hash) {
         return NodesDb.withHashCompat(hash, (key) => {
             this.nodes.delete(key);
@@ -15158,7 +15230,7 @@ class InMemoryTrie {
     root;
     /** Create an empty in-memory trie. */
     static empty(hasher) {
-        return new InMemoryTrie(new WriteableNodesDb(hasher));
+        return new InMemoryTrie(WriteableNodesDb.new(hasher));
     }
     /** Given a collection of leaves, compute the state root. */
     static computeStateRoot(hasher, leaves) {
@@ -15246,7 +15318,7 @@ class InMemoryTrie {
     static fromLeaves(hasher, leaves) {
         // TODO [ToDr] [opti] Pair up the leaves and build upper levels.
         let root = null;
-        const nodes = new WriteableNodesDb(hasher);
+        const nodes = WriteableNodesDb.new(hasher);
         for (const leaf of leaves) {
             root = trieInsert(root, nodes, leaf);
         }
@@ -15970,7 +16042,7 @@ const lookupHistoryItemCodec = codec_codec.object({
     slots: codec_codec
         .readonlyArray(codec_codec.sequenceVarLen(codec_codec.u32.asOpaque()))
         .convert(seeThrough, service_tryAsLookupHistorySlots),
-}, "LookupHistoryItem", ({ hash, length, slots }) => new LookupHistoryItem(hash, length, slots));
+}, "LookupHistoryItem", ({ hash, length, slots }) => LookupHistoryItem.new(hash, length, slots));
 const lookupHistoryEntryCodec = codec_codec.object({
     key: codec_codec.bytes(hash_HASH_SIZE).asOpaque(),
     data: codec_codec.sequenceVarLen(lookupHistoryItemCodec),
@@ -16199,10 +16271,10 @@ const workPackageFromJson = json.object({
     context: refineContextFromJson,
     items: json.array(workItemFromJson),
 }, ({ authorization, auth_code_host, auth_code_hash, authorizer_config, context, items }) => work_package_WorkPackage.create({
-    authorization,
+    authToken: authorization,
     authCodeHost: auth_code_host,
     authCodeHash: auth_code_hash,
-    parametrization: authorizer_config,
+    authConfiguration: authorizer_config,
     context,
     items: FixedSizeArray.new(items, tryAsWorkItemsCount(items.length)),
 }));
@@ -16287,6 +16359,9 @@ class mask_Mask {
      * There are instructions at indices `0, 3, 5, 9`.
      */
     lookupTableForward;
+    static new(mask) {
+        return new mask_Mask(mask);
+    }
     constructor(mask) {
         this.lookupTableForward = this.buildLookupTableForward(mask);
     }
@@ -16371,7 +16446,7 @@ class nibbles_decoder_NibblesDecoder {
 const IMMEDIATE_AND_OFFSET_MAX_LENGTH = 4;
 class args_decoder_ArgsDecoder {
     nibblesDecoder = new NibblesDecoder();
-    offsetDecoder = new ImmediateDecoder();
+    offsetDecoder = ImmediateDecoder.new();
     code = new Uint8Array();
     mask = Mask.empty();
     reset(code, mask) {
@@ -16544,7 +16619,7 @@ const args_decoding_results_createResults = () => {
     results[ArgumentType.ONE_IMMEDIATE] = {
         type: ArgumentType.ONE_IMMEDIATE,
         noOfBytesToSkip: 1,
-        immediateDecoder: new ImmediateDecoder(),
+        immediateDecoder: ImmediateDecoder.new(),
     };
     results[ArgumentType.TWO_REGISTERS] = {
         type: ArgumentType.TWO_REGISTERS,
@@ -16563,7 +16638,7 @@ const args_decoding_results_createResults = () => {
         type: ArgumentType.ONE_REGISTER_ONE_IMMEDIATE_ONE_OFFSET,
         noOfBytesToSkip: 1,
         registerIndex: 0,
-        immediateDecoder: new ImmediateDecoder(),
+        immediateDecoder: ImmediateDecoder.new(),
         nextPc: 0,
     };
     results[ArgumentType.TWO_REGISTERS_ONE_OFFSET] = {
@@ -16578,20 +16653,20 @@ const args_decoding_results_createResults = () => {
         noOfBytesToSkip: 1,
         firstRegisterIndex: 0,
         secondRegisterIndex: 0,
-        immediateDecoder: new ImmediateDecoder(),
+        immediateDecoder: ImmediateDecoder.new(),
     };
     results[ArgumentType.ONE_REGISTER_ONE_IMMEDIATE] = {
         type: ArgumentType.ONE_REGISTER_ONE_IMMEDIATE,
         noOfBytesToSkip: 1,
         registerIndex: 0,
-        immediateDecoder: new ImmediateDecoder(),
+        immediateDecoder: ImmediateDecoder.new(),
     };
     results[ArgumentType.ONE_REGISTER_TWO_IMMEDIATES] = {
         type: ArgumentType.ONE_REGISTER_TWO_IMMEDIATES,
         noOfBytesToSkip: 1,
         registerIndex: 0,
-        firstImmediateDecoder: new ImmediateDecoder(),
-        secondImmediateDecoder: new ImmediateDecoder(),
+        firstImmediateDecoder: ImmediateDecoder.new(),
+        secondImmediateDecoder: ImmediateDecoder.new(),
     };
     results[ArgumentType.ONE_OFFSET] = {
         type: ArgumentType.ONE_OFFSET,
@@ -16601,14 +16676,14 @@ const args_decoding_results_createResults = () => {
     results[ArgumentType.TWO_IMMEDIATES] = {
         type: ArgumentType.TWO_IMMEDIATES,
         noOfBytesToSkip: 1,
-        firstImmediateDecoder: new ImmediateDecoder(),
-        secondImmediateDecoder: new ImmediateDecoder(),
+        firstImmediateDecoder: ImmediateDecoder.new(),
+        secondImmediateDecoder: ImmediateDecoder.new(),
     };
     results[ArgumentType.TWO_REGISTERS_TWO_IMMEDIATES] = {
         type: ArgumentType.TWO_REGISTERS_TWO_IMMEDIATES,
         noOfBytesToSkip: 1,
-        firstImmediateDecoder: new ImmediateDecoder(),
-        secondImmediateDecoder: new ImmediateDecoder(),
+        firstImmediateDecoder: ImmediateDecoder.new(),
+        secondImmediateDecoder: ImmediateDecoder.new(),
         firstRegisterIndex: 0,
         secondRegisterIndex: 0,
     };
@@ -16616,7 +16691,7 @@ const args_decoding_results_createResults = () => {
         type: ArgumentType.ONE_REGISTER_ONE_EXTENDED_WIDTH_IMMEDIATE,
         noOfBytesToSkip: 9,
         registerIndex: 0,
-        immediateDecoder: new ExtendedWitdthImmediateDecoder(),
+        immediateDecoder: ExtendedWitdthImmediateDecoder.new(),
     };
     return results;
 };
@@ -17173,11 +17248,14 @@ function assemblify_assemblify(program, mask) {
 
 /** Create a new gas counter instance depending on the gas value. */
 function gas_gasCounter(gas) {
-    return new GasCounterU64(tryAsU64(gas));
+    return GasCounterU64.new(tryAsU64(gas));
 }
 class GasCounterU64 {
     gas;
     initialGas;
+    static new(gas) {
+        return new GasCounterU64(gas);
+    }
     constructor(gas) {
         this.gas = gas;
         this.initialGas = tryAsGas(gas);
@@ -17534,6 +17612,9 @@ class MemoryPage {
 
 class readable_page_ReadablePage extends MemoryPage {
     data;
+    static new(pageNumber, data) {
+        return new readable_page_ReadablePage(pageNumber, data);
+    }
     constructor(pageNumber, data) {
         super(pageNumber);
         this.data = data;
@@ -17571,6 +17652,9 @@ class readable_page_ReadablePage extends MemoryPage {
 class writeable_page_WriteablePage extends MemoryPage {
     buffer;
     view;
+    static new(pageNumber, initialData) {
+        return new writeable_page_WriteablePage(pageNumber, initialData);
+    }
     constructor(pageNumber, initialData) {
         super(pageNumber);
         const dataLength = initialData?.length ?? 0;
@@ -17646,6 +17730,9 @@ class memory_Memory {
     static fromInitialMemory(initialMemoryState) {
         return new memory_Memory(initialMemoryState?.sbrkIndex, initialMemoryState?.sbrkIndex, initialMemoryState?.endHeapIndex, initialMemoryState?.memory);
     }
+    static new(sbrkIndex = tryAsSbrkIndex(RESERVED_MEMORY_RANGE.end), virtualSbrkIndex = tryAsSbrkIndex(RESERVED_MEMORY_RANGE.end), endHeapIndex = tryAsSbrkIndex(MAX_MEMORY_INDEX), memory = new Map()) {
+        return new memory_Memory(sbrkIndex, virtualSbrkIndex, endHeapIndex, memory);
+    }
     constructor(sbrkIndex = tryAsSbrkIndex(RESERVED_MEMORY_RANGE.end), virtualSbrkIndex = tryAsSbrkIndex(RESERVED_MEMORY_RANGE.end), endHeapIndex = tryAsSbrkIndex(MAX_MEMORY_INDEX), memory = new Map()) {
         this.sbrkIndex = sbrkIndex;
         this.virtualSbrkIndex = virtualSbrkIndex;
@@ -17764,7 +17851,7 @@ class memory_Memory {
         const pagesToAllocate = (newSbrkIndex - currentSbrkIndex) / PAGE_SIZE;
         const rangeToAllocate = PageRange.fromStartAndLength(firstPageNumber, pagesToAllocate);
         for (const pageNumber of rangeToAllocate) {
-            const page = new WriteablePage(pageNumber);
+            const page = WriteablePage.new(pageNumber);
             this.memory.set(pageNumber, page);
         }
         this.virtualSbrkIndex = newVirtualSbrkIndex;
@@ -17827,7 +17914,7 @@ class memory_builder_MemoryBuilder {
         for (let i = 0; i < noOfPages; i++) {
             const pageNumber = pages[i];
             const dataChunk = data.subarray(i * PAGE_SIZE, (i + 1) * PAGE_SIZE);
-            const page = new ReadablePage(pageNumber, dataChunk);
+            const page = ReadablePage.new(pageNumber, dataChunk);
             this.initialMemory.set(pageNumber, page);
         }
         return this;
@@ -17855,7 +17942,7 @@ class memory_builder_MemoryBuilder {
         for (let i = 0; i < noOfPages; i++) {
             const pageNumber = pages[i];
             const dataChunk = data.subarray(i * PAGE_SIZE, (i + 1) * PAGE_SIZE);
-            const page = new WriteablePage(pageNumber, dataChunk);
+            const page = WriteablePage.new(pageNumber, dataChunk);
             this.initialMemory.set(pageNumber, page);
         }
         return this;
@@ -18050,6 +18137,9 @@ function math_utils_minBigInt(...args) {
 
 class bit_rotation_ops_BitRotationOps {
     regs;
+    static new(regs) {
+        return new bit_rotation_ops_BitRotationOps(regs);
+    }
     constructor(regs) {
         this.regs = regs;
     }
@@ -18144,6 +18234,9 @@ class branch_ops_BranchOps {
     regs;
     instructionResult;
     basicBlocks;
+    static new(regs, instructionResult, basicBlocks) {
+        return new branch_ops_BranchOps(regs, instructionResult, basicBlocks);
+    }
     constructor(regs, instructionResult, basicBlocks) {
         this.regs = regs;
         this.instructionResult = instructionResult;
@@ -18226,6 +18319,9 @@ class dynamic_jump_ops_DynamicJumpOps {
     jumpTable;
     instructionResult;
     basicBlocks;
+    static new(regs, jumpTable, instructionResult, basicBlocks) {
+        return new dynamic_jump_ops_DynamicJumpOps(regs, jumpTable, instructionResult, basicBlocks);
+    }
     constructor(regs, jumpTable, instructionResult, basicBlocks) {
         this.regs = regs;
         this.jumpTable = jumpTable;
@@ -18266,6 +18362,9 @@ class dynamic_jump_ops_DynamicJumpOps {
 
 class host_call_ops_HostCallOps {
     instructionResult;
+    static new(instructionResult) {
+        return new host_call_ops_HostCallOps(instructionResult);
+    }
     constructor(instructionResult) {
         this.instructionResult = instructionResult;
     }
@@ -18284,6 +18383,9 @@ class load_ops_LoadOps {
     regs;
     memory;
     instructionResult;
+    static new(regs, memory, instructionResult) {
+        return new load_ops_LoadOps(regs, memory, instructionResult);
+    }
     constructor(regs, memory, instructionResult) {
         this.regs = regs;
         this.memory = memory;
@@ -18395,9 +18497,17 @@ class registers_Registers {
     bytes;
     asSigned;
     asUnsigned;
-    constructor(bytes = safeAllocUint8Array(NO_OF_REGISTERS << REGISTER_SIZE_SHIFT)) {
-        this.bytes = bytes;
+    /** Creates an empty registers object backed by a freshly allocated buffer. */
+    static empty() {
+        return new registers_Registers(safeAllocUint8Array(NO_OF_REGISTERS << REGISTER_SIZE_SHIFT));
+    }
+    /** Wraps an existing byte buffer, validating its size. */
+    static fromBytes(bytes) {
         check `${bytes.length === NO_OF_REGISTERS << REGISTER_SIZE_SHIFT} Invalid size of registers array.`;
+        return new registers_Registers(bytes);
+    }
+    constructor(bytes) {
+        this.bytes = bytes;
         this.asSigned = new BigInt64Array(bytes.buffer, bytes.byteOffset);
         this.asUnsigned = new BigUint64Array(bytes.buffer, bytes.byteOffset);
     }
@@ -18408,10 +18518,6 @@ class registers_Registers {
         check `${bytes.length === this.bytes.length} Incorrect size of input registers. Got: ${bytes.length}, need: ${this.bytes.length}`;
         this.bytes.set(bytes, 0);
     }
-    static fromBytes(bytes) {
-        check `${bytes.length === NO_OF_REGISTERS << REGISTER_SIZE_SHIFT} Invalid size of registers array.`;
-        return new registers_Registers(bytes);
-    }
     getBytesAsLittleEndian(index, len) {
         const offset = index << REGISTER_SIZE_SHIFT;
         return this.bytes.subarray(offset, offset + len);
@@ -18475,6 +18581,9 @@ function registers_signExtend32To64(value) {
 
 class math_ops_MathOps {
     regs;
+    static new(regs) {
+        return new math_ops_MathOps(regs);
+    }
     constructor(regs) {
         this.regs = regs;
     }
@@ -18625,6 +18734,9 @@ class memory_ops_MemoryOps {
     regs;
     memory;
     instructionResult;
+    static new(regs, memory, instructionResult) {
+        return new memory_ops_MemoryOps(regs, memory, instructionResult);
+    }
     constructor(regs, memory, instructionResult) {
         this.regs = regs;
         this.memory = memory;
@@ -18644,6 +18756,9 @@ class memory_ops_MemoryOps {
 
 class no_args_ops_NoArgsOps {
     instructionResult;
+    static new(instructionResult) {
+        return new no_args_ops_NoArgsOps(instructionResult);
+    }
     constructor(instructionResult) {
         this.instructionResult = instructionResult;
     }
@@ -18660,6 +18775,9 @@ class no_args_ops_NoArgsOps {
 
 class shift_ops_ShiftOps {
     regs;
+    static new(regs) {
+        return new shift_ops_ShiftOps(regs);
+    }
     constructor(regs) {
         this.regs = regs;
     }
@@ -18728,6 +18846,9 @@ class store_ops_StoreOps {
     regs;
     memory;
     instructionResult;
+    static new(regs, memory, instructionResult) {
+        return new store_ops_StoreOps(regs, memory, instructionResult);
+    }
     constructor(regs, memory, instructionResult) {
         this.regs = regs;
         this.memory = memory;
@@ -19478,7 +19599,7 @@ class program_Program {
     static fromSpi(blob, args, hasMetadata) {
         const { code: spiCode, metadata } = hasMetadata ? extractCodeAndMetadata(blob) : { code: blob };
         const { code, memory: rawMemory, registers } = decodeStandardProgram(spiCode, args);
-        const regs = new Registers();
+        const regs = Registers.empty();
         regs.copyFrom(registers);
         const memoryBuilder = new MemoryBuilder();
         for (const { start, end, data } of rawMemory.readable) {
@@ -19498,8 +19619,8 @@ class program_Program {
     }
     static fromGeneric(blob, hasMetadata) {
         const { code, metadata } = hasMetadata ? extractCodeAndMetadata(blob) : { code: blob };
-        const regs = new Registers();
-        const memory = new Memory();
+        const regs = Registers.empty();
+        const memory = Memory.new();
         return new program_Program(code, regs, memory, metadata);
     }
     constructor(code, registers, memory, metadata = new Uint8Array()) {
@@ -19525,11 +19646,19 @@ function extractCodeAndMetadata(blobWithMetadata) {
 
 class jump_table_JumpTable {
     indices;
-    constructor(itemByteLength, bytes) {
+    /** Create an empty jump table. */
+    static empty() {
+        return new jump_table_JumpTable(0, new Uint8Array());
+    }
+    /** Decode a jump table from a raw bytes buffer. */
+    static fromRaw(itemByteLength, bytes) {
         check `
       ${itemByteLength === 0 || bytes.length % itemByteLength === 0}
       Length of jump table (${bytes.length}) should be a multiple of item lenght (${itemByteLength})!
     `;
+        return new jump_table_JumpTable(itemByteLength, bytes);
+    }
+    constructor(itemByteLength, bytes) {
         const length = itemByteLength === 0 ? 0 : bytes.length / itemByteLength;
         this.indices = new Uint32Array(length);
         for (let i = 0; i < length; i++) {
@@ -19555,9 +19684,6 @@ class jump_table_JumpTable {
     getDestination(index) {
         return this.indices[index];
     }
-    static empty() {
-        return new jump_table_JumpTable(0, new Uint8Array());
-    }
     getSize() {
         return this.indices.length;
     }
@@ -19581,11 +19707,14 @@ class program_decoder_ProgramDecoder {
     code;
     mask;
     jumpTable;
+    static new(rawProgram) {
+        return new program_decoder_ProgramDecoder(rawProgram);
+    }
     constructor(rawProgram) {
         const { code, mask, jumpTable, jumpTableItemLength } = this.decodeProgram(rawProgram);
         this.code = new Uint8Array(code);
-        this.mask = new Mask(mask);
-        this.jumpTable = new JumpTable(jumpTableItemLength, jumpTable);
+        this.mask = Mask.new(mask);
+        this.jumpTable = JumpTable.fromRaw(jumpTableItemLength, jumpTable);
     }
     decodeProgram(program) {
         const decoder = Decoder.fromBlob(program);
@@ -19619,7 +19748,7 @@ class program_decoder_ProgramDecoder {
     /** https://graypaper.fluffylabs.dev/#/68eaa1f/23f400234701?v=0.6.4 */
     static deblob(program) {
         try {
-            return Result.ok(new program_decoder_ProgramDecoder(program));
+            return Result.ok(program_decoder_ProgramDecoder.new(program));
         }
         catch (e) {
             program_decoder_logger.error `Invalid program: ${e}`;
@@ -19657,8 +19786,8 @@ class program_decoder_ProgramDecoder {
 const interpreter_logger = Logger.new(import.meta.filename, "pvm");
 class interpreter_Interpreter {
     useSbrkGas;
-    registers = new Registers();
-    memory = new Memory();
+    registers = Registers.empty();
+    memory = Memory.new();
     gas = gasCounter(tryAsGas(0));
     code = new Uint8Array();
     mask = Mask.empty();
@@ -19682,23 +19811,26 @@ class interpreter_Interpreter {
     argsDecodingResults = createResults();
     basicBlocks;
     jumpTable = JumpTable.empty();
+    static new(options = {}) {
+        return new interpreter_Interpreter(options);
+    }
     constructor({ useSbrkGas = false } = {}) {
         this.useSbrkGas = useSbrkGas;
         this.argsDecoder = new ArgsDecoder();
         this.basicBlocks = new BasicBlocks();
-        const mathOps = new MathOps(this.registers);
-        const shiftOps = new ShiftOps(this.registers);
-        const bitOps = new BitOps(this.registers);
-        const booleanOps = new BooleanOps(this.registers);
-        const moveOps = new MoveOps(this.registers);
-        const branchOps = new BranchOps(this.registers, this.instructionResult, this.basicBlocks);
-        const loadOps = new LoadOps(this.registers, this.memory, this.instructionResult);
-        const storeOps = new StoreOps(this.registers, this.memory, this.instructionResult);
-        const noArgsOps = new NoArgsOps(this.instructionResult);
-        const dynamicJumpOps = new DynamicJumpOps(this.registers, this.jumpTable, this.instructionResult, this.basicBlocks);
-        const hostCallOps = new HostCallOps(this.instructionResult);
-        const memoryOps = new MemoryOps(this.registers, this.memory, this.instructionResult);
-        const bitRotationOps = new BitRotationOps(this.registers);
+        const mathOps = MathOps.new(this.registers);
+        const shiftOps = ShiftOps.new(this.registers);
+        const bitOps = BitOps.new(this.registers);
+        const booleanOps = BooleanOps.new(this.registers);
+        const moveOps = MoveOps.new(this.registers);
+        const branchOps = BranchOps.new(this.registers, this.instructionResult, this.basicBlocks);
+        const loadOps = LoadOps.new(this.registers, this.memory, this.instructionResult);
+        const storeOps = StoreOps.new(this.registers, this.memory, this.instructionResult);
+        const noArgsOps = NoArgsOps.new(this.instructionResult);
+        const dynamicJumpOps = DynamicJumpOps.new(this.registers, this.jumpTable, this.instructionResult, this.basicBlocks);
+        const hostCallOps = HostCallOps.new(this.instructionResult);
+        const memoryOps = MemoryOps.new(this.registers, this.memory, this.instructionResult);
+        const bitRotationOps = BitRotationOps.new(this.registers);
         this.threeRegsDispatcher = new ThreeRegsDispatcher(mathOps, shiftOps, bitOps, booleanOps, moveOps, bitRotationOps);
         this.twoRegsOneImmDispatcher = new TwoRegsOneImmDispatcher(mathOps, shiftOps, bitOps, booleanOps, moveOps, storeOps, loadOps, bitRotationOps);
         this.twoRegsDispatcher = new TwoRegsDispatcher(moveOps, memoryOps, bitOps, bitRotationOps);
@@ -19718,7 +19850,7 @@ class interpreter_Interpreter {
         this.resetGeneric(p.code, pc, gas, p.registers, p.memory);
     }
     resetGeneric(rawProgram, pc, gas, maybeRegisters, maybeMemory) {
-        const programDecoder = new ProgramDecoder(rawProgram);
+        const programDecoder = ProgramDecoder.new(rawProgram);
         this.code = programDecoder.getCode();
         this.mask = programDecoder.getMask();
         this.jumpTable.copyFrom(programDecoder.getJumpTable());
@@ -19895,14 +20027,17 @@ class interpreter_Interpreter {
 
 class DebuggerAdapter {
     pvm;
+    static new(useSbrkGas = false) {
+        return new DebuggerAdapter(useSbrkGas);
+    }
     constructor(useSbrkGas = false) {
-        this.pvm = new Interpreter({ useSbrkGas });
+        this.pvm = Interpreter.new({ useSbrkGas });
     }
     resetJAM(jamProgram, pc, gas, args, hasMetadata = false) {
         this.pvm.resetJam(jamProgram, args, pc, tryAsGas(gas), hasMetadata);
     }
     resetGeneric(rawProgram, flatRegisters, initialGas) {
-        this.pvm.resetGeneric(rawProgram, 0, tryAsGas(initialGas), new Registers(flatRegisters));
+        this.pvm.resetGeneric(rawProgram, 0, tryAsGas(initialGas), Registers.fromBytes(flatRegisters));
     }
     reset(rawProgram, pc, gas, maybeRegisters, maybeMemory) {
         this.pvm.resetGeneric(rawProgram, pc, tryAsGas(gas), maybeRegisters, maybeMemory);
@@ -19948,7 +20083,7 @@ class DebuggerAdapter {
         return this.pvm.registers.getAllEncoded();
     }
     setRegisters(registers) {
-        this.pvm.registers.copyFrom(new Registers(registers));
+        this.pvm.registers.copyFrom(Registers.fromBytes(registers));
     }
     getProgramCounter() {
         return this.pvm.getPC();
@@ -20066,9 +20201,9 @@ async function runPvmTest(testContent) {
     const HEAP_START_PAGE = hasMemoryLayout ? maxAddressFromPageMap + PAGE_SIZE : 0;
     const HEAP_END_PAGE = MAX_MEMORY_INDEX;
     const memory = memoryBuilder.finalize(tryAsMemoryIndex(HEAP_START_PAGE), tryAsSbrkIndex(HEAP_END_PAGE));
-    const regs = new Registers();
+    const regs = Registers.empty();
     regs.copyFrom(testContent["initial-regs"]);
-    const pvm = new Interpreter();
+    const pvm = Interpreter.new();
     const mapPvmStatus = (status) => {
         if (status === Status.FAULT) {
             return "page-fault";