@typeberry/lib 0.1.0-08a9db1 → 0.1.0-b2d0b72

package/index.js

@@ -95,29 +95,17 @@ function isBrowser() {
  * We avoid using `node:assert` to keep compatibility with a browser environment.
  * Note the checks should not have any side effects, since we might decide
  * to remove all of them in a post-processing step.
- */
-function check(condition, message) {
-    if (!condition) {
-        throw new Error(`Assertion failure: ${message ?? ""}`);
-    }
-}
-function cast(_a, condition) {
-    return condition;
-}
-/**
- * Yet another function to perform runtime assertions.
- * This function returns a new type to mark in the code that this value was checked and you don't have to do it again.
  *
- * In the post-processing step all usages of this functions should be replaced with simple casting. An example:
- * const x = checkAndType<number, CheckedNumber>(y);
- * should be replaced with:
- * const x = y as CheckedNumber;
+ * NOTE the function is intended to be used as tagged template string for the performance
+ * reasons.
  */
-function ensure(a, condition, message) {
-    if (cast(a, condition)) {
-        return a;
+function check(strings, condition, ...data) {
+    if (!condition) {
+        // add an empty value so that `data.length === strings.length`
+        data.unshift("");
+        const message = strings.map((v, index) => `${v}${data[index] ?? ""}`);
+        throw new Error(`Assertion failure:${message.join("")}`);
     }
-    throw new Error(`Assertion failure: ${message ?? ""}`);
 }
 /**
  * The function can be used to make sure that a particular type is `never`
@@ -284,7 +272,7 @@ function resultToString(res) {
 const Result$1 = {
     /** Create new [`Result`] with `Ok` status. */
     ok: (ok) => {
-        check(ok !== undefined, "`Ok` type cannot be undefined.");
+        check `${ok !== undefined} 'ok' type cannot be undefined.`;
         return {
             isOk: true,
             isError: false,
@@ -293,7 +281,7 @@ const Result$1 = {
     },
     /** Create new [`Result`] with `Error` status. */
     error: (error, details = "") => {
-        check(error !== undefined, "`Error` type cannot be undefined.");
+        check `${error !== undefined} 'Error' type cannot be undefined.`;
         return {
             isOk: false,
             isError: true,
@@ -557,7 +545,6 @@ var index$s = /*#__PURE__*/Object.freeze({
   assertNever: assertNever,
   check: check,
   deepEqual: deepEqual,
-  ensure: ensure,
   inspect: inspect,
   isBrowser: isBrowser,
   measure: measure,
@@ -591,7 +578,10 @@ class BitVec {
     constructor(data, bitLength) {
         this.data = data;
         this.bitLength = bitLength;
-        check(data.length * 8 >= bitLength, `Not enough bytes in the data array. Need ${data.length * 8} has ${bitLength}.`);
+        check `
+      ${data.length * 8 >= bitLength}
+      Not enough bytes in the data array. Need ${data.length * 8} has ${bitLength}.
+    `;
         this.byteLength = Math.ceil(bitLength / 8);
     }
     /** Return a raw in-memory representation of this [`BitVec`]. */
@@ -600,7 +590,10 @@ class BitVec {
     }
     /** Perform OR operation on all bits in place. */
     sumWith(other) {
-        check(other.bitLength === this.bitLength, `Invalid bit length for sumWith: ${other.bitLength} vs ${this.bitLength}`);
+        check `
+      ${other.bitLength === this.bitLength}
+      Invalid bit length for sumWith: ${other.bitLength} vs ${this.bitLength}
+    `;
         const otherRaw = other.raw;
         for (let i = 0; i < this.byteLength; i++) {
             this.data[i] |= otherRaw[i];
@@ -610,7 +603,7 @@ class BitVec {
      * Set the bit at index `idx` to value `val`.
      */
     setBit(idx, val) {
-        check(idx < this.bitLength, `Index out of bounds. Need ${idx} has ${this.bitLength}.`);
+        check `${idx >= 0 && idx < this.bitLength} Index out of bounds. Need ${idx} has ${this.bitLength}.`;
         const byteIndex = Math.floor(idx / 8);
         const bitIndexInByte = idx % 8;
         const mask = 1 << bitIndexInByte;
@@ -625,7 +618,7 @@ class BitVec {
      * Return `true` if the bit at index `idx` is set.
      */
     isSet(idx) {
-        check(idx < this.bitLength, `Index out of bounds. Need ${idx} has ${this.bitLength}.`);
+        check `${idx >= 0 && idx < this.bitLength} Index out of bounds. Need ${idx} has ${this.bitLength}.`;
         const byteIndex = Math.floor(idx / 8);
         const bitIndexInByte = idx % 8;
         const mask = 1 << bitIndexInByte;
@@ -793,7 +786,7 @@ class BytesBlob {
     }
     /** Create a new [`BytesBlob`] from an array of bytes. */
     static blobFromNumbers(v) {
-        check(v.find((x) => (x & 0xff) !== x) === undefined, "BytesBlob.blobFromNumbers used with non-byte number array.");
+        check `${v.find((x) => (x & 0xff) !== x) === undefined} BytesBlob.blobFromNumbers used with non-byte number array.`;
         const arr = new Uint8Array(v);
         return new BytesBlob(arr);
     }
@@ -837,7 +830,7 @@ class Bytes extends BytesBlob {
     length;
     constructor(raw, len) {
         super(raw);
-        check(raw.byteLength === len, `Given buffer has incorrect size ${raw.byteLength} vs expected ${len}`);
+        check `${raw.byteLength === len} Given buffer has incorrect size ${raw.byteLength} vs expected ${len}`;
         this.length = len;
     }
     /** Create new [`Bytes<X>`] given a backing buffer and it's length. */
@@ -846,7 +839,7 @@ class Bytes extends BytesBlob {
     }
     /** Create new [`Bytes<X>`] given an array of bytes and it's length. */
     static fromNumbers(v, len) {
-        check(v.find((x) => (x & 0xff) !== x) === undefined, "Bytes.fromNumbers used with non-byte number array.");
+        check `${v.find((x) => (x & 0xff) !== x) === undefined} Bytes.fromNumbers used with non-byte number array.`;
         const x = new Uint8Array(v);
         return new Bytes(x, len);
     }
@@ -857,7 +850,7 @@ class Bytes extends BytesBlob {
     // TODO [ToDr] `fill` should have the argments swapped to align with the rest.
     /** Create a [`Bytes<X>`] with all bytes filled with given input number. */
     static fill(len, input) {
-        check((input & 0xff) === input, "Input has to be a byte.");
+        check `${(input & 0xff) === input} Input has to be a byte.`;
         const bytes = Bytes.zero(len);
         bytes.raw.fill(input, 0, len);
         return bytes;
@@ -880,7 +873,7 @@ class Bytes extends BytesBlob {
     }
     /** Compare the sequence to another one. */
     isEqualTo(other) {
-        check(this.length === other.length, "Comparing incorrectly typed bytes!");
+        check `${this.length === other.length} Comparing incorrectly typed bytes!`;
         return u8ArraySameLengthEqual(this.raw, other.raw);
     }
     /** Converts current type into some opaque extension. */
@@ -889,7 +882,7 @@ class Bytes extends BytesBlob {
     }
 }
 function byteFromString(s) {
-    check(s.length === 2, "Two-character string expected");
+    check `${s.length === 2} Two-character string expected`;
     const a = numberFromCharCode(s.charCodeAt(0));
     const b = numberFromCharCode(s.charCodeAt(1));
     return (a << 4) | b;
@@ -945,42 +938,53 @@ var index$q = /*#__PURE__*/Object.freeze({
   bytesBlobComparator: bytesBlobComparator
 });
 
-const asWithBytesRepresentation = (v) => v;
+const asTypedNumber = (v) => v;
 const MAX_VALUE_U8 = 0xff;
 const MAX_VALUE_U16 = 0xffff;
 const MAX_VALUE_U32 = 0xffff_ffff;
 const MAX_VALUE_U64 = 0xffffffffffffffffn;
 /** Attempt to cast an input number into U8. */
-const tryAsU8 = (v) => ensure(v, isU8(v), `input must have one-byte representation, got ${v}`);
+const tryAsU8 = (v) => {
+    check `${isU8(v)} input must have one-byte representation, got ${v}`;
+    return asTypedNumber(v);
+};
 /** Check if given number is a valid U8 number. */
 const isU8 = (v) => (v & MAX_VALUE_U8) === v;
 /** Attempt to cast an input number into U16. */
-const tryAsU16 = (v) => ensure(v, isU16(v), `input must have two-byte representation, got ${v}`);
+const tryAsU16 = (v) => {
+    check `${isU16(v)} input must have two-byte representation, got ${v}`;
+    return asTypedNumber(v);
+};
 /** Check if given number is a valid U16 number. */
 const isU16 = (v) => (v & MAX_VALUE_U16) === v;
 /** Attempt to cast an input number into U32. */
-const tryAsU32 = (v) => ensure(v, isU32(v), `input must have four-byte representation, got ${v}`);
+const tryAsU32 = (v) => {
+    check `${isU32(v)} input must have four-byte representation, got ${v}`;
+    return asTypedNumber(v);
+};
 /** Check if given number is a valid U32 number. */
 const isU32 = (v) => (v & MAX_VALUE_U32) >>> 0 === v;
 /** Attempt to cast an input number into U64. */
 const tryAsU64 = (x) => {
     const v = BigInt(x);
-    return ensure(v, isU64(v), `input must have eight-byte representation, got ${x}`);
+    check `${isU64(v)} input must have eight-byte representation, got ${x}`;
+    return asTypedNumber(v);
 };
 /** Check if given number is a valid U64 number. */
 const isU64 = (v) => (v & MAX_VALUE_U64) === v;
 /** Collate two U32 parts into one U64. */
 const u64FromParts = ({ lower, upper }) => {
     const val = (BigInt(upper) << 32n) + BigInt(lower);
-    return asWithBytesRepresentation(val);
+    return asTypedNumber(val);
 };
 /** Split U64 into lower & upper parts. */
 const u64IntoParts = (v) => {
-    const lower = v & (2n ** 32n - 1n);
-    const upper = v >> 32n;
+    // Number(...) safe: both parts are <= 0xffffffff
+    const lower = Number(v & (2n ** 32n - 1n));
+    const upper = Number(v >> 32n);
     return {
-        lower: asWithBytesRepresentation(Number(lower)),
-        upper: asWithBytesRepresentation(Number(upper)),
+        lower: asTypedNumber(lower),
+        upper: asTypedNumber(upper),
     };
 };
 /**
@@ -1020,8 +1024,8 @@ function u32AsLeBytes(value) {
  * Interpret 4-byte `Uint8Array` as U32 written as little endian.
  */
 function leBytesAsU32(uint8Array) {
-    check(uint8Array.length === 4, "Input must be a Uint8Array of length 4");
-    return asWithBytesRepresentation(uint8Array[0] | (uint8Array[1] << 8) | (uint8Array[2] << 16) | (uint8Array[3] << 24));
+    check `${uint8Array.length === 4} Input must be a Uint8Array of length 4`;
+    return asTypedNumber(uint8Array[0] | (uint8Array[1] << 8) | (uint8Array[2] << 16) | (uint8Array[3] << 24));
 }
 /** Get the smallest value between U64 a and values given as input parameters. */
 const minU64 = (a, ...values) => values.reduce((min, value) => (value > min ? min : value), a);
@@ -1328,7 +1332,7 @@ class Decoder {
             this.skip(newOffset - this.offset);
         }
         else {
-            check(newOffset >= 0, "The offset has to be positive");
+            check `${newOffset >= 0} The offset has to be positive`;
             this.offset = newOffset;
         }
     }
@@ -1356,7 +1360,7 @@ class Decoder {
         return num;
     }
     ensureHasBytes(bytes) {
-        check(bytes >= 0, "Negative number of bytes given.");
+        check `${bytes >= 0} Negative number of bytes given.`;
         if (this.offset + bytes > this.source.length) {
             throw new Error(`Attempting to decode more data than there is left. Need ${bytes}, left: ${this.source.length - this.offset}.`);
         }
@@ -1364,7 +1368,7 @@ class Decoder {
 }
 const MASKS = [0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80];
 function decodeVariableLengthExtraBytes(firstByte) {
-    check(firstByte >= 0 && firstByte < 256, `Incorrect byte value: ${firstByte}`);
+    check `${firstByte >= 0 && firstByte < 256} Incorrect byte value: ${firstByte}`;
     for (let i = 0; i < MASKS.length; i++) {
         if (firstByte >= MASKS[i]) {
             return 8 - i;
@@ -1509,7 +1513,7 @@ class Descriptor {
 }
 
 function tryAsExactBytes(a) {
-    check(a.isExact, "The value is not exact size estimation!");
+    check `${a.isExact} The value is not exact size estimation!`;
     return a.bytes;
 }
 function addSizeHints(a, b) {
@@ -1616,8 +1620,8 @@ class Encoder {
         // we still allow positive numbers from `[maxNum / 2, maxNum)`.
         // So it does not matter if the argument is a negative value,
         // OR if someone just gave us two-complement already.
-        check(num < maxNum, "Only for numbers up to 2**64 - 1");
-        check(-num <= maxNum / 2n, "Only for numbers down to -2**63");
+        check `${num < maxNum} Only for numbers up to 2**64 - 1`;
+        check `${-num <= maxNum / 2n} Only for numbers down to -2**63`;
         this.ensureBigEnough(8);
         this.dataView.setBigInt64(this.offset, num, true);
         this.offset += 8;
@@ -1681,8 +1685,8 @@ class Encoder {
         // we still allow positive numbers from `[maxNum / 2, maxNum)`.
         // So it does not matter if the argument is a negative value,
         // OR if someone just gave us two-complement already.
-        check(num < maxNum, `Only for numbers up to 2**${BITS * bytesToEncode} - 1`);
-        check(-num <= maxNum / 2, `Only for numbers down to -2**${BITS * bytesToEncode - 1}`);
+        check `${num < maxNum} Only for numbers up to 2**${BITS * bytesToEncode} - 1`;
+        check `${-num <= maxNum / 2} Only for numbers down to -2**${BITS * bytesToEncode - 1}`;
         this.ensureBigEnough(bytesToEncode);
     }
     /**
@@ -1693,8 +1697,8 @@ class Encoder {
      * https://graypaper.fluffylabs.dev/#/579bd12/365202365202
      */
     varU32(num) {
-        check(num >= 0, "Only for natural numbers.");
-        check(num < 2 ** 32, "Only for numbers up to 2**32");
+        check `${num >= 0} Only for natural numbers.`;
+        check `${num < 2 ** 32} Only for numbers up to 2**32`;
         this.varU64(BigInt(num));
     }
     /**
@@ -1845,7 +1849,7 @@ class Encoder {
      * https://graypaper.fluffylabs.dev/#/579bd12/374400374400
      */
     sequenceVarLen(encode, elements) {
-        check(elements.length <= 2 ** 32, "Wow, that's a nice long sequence you've got here.");
+        check `${elements.length <= 2 ** 32} Wow, that's a nice long sequence you've got here.`;
         this.varU32(tryAsU32(elements.length));
         this.sequenceFixLen(encode, elements);
     }
@@ -1866,7 +1870,7 @@ class Encoder {
      * anyway, so if we really should throw we will.
      */
     ensureBigEnough(length, options = { silent: false }) {
-        check(length >= 0, "Negative length given");
+        check `${length >= 0} Negative length given`;
         const newLength = this.offset + length;
         if (newLength > MAX_LENGTH$1) {
             if (options.silent) {
@@ -1997,10 +2001,12 @@ class ObjectView {
     decodeUpTo(field) {
         const index = this.descriptorsKeys.indexOf(field);
         const lastField = this.descriptorsKeys[this.lastDecodedFieldIdx];
-        check(this.lastDecodedFieldIdx < index, `Unjustified call to 'decodeUpTo' -
+        check `
+      ${this.lastDecodedFieldIdx < index}
+      Unjustified call to 'decodeUpTo' -
        the index ($Blobindex}, ${String(field)})
        is already decoded (${this.lastDecodedFieldIdx}, ${String(lastField)}).
-      `);
+    `;
         let lastItem = this.cache.get(lastField);
         const skipper = new Skipper(this.decoder);
         // now skip all of the fields and further populate the cache.
@@ -2016,8 +2022,10 @@ class ObjectView {
             this.cache.set(field, lastItem);
             this.lastDecodedFieldIdx = i;
         }
-        const last = ensure(lastItem, lastItem !== undefined, "Last item must be set, since the loop turns at least once.");
-        return last;
+        if (lastItem === undefined) {
+            throw new Error("Last item must be set, since the loop turns at least once.");
+        }
+        return lastItem;
     }
 }
 /**
@@ -2050,8 +2058,10 @@ class SequenceView {
     *[Symbol.iterator]() {
         for (let i = 0; i < this.length; i++) {
             const val = this.get(i);
-            const v = ensure(val, val !== undefined, "We are within 0..this.length so all items are defined.");
-            yield v;
+            if (val === undefined) {
+                throw new Error("We are within 0..this.length so all items are defined.");
+            }
+            yield val;
         }
     }
     /** Create an array of all views mapped to some particular value. */
@@ -2094,7 +2104,10 @@ class SequenceView {
         return BytesBlob.blobFrom(this.decoder.source.subarray(this.initialDecoderOffset, this.decoder.bytesRead()));
     }
     decodeUpTo(index) {
-        check(this.lastDecodedIdx < index, `Unjustified call to 'decodeUpTo' - the index (${index}) is already decoded (${this.lastDecodedIdx}).`);
+        check `
+      ${this.lastDecodedIdx < index}
+      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);
         // now skip all of the fields and further populate the cache.
@@ -2109,8 +2122,10 @@ class SequenceView {
             this.cache.set(i, lastItem);
             this.lastDecodedIdx = i;
         }
-        const last = ensure(lastItem, lastItem !== undefined, "Last item must be set, since the loop turns at least once.");
-        return last;
+        if (lastItem === undefined) {
+            throw new Error("Last item must be set, since the loop turns at least once.");
+        }
+        return lastItem;
     }
 }
 
@@ -2134,7 +2149,10 @@ const TYPICAL_DICTIONARY_LENGTH = 32;
  */
 function readonlyArray(desc) {
     return desc.convert((x) => {
-        check(Array.isArray(x), `Non-arrays are not supported as 'readonly': got ${typeof x}, ${x}`);
+        check `
+        ${Array.isArray(x)}
+        Non-arrays are not supported as 'readonly': got ${typeof x}, ${x}
+      `;
         // NOTE [ToDr] This assumption is incorrect in general, but it's documented
         // in the general note. We avoid `.slice()` the array for performance reasons.
         return x;
@@ -3091,7 +3109,7 @@ const BLS_KEY_BYTES = 144;
 /** Derive a Bandersnatch public key from a seed. */
 function publicKey(seed) {
     const key = bandersnatch_exports.derive_public_key(seed);
-    check(key[0] === 0, "Invalid Bandersnatch public key derived from seed");
+    check `${key[0] === 0} Invalid Bandersnatch public key derived from seed`;
     return Bytes.fromBlob(key.subarray(1), BANDERSNATCH_KEY_BYTES).asOpaque();
 }
 
@@ -3533,7 +3551,7 @@ async function verify(input) {
         data.set(signature.raw, offset);
         offset += ED25519_SIGNATURE_BYTES;
         const messageLength = message.length;
-        check(messageLength < 256, `Message needs to be shorter than 256 bytes. Got: ${messageLength}`);
+        check `${messageLength < 256} Message needs to be shorter than 256 bytes. Got: ${messageLength}`;
         data[offset] = messageLength;
         offset += 1;
         data.set(message.raw, offset);
@@ -3622,7 +3640,7 @@ class PageAllocator {
     // TODO [ToDr] Benchmark the performance!
     constructor(hashesPerPage) {
         this.hashesPerPage = hashesPerPage;
-        check(hashesPerPage > 0 && hashesPerPage >>> 0 === hashesPerPage, "Expected a non-zero integer.");
+        check `${hashesPerPage > 0 && hashesPerPage >>> 0 === hashesPerPage} Expected a non-zero integer.`;
         this.resetPage();
     }
     resetPage() {
@@ -5093,8 +5111,8 @@ class MultiMap {
      * if needed.
      */
     constructor(keysLength, keyMappers) {
-        check(keysLength > 0, "Keys cannot be empty.");
-        check(keyMappers === undefined || keyMappers.length === keysLength, "Incorrect number of key mappers given!");
+        check `${keysLength > 0} Keys cannot be empty.`;
+        check `${keyMappers === undefined || keyMappers.length === keysLength} Incorrect number of key mappers given!`;
         this.data = new Map();
         this.keyMappers = keyMappers === undefined ? Array(keysLength).fill(null) : keyMappers;
     }
@@ -5193,7 +5211,7 @@ class FixedSizeArray extends Array {
         this.fixedLength = this.length;
     }
     static new(data, len) {
-        check(data.length === len, `Expected an array of size: ${len}, got: ${data.length}`);
+        check `${data.length === len} Expected an array of size: ${len}, got: ${data.length}`;
         const arr = new FixedSizeArray(len);
         for (let i = 0; i < len; i++) {
             arr[i] = data[i];
@@ -5325,7 +5343,7 @@ class SortedArray {
     }
     /** Create a new SortedSet from two sorted collections. */
     static fromTwoSortedCollections(first, second) {
-        check(first.comparator === second.comparator, "Cannot merge arrays if they do not use the same comparator");
+        check `${first.comparator === second.comparator} Cannot merge arrays if they do not use the same comparator`;
         const comparator = first.comparator;
         const arr1 = first.array;
         const arr1Length = arr1.length;
@@ -5442,7 +5460,7 @@ class SortedSet extends SortedArray {
     }
     /** Create a new SortedSet from two sorted collections. */
     static fromTwoSortedCollections(first, second) {
-        check(first.comparator === second.comparator, "Cannot merge arrays if they do not use the same comparator");
+        check `${first.comparator === second.comparator} Cannot merge arrays if they do not use the same comparator`;
         const comparator = first.comparator;
         if (first.length === 0) {
             return SortedSet.fromSortedArray(comparator, second.array);
@@ -6104,7 +6122,10 @@ const tryAsCoreIndex = (v) => asOpaqueType(tryAsU16(v));
 /** Attempt to convert a number into `Epoch`. */
 const tryAsEpoch = (v) => asOpaqueType(tryAsU32(v));
 function tryAsPerValidator(array, spec) {
-    check(array.length === spec.validatorsCount, `Invalid per-validator array length. Expected ${spec.validatorsCount}, got: ${array.length}`);
+    check `
+    ${array.length === spec.validatorsCount}
+    Invalid per-validator array length. Expected ${spec.validatorsCount}, got: ${array.length}
+  `;
     return asKnownSize(array);
 }
 const codecPerValidator = (val) => codecWithContext((context) => {
@@ -6113,7 +6134,10 @@ const codecPerValidator = (val) => codecWithContext((context) => {
     });
 });
 function tryAsPerEpochBlock(array, spec) {
-    check(array.length === spec.epochLength, `Invalid per-epoch-block array length. Expected ${spec.epochLength}, got: ${array.length}`);
+    check `
+    ${array.length === spec.epochLength}
+    Invalid per-epoch-block array length. Expected ${spec.epochLength}, got: ${array.length}
+  `;
     return asKnownSize(array);
 }
 const codecPerEpochBlock = (val) => codecWithContext((context) => {
@@ -6378,7 +6402,11 @@ var workItem = /*#__PURE__*/Object.freeze({
 
 /** Verify the value is within the `WorkItemsCount` bounds. */
 function tryAsWorkItemsCount(len) {
-    return ensure(len, len >= MIN_NUMBER_OF_WORK_ITEMS && len <= MAX_NUMBER_OF_WORK_ITEMS, `WorkItemsCount: Expected '${MIN_NUMBER_OF_WORK_ITEMS} <= count <= ${MAX_NUMBER_OF_WORK_ITEMS}' got ${len}`);
+    check `
+    ${len >= MIN_NUMBER_OF_WORK_ITEMS && len <= MAX_NUMBER_OF_WORK_ITEMS}
+    WorkItemsCount: Expected '${MIN_NUMBER_OF_WORK_ITEMS} <= count <= ${MAX_NUMBER_OF_WORK_ITEMS}' got ${len}
+  `;
+    return tryAsU8(len);
 }
 /** Minimal number of work items in the work package or results in work report. */
 const MIN_NUMBER_OF_WORK_ITEMS = 1;
@@ -8594,7 +8622,10 @@ class AvailabilityAssignment extends WithDebug {
 
 /** Check if given array has correct length before casting to the opaque type. */
 function tryAsPerCore(array, spec) {
-    check(array.length === spec.coresCount, `Invalid per-core array length. Expected ${spec.coresCount}, got: ${array.length}`);
+    check `
+    ${array.length === spec.coresCount}
+    Invalid per-core array length. Expected ${spec.coresCount}, got: ${array.length}
+  `;
     return asOpaqueType(array);
 }
 const codecPerCore = (val) => codecWithContext((context) => {
@@ -9742,7 +9773,7 @@ class InMemoryState extends WithDebug {
     }
     removeServices(servicesRemoved) {
         for (const serviceId of servicesRemoved ?? []) {
-            check(this.services.has(serviceId), `Attempting to remove non-existing service: ${serviceId}`);
+            check `${this.services.has(serviceId)} Attempting to remove non-existing service: ${serviceId}`;
             this.services.delete(serviceId);
         }
     }
@@ -9759,7 +9790,10 @@ class InMemoryState extends WithDebug {
             }
             else if (kind === UpdateStorageKind.Remove) {
                 const { key } = action;
-                check(service.data.storage.has(key.toString()), `Attempting to remove non-existing storage item at ${serviceId}: ${action.key}`);
+                check `
+          ${service.data.storage.has(key.toString())}
+          Attempting to remove non-existing storage item at ${serviceId}: ${action.key}
+        `;
                 service.data.storage.delete(key.toString());
             }
             else {
@@ -10438,12 +10472,12 @@ class TrieNode {
     }
     /** View this node as a branch node */
     asBranchNode() {
-        check(this.getNodeType() === NodeType.Branch);
+        check `${this.getNodeType() === NodeType.Branch} not a branch!`;
         return new BranchNode(this);
     }
     /** View this node as a leaf node */
     asLeafNode() {
-        check(this.getNodeType() !== NodeType.Branch);
+        check `${this.getNodeType() !== NodeType.Branch} not a leaf!`;
         return new LeafNode(this);
     }
     toString() {
@@ -10921,7 +10955,7 @@ function createSubtreeForBothLeaves(traversedPath, nodes, leafToReplace, leaf) {
  * Return a single bit from `key` located at `bitIndex`.
  */
 function getBit(key, bitIndex) {
-    check(bitIndex < TRUNCATED_KEY_BITS);
+    check `${bitIndex < TRUNCATED_KEY_BITS} invalid bit index passed ${bitIndex}`;
     const byte = bitIndex >>> 3;
     const bit = bitIndex - (byte << 3);
     const mask = 0b10_00_00_00 >>> bit;
@@ -11649,7 +11683,6 @@ const N_CHUNKS_REQUIRED = 342;
 const N_CHUNKS_REDUNDANCY = 681;
 /** Total number of chunks generated by EC. */
 const N_CHUNKS_TOTAL = 1023;
-// check(N_CHUNKS_TOTAL === N_CHUNKS_REQUIRED + N_CHUNKS_REDUNDANCY);
 /**
  * reed-solomon-simd requires point size to be multiple of 64 bytes but we need only 2 bytes.
  * It does not matter what indices are selected, but it has to be n and n + 32
@@ -11661,7 +11694,10 @@ const HALF_POINT_SIZE = 32;
  */
 const POINT_LENGTH = 2;
 const PIECE_SIZE = 684;
-// check(PIECE_SIZE === N_CHUNKS_REQUIRED * POINT_LENGTH);
+function checkConsistency() {
+    check `${N_CHUNKS_TOTAL === N_CHUNKS_REQUIRED + N_CHUNKS_REDUNDANCY} no of required and redundancy chunks need to match ${N_CHUNKS_TOTAL}`;
+    check `${PIECE_SIZE === N_CHUNKS_REQUIRED * POINT_LENGTH} piece size needs to match ${N_CHUNKS_REQUIRED} * ${POINT_LENGTH}`;
+}
 /**
  * Takes arbitrarily long input data, padds it to multiple of `PIECE_SIZE` and returns
  * exactly `N_CHUNKS_TOTAL` ec-coded segments.
@@ -11694,8 +11730,11 @@ function decodeDataAndTrim(input, expectedLength) {
 function decodeData(input) {
     const pointBytes = input[0][1].length;
     const points = Math.floor(pointBytes / POINT_LENGTH);
-    check(points * POINT_LENGTH === pointBytes, "Each point length needs to be a multiple of `POINT_LENGTH`");
-    check(input.every(([_idx, point]) => point.length === pointBytes), "Every piece must have the same length!");
+    check `${points * POINT_LENGTH === pointBytes} Each point length needs to be a multiple of ${POINT_LENGTH}`;
+    check `
+    ${input.every(([_idx, point]) => point.length === pointBytes)},
+    Every piece must have the same length!
+  `;
     const pieces = FixedSizeArray.fill(() => Bytes.zero(PIECE_SIZE), points);
     for (let i = 0; i < points; i++) {
         const start = i * POINT_LENGTH;
@@ -11768,7 +11807,7 @@ function decodePiece(input) {
     if (resultIndices === undefined) {
         throw new Error("indices array in decoded result must exist!");
     }
-    check(resultData.length === resultIndices.length * POINT_ALIGNMENT, "incorrect length of data or indices!");
+    check `${resultData.length === resultIndices.length * POINT_ALIGNMENT} incorrect length of data or indices!`;
     for (let i = 0; i < resultIndices.length; i++) {
         // fill reconstructed shards in result
         const index = resultIndices[i];
@@ -11793,7 +11832,7 @@ function decodePiece(input) {
  * https://graypaper.fluffylabs.dev/#/9a08063/3eb4013eb401?v=0.6.6
  */
 function split(input, n, k) {
-    check(n * k === input.length);
+    check `${n * k === input.length}`;
     const result = [];
     for (let i = 0; i < k; i++) {
         const start = i * n;
@@ -11906,7 +11945,7 @@ function transpose(input, k) {
  */
 function chunkingFunction(input) {
     const k = Math.floor(input.length / PIECE_SIZE);
-    check(k * PIECE_SIZE === input.length, `Input length ${input.length} is not divisible by ${PIECE_SIZE}`);
+    check `${k * PIECE_SIZE === input.length} Input length ${input.length} is not divisible by ${PIECE_SIZE}`;
     // we get a `k` pieces.
     const pieces = unzip(input, PIECE_SIZE, k);
     // and each piece get's ec-codec
@@ -11924,7 +11963,10 @@ function chunkingFunction(input) {
 function shardsToChunks(spec, shards) {
     const result = [];
     const shardSize = shards[0].length;
-    check(shards.every((s) => s.length === shardSize), "Each shard must be the same length!");
+    check `
+    ${shards.every((s) => s.length === shardSize)}
+    Each shard must be the same length!
+  `;
     const totalData = shards.map((s) => s.length).reduce((sum, sLength) => sum + sLength, 0);
     const chunkSize = Math.floor(totalData / N_CHUNKS_TOTAL);
     const piecesPerChunk = Math.floor(shardSize / chunkSize);
@@ -11974,6 +12016,7 @@ var index$a = /*#__PURE__*/Object.freeze({
   N_CHUNKS_TOTAL: N_CHUNKS_TOTAL,
   PIECE_SIZE: PIECE_SIZE,
   POINT_LENGTH: POINT_LENGTH,
+  checkConsistency: checkConsistency,
   chunkingFunction: chunkingFunction,
   chunksToShards: chunksToShards,
   decodeData: decodeData,
@@ -12436,8 +12479,8 @@ class PartiallyUpdatedState {
         this.stateUpdate.services.preimages.push(newUpdate);
     }
     updateServiceStorageUtilisation(serviceId, items, bytes, serviceInfo) {
-        check(items >= 0, `storageUtilisationCount has to be a positive number, got: ${items}`);
-        check(bytes >= 0, `storageUtilisationBytes has to be a positive number, got: ${bytes}`);
+        check `${items >= 0} storageUtilisationCount has to be a positive number, got: ${items}`;
+        check `${bytes >= 0} storageUtilisationBytes has to be a positive number, got: ${bytes}`;
         const overflowItems = !isU32(items);
         const overflowBytes = !isU64(bytes);
         // TODO [ToDr] this is not specified in GP, but it seems sensible.
@@ -12532,7 +12575,7 @@ function getServiceId(serviceId) {
     return null;
 }
 function writeServiceIdAsLeBytes(serviceId, destination) {
-    check(destination.length >= SERVICE_ID_BYTES, "Not enough space in the destination.");
+    check `${destination.length >= SERVICE_ID_BYTES} Not enough space in the destination.`;
     destination.set(u32AsLeBytes(serviceId));
 }
 /** Clamp a U64 to the maximum value of a 32-bit unsigned integer. */
@@ -12700,19 +12743,22 @@ var index$8 = /*#__PURE__*/Object.freeze({
 
 const NO_OF_REGISTERS$1 = 13;
 const REGISTER_SIZE_SHIFT = 3;
-const tryAsRegisterIndex = (index) => ensure(index, index >= 0 && index <= NO_OF_REGISTERS$1, `Incorrect register index: ${index}!`);
+const tryAsRegisterIndex = (index) => {
+    check `${index >= 0 && index < NO_OF_REGISTERS$1} Incorrect register index: ${index}!`;
+    return asOpaqueType(index);
+};
 class Registers {
     bytes;
     asSigned;
     asUnsigned;
     constructor(bytes = new Uint8Array(NO_OF_REGISTERS$1 << REGISTER_SIZE_SHIFT)) {
         this.bytes = bytes;
-        check(bytes.length === NO_OF_REGISTERS$1 << REGISTER_SIZE_SHIFT, "Invalid size of registers array.");
+        check `${bytes.length === NO_OF_REGISTERS$1 << REGISTER_SIZE_SHIFT} Invalid size of registers array.`;
         this.asSigned = new BigInt64Array(bytes.buffer, bytes.byteOffset);
         this.asUnsigned = new BigUint64Array(bytes.buffer, bytes.byteOffset);
     }
     static fromBytes(bytes) {
-        check(bytes.length === NO_OF_REGISTERS$1 << REGISTER_SIZE_SHIFT, "Invalid size of registers array.");
+        check `${bytes.length === NO_OF_REGISTERS$1 << REGISTER_SIZE_SHIFT} Invalid size of registers array.`;
         return new Registers(bytes);
     }
     getBytesAsLittleEndian(index, len) {
@@ -12848,7 +12894,7 @@ class Mask {
         return this.lookupTableForward[index] === 0;
     }
     getNoOfBytesToNextInstruction(index) {
-        check(index >= 0, `index (${index}) cannot be a negative number`);
+        check `${index >= 0} index (${index}) cannot be a negative number`;
         return Math.min(this.lookupTableForward[index] ?? 0, MAX_INSTRUCTION_DISTANCE);
     }
     buildLookupTableForward(mask) {
@@ -13814,7 +13860,7 @@ const PAGE_SIZE_SHIFT = 12;
 const PAGE_SIZE$1 = 1 << PAGE_SIZE_SHIFT;
 const MIN_ALLOCATION_SHIFT = (() => {
     const MIN_ALLOCATION_SHIFT = 7;
-    check(MIN_ALLOCATION_SHIFT < PAGE_SIZE_SHIFT, "incorrect minimal allocation shift");
+    check `${MIN_ALLOCATION_SHIFT < PAGE_SIZE_SHIFT} incorrect minimal allocation shift`;
     return MIN_ALLOCATION_SHIFT;
 })();
 const MIN_ALLOCATION_LENGTH = PAGE_SIZE$1 >> MIN_ALLOCATION_SHIFT;
@@ -13824,13 +13870,25 @@ const RESERVED_NUMBER_OF_PAGES = 16;
 /** https://graypaper.fluffylabs.dev/#/68eaa1f/35a60235a602?v=0.6.4 */
 const MAX_NUMBER_OF_PAGES = MEMORY_SIZE / PAGE_SIZE$1;
 
-const tryAsMemoryIndex = (index) => ensure(index, index >= 0 && index <= MAX_MEMORY_INDEX, `Incorrect memory index: ${index}!`);
-const tryAsSbrkIndex = (index) => ensure(index, index >= 0 && index <= MAX_MEMORY_INDEX + 1, `Incorrect sbrk index: ${index}!`);
+const tryAsMemoryIndex = (index) => {
+    check `${index >= 0 && index <= MAX_MEMORY_INDEX} Incorrect memory index: ${index}!`;
+    return asOpaqueType(index);
+};
+const tryAsSbrkIndex = (index) => {
+    check `${index >= 0 && index <= MAX_MEMORY_INDEX + 1} Incorrect sbrk index: ${index}!`;
+    return asOpaqueType(index);
+};
 
 /** Ensure that given memory `index` is within `[0...PAGE_SIZE)` and can be used to index a page */
-const tryAsPageIndex = (index) => ensure(index, index >= 0 && index < PAGE_SIZE$1, `Incorect page index: ${index}!`);
+const tryAsPageIndex = (index) => {
+    check `${index >= 0 && index < PAGE_SIZE$1}, Incorect page index: ${index}!`;
+    return asOpaqueType(index);
+};
 /** Ensure that given `index` represents an index of one of the pages. */
-const tryAsPageNumber = (index) => ensure(index, index >= 0 && index <= LAST_PAGE_NUMBER, `Incorrect page number: ${index}!`);
+const tryAsPageNumber = (index) => {
+    check `${index >= 0 && index <= LAST_PAGE_NUMBER}, Incorect page number: ${index}!`;
+    return asOpaqueType(index);
+};
 /**
  * Get the next page number and wrap the result if it is bigger than LAST_PAGE_NUMBER
  *
@@ -14294,10 +14352,10 @@ class MemoryBuilder {
      */
     setReadablePages(start, end, data = new Uint8Array()) {
         this.ensureNotFinalized();
-        check(start < end, "end has to be bigger than start");
-        check(start % PAGE_SIZE$1 === 0, `start needs to be a multiple of page size (${PAGE_SIZE$1})`);
-        check(end % PAGE_SIZE$1 === 0, `end needs to be a multiple of page size (${PAGE_SIZE$1})`);
-        check(data.length <= end - start, "the initial data is longer than address range");
+        check `${start < end} end has to be bigger than start`;
+        check `${start % PAGE_SIZE$1 === 0} start needs to be a multiple of page size (${PAGE_SIZE$1})`;
+        check `${end % PAGE_SIZE$1 === 0} end needs to be a multiple of page size (${PAGE_SIZE$1})`;
+        check `${data.length <= end - start} the initial data is longer than address range`;
         const length = end - start;
         const range = MemoryRange.fromStartAndLength(start, length);
         this.ensureNoReservedMemoryUsage(range);
@@ -14322,10 +14380,10 @@ class MemoryBuilder {
      */
     setWriteablePages(start, end, data = new Uint8Array()) {
         this.ensureNotFinalized();
-        check(start < end, "end has to be bigger than start");
-        check(start % PAGE_SIZE$1 === 0, `start needs to be a multiple of page size (${PAGE_SIZE$1})`);
-        check(end % PAGE_SIZE$1 === 0, `end needs to be a multiple of page size (${PAGE_SIZE$1})`);
-        check(data.length <= end - start, "the initial data is longer than address range");
+        check `${start < end} end has to be bigger than start`;
+        check `${start % PAGE_SIZE$1 === 0} start needs to be a multiple of page size (${PAGE_SIZE$1})`;
+        check `${end % PAGE_SIZE$1 === 0} end needs to be a multiple of page size (${PAGE_SIZE$1})`;
+        check `${data.length <= end - start} the initial data is longer than address range`;
         const length = end - start;
         const range = MemoryRange.fromStartAndLength(start, length);
         this.ensureNoReservedMemoryUsage(range);
@@ -14347,7 +14405,7 @@ class MemoryBuilder {
         this.ensureNotFinalized();
         const pageOffset = start % PAGE_SIZE$1;
         const remainingSpaceOnPage = PAGE_SIZE$1 - pageOffset;
-        check(data.length <= remainingSpaceOnPage, "The data has to fit into a single page.");
+        check `${data.length <= remainingSpaceOnPage} The data has to fit into a single page.`;
         const length = data.length;
         const range = MemoryRange.fromStartAndLength(start, length);
         this.ensureNoReservedMemoryUsage(range);
@@ -14361,7 +14419,10 @@ class MemoryBuilder {
         return this;
     }
     finalize(startHeapIndex, endHeapIndex) {
-        check(startHeapIndex <= endHeapIndex, `startHeapIndex (${startHeapIndex}) has to be less than or equal to endHeapIndex (${endHeapIndex})`);
+        check `
+      ${startHeapIndex <= endHeapIndex}
+      startHeapIndex (${startHeapIndex}) has to be less than or equal to endHeapIndex (${endHeapIndex})
+    `;
         this.ensureNotFinalized();
         const range = MemoryRange.fromStartAndLength(startHeapIndex, endHeapIndex - startHeapIndex);
         const pages = PageRange.fromMemoryRange(range);
@@ -14606,7 +14667,7 @@ function mulUpperSS(a, b) {
     return interpretAsSigned(resultLimitedTo64Bits);
 }
 function unsignedRightShiftBigInt(value, shift) {
-    check(shift >= 0, "Shift count must be non-negative");
+    check `${shift >= 0} Shift count must be non-negative`;
     const fillBit = value < 0 ? "1" : "0";
     // Convert the BigInt to its binary representation
     const binaryRepresentation = value.toString(2).padStart(64, fillBit);
@@ -15932,7 +15993,10 @@ class TwoRegsTwoImmsDispatcher {
 class JumpTable {
     indices;
     constructor(itemByteLength, bytes) {
-        check(itemByteLength === 0 || bytes.length % itemByteLength === 0, `Length of jump table (${bytes.length}) should be a multiple of item lenght (${itemByteLength})!`);
+        check `
+      ${itemByteLength === 0 || bytes.length % itemByteLength === 0}
+      Length of jump table (${bytes.length}) should be a multiple of item lenght (${itemByteLength})!
+    `;
         const length = itemByteLength === 0 ? 0 : bytes.length / itemByteLength;
         this.indices = new Uint32Array(length);
         for (let i = 0; i < length; i++) {
@@ -16322,7 +16386,10 @@ class ReturnValue {
         this.consumedGas = consumedGas;
         this.status = status;
         this.memorySlice = memorySlice;
-        check((status === null && memorySlice !== null) || (status !== null && memorySlice === null), "`status` and `memorySlice` must not both be null or both be non-null — exactly one must be provided");
+        check `
+      ${(status === null && memorySlice !== null) || (status !== null && memorySlice === null)}
+      'status' and 'memorySlice' must not both be null or both be non-null — exactly one must be provided
+    `;
     }
     static fromStatus(consumedGas, status) {
         return new ReturnValue(consumedGas, status, null);
@@ -16371,7 +16438,10 @@ class HostCalls {
             if (status !== Status.HOST) {
                 return this.getReturnValue(status, pvmInstance);
             }
-            check(pvmInstance.getExitParam() !== null, "We know that the exit param is not null, because the status is `Status.HOST`");
+            check `
+        ${pvmInstance.getExitParam() !== null}
+        "We know that the exit param is not null, because the status is 'Status.HOST'
+      `;
             const hostCallIndex = pvmInstance.getExitParam() ?? -1;
             const gas = pvmInstance.getGasCounter();
             const regs = new HostCallRegisters(pvmInstance.getRegisters());
@@ -16425,7 +16495,7 @@ class HostCallsManager {
     constructor({ missing, handlers = [], }) {
         this.missing = missing;
         for (const handler of handlers) {
-            check(this.hostCalls.get(handler.index) === undefined, `Overwriting host call handler at index ${handler.index}`);
+            check `${this.hostCalls.get(handler.index) === undefined} Overwriting host call handler at index ${handler.index}`;
             this.hostCalls.set(handler.index, handler);
         }
     }
@@ -16545,13 +16615,27 @@ class SpiProgram extends WithDebug {
         this.registers = registers;
     }
 }
+/**
+ * program = E_3(|o|) ++ E_3(|w|) ++ E_2(z) ++ E_3(s) ++ o ++ w ++ E_4(|c|) ++ c
+ *
+ * E_n - little endian encoding, n - length
+ * o - initial read only data
+ * w - initial heap
+ * z - heap pages filled with zeros
+ * s - stack size
+ * c - program code
+ *
+ * https://graypaper.fluffylabs.dev/#/579bd12/2b92022b9202
+ */
 function decodeStandardProgram(program, args) {
     const decoder = Decoder.fromBlob(program);
     const oLength = decoder.u24();
     const wLength = decoder.u24();
-    const argsLength = ensure(args.length, args.length <= DATA_LEGNTH, "Incorrect arguments length");
-    const readOnlyLength = ensure(oLength, oLength <= DATA_LEGNTH, "Incorrect readonly segment length");
-    const heapLength = ensure(wLength, wLength <= DATA_LEGNTH, "Incorrect heap segment length");
+    check `${args.length <= DATA_LEGNTH} Incorrect arguments length`;
+    check `${oLength <= DATA_LEGNTH} Incorrect readonly segment length`;
+    const readOnlyLength = oLength;
+    check `${wLength <= DATA_LEGNTH} Incorrect heap segment length`;
+    const heapLength = wLength;
     const noOfHeapZerosPages = decoder.u16();
     const stackSize = decoder.u24();
     const readOnlyMemory = decoder.bytes(readOnlyLength).raw;
@@ -16567,14 +16651,14 @@ function decodeStandardProgram(program, args) {
     const stackStart = STACK_SEGMENT - alignToPageSize(stackSize);
     const stackEnd = STACK_SEGMENT;
     const argsStart = ARGS_SEGMENT;
-    const argsEnd = argsStart + alignToPageSize(argsLength);
-    const argsZerosEnd = argsEnd + alignToPageSize(argsLength);
+    const argsEnd = argsStart + alignToPageSize(args.length);
+    const argsZerosEnd = argsEnd + alignToPageSize(args.length);
     function nonEmpty(s) {
         return s !== false;
     }
     const readableMemory = [
         readOnlyLength > 0 && getMemorySegment(readonlyDataStart, readonlyDataEnd, readOnlyMemory),
-        argsLength > 0 && getMemorySegment(argsStart, argsEnd, args),
+        args.length > 0 && getMemorySegment(argsStart, argsEnd, args),
         argsEnd < argsZerosEnd && getMemorySegment(argsEnd, argsZerosEnd),
     ].filter(nonEmpty);
     const writeableMemory = [
@@ -16705,7 +16789,7 @@ class DebuggerAdapter {
         return this.pvm.nextStep() === Status.OK;
     }
     nSteps(steps) {
-        check(steps >>> 0 > 0, `Expected a positive integer got ${steps}`);
+        check `${steps >>> 0 > 0} Expected a positive integer got ${steps}`;
         for (let i = 0; i < steps; i++) {
             const isOk = this.nextStep();
             if (!isOk) {
@@ -16789,7 +16873,6 @@ var index$3 = /*#__PURE__*/Object.freeze({
   clampU64ToU32: clampU64ToU32,
   createResults: createResults,
   decodeStandardProgram: decodeStandardProgram,
-  ensure: ensure,
   extractCodeAndMetadata: extractCodeAndMetadata,
   getServiceId: getServiceId,
   getServiceIdOrCurrent: getServiceIdOrCurrent,
@@ -16816,7 +16899,7 @@ const ENTROPY_BYTES = 32;
  * https://graypaper.fluffylabs.dev/#/579bd12/3b9a013b9a01
  */
 function fisherYatesShuffle(arr, entropy) {
-    check(entropy.length === ENTROPY_BYTES, `Expected entropy of length ${ENTROPY_BYTES}, got ${entropy.length}`);
+    check `${entropy.length === ENTROPY_BYTES} Expected entropy of length ${ENTROPY_BYTES}, got ${entropy.length}`;
     const n = arr.length;
     const randomNumbers = hashToNumberSequence(entropy, arr.length);
     const result = new Array(n);