@typeberry/lib 0.5.1-aff8b4f → 0.5.1-eb84786

package/packages/core/codec/encoder.js

@@ -0,0 +1,387 @@
+import { Bytes, BytesBlob } from "#@typeberry/bytes";
+import { tryAsU32 } from "#@typeberry/numbers";
+import { check } from "#@typeberry/utils";
+export function tryAsExactBytes(a) {
+    check `${a.isExact} The value is not exact size estimation!`;
+    return a.bytes;
+}
+export function addSizeHints(a, b) {
+    return {
+        bytes: a.bytes + b.bytes,
+        isExact: a.isExact && b.isExact,
+    };
+}
+const DEFAULT_START_LENGTH = 512; // 512B
+const MAX_LENGTH = 20 * 1024 * 1024; // 20MB
+/**
+ * JAM encoder.
+ */
+export class Encoder {
+    destination;
+    buffer;
+    /**
+     * Create a new encoder either to fill up given `destination`
+     * or with a minimal expected size.
+     */
+    static create(options) {
+        if (options !== undefined && "destination" in options) {
+            return new Encoder(options.destination);
+        }
+        const startLength = options?.expectedLength ?? DEFAULT_START_LENGTH;
+        const buffer = new ArrayBuffer(Math.min(MAX_LENGTH, startLength), { maxByteLength: MAX_LENGTH });
+        const destination = new Uint8Array(buffer);
+        return new Encoder(destination, buffer);
+    }
+    /**
+     * Encode just a single object.
+     *
+     * NOTE that if you need to encode a tuple glueing together outputs
+     * of that function is going to be sub-optimal!
+     *
+     * This is only for one-shot encodings.
+     */
+    static encodeObject(encode, object, context) {
+        const encoder = Encoder.create({
+            expectedLength: encode.sizeHint.bytes || DEFAULT_START_LENGTH,
+        });
+        encoder.attachContext(context);
+        encoder.object(encode, object);
+        return encoder.viewResult();
+    }
+    offset = 0;
+    context;
+    dataView;
+    constructor(destination, buffer) {
+        this.destination = destination;
+        this.buffer = buffer;
+        if (buffer !== undefined) {
+            this.dataView = new DataView(buffer);
+        }
+        else {
+            this.dataView = new DataView(destination.buffer, destination.byteOffset, destination.byteLength);
+        }
+    }
+    /**
+     * Attach context to the encoder.
+     *
+     * The context object can be used to pass some "global" parameters
+     * down to custom encoders.
+     */
+    attachContext(context) {
+        this.context = context;
+    }
+    /**
+     * Get the encoding context object.
+     */
+    getContext() {
+        return this.context;
+    }
+    /**
+     * View the current encoding result.
+     *
+     * Note that the resulting array here, might be shorter than the
+     * underlying `destination`.
+     */
+    viewResult() {
+        return BytesBlob.blobFrom(this.destination.subarray(0, this.offset));
+    }
+    /**
+     * Encode a 32-bit integer.
+     *
+     * The encoding will always occupy 4 bytes in little-endian ordering.
+     * Negative numbers are represented as a two-complement.
+     */
+    i32(num) {
+        this.prepareIntegerN(num, 4);
+        this.dataView.setInt32(this.offset, num, true);
+        this.offset += 4;
+    }
+    /**
+     * Encode a 64-bit integer.
+     *
+     * The encoding will always occupy 8 bytes in little-endian ordering.
+     * Negative numbers are represented as a two-complement.
+     */
+    i64(num) {
+        const maxNum = 2n ** 64n;
+        // note that despite the actual range of values being within:
+        // `[ - maxNum / 2, maxNum / 2)`
+        // 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`;
+        this.ensureBigEnough(8);
+        this.dataView.setBigInt64(this.offset, num, true);
+        this.offset += 8;
+    }
+    /**
+     * Encode a 24-bit integer.
+     *
+     * The encoding will always occupy 3 bytes in little-endian ordering.
+     * Negative numbers are represented as a two-complement.
+     */
+    i24(num) {
+        this.prepareIntegerN(num, 3);
+        this.dataView.setInt8(this.offset, num & 0xff);
+        this.dataView.setInt16(this.offset + 1, num >> 8, true);
+        this.offset += 3;
+    }
+    /**
+     * Encode a 16-bit integer.
+     *
+     * The encoding will always occupy 2 bytes in little-endian ordering.
+     * Negative numbers are represented as a two-complement.
+     */
+    i16(num) {
+        this.prepareIntegerN(num, 2);
+        this.dataView.setInt16(this.offset, num, true);
+        this.offset += 2;
+    }
+    /**
+     * Encode a 8-bit integer.
+     *
+     * The encoding will always occupy 1 byte in little-endian ordering.
+     * Negative numbers are represented as a two-complement.
+     */
+    i8(num) {
+        this.prepareIntegerN(num, 1);
+        this.dataView.setInt8(this.offset, num);
+        this.offset += 1;
+    }
+    /**
+     * Encode a single boolean discriminator using variable encoding.
+     *
+     * https://graypaper.fluffylabs.dev/#/579bd12/375300375300
+     */
+    bool(bool) {
+        this.varU32(tryAsU32(bool ? 1 : 0));
+    }
+    /**
+     * Prepare for encoding of a fixed-bytes number.
+     *
+     *
+     * The encoding will always occupy N bytes in little-endian ordering.
+     * Negative numbers are represented as a two-complement.
+     *
+     * https://graypaper.fluffylabs.dev/#/579bd12/36fc0136fc01
+     */
+    prepareIntegerN(num, bytesToEncode) {
+        const BITS = 8;
+        const maxNum = 2 ** (BITS * bytesToEncode);
+        // note that despite the actual range of values being within:
+        // `[ - maxNum / 2, maxNum / 2)`
+        // 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}`;
+        this.ensureBigEnough(bytesToEncode);
+    }
+    /**
+     * Encode a 32-bit natural number (compact).
+     *
+     * The encoding can take variable amount of bytes depending on the actual value.
+     *
+     * 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`;
+        this.varU64(BigInt(num));
+    }
+    /**
+     * Encode a 64-bit natural number (compact).
+     *
+     * The encoding can take variable amount of bytes depending on the actual value.
+     *
+     * https://graypaper.fluffylabs.dev/#/579bd12/365202365202
+     */
+    varU64(value) {
+        const num = BigInt(value); // this should be a no-op, but fixes incorrect usage in JS
+        if (num === 0n) {
+            this.ensureBigEnough(1);
+            this.destination[this.offset] = 0;
+            this.offset += 1;
+            return;
+        }
+        // handle the biggest case
+        let maxEncoded = 2n ** (7n * 8n);
+        if (num >= maxEncoded) {
+            this.ensureBigEnough(9);
+            this.destination[this.offset] = 0xff;
+            this.dataView.setBigUint64(this.offset + 1, num, true);
+            this.offset += 9;
+            return;
+        }
+        // let's look for the correct range
+        let minEncoded = maxEncoded >> 7n;
+        for (let l = 7; l >= 0; l -= 1) {
+            if (num >= minEncoded) {
+                this.ensureBigEnough(l + 1);
+                // encode the first byte
+                const maxVal = 2n ** BigInt(8 * l);
+                const byte = BigInt(2 ** 8 - 2 ** (8 - l)) + num / maxVal;
+                this.destination[this.offset] = Number(byte) & 0xff;
+                this.offset += 1;
+                // now encode the rest of bytes of len `l`
+                let rest = num % maxVal;
+                for (let i = this.offset; i < this.offset + l; i += 1) {
+                    this.destination[i] = Number(rest & 0xffn);
+                    rest >>= 8n;
+                }
+                this.offset += l;
+                return;
+            }
+            // move one power down
+            maxEncoded = minEncoded;
+            minEncoded >>= 7n;
+        }
+        throw new Error(`Unhandled number encoding: ${num}`);
+    }
+    /**
+     * Encode a variable-length sequence of bytes given as [`BytesBlob`].
+     *
+     * That's just a convenience wrapper for [`blob`] function.
+     */
+    bytesBlob(blob) {
+        this.blob(blob.raw);
+    }
+    /**
+     * Encode a variable-length sequence of bytes.
+     *
+     * The data is placed in the destination, but with an
+     * extra length-discriminator (see [`u32`]) encoded in a compact form.
+     *
+     * https://graypaper.fluffylabs.dev/#/579bd12/372600372600
+     */
+    blob(blob) {
+        // first encode the length
+        this.varU32(tryAsU32(blob.length));
+        // now encode the bytes
+        this.ensureBigEnough(blob.length);
+        this.destination.set(blob, this.offset);
+        this.offset += blob.length;
+    }
+    /**
+     * Encode a fixed-length sequence of bytes.
+     *
+     * The data is simply copied to the destination
+     * without any discriminator (i.e. no length prefix).
+     *
+     * https://graypaper.fluffylabs.dev/#/579bd12/371100371100
+     *
+     */
+    bytes(bytes) {
+        this.ensureBigEnough(bytes.length);
+        this.destination.set(bytes.raw, this.offset);
+        this.offset += bytes.length;
+    }
+    /**
+     * Encode a bit vector with known length.
+     *
+     * The bits are packed into bytes and just placed as-is in the destination.
+     * https://graypaper.fluffylabs.dev/#/579bd12/378000378000
+     */
+    bitVecFixLen(bitvec) {
+        const bytes = bitvec.raw;
+        this.bytes(Bytes.fromBlob(bytes, bytes.length));
+    }
+    /**
+     * Encode a bit vector with variable length.
+     *
+     * A bit-length discriminator (varU32) is placed before the packed bit content.
+     * https://graypaper.fluffylabs.dev/#/579bd12/378200378200
+     */
+    bitVecVarLen(bitvec) {
+        const len = bitvec.bitLength;
+        this.varU32(tryAsU32(len));
+        this.bitVecFixLen(bitvec);
+    }
+    /**
+     * Encode a composite object.
+     */
+    object(encode, element) {
+        this.applySizeHint(encode);
+        encode.encode(this, element);
+    }
+    /**
+     * Encode a potentially empty value.
+     *
+     * A 0 or 1 is placed before the element to indicate it's presence.
+     * https://graypaper.fluffylabs.dev/#/579bd12/375f00375f00
+     */
+    optional(encode, element) {
+        const isSet = element !== null && element !== undefined;
+        this.bool(isSet);
+        if (isSet) {
+            this.applySizeHint(encode);
+            encode.encode(this, element);
+        }
+    }
+    /**
+     * Encode a fixed-length sequence of elements of some type.
+     *
+     * https://graypaper.fluffylabs.dev/#/579bd12/371100371100
+     */
+    sequenceFixLen(encode, elements) {
+        this.applySizeHint(encode, elements.length);
+        for (const e of elements) {
+            encode.encode(this, e);
+        }
+    }
+    /**
+     * Encode a variable-length sequence of elements of some type.
+     *
+     * A length discriminator is placed before the concatentation of encodings of all the elements.
+     *
+     * 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.`;
+        this.varU32(tryAsU32(elements.length));
+        this.sequenceFixLen(encode, elements);
+    }
+    applySizeHint(encode, multiply = 1) {
+        const sizeHint = encode.sizeHint.bytes;
+        if (sizeHint > 0 && multiply > 0) {
+            this.ensureBigEnough(sizeHint * multiply, { silent: true });
+        }
+    }
+    /**
+     * Expand the destination to fit given length.
+     *
+     * The `silent` flag can be set when we are just giving a size hint about
+     * a composite type being encoded.
+     * In such case we are not sure if we are going to use all of the bytes from the hint,
+     * so going over `MAX_LENGTH` or destination is not an error here.
+     * When subsequent fields of a composite object will be encode they call this function
+     * anyway, so if we really should throw we will.
+     */
+    ensureBigEnough(length, options = { silent: false }) {
+        check `${length >= 0} Negative length given`;
+        const newLength = this.offset + length;
+        if (newLength > MAX_LENGTH) {
+            if (options.silent) {
+                return;
+            }
+            throw new Error(`The encoded size (${newLength}) would reach the maximum of ${MAX_LENGTH}.`);
+        }
+        if (newLength > this.destination.length) {
+            // we can try to resize the underlying buffer
+            if (this.buffer !== undefined) {
+                // make sure we at least double the size of the buffer every time.
+                const minExtend = Math.max(newLength, this.buffer.byteLength << 1);
+                // but we must never exceed the max length.
+                this.buffer.resize(Math.min(MAX_LENGTH, minExtend));
+            }
+            // and then check again
+            if (newLength > this.destination.length) {
+                if (options.silent) {
+                    return;
+                }
+                throw new Error(`Not enough space in the destination array. Needs ${newLength}, has ${this.destination.length}.`);
+            }
+        }
+    }
+}

package/packages/core/codec/encoder.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=encoder.test.d.ts.map

package/packages/core/codec/encoder.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encoder.test.d.ts","sourceRoot":"","sources":["../../../../../packages/core/codec/encoder.test.ts"],"names":[],"mappings":""}

package/packages/core/codec/encoder.test.js

@@ -0,0 +1,182 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { BitVec, Bytes, BytesBlob } from "#@typeberry/bytes";
+import { Encoder } from "./encoder.js";
+describe("JAM encoder / bytes", () => {
+    it("should encode empty bytes sequence", () => {
+        const blob = BytesBlob.parseBlob("0x");
+        const encoder = Encoder.create();
+        encoder.bytesBlob(blob);
+        assert.deepStrictEqual(encoder.viewResult(), 
+        // we have the length prefix.
+        BytesBlob.parseBlob("0x00"));
+    });
+    it("should encode bytes sequence", () => {
+        const blob = BytesBlob.parseBlob("0xdeadbeef");
+        const encoder = Encoder.create();
+        encoder.bytesBlob(blob);
+        assert.deepStrictEqual(encoder.viewResult(), BytesBlob.parseBlob("0x04deadbeef"));
+    });
+    it("should encode a fixed-length bytes", () => {
+        const bytes = Bytes.parseBytes("0xdeadbeef", 4);
+        const encoder = Encoder.create();
+        encoder.bytes(bytes);
+        assert.deepStrictEqual(encoder.viewResult(), BytesBlob.parseBlob("0xdeadbeef"));
+    });
+});
+describe("JAM encoder / numbers", () => {
+    it("should encode a large 32-bit number", () => {
+        const encoder = Encoder.create();
+        encoder.varU32((2 ** 32 - 1));
+        assert.deepStrictEqual(encoder.viewResult().toString(), "0xf0ffffffff");
+    });
+    it("should encode variable length u32", () => {
+        const encoder = Encoder.create();
+        encoder.varU32(0);
+        encoder.varU32(1);
+        encoder.varU32(2);
+        encoder.varU32(3);
+        encoder.varU32(42);
+        encoder.varU32((2 ** 32 - 1));
+        encoder.varU32((2 ** 31 - 1));
+        encoder.varU32(0x42424242);
+        assert.deepStrictEqual(encoder.viewResult().toString(), "0x000102032af0fffffffff0ffffff7ff042424242");
+    });
+    it("should encode variable length u64", () => {
+        const encoder = Encoder.create();
+        encoder.varU64(0n);
+        encoder.varU64(1n);
+        encoder.varU64(2n ** 32n);
+        encoder.varU64(2n ** 56n);
+        encoder.varU64(2n ** 64n - 1n);
+        assert.deepStrictEqual(encoder.viewResult().toString(), "0x0001f100000000ff0000000000000001ffffffffffffffffff");
+    });
+    it("should encode a bunch of i64 numbers", () => {
+        const encoder = Encoder.create();
+        encoder.i64(2n ** 63n - 1n);
+        encoder.i64(-(2n ** 63n));
+        encoder.i64(0x42424242n);
+        encoder.i64(-42n);
+        encoder.i64(0n);
+        assert.deepStrictEqual(encoder.viewResult().toString(), BytesBlob.parseBlob("0xffffffffffffff7f00000000000000804242424200000000d6ffffffffffffff0000000000000000").toString());
+    });
+    it("should encode a bunch of i32 numbers", () => {
+        const encoder = Encoder.create();
+        encoder.i32(2 ** 31 - 1);
+        encoder.i32(-(2 ** 31));
+        encoder.i32(0x42424242);
+        encoder.i32(-42);
+        encoder.i32(0);
+        assert.deepStrictEqual(encoder.viewResult().toString(), BytesBlob.parseBlob("0xffffff7f0000008042424242d6ffffff00000000").toString());
+    });
+    it("should encode a bunch of i24 numbers", () => {
+        const encoder = Encoder.create();
+        encoder.i24(0x424242);
+        encoder.i24(-42);
+        encoder.i24(0);
+        encoder.i24(-127);
+        encoder.i24(1383553);
+        encoder.i24(2 ** 23);
+        encoder.i24(2 ** 23 - 1);
+        encoder.i24(2 ** 23 + 1);
+        assert.deepStrictEqual(encoder.viewResult().toString(), BytesBlob.parseBlob("0x424242d6ffff00000081ffff811c15000080ffff7f010080").toString());
+    });
+    it("should encode a bunch of i16 numbers", () => {
+        const encoder = Encoder.create();
+        encoder.i16(0x4242);
+        encoder.i16(-42);
+        encoder.i16(0);
+        assert.deepStrictEqual(encoder.viewResult().toString(), BytesBlob.parseBlob("0x4242d6ff0000").toString());
+    });
+    it("should encode a bunch of i8 numbers", () => {
+        const encoder = Encoder.create();
+        encoder.i8(0x42);
+        encoder.i8(-42);
+        encoder.i8(0);
+        assert.deepStrictEqual(encoder.viewResult(), BytesBlob.parseBlob("0x42d600"));
+    });
+    it("should encode a bool", () => {
+        const encoder = Encoder.create();
+        encoder.bool(true);
+        encoder.bool(false);
+        assert.deepStrictEqual(encoder.viewResult(), BytesBlob.parseBlob("0x0100"));
+    });
+});
+describe("JAM encoder / sizing", () => {
+    it("should throw exception if destination is too small", () => {
+        const encoder = Encoder.create({
+            destination: new Uint8Array(2),
+        });
+        assert.throws(() => {
+            encoder.i32(5);
+        }, {
+            name: "Error",
+            message: "Not enough space in the destination array. Needs 4, has 2.",
+        });
+    });
+    it("should extend the space", () => {
+        const encoder = Encoder.create({
+            expectedLength: 1,
+        });
+        encoder.i32(5);
+        assert.deepStrictEqual(encoder.viewResult(), BytesBlob.parseBlob("0x05000000"));
+    });
+});
+describe("JAM encoder / bitvec", () => {
+    it("should encode a 1-byte bit vector", () => {
+        const encoder = Encoder.create();
+        // 1 byte long bit vec
+        const bitvec = BitVec.empty(8);
+        bitvec.setBit(0, true);
+        bitvec.setBit(6, true);
+        // when
+        encoder.bitVecFixLen(bitvec);
+        encoder.bitVecVarLen(bitvec);
+        assert.deepStrictEqual(encoder.viewResult().toString(), "0x410841");
+    });
+    it("should encode a longer bit vector", () => {
+        const encoder = Encoder.create();
+        const bitvec = BitVec.empty(65);
+        bitvec.setBit(0, true);
+        bitvec.setBit(32, true);
+        bitvec.setBit(63, true);
+        bitvec.setBit(64, true);
+        // when
+        encoder.bitVecFixLen(bitvec);
+        encoder.bitVecVarLen(bitvec);
+        assert.deepStrictEqual(encoder.viewResult().toString(), "0x01000000010000800141010000000100008001");
+    });
+});
+describe("JAM encoder / generics", () => {
+    class MyType {
+        x;
+        y;
+        z;
+        constructor(x, y, z) {
+            this.x = x;
+            this.y = y;
+            this.z = z ?? Bytes.parseBytes("0xdeadbeef", 4);
+        }
+        static encode(encoder, elem) {
+            encoder.i32(elem.x);
+            encoder.bool(elem.y);
+            encoder.bytes(elem.z);
+        }
+        static sizeHint = { bytes: 4 + 1 + 4, isExact: true };
+    }
+    it("should encode an optional value", () => {
+        const encoder = Encoder.create();
+        encoder.optional(MyType, new MyType(3, true));
+        encoder.optional(MyType, null);
+        encoder.optional(MyType, null);
+        encoder.optional(MyType, new MyType(5, false));
+        assert.deepStrictEqual(encoder.viewResult().toString(), "0x010300000001deadbeef0000010500000000deadbeef");
+    });
+    it("should encode a sequence", () => {
+        const encoder = Encoder.create();
+        const seq = [new MyType(5, true), new MyType(7, true), new MyType(10, true)];
+        encoder.sequenceVarLen(MyType, seq);
+        encoder.sequenceFixLen(MyType, seq);
+        assert.deepStrictEqual(encoder.viewResult().toString(), "0x030500000001deadbeef0700000001deadbeef0a00000001deadbeef0500000001deadbeef0700000001deadbeef0a00000001deadbeef");
+    });
+});

package/packages/core/codec/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./decoder.js";
+export * from "./descriptor.js";
+export * from "./descriptors.js";
+export * from "./encoder.js";
+export * from "./validation.js";
+export * from "./view.js";
+import * as descriptors from "./descriptors.js";
+export declare const codec: typeof descriptors;
+//# sourceMappingURL=index.d.ts.map

package/packages/core/codec/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/core/codec/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAK1B,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAC;AAChD,eAAO,MAAM,KAAK,oBAAc,CAAC"}

package/packages/core/codec/index.js

@@ -0,0 +1,11 @@
+export * from "./decoder.js";
+export * from "./descriptor.js";
+export * from "./descriptors.js";
+export * from "./encoder.js";
+export * from "./validation.js";
+export * from "./view.js";
+// additional re-export of descriptors namespace under `codec`
+// note we export descriptors in top level as well,
+// because writing `codec.codec.u32` when using the library looks weird
+import * as descriptors from "./descriptors.js";
+export const codec = descriptors;

package/packages/core/codec/index.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.test.d.ts.map

package/packages/core/codec/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../../../../packages/core/codec/index.test.ts"],"names":[],"mappings":""}

package/packages/core/codec/index.test.js

@@ -0,0 +1,80 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { BitVec, BytesBlob } from "#@typeberry/bytes";
+import { tryAsU8, tryAsU16, tryAsU32, tryAsU64 } from "#@typeberry/numbers";
+import { Decoder } from "./decoder.js";
+import * as codec from "./descriptors.js";
+import { Encoder } from "./encoder.js";
+import { Skipper } from "./skip.js";
+let seed = 1;
+function random() {
+    const x = Math.sin(seed++) * 10000;
+    return x - Math.floor(x);
+}
+describe("JAM encoder / decoder", () => {
+    function generator(generate, descriptor) {
+        return {
+            generate,
+            descriptor,
+        };
+    }
+    // biome-ignore lint/suspicious/noExplicitAny: I need to make sure that the generator output matches the type.
+    const types = [
+        generator(() => tryAsU64(BigInt(Math.floor(random() * 2 ** 32)) ** 2n), codec.varU64),
+        generator(() => tryAsU32(Math.floor(random() * 2 ** 32)), codec.varU32),
+        generator(() => tryAsU64(BigInt(Math.floor(random() * 2 ** 32)) ** 2n), codec.u64),
+        generator(() => tryAsU32(Math.floor(random() * 2 ** 32)), codec.u32),
+        generator(() => Math.floor(random() * 2 ** 24), codec.u24),
+        generator(() => tryAsU16(Math.floor(random() * 2 ** 16)), codec.u16),
+        generator(() => tryAsU8(Math.floor(random() * 2 ** 8)), codec.u8),
+        generator(() => BigInt(Math.floor(random() * 2 ** 32)) ** 2n - 2n ** 63n, codec.i64),
+        generator(() => Math.floor(random() * 2 ** 32) - 2 ** 31, codec.i32),
+        generator(() => Math.floor(random() * 2 ** 24) - 2 ** 23, codec.i24),
+        generator(() => Math.floor(random() * 2 ** 16) - 2 ** 15, codec.i16),
+        generator(() => Math.floor(random() * 2 ** 8) - 2 ** 7, codec.i8),
+        generator(() => {
+            let len = Math.floor(random() * 10_000);
+            const res = new Uint8Array(len);
+            while (--len >= 0) {
+                res[len] = Math.floor(random() * 256);
+            }
+            return BytesBlob.blobFrom(res);
+        }, codec.blob),
+        generator(() => {
+            let len = Math.floor(random() * 10_000);
+            const vec = BitVec.empty(len);
+            while (--len >= 0) {
+                vec.setBit(len, random() > 0.5);
+            }
+            return vec;
+        }, codec.bitVecVarLen),
+        generator(() => {
+            let len = 10;
+            const vec = BitVec.empty(len);
+            while (--len >= 0) {
+                vec.setBit(len, random() > 0.5);
+            }
+            return vec;
+        }, codec.bitVecFixLen(10)),
+    ];
+    for (const g of types) {
+        const max = 100;
+        for (let i = 0; i < max; i += 1) {
+            it(`should run random tests for ${g.descriptor.name} (${i + 1} / ${max})`, () => {
+                const encoder = Encoder.create();
+                const expected = g.generate();
+                g.descriptor.encode(encoder, expected);
+                const encoded = encoder.viewResult();
+                const decoder = Decoder.fromBytesBlob(encoded);
+                // skipping
+                const skip = new Skipper(decoder.clone());
+                g.descriptor.skip(skip);
+                skip.decoder.finish();
+                // decoding
+                const result = g.descriptor.decode(decoder);
+                decoder.finish();
+                assert.deepStrictEqual(result, expected);
+            });
+        }
+    }
+});