@leofcoin/chain 1.10.21 → 1.11.0

package/exports/{browser/workers/worker-BDTWOCzS-COrAszCt.js → workers/proposal.proto-8zgMfutf-B3So_tnS.js}

@@ -1,4 +1,678 @@
-var proto$3 = {
+class EasyWorker {
+    #messageEvent = 'message';
+    #errorEvent = 'error';
+    #isBrowser = false;
+    #isWorker = false;
+    #messageHandler = null;
+    #errorHandler = null;
+    worker;
+    get isWorker() {
+        return this.#isWorker;
+    }
+    constructor(url, options) {
+        return this.#init(url, options);
+    }
+    #init(url, options = {}) {
+        if (url) {
+            if (globalThis.Worker) {
+                this.#isBrowser = true;
+                this.worker = new Worker(url, { ...options });
+            }
+            else {
+                return new Promise((resolve, reject) => {
+                    import('child_process').then(({ fork }) => {
+                        const child = fork(url, ['easy-worker-child'], options);
+                        child.once('error', reject);
+                        this.worker = child;
+                        resolve(this);
+                    }).catch(reject);
+                });
+            }
+        }
+        else {
+            this.#isWorker = true;
+            if (globalThis.process?.argv[2] === 'easy-worker-child') {
+                this.worker = process;
+            }
+            else {
+                this.#isBrowser = true;
+                this.worker = globalThis;
+            }
+        }
+        return this;
+    }
+    onmessage(fn) {
+        if (this.#isBrowser) {
+            this.worker.onmessage = ({ data }) => fn(data);
+        }
+        else {
+            if (this.#messageHandler)
+                this.worker.off(this.#messageEvent, this.#messageHandler);
+            this.#messageHandler = fn;
+            this.worker.on(this.#messageEvent, fn);
+        }
+    }
+    postMessage(message) {
+        if (this.#isBrowser)
+            this.worker.postMessage(message);
+        else
+            this.worker.send(message);
+    }
+    terminate() {
+        if (this.#isBrowser)
+            this.worker.terminate();
+        else
+            this.worker.kill();
+    }
+    onerror(fn) {
+        if (this.#isBrowser) {
+            this.worker.onerror = fn;
+        }
+        else {
+            if (this.#errorHandler)
+                this.worker.off(this.#errorEvent, this.#errorHandler);
+            this.#errorHandler = fn;
+            this.worker.on(this.#errorEvent, fn);
+        }
+    }
+    /**
+     *
+     * @param {*} data
+     * @returns {Promise} resolves result onmessage & rejects on error
+     */
+    once(data) {
+        return new Promise((resolve, reject) => {
+            if (this.#isBrowser) {
+                const handleMessage = ({ data: result }) => {
+                    this.worker.onerror = null;
+                    resolve(result);
+                    this.terminate();
+                };
+                const handleError = (error) => {
+                    this.worker.onmessage = null;
+                    reject(error);
+                    this.terminate();
+                };
+                this.worker.onmessage = handleMessage;
+                this.worker.onerror = handleError;
+            }
+            else {
+                const handleMessage = (result) => {
+                    this.worker.off(this.#errorEvent, handleError);
+                    resolve(result);
+                    this.terminate();
+                };
+                const handleError = (error) => {
+                    this.worker.off(this.#messageEvent, handleMessage);
+                    reject(error);
+                    this.terminate();
+                };
+                this.worker.once(this.#messageEvent, handleMessage);
+                this.worker.once(this.#errorEvent, handleError);
+            }
+            this.postMessage(data);
+        });
+    }
+}
+
+/** @leofcoin/binary: dependency-free unsigned framing, with no global byte counters. */
+const MAX_BIGINT = (1n << 256n) - 1n;
+function size(value) {
+    if (!Number.isSafeInteger(value) || value < 0)
+        throw new RangeError('Expected an unsigned safe integer');
+}
+function bytes(value) {
+    if (!(value instanceof Uint8Array))
+        throw new TypeError('Expected Uint8Array');
+}
+function varUintLength(value) {
+    size(value);
+    let length = 1;
+    while (value >= 128) {
+        value = Math.floor(value / 128);
+        length++;
+    }
+    return length;
+}
+function varBigIntLength(value) {
+    if (typeof value !== 'bigint')
+        throw new TypeError('Expected BigInt');
+    if (value < 0n || value > MAX_BIGINT)
+        throw new RangeError('Expected an unsigned 256-bit integer');
+    let length = 1;
+    // Count whole eight-byte varint groups before the short tail.
+    while (value >= 0x100000000000000n) {
+        value >>= 56n;
+        length += 8;
+    }
+    while (value >= 128n) {
+        value >>= 7n;
+        length++;
+    }
+    return length;
+}
+/** Fixed-capacity writer. finish() is a view; copy it before reusing/resetting the writer. */
+class BinaryWriter {
+    #buffer;
+    #position = 0;
+    constructor(capacity = 64) {
+        if (typeof capacity === 'number') {
+            size(capacity);
+            this.#buffer = new Uint8Array(capacity);
+        }
+        else {
+            bytes(capacity);
+            this.#buffer = capacity;
+        }
+    }
+    get position() {
+        return this.#position;
+    }
+    get remaining() {
+        return this.#buffer.length - this.#position;
+    }
+    #require(length) {
+        size(length);
+        if (length > this.remaining)
+            throw new RangeError('Binary output buffer is too small');
+    }
+    writeVarUint(value) {
+        this.#require(varUintLength(value));
+        this.#writeVarUint(value);
+        return this;
+    }
+    #writeVarUint(value) {
+        while (value >= 128) {
+            this.#buffer[this.#position++] = value % 128 | 128;
+            value = Math.floor(value / 128);
+        }
+        this.#buffer[this.#position++] = value;
+    }
+    writeVarBigInt(value) {
+        this.#require(varBigIntLength(value));
+        do {
+            const byte = Number(value & 127n);
+            value >>= 7n;
+            this.#buffer[this.#position++] = byte | (value ? 128 : 0);
+        } while (value);
+        return this;
+    }
+    writeBytes(value) {
+        bytes(value);
+        this.#require(value.length);
+        this.#buffer.set(value, this.#position);
+        this.#position += value.length;
+        return this;
+    }
+    writeFrame(value) {
+        bytes(value);
+        // Check the complete operation before writing its length prefix.
+        const prefixLength = varUintLength(value.length);
+        this.#require(prefixLength + value.length);
+        const prefixStart = this.#buffer.byteOffset + this.#position;
+        if (value.buffer === this.#buffer.buffer &&
+            value.byteOffset < prefixStart + prefixLength &&
+            value.byteOffset + value.length > prefixStart)
+            throw new RangeError('Frame source overlaps its length prefix');
+        this.#writeVarUint(value.length);
+        this.#buffer.set(value, this.#position);
+        this.#position += value.length;
+        return this;
+    }
+    reset() {
+        this.#position = 0;
+        return this;
+    }
+    finish(copy = false) {
+        const result = this.#buffer.subarray(0, this.#position);
+        // Buffer.slice() aliases memory; this constructor copies every Uint8Array subtype.
+        return copy ? new Uint8Array(result) : result;
+    }
+}
+/** Reads views of the original buffer. Failed operations leave the cursor unchanged. */
+class BinaryReader {
+    #buffer;
+    #position = 0;
+    constructor(buffer) {
+        bytes(buffer);
+        this.#buffer = buffer;
+    }
+    get position() {
+        return this.#position;
+    }
+    get remaining() {
+        return this.#buffer.length - this.#position;
+    }
+    readVarUint(canonical = true) {
+        let result = 0;
+        let multiplier = 1;
+        for (let index = 0; index < 8; index++) {
+            const cursor = this.#position + index;
+            if (cursor >= this.#buffer.length)
+                throw new RangeError('Truncated varint');
+            const byte = this.#buffer[cursor];
+            const payload = byte & 127;
+            if (index === 7 && payload > Math.floor((Number.MAX_SAFE_INTEGER - result) / multiplier))
+                throw new RangeError('Varint exceeds safe integer range');
+            result += payload * multiplier;
+            if (byte < 128) {
+                if (canonical && index > 0 && payload === 0)
+                    throw new RangeError('Non-canonical varint');
+                this.#position = cursor + 1;
+                return result;
+            }
+            multiplier *= 128;
+        }
+        throw new RangeError('Varint exceeds safe integer range');
+    }
+    readVarBigInt(canonical = true) {
+        let result = 0n;
+        for (let index = 0; index < 37; index++) {
+            const cursor = this.#position + index;
+            if (cursor >= this.#buffer.length)
+                throw new RangeError('Truncated varint');
+            const byte = this.#buffer[cursor];
+            result |= BigInt(byte & 127) << BigInt(index * 7);
+            if (result > MAX_BIGINT)
+                throw new RangeError('Varint exceeds 256 bits');
+            if (byte < 128) {
+                if (canonical && index > 0 && byte === 0)
+                    throw new RangeError('Non-canonical varint');
+                this.#position = cursor + 1;
+                return result;
+            }
+        }
+        throw new RangeError('Varint exceeds 256 bits');
+    }
+    readBytes(length) {
+        size(length);
+        if (length > this.remaining)
+            throw new RangeError('Truncated binary field');
+        const start = this.#position;
+        this.#position += length;
+        return this.#buffer.subarray(start, this.#position);
+    }
+    readFrame(canonical = true) {
+        const start = this.#position;
+        try {
+            return this.readBytes(this.readVarUint(canonical));
+        }
+        catch (error) {
+            this.#position = start;
+            throw error;
+        }
+    }
+}
+/** Existing smart-concat bytes, with exactly one output allocation and no prefix arrays. */
+function encodeFrames(frames, prefix) {
+    if (!Array.isArray(frames))
+        throw new TypeError('Expected an array of byte frames');
+    let length = 0;
+    for (const frame of frames) {
+        bytes(frame);
+        length += varUintLength(frame.length) + frame.length;
+        size(length);
+    }
+    const writer = new BinaryWriter(length);
+    for (const frame of frames)
+        writer.writeFrame(frame);
+    return writer.finish();
+}
+/** Iterative framing: bounded by the input length, not recursive stack depth. */
+function decodeFrames(buffer, prefixLength = 0, options = {}) {
+    const reader = new BinaryReader(buffer);
+    reader.readBytes(prefixLength);
+    const maxFrames = options.maxFrames ?? buffer.length;
+    size(maxFrames);
+    const frames = [];
+    while (reader.remaining) {
+        if (frames.length >= maxFrames)
+            throw new RangeError('Too many binary frames');
+        frames.push(reader.readFrame(options.canonical ?? true));
+    }
+    return frames;
+}
+
+const MAGIC = new Uint8Array([0x4c, 0x46, 0x43, 1]);
+const utf8 = new TextEncoder();
+const text = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
+const defaults = { maxBytes: 16 * 1024 * 1024, maxDepth: 64, maxNodes: 200000 };
+const BIGINT_LIMB = 1n << 49n;
+const BIGINT_MASK = BIGINT_LIMB - 1n;
+const limitsFor = (options) => {
+    const limits = { ...defaults, ...options };
+    for (const value of Object.values(limits))
+        if (!Number.isSafeInteger(value) || value < 1)
+            throw new RangeError('Invalid binary limits');
+    return limits;
+};
+/** Canonical UTF-8 length without allocating a temporary encoded string. */
+function stringLength(value, maximum) {
+    if (value.length > maximum)
+        throw new RangeError('Invalid binary string');
+    let length = value.length;
+    for (let index = 0; index < value.length; index++) {
+        const code = value.charCodeAt(index);
+        if (code < 0x80)
+            continue;
+        if (code < 0x800) {
+            length++;
+            continue;
+        }
+        if (code >= 0xd800 && code <= 0xdbff) {
+            const low = value.charCodeAt(++index);
+            if (!(low >= 0xdc00 && low <= 0xdfff))
+                throw new RangeError('Invalid binary string');
+            length += 2;
+        }
+        else {
+            if (code >= 0xdc00 && code <= 0xdfff)
+                throw new RangeError('Invalid binary string');
+            length += 2;
+        }
+    }
+    return length;
+}
+/** Versioned canonical typed values. Validation/planning allocates no byte buffers. */
+function encodeValue(value, options = {}) {
+    return encodeValueWithPrefix(value, EMPTY, options);
+}
+const EMPTY = new Uint8Array();
+/** Prepend an existing framing/codec header in the same allocation.
+ * maxBytes bounds the typed value (including MAGIC), as with encodeValue.
+ * The caller-owned prefix is separate framing and is copied, never retained.
+ */
+function encodeValueWithPrefix(value, prefix, options = {}) {
+    if (!(prefix instanceof Uint8Array))
+        throw new TypeError('Expected Uint8Array prefix');
+    const limits = limitsFor(options);
+    // Flat plan retains validated data-property values; writing never reads user properties again.
+    // Internal tag 11 is an untagged map key and is never emitted on the wire.
+    const plan = [];
+    const ancestors = new Set();
+    let size = MAGIC.length;
+    let nodes = 0;
+    const reserve = (length) => {
+        size += length;
+        if (size > limits.maxBytes)
+            throw new RangeError('Binary value exceeds byte limit');
+    };
+    const string = (value, tag) => {
+        const length = stringLength(value, limits.maxBytes);
+        reserve((tag === 7 ? 1 : 0) + varUintLength(length) + length);
+        plan.push(tag, value, length);
+    };
+    const visit = (value, depth) => {
+        if (++nodes > limits.maxNodes || depth > limits.maxDepth)
+            throw new RangeError('Binary value exceeds complexity limit');
+        if (value === undefined || value === null || typeof value === 'boolean') {
+            reserve(1);
+            plan.push(value === undefined ? 0 : value === null ? 1 : value === false ? 2 : 3);
+            return;
+        }
+        if (typeof value === 'number') {
+            if (!Number.isFinite(value))
+                throw new TypeError('Binary numbers must be finite');
+            reserve(9);
+            plan.push(4, value);
+            return;
+        }
+        if (typeof value === 'bigint') {
+            const magnitude = value < 0n ? -value : value;
+            reserve(1 + varBigIntLength(magnitude));
+            plan.push(value < 0n ? 6 : 5, magnitude);
+            return;
+        }
+        if (typeof value === 'string')
+            return string(value, 7);
+        if (value instanceof Uint8Array) {
+            reserve(1 + varUintLength(value.length) + value.length);
+            plan.push(8, value, value.length);
+            return;
+        }
+        if (typeof value !== 'object')
+            throw new TypeError('Unsupported binary value');
+        if (ancestors.has(value))
+            throw new TypeError('Cyclic binary value');
+        ancestors.add(value);
+        try {
+            if (Array.isArray(value)) {
+                if (value.length > limits.maxNodes - nodes)
+                    throw new RangeError('Binary array exceeds node limit');
+                if (Object.keys(value).length !== value.length || Object.getOwnPropertySymbols(value).length)
+                    throw new TypeError('Binary arrays cannot have extra properties or holes');
+                reserve(1 + varUintLength(value.length));
+                plan.push(9, value.length);
+                for (let index = 0; index < value.length; index++) {
+                    const entry = Object.getOwnPropertyDescriptor(value, String(index));
+                    if (!entry || !('value' in entry))
+                        throw new TypeError('Sparse arrays and accessors are not binary values');
+                    visit(entry.value, depth + 1);
+                }
+            }
+            else {
+                const prototype = Object.getPrototypeOf(value);
+                if (prototype !== Object.prototype && prototype !== null)
+                    throw new TypeError('Binary maps must be plain objects');
+                const keys = Object.keys(value).sort();
+                if (Object.getOwnPropertySymbols(value).length)
+                    throw new TypeError('Symbol keys are not binary values');
+                if (keys.length > limits.maxNodes - nodes)
+                    throw new RangeError('Binary map exceeds node limit');
+                reserve(1 + varUintLength(keys.length));
+                plan.push(10, keys.length);
+                for (const key of keys) {
+                    const entry = Object.getOwnPropertyDescriptor(value, key);
+                    if (!('value' in entry))
+                        throw new TypeError('Accessors are not binary values');
+                    string(key, 11);
+                    visit(entry.value, depth + 1);
+                }
+            }
+        }
+        finally {
+            ancestors.delete(value);
+        }
+    };
+    visit(value, 0);
+    const capacity = prefix.length + size;
+    if (!Number.isSafeInteger(capacity))
+        throw new RangeError('Binary output is too large');
+    const output = new Uint8Array(capacity);
+    output.set(prefix);
+    output.set(MAGIC, prefix.length);
+    let position = prefix.length + MAGIC.length;
+    let view;
+    const uint = (value) => {
+        while (value >= 128) {
+            output[position++] = value % 128 | 128;
+            value = Math.floor(value / 128);
+        }
+        output[position++] = value;
+    };
+    for (let cursor = 0; cursor < plan.length;) {
+        const tag = plan[cursor++];
+        if (tag !== 11)
+            output[position++] = tag;
+        if (tag < 4)
+            continue;
+        if (tag === 4) {
+            view ??= new DataView(output.buffer);
+            view.setFloat64(position, plan[cursor++], false);
+            position += 8;
+        }
+        else if (tag === 5 || tag === 6) {
+            let value = plan[cursor++];
+            // Seven varint bytes fit exactly in a safe-integer Number (49 bits).
+            // Extract one BigInt limb rather than shifting/masking BigInt for every byte.
+            while (value >= BIGINT_LIMB) {
+                let limb = Number(value & BIGINT_MASK);
+                for (let index = 0; index < 7; index++) {
+                    output[position++] = limb % 128 | 128;
+                    limb = Math.floor(limb / 128);
+                }
+                value >>= 49n;
+            }
+            uint(Number(value));
+        }
+        else if (tag === 7 || tag === 11) {
+            const value = plan[cursor++];
+            const length = plan[cursor++];
+            uint(length);
+            if (length === value.length) {
+                for (let index = 0; index < length; index++)
+                    output[position++] = value.charCodeAt(index);
+            }
+            else {
+                const result = utf8.encodeInto(value, output.subarray(position, position + length));
+                if (result.read !== value.length || result.written !== length)
+                    throw new Error('UTF-8 planning mismatch');
+                position += length;
+            }
+        }
+        else if (tag === 8) {
+            const value = plan[cursor++];
+            const length = plan[cursor++];
+            if (value.length !== length)
+                throw new RangeError('Byte input changed while encoding');
+            uint(length);
+            output.set(value, position);
+            position += length;
+        }
+        else {
+            uint(plan[cursor++]);
+        }
+    }
+    if (position !== capacity)
+        throw new Error('Binary planning mismatch');
+    return output;
+}
+/** Strict decoder: byte input, version, canonical ordering, bounds and complete consumption. */
+function decodeValue(input, options = {}) {
+    const limits = limitsFor(options);
+    if (!(input instanceof Uint8Array))
+        throw new TypeError('Wire payload must be Uint8Array');
+    if (input.length > limits.maxBytes)
+        throw new RangeError('Binary value exceeds byte limit');
+    const reader = new BinaryReader(input);
+    if (reader.readBytes(MAGIC.length).some((byte, index) => byte !== MAGIC[index]))
+        throw new TypeError('Unsupported binary wire version');
+    let nodes = 0;
+    const string = () => text.decode(reader.readFrame());
+    const read = (depth) => {
+        if (++nodes > limits.maxNodes || depth > limits.maxDepth)
+            throw new RangeError('Binary value exceeds complexity limit');
+        const tag = reader.readBytes(1)[0];
+        if (tag === 0)
+            return undefined;
+        if (tag === 1)
+            return null;
+        if (tag === 2)
+            return false;
+        if (tag === 3)
+            return true;
+        if (tag === 4) {
+            const bytes = reader.readBytes(8);
+            const value = new DataView(bytes.buffer, bytes.byteOffset, 8).getFloat64(0, false);
+            if (!Number.isFinite(value))
+                throw new TypeError('Binary numbers must be finite');
+            return value;
+        }
+        if (tag === 5 || tag === 6) {
+            const value = reader.readVarBigInt();
+            if (tag === 6 && value === 0n)
+                throw new TypeError('Non-canonical negative zero');
+            return tag === 6 ? -value : value;
+        }
+        if (tag === 7)
+            return string();
+        if (tag === 8)
+            return new Uint8Array(reader.readFrame());
+        if (tag === 9 || tag === 10) {
+            const count = reader.readVarUint();
+            if (count > limits.maxNodes - nodes || count > reader.remaining)
+                throw new RangeError('Invalid binary collection size');
+            if (tag === 9)
+                return Array.from({ length: count }, () => read(depth + 1));
+            const result = {};
+            let previous;
+            for (let index = 0; index < count; index++) {
+                const key = string();
+                if (previous !== undefined && key <= previous)
+                    throw new TypeError('Non-canonical binary map keys');
+                previous = key;
+                Object.defineProperty(result, key, { value: read(depth + 1), enumerable: true, writable: true, configurable: true });
+            }
+            return result;
+        }
+        throw new TypeError('Unknown binary value tag');
+    };
+    const value = read(0);
+    if (reader.remaining)
+        throw new TypeError('Trailing binary data');
+    return value;
+}
+/** Domain separation prevents RPC bytes from being accepted as worker/chat/peer messages. */
+const encodeWire = (channel, value, limits) => encodeValue([channel, value], limits);
+function decodeWire(channel, bytes, limits) {
+    const envelope = decodeValue(bytes, limits);
+    if (!Array.isArray(envelope) || envelope.length !== 2 || envelope[0] !== channel)
+        throw new TypeError('Wrong binary message channel');
+    return envelope[1];
+}
+
+/** Decoded objects stay inside a process. Every actual IPC payload is canonical bytes. */
+class BinaryWorker {
+    #transport;
+    #errorHandler;
+    constructor(url, options = {}) {
+        const transport = new EasyWorker(url, { ...options, serialization: 'advanced' });
+        // EasyWorker's parent constructor is asynchronous, the child constructor is not.
+        if (transport && typeof transport.then === 'function')
+            return transport.then(value => { this.#transport = value; this.worker = value.worker; return this; });
+        this.#transport = transport;
+        this.worker = transport.worker;
+    }
+    postMessage(value) { this.#transport.postMessage(encodeWire('worker', value)); }
+    onmessage(handler) {
+        this.#transport.onmessage(bytes => {
+            let value;
+            try {
+                value = decodeWire('worker', bytes);
+            }
+            catch (error) {
+                if (this.#errorHandler)
+                    this.#errorHandler(error);
+                else
+                    throw error;
+                return;
+            }
+            handler(value);
+        });
+    }
+    onerror(handler) { this.#errorHandler = handler; this.#transport.onerror(handler); }
+    terminate() { return this.#transport.terminate(); }
+    async once(value) {
+        let timer;
+        try {
+            return await new Promise((resolve, reject) => {
+                timer = setTimeout(() => reject(new Error('Binary worker request timed out')), 10000);
+                this.onerror(reject);
+                this.onmessage(resolve);
+                this.postMessage(value);
+            });
+        }
+        finally {
+            clearTimeout(timer);
+            this.terminate();
+        }
+    }
+}
+
+/** Freeze declarations, not decoded messages. Keep existing consumer field types mutable. */
+const defineSchema = (proto) => Object.freeze(proto);
+
+var proto$2 = defineSchema({
     index: BigInt(0),
     previousHash: String(),
     timestamp: Number(),
@@ -9,7 +683,7 @@ var proto$3 = {
     producer: String(),
     producerProof: String(),
     protocolVersion: String()
-};
+});
 
 // base-x encoding / decoding
 // Copyright (c) 2018 base-x contributors
@@ -397,261 +1071,48 @@ const isBase58 = (string) => {
         return true;
     }
     catch (e) {
-        return false;
-    }
-};
-const isBase58Hex = (string) => {
-    try {
-        decodeHex(string);
-        return true;
-    }
-    catch (e) {
-        return false;
-    }
-};
-const whatType = (string) => {
-    try {
-        decode$1(string);
-        return "base58";
-    }
-    catch (e) {
-        try {
-            decodeHex(string);
-            return "base58Hex";
-        }
-        catch {
-            return;
-        }
-    }
-};
-var base58$1 = {
-    encode: encode$1,
-    decode: decode$1,
-    isBase58,
-    isBase58Hex,
-    encodeHex,
-    decodeHex,
-    whatType,
-};
-
-var isHex = string => /^[A-F0-9]+$/i.test(
-  string.startsWith('0x') ?
-  string.slice(2) :
-  string
-);
-
-/** @leofcoin/binary: dependency-free unsigned framing, with no global byte counters. */
-const MAX_BIGINT = (1n << 256n) - 1n;
-function size(value) {
-    if (!Number.isSafeInteger(value) || value < 0)
-        throw new RangeError('Expected an unsigned safe integer');
-}
-function bytes(value) {
-    if (!(value instanceof Uint8Array))
-        throw new TypeError('Expected Uint8Array');
-}
-function varUintLength(value) {
-    size(value);
-    let length = 1;
-    while (value >= 128) {
-        value = Math.floor(value / 128);
-        length++;
-    }
-    return length;
-}
-function varBigIntLength(value) {
-    if (typeof value !== 'bigint')
-        throw new TypeError('Expected BigInt');
-    if (value < 0n || value > MAX_BIGINT)
-        throw new RangeError('Expected an unsigned 256-bit integer');
-    let length = 1;
-    while (value >= 128n) {
-        value >>= 7n;
-        length++;
-    }
-    return length;
-}
-/** Fixed-capacity writer. finish() is a view; copy it before reusing/resetting the writer. */
-class BinaryWriter {
-    #buffer;
-    #position = 0;
-    constructor(capacity = 64) {
-        if (typeof capacity === 'number') {
-            size(capacity);
-            this.#buffer = new Uint8Array(capacity);
-        }
-        else {
-            bytes(capacity);
-            this.#buffer = capacity;
-        }
-    }
-    get position() {
-        return this.#position;
-    }
-    get remaining() {
-        return this.#buffer.length - this.#position;
-    }
-    #require(length) {
-        size(length);
-        if (length > this.remaining)
-            throw new RangeError('Binary output buffer is too small');
-    }
-    writeVarUint(value) {
-        this.#require(varUintLength(value));
-        this.#writeVarUint(value);
-        return this;
-    }
-    #writeVarUint(value) {
-        while (value >= 128) {
-            this.#buffer[this.#position++] = value % 128 | 128;
-            value = Math.floor(value / 128);
-        }
-        this.#buffer[this.#position++] = value;
-    }
-    writeVarBigInt(value) {
-        this.#require(varBigIntLength(value));
-        do {
-            const byte = Number(value & 127n);
-            value >>= 7n;
-            this.#buffer[this.#position++] = byte | (value ? 128 : 0);
-        } while (value);
-        return this;
-    }
-    writeBytes(value) {
-        bytes(value);
-        this.#require(value.length);
-        this.#buffer.set(value, this.#position);
-        this.#position += value.length;
-        return this;
-    }
-    writeFrame(value) {
-        bytes(value);
-        // Check the complete operation before writing its length prefix.
-        const prefixLength = varUintLength(value.length);
-        this.#require(prefixLength + value.length);
-        const prefixStart = this.#buffer.byteOffset + this.#position;
-        if (value.buffer === this.#buffer.buffer &&
-            value.byteOffset < prefixStart + prefixLength &&
-            value.byteOffset + value.length > prefixStart)
-            throw new RangeError('Frame source overlaps its length prefix');
-        this.#writeVarUint(value.length);
-        this.#buffer.set(value, this.#position);
-        this.#position += value.length;
-        return this;
-    }
-    reset() {
-        this.#position = 0;
-        return this;
-    }
-    finish(copy = false) {
-        const result = this.#buffer.subarray(0, this.#position);
-        // Buffer.slice() aliases memory; this constructor copies every Uint8Array subtype.
-        return copy ? new Uint8Array(result) : result;
-    }
-}
-/** Reads views of the original buffer. Failed operations leave the cursor unchanged. */
-class BinaryReader {
-    #buffer;
-    #position = 0;
-    constructor(buffer) {
-        bytes(buffer);
-        this.#buffer = buffer;
-    }
-    get position() {
-        return this.#position;
-    }
-    get remaining() {
-        return this.#buffer.length - this.#position;
-    }
-    readVarUint(canonical = true) {
-        let result = 0;
-        let multiplier = 1;
-        for (let index = 0; index < 8; index++) {
-            const cursor = this.#position + index;
-            if (cursor >= this.#buffer.length)
-                throw new RangeError('Truncated varint');
-            const byte = this.#buffer[cursor];
-            const payload = byte & 127;
-            if (index === 7 && payload > Math.floor((Number.MAX_SAFE_INTEGER - result) / multiplier))
-                throw new RangeError('Varint exceeds safe integer range');
-            result += payload * multiplier;
-            if (byte < 128) {
-                if (canonical && index > 0 && payload === 0)
-                    throw new RangeError('Non-canonical varint');
-                this.#position = cursor + 1;
-                return result;
-            }
-            multiplier *= 128;
-        }
-        throw new RangeError('Varint exceeds safe integer range');
-    }
-    readVarBigInt(canonical = true) {
-        let result = 0n;
-        for (let index = 0; index < 37; index++) {
-            const cursor = this.#position + index;
-            if (cursor >= this.#buffer.length)
-                throw new RangeError('Truncated varint');
-            const byte = this.#buffer[cursor];
-            result |= BigInt(byte & 127) << BigInt(index * 7);
-            if (result > MAX_BIGINT)
-                throw new RangeError('Varint exceeds 256 bits');
-            if (byte < 128) {
-                if (canonical && index > 0 && byte === 0)
-                    throw new RangeError('Non-canonical varint');
-                this.#position = cursor + 1;
-                return result;
-            }
-        }
-        throw new RangeError('Varint exceeds 256 bits');
+        return false;
     }
-    readBytes(length) {
-        size(length);
-        if (length > this.remaining)
-            throw new RangeError('Truncated binary field');
-        const start = this.#position;
-        this.#position += length;
-        return this.#buffer.subarray(start, this.#position);
+};
+const isBase58Hex = (string) => {
+    try {
+        decodeHex(string);
+        return true;
     }
-    readFrame(canonical = true) {
-        const start = this.#position;
+    catch (e) {
+        return false;
+    }
+};
+const whatType = (string) => {
+    try {
+        decode$1(string);
+        return "base58";
+    }
+    catch (e) {
         try {
-            return this.readBytes(this.readVarUint(canonical));
+            decodeHex(string);
+            return "base58Hex";
         }
-        catch (error) {
-            this.#position = start;
-            throw error;
+        catch {
+            return;
         }
     }
-}
-/** Existing smart-concat bytes, with exactly one output allocation and no prefix arrays. */
-function encodeFrames(frames, prefix) {
-    if (!Array.isArray(frames))
-        throw new TypeError('Expected an array of byte frames');
-    let length = 0;
-    for (const frame of frames) {
-        bytes(frame);
-        length += varUintLength(frame.length) + frame.length;
-        size(length);
-    }
-    const writer = new BinaryWriter(length);
-    for (const frame of frames)
-        writer.writeFrame(frame);
-    return writer.finish();
-}
-/** Iterative framing: bounded by the input length, not recursive stack depth. */
-function decodeFrames(buffer, prefixLength = 0, options = {}) {
-    const reader = new BinaryReader(buffer);
-    reader.readBytes(prefixLength);
-    const maxFrames = options.maxFrames ?? buffer.length;
-    size(maxFrames);
-    const frames = [];
-    while (reader.remaining) {
-        if (frames.length >= maxFrames)
-            throw new RangeError('Too many binary frames');
-        frames.push(reader.readFrame(options.canonical ?? true));
-    }
-    return frames;
-}
+};
+var base58$1 = {
+    encode: encode$1,
+    decode: decode$1,
+    isBase58,
+    isBase58Hex,
+    encodeHex,
+    decodeHex,
+    whatType,
+};
+
+var isHex = string => /^[A-F0-9]+$/i.test(
+  string.startsWith('0x') ?
+  string.slice(2) :
+  string
+);
 
 const asBytes = (source) => {
     if (source instanceof Uint8Array)
@@ -8212,7 +8673,7 @@ const utils = {
     codecs: registry
 };
 
-class Codec extends BasicInterface {
+let Codec$1 = class Codec extends BasicInterface {
     codecBuffer;
     codec;
     hashAlg;
@@ -8313,7 +8774,7 @@ class Codec extends BasicInterface {
         this.encoded = new BinaryWriter(varUintLength(codec)).writeVarUint(codec).finish();
         return this.encoded;
     }
-}
+};
 
 /*!
  * hash-wasm (https://www.npmjs.com/package/hash-wasm)
@@ -8985,7 +9446,7 @@ class CodecHash extends BasicInterface {
             this.name = name;
         if (!buffer)
             throw new Error('buffer is required for encoding');
-        this.discoCodec = new Codec(this.name);
+        this.discoCodec = new Codec$1(this.name);
         let hashAlg = this.discoCodec.hashAlg;
         const hashVariant = Number(hashAlg.split('-')[hashAlg.split('-').length - 1]);
         if (hashAlg.includes('dbl')) {
@@ -9014,7 +9475,7 @@ class CodecHash extends BasicInterface {
         buffer = buffer ?? this.encoded;
         // Validate completely before changing this instance, including cached encodings.
         const header = hashHeader(buffer);
-        const codec = new Codec(header.name);
+        const codec = new Codec$1(header.name);
         const digest = new Uint8Array(buffer.subarray(header.offset));
         this.#clearEncodingCache();
         this.encoded = buffer;
@@ -9054,13 +9515,13 @@ let FormatInterface$1 = class FormatInterface extends BasicInterface {
     hasCodec() {
         if (!this.encoded)
             return false;
-        const codec = new Codec(this.encoded);
+        const codec = new Codec$1(this.encoded);
         if (codec.name)
             return true;
     }
     decode(encoded) {
         encoded = encoded || this.encoded;
-        const codec = new Codec(encoded);
+        const codec = new Codec$1(encoded);
         if (codec.codecBuffer) {
             encoded = encoded.slice(codec.codecBuffer.length);
             this.name = codec.name;
@@ -9078,7 +9539,7 @@ let FormatInterface$1 = class FormatInterface extends BasicInterface {
     encode(decoded) {
         let encoded;
         decoded = decoded || this.decoded;
-        const codec = new Codec(this.name);
+        const codec = new Codec$1(this.name);
         if (decoded instanceof Uint8Array)
             encoded = decoded;
         else
@@ -9117,7 +9578,7 @@ let FormatInterface$1 = class FormatInterface extends BasicInterface {
     get contentBytes() {
         if (!this.encoded)
             return new Uint8Array(0);
-        const codec = new Codec(this.encoded);
+        const codec = new Codec$1(this.encoded);
         if (codec.codecBuffer) {
             return this.encoded.slice(codec.codecBuffer.length);
         }
@@ -9198,37 +9659,182 @@ let FormatInterface$1 = class FormatInterface extends BasicInterface {
  * Interface for defining codec formats
  */
 const FormatInterface = FormatInterface$1;
+/**
+ * Codec utility class
+ */
+const Codec = Codec$1;
+
+const schemas = new WeakMap();
+const kindOf = (value) => value === undefined ? 'any'
+    : value instanceof Uint8Array ? 'bytes' : Array.isArray(value) ? 'array' : typeof value;
+function schemaFor(proto) {
+    const cached = schemas.get(proto);
+    if (cached)
+        return cached;
+    const keys = Object.keys(proto);
+    const schema = {
+        fields: keys.map(key => ({
+            key, name: key.endsWith('?') ? key.slice(0, -1) : key, kind: kindOf(proto[key])
+        })),
+        prefixes: new Map()
+    };
+    // Only immutable declarations can safely reuse keys, types and codec framing.
+    // Caller-defined mutable schemas remain supported and are recompiled per operation.
+    if (Object.isFrozen(proto) && keys.every(key => 'value' in Object.getOwnPropertyDescriptor(proto, key)))
+        schemas.set(proto, schema);
+    return schema;
+}
+function codecPrefix(schema, name) {
+    let prefix = schema.prefixes.get(name);
+    if (!prefix) {
+        const codec = new Codec(name);
+        if (!codec.codecBuffer)
+            throw new Error('invalid codec');
+        prefix = new Uint8Array(codec.codecBuffer);
+        schema.prefixes.set(name, prefix);
+    }
+    return prefix;
+}
+/** Codec prefix + versioned binary tuple, in declared schema order. No proto-array JSON. */
+class BinaryFormat extends FormatInterface {
+    field(key, value, kind) {
+        if (value === undefined)
+            return value;
+        kind ??= kindOf(this.proto[key]);
+        if (kind === 'any')
+            return value;
+        if (kind === 'bigint') {
+            if (typeof value === 'number' && !Number.isSafeInteger(value))
+                throw new TypeError('Unsafe integer message field');
+            if (!['number', 'string', 'bigint'].includes(typeof value))
+                throw new TypeError('Invalid BigInt message field');
+            return BigInt(value);
+        }
+        if (kind === 'bytes') {
+            if (!(value instanceof Uint8Array))
+                throw new TypeError('Message byte field must be Uint8Array');
+        }
+        else if (kind === 'array') {
+            if (!Array.isArray(value))
+                throw new TypeError('Message array field must be an array');
+        }
+        else if (typeof value !== kind || value === null)
+            throw new TypeError('Message field type mismatch');
+        return value;
+    }
+    create(value) {
+        const { fields } = schemaFor(this.proto);
+        // Content hashes are derived, never trusted from a caller-supplied cache field.
+        this.decoded = Object.fromEntries(fields.map(field => {
+            const input = value?.[field.name];
+            return [field.name, field.kind === 'bigint' ? this.field(field.key, input, field.kind) : input];
+        }));
+    }
+    tuple(value, fields) {
+        const tuple = new Array(fields.length);
+        for (let index = 0; index < fields.length; index++) {
+            const field = fields[index];
+            tuple[index] = this.field(field.key, value[field.name], field.kind);
+        }
+        return tuple;
+    }
+    protoEncode(value) {
+        return encodeValue(this.tuple(value, schemaFor(this.proto).fields));
+    }
+    encode(value) {
+        value = value || this.decoded;
+        const schema = schemaFor(this.proto);
+        const prefix = codecPrefix(schema, this.name);
+        if (value instanceof Uint8Array) {
+            // Preserve the base interface's already-encoded-content path.
+            const output = new Uint8Array(prefix.length + value.length);
+            output.set(prefix);
+            output.set(value, prefix.length);
+            this.encoded = output;
+        }
+        else {
+            this.encoded = encodeValueWithPrefix(this.tuple(value, schema.fields), prefix);
+        }
+        return this.encoded;
+    }
+    protoDecode(bytes) {
+        const values = decodeValue(bytes);
+        const { fields } = schemaFor(this.proto);
+        if (!Array.isArray(values) || values.length !== fields.length)
+            throw new TypeError('Binary message schema mismatch');
+        return Object.fromEntries(fields.map((field, index) => {
+            const value = this.field(field.key, values[index], field.kind);
+            if (typeof value !== typeof values[index])
+                throw new TypeError('Non-canonical message field type');
+            return [field.name, value];
+        }));
+    }
+    decode(bytes) {
+        bytes ??= this.encoded;
+        if (!(bytes instanceof Uint8Array))
+            throw new TypeError('Message payload must be Uint8Array');
+        const codec = new Codec(bytes);
+        if (codec.name !== this.name)
+            throw new TypeError('Wrong binary message codec');
+        // Parse the codec once and borrow its content view; decoded byte fields still own copies.
+        this.decoded = this.protoDecode(bytes.subarray(codec.codecBuffer.length));
+        return this.decoded;
+    }
+    fromUint8Array(bytes) { this.encoded = bytes; return this.decode(bytes); }
+    fromArrayBuffer(buffer) { return this.fromUint8Array(new Uint8Array(buffer)); }
+}
 
-var proto$2 = {
+var proto$1 = defineSchema({
     address: String(),
     reward: BigInt(0)
-};
+});
 
-({
-    epoch: BigInt(0)});
+defineSchema({
+    epoch: BigInt(0),
+    configDigest: String(),
+    from: String(),
+    signature: String()
+});
 
-({
+defineSchema({
     epoch: BigInt(0),
     threshold: BigInt(0),
     participant: BigInt(0),
-    commitments: Array()});
+    from: String(),
+    commitments: Array(),
+    signature: String()
+});
 
-({
+defineSchema({
     epoch: BigInt(0),
     round: BigInt(0),
-    participant: BigInt(0)});
+    participant: BigInt(0),
+    from: String(),
+    signatureShare: String(),
+    signature: String()
+});
+
+defineSchema({
+    up: Number(),
+    down: Number()
+});
 
-var proto$1 = {
+defineSchema({});
+
+var proto = defineSchema({
     creator: String(),
     contract: new Uint8Array(),
     constructorParameters: Array()
-};
+});
 
-({
+defineSchema({
+    hash: String(),
     index: BigInt(0)
 });
 
-var proto = {
+defineSchema({});
+
+defineSchema({
     timestamp: Number(),
     from: String(),
     to: String(),
@@ -9238,138 +9844,44 @@ var proto = {
     'nonce?': Number(),
     'dependsOn?': Array(),
     'priority?': Boolean()
-};
+});
+
+defineSchema({
+    timestamp: Number(),
+    from: String(),
+    to: String(),
+    method: String(),
+    params: Array(),
+    'nonce?': Number()
+});
 
-({
-    params: Array()});
+defineSchema({
+    lastblock: Object(),
+    values: Object()
+});
 
-({
+defineSchema({
+    blockHash: String(),
     index: BigInt(0),
-    round: BigInt(0)});
+    round: BigInt(0),
+    from: String(),
+    signature: String()
+});
 
-({
+defineSchema({
+    blockHash: String(),
     index: BigInt(0),
-    round: BigInt(0)});
+    round: BigInt(0),
+    from: String(),
+    signature: String()
+});
 
-({
+defineSchema({
+    blockHash: String(),
     index: BigInt(0),
-    round: BigInt(0)});
-
-class EasyWorker {
-    #messageEvent = 'message';
-    #errorEvent = 'error';
-    #isBrowser = false;
-    #isWorker = false;
-    #messageHandler = null;
-    #errorHandler = null;
-    worker;
-    get isWorker() {
-        return this.#isWorker;
-    }
-    constructor(url, options) {
-        return this.#init(url, options);
-    }
-    #init(url, options = {}) {
-        if (url) {
-            if (globalThis.Worker) {
-                this.#isBrowser = true;
-                this.worker = new Worker(url, { ...options });
-            }
-            else {
-                return new Promise((resolve, reject) => {
-                    import('child_process').then(({ fork }) => {
-                        const child = fork(url, ['easy-worker-child'], options);
-                        child.once('error', reject);
-                        this.worker = child;
-                        resolve(this);
-                    }).catch(reject);
-                });
-            }
-        }
-        else {
-            this.#isWorker = true;
-            if (globalThis.process?.argv[2] === 'easy-worker-child') {
-                this.worker = process;
-            }
-            else {
-                this.#isBrowser = true;
-                this.worker = globalThis;
-            }
-        }
-        return this;
-    }
-    onmessage(fn) {
-        if (this.#isBrowser) {
-            this.worker.onmessage = ({ data }) => fn(data);
-        }
-        else {
-            if (this.#messageHandler)
-                this.worker.off(this.#messageEvent, this.#messageHandler);
-            this.#messageHandler = fn;
-            this.worker.on(this.#messageEvent, fn);
-        }
-    }
-    postMessage(message) {
-        if (this.#isBrowser)
-            this.worker.postMessage(message);
-        else
-            this.worker.send(message);
-    }
-    terminate() {
-        if (this.#isBrowser)
-            this.worker.terminate();
-        else
-            this.worker.kill();
-    }
-    onerror(fn) {
-        if (this.#isBrowser) {
-            this.worker.onerror = fn;
-        }
-        else {
-            if (this.#errorHandler)
-                this.worker.off(this.#errorEvent, this.#errorHandler);
-            this.#errorHandler = fn;
-            this.worker.on(this.#errorEvent, fn);
-        }
-    }
-    /**
-     *
-     * @param {*} data
-     * @returns {Promise} resolves result onmessage & rejects on error
-     */
-    once(data) {
-        return new Promise((resolve, reject) => {
-            if (this.#isBrowser) {
-                const handleMessage = ({ data: result }) => {
-                    this.worker.onerror = null;
-                    resolve(result);
-                    this.terminate();
-                };
-                const handleError = (error) => {
-                    this.worker.onmessage = null;
-                    reject(error);
-                    this.terminate();
-                };
-                this.worker.onmessage = handleMessage;
-                this.worker.onerror = handleError;
-            }
-            else {
-                const handleMessage = (result) => {
-                    this.worker.off(this.#errorEvent, handleError);
-                    resolve(result);
-                    this.terminate();
-                };
-                const handleError = (error) => {
-                    this.worker.off(this.#messageEvent, handleMessage);
-                    reject(error);
-                    this.terminate();
-                };
-                this.worker.once(this.#messageEvent, handleMessage);
-                this.worker.once(this.#errorEvent, handleError);
-            }
-            this.postMessage(data);
-        });
-    }
-}
+    round: BigInt(0),
+    from: String(),
+    signature: String()
+});
 
-export { EasyWorker as E, FormatInterface as F, proto$2 as a, jsonParseBigInt$1 as b, proto$1 as c, decodeFrames as d, encodeFrames as e, proto as f, jsonStringifyBigInt$1 as j, proto$3 as p };
+export { BinaryWorker as B, BinaryFormat as a, proto$1 as b, encodeValue as c, decodeFrames as d, encodeFrames as e, proto as f, jsonStringifyBigInt$1 as j, proto$2 as p };