@typeberry/lib 0.1.0-b2d0b72 → 0.1.0

package/index.d.ts

@@ -113,21 +113,32 @@ declare 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.
- *
- * NOTE the function is intended to be used as tagged template string for the performance
- * reasons.
  */
-declare function check(
-  strings: TemplateStringsArray,
-  condition: boolean,
-  ...data: unknown[]
-): asserts condition is true {
+declare function check(condition: boolean, message?: string): asserts condition is true {
   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 ?? ""}`);
+  }
+}
+
+declare function cast<T, U extends T>(_a: T, condition: boolean): _a is U {
+  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;
+ */
+declare function ensure<T, U extends T>(a: T, condition: boolean, message?: string): U {
+  if (cast<T, U>(a, condition)) {
+    return a;
   }
+
+  throw new Error(`Assertion failure: ${message ?? ""}`);
 }
 
 /**
@@ -358,8 +369,8 @@ type Result$2<Ok, Error> = OkResult<Ok> | ErrorResult<Error>;
 /** An indication of two possible outcomes returned from a function. */
 declare const Result$2 = {
   /** Create new [`Result`] with `Ok` status. */
-  ok: <Ok>(ok: Ok): OkResult<Ok> => {
-    check`${ok !== undefined} 'ok' type cannot be undefined.`;
+  ok: <Ok, Error>(ok: Ok): Result<Ok, Error> => {
+    check(ok !== undefined, "`Ok` type cannot be undefined.");
     return {
       isOk: true,
       isError: false,
@@ -368,8 +379,8 @@ declare const Result$2 = {
   },
 
   /** Create new [`Result`] with `Error` status. */
-  error: <Error>(error: Error, details = ""): ErrorResult<Error> => {
-    check`${error !== undefined} 'Error' type cannot be undefined.`;
+  error: <Ok, Error>(error: Error, details = ""): Result<Ok, Error> => {
+    check(error !== undefined, "`Error` type cannot be undefined.");
     return {
       isOk: false,
       isError: true,
@@ -710,8 +721,10 @@ declare const index$s_asOpaqueType: typeof asOpaqueType;
 declare const index$s_assertEmpty: typeof assertEmpty;
 declare const index$s_assertNever: typeof assertNever;
 declare const index$s_callCompareFunction: typeof callCompareFunction;
+declare const index$s_cast: typeof cast;
 declare const index$s_check: typeof check;
 declare const index$s_deepEqual: typeof deepEqual;
+declare const index$s_ensure: typeof ensure;
 declare const index$s_env: typeof env;
 declare const index$s_getAllKeysSorted: typeof getAllKeysSorted;
 declare const index$s_inspect: typeof inspect;
@@ -727,7 +740,7 @@ declare const index$s_resultToString: typeof resultToString;
 declare const index$s_seeThrough: typeof seeThrough;
 declare const index$s_trimStack: typeof trimStack;
 declare namespace index$s {
-  export { index$s_ALL_VERSIONS_IN_ORDER as ALL_VERSIONS_IN_ORDER, index$s_CURRENT_SUITE as CURRENT_SUITE, index$s_CURRENT_VERSION as CURRENT_VERSION, index$s_Compatibility as Compatibility, index$s_DEFAULT_SUITE as DEFAULT_SUITE, index$s_DEFAULT_VERSION as DEFAULT_VERSION, index$s_ErrorsCollector as ErrorsCollector, index$s_GpVersion as GpVersion, Result$2 as Result, index$s_RichTaggedError as RichTaggedError, index$s_TEST_COMPARE_USING as TEST_COMPARE_USING, index$s_TestSuite as TestSuite, index$s_WithDebug as WithDebug, index$s___OPAQUE_TYPE__ as __OPAQUE_TYPE__, index$s_asOpaqueType as asOpaqueType, index$s_assertEmpty as assertEmpty, index$s_assertNever as assertNever, index$s_callCompareFunction as callCompareFunction, index$s_check as check, index$s_deepEqual as deepEqual, index$s_env as env, index$s_getAllKeysSorted as getAllKeysSorted, index$s_inspect as inspect, index$s_isBrowser as isBrowser, index$s_isResult as isResult, index$s_isTaggedError as isTaggedError, index$s_maybeTaggedErrorToString as maybeTaggedErrorToString, index$s_measure as measure, index$s_oomWarningPrinted as oomWarningPrinted, index$s_parseCurrentSuite as parseCurrentSuite, index$s_parseCurrentVersion as parseCurrentVersion, index$s_resultToString as resultToString, index$s_seeThrough as seeThrough, index$s_trimStack as trimStack };
+  export { index$s_ALL_VERSIONS_IN_ORDER as ALL_VERSIONS_IN_ORDER, index$s_CURRENT_SUITE as CURRENT_SUITE, index$s_CURRENT_VERSION as CURRENT_VERSION, index$s_Compatibility as Compatibility, index$s_DEFAULT_SUITE as DEFAULT_SUITE, index$s_DEFAULT_VERSION as DEFAULT_VERSION, index$s_ErrorsCollector as ErrorsCollector, index$s_GpVersion as GpVersion, Result$2 as Result, index$s_RichTaggedError as RichTaggedError, index$s_TEST_COMPARE_USING as TEST_COMPARE_USING, index$s_TestSuite as TestSuite, index$s_WithDebug as WithDebug, index$s___OPAQUE_TYPE__ as __OPAQUE_TYPE__, index$s_asOpaqueType as asOpaqueType, index$s_assertEmpty as assertEmpty, index$s_assertNever as assertNever, index$s_callCompareFunction as callCompareFunction, index$s_cast as cast, index$s_check as check, index$s_deepEqual as deepEqual, index$s_ensure as ensure, index$s_env as env, index$s_getAllKeysSorted as getAllKeysSorted, index$s_inspect as inspect, index$s_isBrowser as isBrowser, index$s_isResult as isResult, index$s_isTaggedError as isTaggedError, index$s_maybeTaggedErrorToString as maybeTaggedErrorToString, index$s_measure as measure, index$s_oomWarningPrinted as oomWarningPrinted, index$s_parseCurrentSuite as parseCurrentSuite, index$s_parseCurrentVersion as parseCurrentVersion, index$s_resultToString as resultToString, index$s_seeThrough as seeThrough, index$s_trimStack as trimStack };
   export type { index$s_DeepEqualOptions as DeepEqualOptions, index$s_EnumMapping as EnumMapping, index$s_ErrorResult as ErrorResult, index$s_OK as OK, index$s_OkResult as OkResult, index$s_Opaque as Opaque, index$s_StringLiteral as StringLiteral, index$s_TaggedError as TaggedError, index$s_TokenOf as TokenOf, index$s_Uninstantiable as Uninstantiable, index$s_WithOpaque as WithOpaque };
 }
 
@@ -912,7 +925,7 @@ declare class BytesBlob {
 
   /** Create a new [`BytesBlob`] from an array of bytes. */
   static blobFromNumbers(v: number[]): BytesBlob {
-    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);
   }
@@ -962,7 +975,7 @@ declare class Bytes<T extends number> extends BytesBlob {
 
   private constructor(raw: Uint8Array, len: T) {
     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;
   }
 
@@ -973,7 +986,7 @@ declare class Bytes<T extends number> extends BytesBlob {
 
   /** Create new [`Bytes<X>`] given an array of bytes and it's length. */
   static fromNumbers<X extends number>(v: number[], len: X): Bytes<X> {
-    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);
   }
@@ -986,7 +999,7 @@ declare class Bytes<T extends number> 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<X extends number>(len: X, input: number): Bytes<X> {
-    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;
@@ -1014,7 +1027,7 @@ declare class Bytes<T extends number> extends BytesBlob {
 
   /** Compare the sequence to another one. */
   isEqualTo(other: Bytes<T>): boolean {
-    check`${this.length === other.length} Comparing incorrectly typed bytes!`;
+    check(this.length === other.length, "Comparing incorrectly typed bytes!");
     return u8ArraySameLengthEqual(this.raw, other.raw);
   }
 
@@ -1025,7 +1038,7 @@ declare class Bytes<T extends number> extends BytesBlob {
 }
 
 declare function byteFromString(s: string): number {
-  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;
@@ -1111,10 +1124,10 @@ declare class BitVec {
     private readonly data: Uint8Array,
     public readonly bitLength: number,
   ) {
-    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);
   }
@@ -1126,10 +1139,10 @@ declare class BitVec {
 
   /** Perform OR operation on all bits in place. */
   sumWith(other: BitVec) {
-    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++) {
@@ -1141,7 +1154,7 @@ declare class BitVec {
    * Set the bit at index `idx` to value `val`.
    */
   setBit(idx: number, val: boolean) {
-    check`${idx >= 0 && idx < this.bitLength} Index out of bounds. Need ${idx} has ${this.bitLength}.`;
+    check(idx < this.bitLength, `Index out of bounds. Need ${idx} has ${this.bitLength}.`);
 
     const byteIndex = Math.floor(idx / 8);
     const bitIndexInByte = idx % 8;
@@ -1157,7 +1170,7 @@ declare class BitVec {
    * Return `true` if the bit at index `idx` is set.
    */
   isSet(idx: number): boolean {
-    check`${idx >= 0 && idx < this.bitLength} Index out of bounds. Need ${idx} has ${this.bitLength}.`;
+    check(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;
@@ -1228,7 +1241,7 @@ declare const __REPRESENTATION_BYTES__: "REPRESENTATION_BYTES";
 type WithBytesRepresentation<Bytes extends number> = {
   readonly [__REPRESENTATION_BYTES__]: Bytes;
 };
-declare const asTypedNumber = <T, N extends number>(v: T): T & WithBytesRepresentation<N> =>
+declare const asWithBytesRepresentation = <T, N extends number>(v: T): T & WithBytesRepresentation<N> =>
   v as T & WithBytesRepresentation<N>;
 
 type FixedSizeNumber<Bytes extends number> = number & WithBytesRepresentation<Bytes>;
@@ -1247,27 +1260,20 @@ type U64 = bigint & WithBytesRepresentation<8>;
 declare const MAX_VALUE_U64 = 0xffff_ffff_ffff_ffffn;
 
 /** Attempt to cast an input number into U8. */
-declare const tryAsU8 = (v: number): U8 => {
-  check`${isU8(v)} input must have one-byte representation, got ${v}`;
-  return asTypedNumber(v);
-};
+declare const tryAsU8 = (v: number): U8 =>
+  ensure<number, U8>(v, isU8(v), `input must have one-byte representation, got ${v}`);
 /** Check if given number is a valid U8 number. */
 declare const isU8 = (v: number): v is U8 => (v & MAX_VALUE_U8) === v;
 
 /** Attempt to cast an input number into U16. */
-declare const tryAsU16 = (v: number): U16 => {
-  check`${isU16(v)} input must have two-byte representation, got ${v}`;
-  return asTypedNumber(v);
-};
-
+declare const tryAsU16 = (v: number): U16 =>
+  ensure<number, U16>(v, isU16(v), `input must have two-byte representation, got ${v}`);
 /** Check if given number is a valid U16 number. */
 declare const isU16 = (v: number): v is U16 => (v & MAX_VALUE_U16) === v;
 
 /** Attempt to cast an input number into U32. */
-declare const tryAsU32 = (v: number): U32 => {
-  check`${isU32(v)} input must have four-byte representation, got ${v}`;
-  return asTypedNumber(v);
-};
+declare const tryAsU32 = (v: number): U32 =>
+  ensure<number, U32>(v, isU32(v), `input must have four-byte representation, got ${v}`);
 
 /** Check if given number is a valid U32 number. */
 declare const isU32 = (v: number): v is U32 => (v & MAX_VALUE_U32) >>> 0 === v;
@@ -1275,28 +1281,25 @@ declare const isU32 = (v: number): v is U32 => (v & MAX_VALUE_U32) >>> 0 === v;
 /** Attempt to cast an input number into U64. */
 declare const tryAsU64 = (x: number | bigint): U64 => {
   const v = BigInt(x);
-  check`${isU64(v)} input must have eight-byte representation, got ${x}`;
-  return asTypedNumber(v);
+  return ensure<bigint, U64>(v, isU64(v), `input must have eight-byte representation, got ${x}`);
 };
-
 /** Check if given number is a valid U64 number. */
 declare const isU64 = (v: bigint): v is U64 => (v & MAX_VALUE_U64) === v;
 
 /** Collate two U32 parts into one U64. */
 declare const u64FromParts = ({ lower, upper }: { lower: U32; upper: U32 }): U64 => {
   const val = (BigInt(upper) << 32n) + BigInt(lower);
-  return asTypedNumber(val);
+  return asWithBytesRepresentation(val);
 };
 
 /** Split U64 into lower & upper parts. */
 declare const u64IntoParts = (v: U64): { lower: U32; upper: U32 } => {
-  // Number(...) safe: both parts are <= 0xffffffff
-  const lower = Number(v & (2n ** 32n - 1n));
-  const upper = Number(v >> 32n);
+  const lower = v & (2n ** 32n - 1n);
+  const upper = v >> 32n;
 
   return {
-    lower: asTypedNumber(lower),
-    upper: asTypedNumber(upper),
+    lower: asWithBytesRepresentation(Number(lower)),
+    upper: asWithBytesRepresentation(Number(upper)),
   };
 };
 
@@ -1353,8 +1356,10 @@ declare function u32AsLeBytes(value: U32): Uint8Array {
  * Interpret 4-byte `Uint8Array` as U32 written as little endian.
  */
 declare function leBytesAsU32(uint8Array: Uint8Array): U32 {
-  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));
+  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),
+  );
 }
 
 /** Get the smallest value between U64 a and values given as input parameters. */
@@ -1374,7 +1379,7 @@ type index$p_U64 = U64;
 type index$p_U8 = U8;
 type index$p_WithBytesRepresentation<Bytes extends number> = WithBytesRepresentation<Bytes>;
 declare const index$p___REPRESENTATION_BYTES__: typeof __REPRESENTATION_BYTES__;
-declare const index$p_asTypedNumber: typeof asTypedNumber;
+declare const index$p_asWithBytesRepresentation: typeof asWithBytesRepresentation;
 declare const index$p_isU16: typeof isU16;
 declare const index$p_isU32: typeof isU32;
 declare const index$p_isU64: typeof isU64;
@@ -1392,7 +1397,7 @@ declare const index$p_u32AsLeBytes: typeof u32AsLeBytes;
 declare const index$p_u64FromParts: typeof u64FromParts;
 declare const index$p_u64IntoParts: typeof u64IntoParts;
 declare namespace index$p {
-  export { index$p_MAX_VALUE_U16 as MAX_VALUE_U16, index$p_MAX_VALUE_U32 as MAX_VALUE_U32, index$p_MAX_VALUE_U64 as MAX_VALUE_U64, index$p_MAX_VALUE_U8 as MAX_VALUE_U8, index$p___REPRESENTATION_BYTES__ as __REPRESENTATION_BYTES__, index$p_asTypedNumber as asTypedNumber, index$p_isU16 as isU16, index$p_isU32 as isU32, index$p_isU64 as isU64, index$p_isU8 as isU8, index$p_leBytesAsU32 as leBytesAsU32, index$p_maxU64 as maxU64, index$p_minU64 as minU64, index$p_sumU32 as sumU32, index$p_sumU64 as sumU64, index$p_tryAsU16 as tryAsU16, index$p_tryAsU32 as tryAsU32, index$p_tryAsU64 as tryAsU64, index$p_tryAsU8 as tryAsU8, index$p_u32AsLeBytes as u32AsLeBytes, index$p_u64FromParts as u64FromParts, index$p_u64IntoParts as u64IntoParts };
+  export { index$p_MAX_VALUE_U16 as MAX_VALUE_U16, index$p_MAX_VALUE_U32 as MAX_VALUE_U32, index$p_MAX_VALUE_U64 as MAX_VALUE_U64, index$p_MAX_VALUE_U8 as MAX_VALUE_U8, index$p___REPRESENTATION_BYTES__ as __REPRESENTATION_BYTES__, index$p_asWithBytesRepresentation as asWithBytesRepresentation, index$p_isU16 as isU16, index$p_isU32 as isU32, index$p_isU64 as isU64, index$p_isU8 as isU8, index$p_leBytesAsU32 as leBytesAsU32, index$p_maxU64 as maxU64, index$p_minU64 as minU64, index$p_sumU32 as sumU32, index$p_sumU64 as sumU64, index$p_tryAsU16 as tryAsU16, index$p_tryAsU32 as tryAsU32, index$p_tryAsU64 as tryAsU64, index$p_tryAsU8 as tryAsU8, index$p_u32AsLeBytes as u32AsLeBytes, index$p_u64FromParts as u64FromParts, index$p_u64IntoParts as u64IntoParts };
   export type { index$p_FixedSizeNumber as FixedSizeNumber, Result$1 as Result, index$p_U16 as U16, index$p_U32 as U32, index$p_U64 as U64, index$p_U8 as U8, index$p_WithBytesRepresentation as WithBytesRepresentation };
 }
 
@@ -1731,7 +1736,7 @@ declare class Decoder {
     if (this.offset < newOffset) {
       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;
     }
   }
@@ -1763,7 +1768,7 @@ declare class Decoder {
   }
 
   private ensureHasBytes(bytes: number) {
-    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}.`,
@@ -1774,7 +1779,7 @@ declare class Decoder {
 
 declare const MASKS = [0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80];
 declare function decodeVariableLengthExtraBytes(firstByte: number) {
-  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;
@@ -1793,7 +1798,7 @@ type SizeHint = {
 };
 
 declare function tryAsExactBytes(a: SizeHint): number {
-  check`${a.isExact} The value is not exact size estimation!`;
+  check(a.isExact, "The value is not exact size estimation!");
   return a.bytes;
 }
 
@@ -1952,8 +1957,8 @@ declare 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);
@@ -2023,8 +2028,8 @@ declare 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);
   }
@@ -2037,8 +2042,8 @@ declare class Encoder {
    * https://graypaper.fluffylabs.dev/#/579bd12/365202365202
    */
   varU32(num: U32) {
-    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));
   }
 
@@ -2206,7 +2211,7 @@ declare class Encoder {
    * https://graypaper.fluffylabs.dev/#/579bd12/374400374400
    */
   sequenceVarLen<T>(encode: Encode<T>, elements: readonly T[]) {
-    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);
   }
@@ -2229,7 +2234,7 @@ declare class Encoder {
    * anyway, so if we really should throw we will.
    */
   private ensureBigEnough(length: number, options: { silent: boolean } = { silent: false }) {
-    check`${length >= 0} Negative length given`;
+    check(length >= 0, "Negative length given");
 
     const newLength = this.offset + length;
     if (newLength > MAX_LENGTH) {
@@ -2589,12 +2594,13 @@ declare abstract class ObjectView<T> {
   private decodeUpTo<K extends keyof T>(field: K): ViewField<T[K], unknown> {
     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);
@@ -2617,11 +2623,12 @@ declare abstract class ObjectView<T> {
       this.lastDecodedFieldIdx = i;
     }
 
-    if (lastItem === undefined) {
-      throw new Error("Last item must be set, since the loop turns at least once.");
-    }
-
-    return lastItem as ViewField<T[K], unknown>;
+    const last: ViewField<T[K], unknown> = ensure(
+      lastItem,
+      lastItem !== undefined,
+      "Last item must be set, since the loop turns at least once.",
+    );
+    return last;
   }
 }
 
@@ -2657,10 +2664,12 @@ declare class SequenceView<T, V = T> {
   *[Symbol.iterator]() {
     for (let i = 0; i < this.length; i++) {
       const val = this.get(i);
-      if (val === undefined) {
-        throw new Error("We are within 0..this.length so all items are defined.");
-      }
-      yield val;
+      const v: ViewField<T, V> = ensure(
+        val,
+        val !== undefined,
+        "We are within 0..this.length so all items are defined.",
+      );
+      yield v;
     }
   }
 
@@ -2710,10 +2719,10 @@ declare class SequenceView<T, V = T> {
   }
 
   private decodeUpTo(index: number): ViewField<T, V> {
-    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);
 
@@ -2734,10 +2743,12 @@ declare class SequenceView<T, V = T> {
       this.lastDecodedIdx = i;
     }
 
-    if (lastItem === undefined) {
-      throw new Error("Last item must be set, since the loop turns at least once.");
-    }
-    return lastItem;
+    const last: ViewField<T, V> = ensure(
+      lastItem,
+      lastItem !== undefined,
+      "Last item must be set, since the loop turns at least once.",
+    );
+    return last;
   }
 }
 
@@ -2763,10 +2774,7 @@ declare const TYPICAL_DICTIONARY_LENGTH = 32;
 declare function readonlyArray<T, V>(desc: Descriptor<T[], V>): Descriptor<readonly T[], V> {
   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 as T[];
@@ -3439,8 +3447,6 @@ type KeccakHash = Bytes<HASH_SIZE>;
 /** Truncated hash. */
 type TruncatedHash = Bytes<TRUNCATED_HASH_SIZE>;
 
-declare const ZERO_HASH = Bytes.zero(HASH_SIZE);
-
 /**
  * Container for some object with a hash that is related to this object.
  *
@@ -3489,7 +3495,7 @@ declare class PageAllocator implements HashAllocator {
 
   // TODO [ToDr] Benchmark the performance!
   constructor(private readonly hashesPerPage: number) {
-    check`${hashesPerPage > 0 && hashesPerPage >>> 0 === hashesPerPage} Expected a non-zero integer.`;
+    check(hashesPerPage > 0 && hashesPerPage >>> 0 === hashesPerPage, "Expected a non-zero integer.");
     this.resetPage();
   }
 
@@ -3649,12 +3655,11 @@ type index$n_WithHash<THash extends OpaqueHash, TData> = WithHash<THash, TData>;
 declare const index$n_WithHash: typeof WithHash;
 type index$n_WithHashAndBytes<THash extends OpaqueHash, TData> = WithHashAndBytes<THash, TData>;
 declare const index$n_WithHashAndBytes: typeof WithHashAndBytes;
-declare const index$n_ZERO_HASH: typeof ZERO_HASH;
 declare const index$n_blake2b: typeof blake2b;
 declare const index$n_defaultAllocator: typeof defaultAllocator;
 declare const index$n_keccak: typeof keccak;
 declare namespace index$n {
-  export { index$n_PageAllocator as PageAllocator, index$n_SimpleAllocator as SimpleAllocator, index$n_WithHash as WithHash, index$n_WithHashAndBytes as WithHashAndBytes, index$n_ZERO_HASH as ZERO_HASH, index$n_blake2b as blake2b, index$n_defaultAllocator as defaultAllocator, index$n_keccak as keccak };
+  export { index$n_PageAllocator as PageAllocator, index$n_SimpleAllocator as SimpleAllocator, index$n_WithHash as WithHash, index$n_WithHashAndBytes as WithHashAndBytes, index$n_blake2b as blake2b, index$n_defaultAllocator as defaultAllocator, index$n_keccak as keccak };
   export type { index$n_Blake2bHash as Blake2bHash, index$n_HASH_SIZE as HASH_SIZE, index$n_HashAllocator as HashAllocator, index$n_KeccakHash as KeccakHash, index$n_OpaqueHash as OpaqueHash, index$n_TRUNCATED_HASH_SIZE as TRUNCATED_HASH_SIZE, index$n_TruncatedHash as TruncatedHash };
 }
 
@@ -3871,8 +3876,8 @@ declare class MultiMap<TKeys extends readonly unknown[], TValue> {
    * if needed.
    */
   constructor(keysLength: TKeys["length"], keyMappers?: KeyMappers<TKeys>) {
-    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() as NestedMaps<TKeys, TValue>;
     this.keyMappers = keyMappers === undefined ? (Array(keysLength).fill(null) as KeyMappers<TKeys>) : keyMappers;
   }
@@ -3997,7 +4002,7 @@ declare class FixedSizeArray<T, N extends number> extends Array<T> {
   }
 
   static new<T, N extends number>(data: readonly T[], len: N): FixedSizeArray<T, N> {
-    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<T, N>(len);
 
@@ -4185,7 +4190,7 @@ declare class SortedArray<V> implements ImmutableSortedArray<V> {
 
   /** Create a new SortedSet from two sorted collections. */
   static fromTwoSortedCollections<V>(first: ImmutableSortedArray<V>, second: ImmutableSortedArray<V>) {
-    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;
@@ -4322,7 +4327,7 @@ declare class SortedSet<V> extends SortedArray<V> implements ImmutableSortedSet<
 
   /** Create a new SortedSet from two sorted collections. */
   static fromTwoSortedCollections<V>(first: ImmutableSortedArray<V>, second: ImmutableSortedArray<V>) {
-    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) {
@@ -4592,7 +4597,7 @@ type BlsKey = Opaque<Bytes<BLS_KEY_BYTES>, "BlsKey">;
 declare function publicKey(seed: Uint8Array): BandersnatchKey {
   const key = bandersnatch.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();
 }
@@ -4698,7 +4703,7 @@ declare async function verify<T extends BytesBlob>(input: Input<T>[]): Promise<b
     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);
@@ -5253,10 +5258,10 @@ declare const tryAsEpoch = (v: number): Epoch => asOpaqueType(tryAsU32(v));
 /** One entry of `T` per one validator. */
 type PerValidator<T> = KnownSizeArray<T, "ValidatorsCount">;
 declare function tryAsPerValidator<T>(array: T[], spec: ChainSpec): PerValidator<T> {
-  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);
 }
 declare const codecPerValidator = <T, V>(val: Descriptor<T, V>): Descriptor<PerValidator<T>, SequenceView<T, V>> =>
@@ -5269,10 +5274,10 @@ declare const codecPerValidator = <T, V>(val: Descriptor<T, V>): Descriptor<PerV
 /** One entry of `T` per one block in epoch. */
 type PerEpochBlock<T> = KnownSizeArray<T, "EpochLength">;
 declare function tryAsPerEpochBlock<T>(array: T[], spec: ChainSpec): PerEpochBlock<T> {
-  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);
 }
 declare const codecPerEpochBlock = <T, V>(val: Descriptor<T, V>): Descriptor<PerEpochBlock<T>, SequenceView<T, V>> =>
@@ -5887,11 +5892,11 @@ type WorkItemsCount = U8;
 
 /** Verify the value is within the `WorkItemsCount` bounds. */
 declare function tryAsWorkItemsCount(len: number): WorkItemsCount {
-  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);
+  return ensure<number, WorkItemsCount>(
+    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}`,
+  );
 }
 
 /** Minimal number of work items in the work package or results in work report. */
@@ -8314,13 +8319,13 @@ declare class TrieNode {
 
   /** View this node as a branch node */
   asBranchNode(): BranchNode {
-    check`${this.getNodeType() === NodeType.Branch} not a branch!`;
+    check(this.getNodeType() === NodeType.Branch);
     return new BranchNode(this);
   }
 
   /** View this node as a leaf node */
   asLeafNode(): LeafNode {
-    check`${this.getNodeType() !== NodeType.Branch} not a leaf!`;
+    check(this.getNodeType() !== NodeType.Branch);
     return new LeafNode(this);
   }
 
@@ -8861,7 +8866,7 @@ declare function createSubtreeForBothLeaves(
  * Return a single bit from `key` located at `bitIndex`.
  */
 declare function getBit(key: TruncatedStateKey, bitIndex: number): boolean {
-  check`${bitIndex < TRUNCATED_KEY_BITS} invalid bit index passed ${bitIndex}`;
+  check(bitIndex < TRUNCATED_KEY_BITS);
   const byte = bitIndex >>> 3;
   const bit = bitIndex - (byte << 3);
   const mask = 0b10_00_00_00 >>> bit;
@@ -9081,10 +9086,10 @@ declare class AvailabilityAssignment extends WithDebug {
 type PerCore<T> = KnownSizeArray<T, "number of cores">;
 /** Check if given array has correct length before casting to the opaque type. */
 declare function tryAsPerCore<T>(array: T[], spec: ChainSpec): PerCore<T> {
-  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);
 }
 declare const codecPerCore = <T, V>(val: Descriptor<T, V>): Descriptor<PerCore<T>, SequenceView<T, V>> =>
@@ -10787,7 +10792,7 @@ declare class InMemoryState extends WithDebug implements State, EnumerableState
 
   private removeServices(servicesRemoved: ServiceId[] | undefined) {
     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);
     }
   }
@@ -10808,10 +10813,10 @@ declare class InMemoryState extends WithDebug implements State, EnumerableState
         service.data.storage.set(key.toString(), StorageItem.create({ key, value }));
       } 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 {
         assertNever(kind);
@@ -12445,6 +12450,7 @@ declare const N_CHUNKS_REDUNDANCY = 681;
 /** Total number of chunks generated by EC. */
 declare const N_CHUNKS_TOTAL = 1023;
 type N_CHUNKS_TOTAL = typeof N_CHUNKS_TOTAL;
+// 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.
@@ -12461,11 +12467,7 @@ type POINT_LENGTH = typeof POINT_LENGTH;
 
 declare const PIECE_SIZE = 684;
 type PIECE_SIZE = typeof PIECE_SIZE;
-
-declare 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}`;
-}
+// check(PIECE_SIZE === N_CHUNKS_REQUIRED * POINT_LENGTH);
 
 /**
  * Takes arbitrarily long input data, padds it to multiple of `PIECE_SIZE` and returns
@@ -12504,11 +12506,11 @@ declare function decodeDataAndTrim(
 declare function decodeData(input: FixedSizeArray<[number, BytesBlob], N_CHUNKS_REQUIRED>): BytesBlob {
   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);
 
@@ -12599,7 +12601,7 @@ declare function decodePiece(
     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
@@ -12627,7 +12629,7 @@ declare function decodePiece(
  * https://graypaper.fluffylabs.dev/#/9a08063/3eb4013eb401?v=0.6.6
  */
 declare function split<N extends number, K extends number>(input: BytesBlob, n: N, k: K): FixedSizeArray<Bytes<N>, K> {
-  check`${n * k === input.length}`;
+  check(n * k === input.length);
   const result: Bytes<N>[] = [];
   for (let i = 0; i < k; i++) {
     const start = i * n;
@@ -12750,7 +12752,7 @@ declare function transpose<T, N extends number, K extends number>(
  */
 declare function chunkingFunction(input: BytesBlob): FixedSizeArray<BytesBlob, N_CHUNKS_TOTAL> {
   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<PIECE_SIZE, typeof k>(input, PIECE_SIZE, k);
@@ -12773,10 +12775,10 @@ declare function shardsToChunks(spec: ChainSpec, shards: PerValidator<BytesBlob>
   const result: [number, BytesBlob][][] = [];
 
   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);
@@ -12839,7 +12841,6 @@ type index$9_N_CHUNKS_TOTAL = N_CHUNKS_TOTAL;
 type index$9_PIECE_SIZE = PIECE_SIZE;
 declare const index$9_POINT_ALIGNMENT: typeof POINT_ALIGNMENT;
 type index$9_POINT_LENGTH = POINT_LENGTH;
-declare const index$9_checkConsistency: typeof checkConsistency;
 declare const index$9_chunkingFunction: typeof chunkingFunction;
 declare const index$9_chunksToShards: typeof chunksToShards;
 declare const index$9_decodeData: typeof decodeData;
@@ -12855,7 +12856,7 @@ declare const index$9_split: typeof split;
 declare const index$9_transpose: typeof transpose;
 declare const index$9_unzip: typeof unzip;
 declare namespace index$9 {
-  export { index$9_HALF_POINT_SIZE as HALF_POINT_SIZE, index$9_N_CHUNKS_REDUNDANCY as N_CHUNKS_REDUNDANCY, index$9_POINT_ALIGNMENT as POINT_ALIGNMENT, index$9_checkConsistency as checkConsistency, index$9_chunkingFunction as chunkingFunction, index$9_chunksToShards as chunksToShards, index$9_decodeData as decodeData, index$9_decodeDataAndTrim as decodeDataAndTrim, index$9_decodePiece as decodePiece, index$9_encodePoints as encodePoints, index$9_initEc as initEc, index$9_join as join, index$9_lace as lace, index$9_padAndEncodeData as padAndEncodeData, index$9_shardsToChunks as shardsToChunks, index$9_split as split, index$9_transpose as transpose, index$9_unzip as unzip };
+  export { index$9_HALF_POINT_SIZE as HALF_POINT_SIZE, index$9_N_CHUNKS_REDUNDANCY as N_CHUNKS_REDUNDANCY, index$9_POINT_ALIGNMENT as POINT_ALIGNMENT, index$9_chunkingFunction as chunkingFunction, index$9_chunksToShards as chunksToShards, index$9_decodeData as decodeData, index$9_decodeDataAndTrim as decodeDataAndTrim, index$9_decodePiece as decodePiece, index$9_encodePoints as encodePoints, index$9_initEc as initEc, index$9_join as join, index$9_lace as lace, index$9_padAndEncodeData as padAndEncodeData, index$9_shardsToChunks as shardsToChunks, index$9_split as split, index$9_transpose as transpose, index$9_unzip as unzip };
   export type { index$9_N_CHUNKS_REQUIRED as N_CHUNKS_REQUIRED, index$9_N_CHUNKS_TOTAL as N_CHUNKS_TOTAL, index$9_PIECE_SIZE as PIECE_SIZE, index$9_POINT_LENGTH as POINT_LENGTH };
 }
 
@@ -13227,7 +13228,7 @@ declare class Mask {
   }
 
   getNoOfBytesToNextInstruction(index: number) {
-    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);
   }
 
@@ -13377,13 +13378,13 @@ declare class Registers {
   private asUnsigned: BigUint64Array;
 
   constructor(private readonly bytes = new Uint8Array(NO_OF_REGISTERS << REGISTER_SIZE_SHIFT)) {
-    check`${bytes.length === NO_OF_REGISTERS << REGISTER_SIZE_SHIFT} Invalid size of registers array.`;
+    check(bytes.length === NO_OF_REGISTERS << 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: Uint8Array) {
-    check`${bytes.length === NO_OF_REGISTERS << REGISTER_SIZE_SHIFT} Invalid size of registers array.`;
+    check(bytes.length === NO_OF_REGISTERS << REGISTER_SIZE_SHIFT, "Invalid size of registers array.");
     return new Registers(bytes);
   }
 
@@ -14269,17 +14270,13 @@ declare class InstructionResult {
 
 type MemoryIndex = Opaque<number, "memory index">;
 
-declare const tryAsMemoryIndex = (index: number): MemoryIndex => {
-  check`${index >= 0 && index <= MAX_MEMORY_INDEX} Incorrect memory index: ${index}!`;
-  return asOpaqueType(index);
-};
+declare const tryAsMemoryIndex = (index: number): MemoryIndex =>
+  ensure(index, index >= 0 && index <= MAX_MEMORY_INDEX, `Incorrect memory index: ${index}!`);
 
 type SbrkIndex = Opaque<number, "sbrk index">;
 
-declare const tryAsSbrkIndex = (index: number): SbrkIndex => {
-  check`${index >= 0 && index <= MAX_MEMORY_INDEX + 1} Incorrect sbrk index: ${index}!`;
-  return asOpaqueType(index);
-};
+declare const tryAsSbrkIndex = (index: number): SbrkIndex =>
+  ensure(index, index >= 0 && index <= MAX_MEMORY_INDEX + 1, `Incorrect sbrk index: ${index}!`);
 
 type PageIndex = Opaque<number, "memory page index">;
 type PageNumber = Opaque<number, "memory page number">;
@@ -14648,10 +14645,10 @@ declare class MemoryBuilder {
    */
   setReadablePages(start: MemoryIndex, end: MemoryIndex, data: Uint8Array = new Uint8Array()) {
     this.ensureNotFinalized();
-    check`${start < end} end has to be bigger than start`;
-    check`${start % PAGE_SIZE === 0} start needs to be a multiple of page size (${PAGE_SIZE})`;
-    check`${end % PAGE_SIZE === 0} end needs to be a multiple of page size (${PAGE_SIZE})`;
-    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 === 0, `start needs to be a multiple of page size (${PAGE_SIZE})`);
+    check(end % PAGE_SIZE === 0, `end needs to be a multiple of page size (${PAGE_SIZE})`);
+    check(data.length <= end - start, "the initial data is longer than address range");
 
     const length = end - start;
     const range = MemoryRange.fromStartAndLength(start, length);
@@ -14682,10 +14679,10 @@ declare class MemoryBuilder {
    */
   setWriteablePages(start: MemoryIndex, end: MemoryIndex, data: Uint8Array = new Uint8Array()) {
     this.ensureNotFinalized();
-    check`${start < end} end has to be bigger than start`;
-    check`${start % PAGE_SIZE === 0} start needs to be a multiple of page size (${PAGE_SIZE})`;
-    check`${end % PAGE_SIZE === 0} end needs to be a multiple of page size (${PAGE_SIZE})`;
-    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 === 0, `start needs to be a multiple of page size (${PAGE_SIZE})`);
+    check(end % PAGE_SIZE === 0, `end needs to be a multiple of page size (${PAGE_SIZE})`);
+    check(data.length <= end - start, "the initial data is longer than address range");
 
     const length = end - start;
     const range = MemoryRange.fromStartAndLength(start, length);
@@ -14713,7 +14710,7 @@ declare class MemoryBuilder {
     this.ensureNotFinalized();
     const pageOffset = start % PAGE_SIZE;
     const remainingSpaceOnPage = PAGE_SIZE - 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);
@@ -14734,10 +14731,10 @@ declare class MemoryBuilder {
   }
 
   finalize(startHeapIndex: MemoryIndex, endHeapIndex: SbrkIndex): Memory {
-    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);
@@ -15070,10 +15067,10 @@ declare class JumpTable {
   private indices: Uint32Array;
 
   constructor(itemByteLength: number, bytes: Uint8Array) {
-    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;
 
@@ -17281,8 +17278,8 @@ declare class PartiallyUpdatedState<T extends StateSlice = StateSlice> {
     bytes: bigint,
     serviceInfo: ServiceAccountInfo,
   ): Result$2<OK, InsufficientFundsError> {
-    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);
@@ -17487,7 +17484,7 @@ declare class HostCallsManager {
     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);
     }
   }
@@ -17559,10 +17556,10 @@ declare class ReturnValue {
     public status: Status | null,
     public memorySlice: Uint8Array | null,
   ) {
-    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: Gas, status: Status) {
@@ -17620,10 +17617,10 @@ declare 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());
@@ -17732,7 +17729,7 @@ declare function getServiceId(serviceId: U64): ServiceId | null {
 }
 
 declare function writeServiceIdAsLeBytes(serviceId: ServiceId, destination: Uint8Array) {
-  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));
 }
 
@@ -17808,6 +17805,20 @@ declare namespace index$6 {
 
 declare const NO_OF_REGISTERS = 13;
 
+/**
+ * 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
+ */
+type InputLength = Opaque<number, "Number that is lower than 2 ** 24 (Z_I from GP)">;
+
 declare class MemorySegment extends WithDebug {
   static from({ start, end, data }: Omit<MemorySegment, never>) {
     return new MemorySegment(start, end, data);
@@ -17842,27 +17853,17 @@ declare class SpiProgram extends WithDebug {
   }
 }
 
-/**
- * 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
- */
 declare function decodeStandardProgram(program: Uint8Array, args: Uint8Array) {
   const decoder = Decoder.fromBlob(program);
   const oLength = decoder.u24();
   const wLength = decoder.u24();
-  check`${args.length <= DATA_LENGTH} Incorrect arguments length`;
-  check`${oLength <= DATA_LENGTH} Incorrect readonly segment length`;
-  const readOnlyLength = oLength;
-  check`${wLength <= DATA_LENGTH} Incorrect heap segment length`;
-  const heapLength = wLength;
+  const argsLength = ensure<number, InputLength>(args.length, args.length <= DATA_LEGNTH, "Incorrect arguments length");
+  const readOnlyLength = ensure<number, InputLength>(
+    oLength,
+    oLength <= DATA_LEGNTH,
+    "Incorrect readonly segment length",
+  );
+  const heapLength = ensure<number, InputLength>(wLength, wLength <= DATA_LEGNTH, "Incorrect heap segment length");
   const noOfHeapZerosPages = decoder.u16();
   const stackSize = decoder.u24();
   const readOnlyMemory = decoder.bytes(readOnlyLength).raw;
@@ -17879,8 +17880,8 @@ declare function decodeStandardProgram(program: Uint8Array, args: Uint8Array) {
   const stackStart = STACK_SEGMENT - alignToPageSize(stackSize);
   const stackEnd = STACK_SEGMENT;
   const argsStart = ARGS_SEGMENT;
-  const argsEnd = argsStart + alignToPageSize(args.length);
-  const argsZerosEnd = argsEnd + alignToPageSize(args.length);
+  const argsEnd = argsStart + alignToPageSize(argsLength);
+  const argsZerosEnd = argsEnd + alignToPageSize(argsLength);
 
   function nonEmpty(s: MemorySegment | false): s is MemorySegment {
     return s !== false;
@@ -17888,7 +17889,7 @@ declare function decodeStandardProgram(program: Uint8Array, args: Uint8Array) {
 
   const readableMemory = [
     readOnlyLength > 0 && getMemorySegment(readonlyDataStart, readonlyDataEnd, readOnlyMemory),
-    args.length > 0 && getMemorySegment(argsStart, argsEnd, args),
+    argsLength > 0 && getMemorySegment(argsStart, argsEnd, args),
     argsEnd < argsZerosEnd && getMemorySegment(argsEnd, argsZerosEnd),
   ].filter(nonEmpty);
   const writeableMemory = [
@@ -17920,6 +17921,7 @@ declare function getRegisters(argsLength: number) {
   return regs;
 }
 
+type index$5_InputLength = InputLength;
 type index$5_MemorySegment = MemorySegment;
 declare const index$5_MemorySegment: typeof MemorySegment;
 declare const index$5_NO_OF_REGISTERS: typeof NO_OF_REGISTERS;
@@ -17931,15 +17933,8 @@ declare const index$5_decodeStandardProgram: typeof decodeStandardProgram;
 declare const index$5_getMemorySegment: typeof getMemorySegment;
 declare const index$5_getRegisters: typeof getRegisters;
 declare namespace index$5 {
-  export {
-    index$5_MemorySegment as MemorySegment,
-    index$5_NO_OF_REGISTERS as NO_OF_REGISTERS,
-    index$5_SpiMemory as SpiMemory,
-    index$5_SpiProgram as SpiProgram,
-    index$5_decodeStandardProgram as decodeStandardProgram,
-    index$5_getMemorySegment as getMemorySegment,
-    index$5_getRegisters as getRegisters,
-  };
+  export { index$5_MemorySegment as MemorySegment, index$5_NO_OF_REGISTERS as NO_OF_REGISTERS, index$5_SpiMemory as SpiMemory, index$5_SpiProgram as SpiProgram, index$5_decodeStandardProgram as decodeStandardProgram, index$5_getMemorySegment as getMemorySegment, index$5_getRegisters as getRegisters };
+  export type { index$5_InputLength as InputLength };
 }
 
 declare class Program {
@@ -18062,7 +18057,7 @@ declare class DebuggerAdapter {
   }
 
   nSteps(steps: number): boolean {
-    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) {
@@ -18199,10 +18194,12 @@ declare const index$3___OPAQUE_TYPE__: typeof __OPAQUE_TYPE__;
 declare const index$3_asOpaqueType: typeof asOpaqueType;
 declare const index$3_assertEmpty: typeof assertEmpty;
 declare const index$3_assertNever: typeof assertNever;
+declare const index$3_cast: typeof cast;
 declare const index$3_check: typeof check;
 declare const index$3_clampU64ToU32: typeof clampU64ToU32;
 declare const index$3_createResults: typeof createResults;
 declare const index$3_decodeStandardProgram: typeof decodeStandardProgram;
+declare const index$3_ensure: typeof ensure;
 declare const index$3_extractCodeAndMetadata: typeof extractCodeAndMetadata;
 declare const index$3_getServiceId: typeof getServiceId;
 declare const index$3_getServiceIdOrCurrent: typeof getServiceIdOrCurrent;
@@ -18221,7 +18218,7 @@ declare const index$3_tryAsMachineId: typeof tryAsMachineId;
 declare const index$3_tryAsProgramCounter: typeof tryAsProgramCounter;
 declare const index$3_writeServiceIdAsLeBytes: typeof writeServiceIdAsLeBytes;
 declare namespace index$3 {
-  export { index$3_AccumulationStateUpdate as AccumulationStateUpdate, index$3_ArgsDecoder as ArgsDecoder, index$3_ArgumentType as ArgumentType, index$3_BasicBlocks as BasicBlocks, index$3_CURRENT_SERVICE_ID as CURRENT_SERVICE_ID, index$3_EjectError as EjectError, index$3_ExtendedWitdthImmediateDecoder as ExtendedWitdthImmediateDecoder, index$3_ForgetPreimageError as ForgetPreimageError, index$3_HostCallMemory as HostCallMemory, index$3_HostCallRegisters as HostCallRegisters, index$3_HostCallResult as HostCallResult, index$3_ImmediateDecoder as ImmediateDecoder, index$3_MAX_U32 as MAX_U32, index$3_MAX_U32_BIG_INT as MAX_U32_BIG_INT, index$3_MachineInstance as MachineInstance, index$3_Mask as Mask, index$3_MemoryOperation as MemoryOperation, index$3_MemorySegment as MemorySegment, NO_OF_REGISTERS$1 as NO_OF_REGISTERS, index$3_NewServiceError as NewServiceError, index$3_NibblesDecoder as NibblesDecoder, index$3_PagesError as PagesError, index$3_PartiallyUpdatedState as PartiallyUpdatedState, index$3_PeekPokeError as PeekPokeError, index$3_PendingTransfer as PendingTransfer, index$3_PreimageStatusKind as PreimageStatusKind, index$3_Program as Program, index$3_ProgramDecoder as ProgramDecoder, index$3_ProvidePreimageError as ProvidePreimageError, DebuggerAdapter as Pvm, index$3_Registers as Registers, index$3_RequestPreimageError as RequestPreimageError, Result$2 as Result, index$3_RichTaggedError as RichTaggedError, index$3_SERVICE_ID_BYTES as SERVICE_ID_BYTES, index$3_SpiMemory as SpiMemory, index$3_SpiProgram as SpiProgram, index$3_TransferError as TransferError, index$3_UpdatePrivilegesError as UpdatePrivilegesError, index$3_WithDebug as WithDebug, index$3_ZeroVoidError as ZeroVoidError, index$3___OPAQUE_TYPE__ as __OPAQUE_TYPE__, index$3_asOpaqueType as asOpaqueType, index$3_assertEmpty as assertEmpty, index$3_assertNever as assertNever, index$j as block, index$q as bytes, index$3_check as check, index$3_clampU64ToU32 as clampU64ToU32, index$3_createResults as createResults, index$3_decodeStandardProgram as decodeStandardProgram, index$3_extractCodeAndMetadata as extractCodeAndMetadata, index$3_getServiceId as getServiceId, index$3_getServiceIdOrCurrent as getServiceIdOrCurrent, index$n as hash, index$3_inspect as inspect, index$3_instructionArgumentTypeMap as instructionArgumentTypeMap, index$8 as interpreter, index$3_isBrowser as isBrowser, index$3_isTaggedError as isTaggedError, index$3_maybeTaggedErrorToString as maybeTaggedErrorToString, index$3_measure as measure, index$p as numbers, index$3_preimageLenAsU32 as preimageLenAsU32, index$3_resultToString as resultToString, index$3_seeThrough as seeThrough, index$3_slotsToPreimageStatus as slotsToPreimageStatus, index$3_toMemoryOperation as toMemoryOperation, index$3_tryAsMachineId as tryAsMachineId, index$3_tryAsProgramCounter as tryAsProgramCounter, index$3_writeServiceIdAsLeBytes as writeServiceIdAsLeBytes };
+  export { index$3_AccumulationStateUpdate as AccumulationStateUpdate, index$3_ArgsDecoder as ArgsDecoder, index$3_ArgumentType as ArgumentType, index$3_BasicBlocks as BasicBlocks, index$3_CURRENT_SERVICE_ID as CURRENT_SERVICE_ID, index$3_EjectError as EjectError, index$3_ExtendedWitdthImmediateDecoder as ExtendedWitdthImmediateDecoder, index$3_ForgetPreimageError as ForgetPreimageError, index$3_HostCallMemory as HostCallMemory, index$3_HostCallRegisters as HostCallRegisters, index$3_HostCallResult as HostCallResult, index$3_ImmediateDecoder as ImmediateDecoder, index$3_MAX_U32 as MAX_U32, index$3_MAX_U32_BIG_INT as MAX_U32_BIG_INT, index$3_MachineInstance as MachineInstance, index$3_Mask as Mask, index$3_MemoryOperation as MemoryOperation, index$3_MemorySegment as MemorySegment, NO_OF_REGISTERS$1 as NO_OF_REGISTERS, index$3_NewServiceError as NewServiceError, index$3_NibblesDecoder as NibblesDecoder, index$3_PagesError as PagesError, index$3_PartiallyUpdatedState as PartiallyUpdatedState, index$3_PeekPokeError as PeekPokeError, index$3_PendingTransfer as PendingTransfer, index$3_PreimageStatusKind as PreimageStatusKind, index$3_Program as Program, index$3_ProgramDecoder as ProgramDecoder, index$3_ProvidePreimageError as ProvidePreimageError, DebuggerAdapter as Pvm, index$3_Registers as Registers, index$3_RequestPreimageError as RequestPreimageError, Result$2 as Result, index$3_RichTaggedError as RichTaggedError, index$3_SERVICE_ID_BYTES as SERVICE_ID_BYTES, index$3_SpiMemory as SpiMemory, index$3_SpiProgram as SpiProgram, index$3_TransferError as TransferError, index$3_UpdatePrivilegesError as UpdatePrivilegesError, index$3_WithDebug as WithDebug, index$3_ZeroVoidError as ZeroVoidError, index$3___OPAQUE_TYPE__ as __OPAQUE_TYPE__, index$3_asOpaqueType as asOpaqueType, index$3_assertEmpty as assertEmpty, index$3_assertNever as assertNever, index$j as block, index$q as bytes, index$3_cast as cast, index$3_check as check, index$3_clampU64ToU32 as clampU64ToU32, index$3_createResults as createResults, index$3_decodeStandardProgram as decodeStandardProgram, index$3_ensure as ensure, index$3_extractCodeAndMetadata as extractCodeAndMetadata, index$3_getServiceId as getServiceId, index$3_getServiceIdOrCurrent as getServiceIdOrCurrent, index$n as hash, index$3_inspect as inspect, index$3_instructionArgumentTypeMap as instructionArgumentTypeMap, index$8 as interpreter, index$3_isBrowser as isBrowser, index$3_isTaggedError as isTaggedError, index$3_maybeTaggedErrorToString as maybeTaggedErrorToString, index$3_measure as measure, index$p as numbers, index$3_preimageLenAsU32 as preimageLenAsU32, index$3_resultToString as resultToString, index$3_seeThrough as seeThrough, index$3_slotsToPreimageStatus as slotsToPreimageStatus, index$3_toMemoryOperation as toMemoryOperation, index$3_tryAsMachineId as tryAsMachineId, index$3_tryAsProgramCounter as tryAsProgramCounter, index$3_writeServiceIdAsLeBytes as writeServiceIdAsLeBytes };
   export type { index$3_Args as Args, index$3_EnumMapping as EnumMapping, index$3_ErrorResult as ErrorResult, index$3_IHostCallMemory as IHostCallMemory, index$3_IHostCallRegisters as IHostCallRegisters, index$3_InsufficientFundsError as InsufficientFundsError, index$3_MachineId as MachineId, index$3_MachineResult as MachineResult, index$3_MachineStatus as MachineStatus, index$3_NoMachineError as NoMachineError, index$3_OK as OK, index$3_OkResult as OkResult, index$3_Opaque as Opaque, index$3_PartialState as PartialState, index$3_PreimageStatus as PreimageStatus, index$3_ProgramCounter as ProgramCounter, index$3_RefineExternalities as RefineExternalities, index$3_SegmentExportError as SegmentExportError, index$3_ServiceStateUpdate as ServiceStateUpdate, index$3_StateSlice as StateSlice, index$3_StringLiteral as StringLiteral, index$3_TRANSFER_MEMO_BYTES as TRANSFER_MEMO_BYTES, index$3_TaggedError as TaggedError, index$3_TokenOf as TokenOf, index$3_Uninstantiable as Uninstantiable, index$3_UnprivilegedError as UnprivilegedError, index$3_WithOpaque as WithOpaque };
 }
 
@@ -18234,7 +18231,7 @@ type ENTROPY_BYTES = typeof ENTROPY_BYTES;
  * https://graypaper.fluffylabs.dev/#/579bd12/3b9a013b9a01
  */
 declare function fisherYatesShuffle<T>(arr: T[], entropy: Bytes<ENTROPY_BYTES>): T[] {
-  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: T[] = new Array<T>(n);