@leofcoin/chain 1.10.14 → 1.10.16

package/exports/browser/{node-browser-CQugE1WZ.js → node-browser-DWSdi-XP.js}

@@ -1,5 +1,5 @@
-import { F as FormatInterface$2, T as TransactionMessage, C as ContractMessage, n as createHash$1 } from './browser-crypto-CTP3Yk4M.js';
-import { B as BlockMessage, a as BWMessage, V as ValidatorMessage, S as StateMessage, L as LastBlockMessage, D as DEFAULT_NODE_OPTIONS, g as guardPeerMessages } from './connection-monitor-pdopeM1I.js';
+import { F as FormatInterface$2, T as TransactionMessage, C as ContractMessage, n as createHash$1 } from './browser-crypto-CeE-yId5.js';
+import { B as BlockMessage, a as BWMessage, V as ValidatorMessage, S as StateMessage, L as LastBlockMessage, D as DEFAULT_NODE_OPTIONS, g as guardPeerMessages } from './connection-monitor-Cmv00mwl.js';
 import './index-CvKt4UDE.js';
 
 var proto = {};
@@ -398,13 +398,13 @@ const ALPHABET$1$1 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz
 const ALPHABET_HEX$1 = "0123456789ABCDEFGHJKLMNPQRSTUVabcdefghijklmnopqrstuv";
 const base58 = base(ALPHABET$1$1);
 const base58Hex = base(ALPHABET_HEX$1);
-const encode$4 = base58.encode;
-const decode$5 = base58.decode;
+const encode$3 = base58.encode;
+const decode$4 = base58.decode;
 const encodeHex$2 = base58Hex.encode;
 const decodeHex$2 = base58Hex.decode;
 const isBase58 = (string) => {
     try {
-        decode$5(string);
+        decode$4(string);
         return true;
     }
     catch (e) {
@@ -422,7 +422,7 @@ const isBase58Hex = (string) => {
 };
 const whatType = (string) => {
     try {
-        decode$5(string);
+        decode$4(string);
         return "base58";
     }
     catch (e) {
@@ -436,8 +436,8 @@ const whatType = (string) => {
     }
 };
 var base58$1 = {
-    encode: encode$4,
-    decode: decode$5,
+    encode: encode$3,
+    decode: decode$4,
     isBase58,
     isBase58Hex,
     encodeHex: encodeHex$2,
@@ -524,7 +524,7 @@ const concatAndDoubleHash = async (input) => {
     return new Uint8Array(await createDoubleHash(typedArrayConcat(input), 'SHA-256'));
 };
 
-const encode$3 = async (source, prefix = new TextEncoder().encode('00'), hex) => {
+const encode$2 = async (source, prefix = new TextEncoder().encode('00'), hex) => {
     if (!(source instanceof Uint8Array) || !(prefix instanceof Uint8Array)) {
         throw new TypeError('Expected Uint8Array');
     }
@@ -541,7 +541,7 @@ const encode$3 = async (source, prefix = new TextEncoder().encode('00'), hex) =>
         return base58$1.encodeHex(uint8Array);
     return base58$1.encode(uint8Array);
 };
-const decode$4 = async (string, hex) => {
+const decode$3 = async (string, hex) => {
     let uint8Array = hex ? base58$1.decodeHex(string) : base58$1.decode(string);
     const prefix = uint8Array.subarray(0, 2);
     const source = uint8Array.subarray(2, -4);
@@ -561,129 +561,242 @@ const decode$4 = async (string, hex) => {
 };
 const isBase58check = (string, hex) => {
     try {
-        hex ? decode$4(string, true) : decode$4(string);
+        hex ? decode$3(string, true) : decode$3(string);
         return true;
     }
     catch (e) {
         return false;
     }
 };
-const encodeHex$1 = (uint8Array, prefix = new TextEncoder().encode('00')) => encode$3(uint8Array, prefix, true);
-const decodeHex$1 = (string) => decode$4(string, true);
+const encodeHex$1 = (uint8Array, prefix = new TextEncoder().encode('00')) => encode$2(uint8Array, prefix, true);
+const decodeHex$1 = (string) => decode$3(string, true);
 const isBase58checkHex = (string) => isBase58check(string, true);
-var base58check = { encode: encode$3, decode: decode$4, encodeHex: encodeHex$1, decodeHex: decodeHex$1, isBase58check, isBase58checkHex };
-
-const MSB$1 = 0x80;
-const MSBALL = -128;
-const INT = Math.pow(2, 31);
-const encode$2 = (num, out, offset) => {
-    if (Number.MAX_SAFE_INTEGER && num > Number.MAX_SAFE_INTEGER) {
-        encode$2.bytes = 0;
-        throw new RangeError('Could not encode varint');
-    }
-    out = out || [];
-    offset = offset || 0;
-    const oldOffset = offset;
-    while (num >= INT) {
-        out[offset++] = (num & 0xFF) | MSB$1;
-        num /= 128;
-    }
-    while (num & MSBALL) {
-        out[offset++] = (num & 0xFF) | MSB$1;
-        num >>>= 7;
-    }
-    out[offset] = num | 0;
-    encode$2.bytes = offset - oldOffset + 1;
-    return out;
-};
+var base58check = { encode: encode$2, decode: decode$3, encodeHex: encodeHex$1, decodeHex: decodeHex$1, isBase58check, isBase58checkHex };
 
-const MSB = 0x80;
-const REST = 0x7F;
-const decode$3 = (buf, offset) => {
-    offset = offset || 0;
-    const l = buf.length;
-    let counter = offset;
-    let result = 0;
-    let shift = 0;
-    let b;
-    do {
-        if (counter >= l || shift > 49) {
-            decode$3.bytes = 0;
-            throw new RangeError('Could not decode varint');
+/** @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);
         }
-        b = buf[counter++];
-        result += shift < 28
-            ? (b & REST) << shift
-            : (b & REST) * Math.pow(2, shift);
-        shift += 7;
-    } while (b >= MSB);
-    decode$3.bytes = counter - offset;
-    return result;
-};
-
-const N1 = Math.pow(2, 7);
-const N2 = Math.pow(2, 14);
-const N3 = Math.pow(2, 21);
-const N4 = Math.pow(2, 28);
-const N5 = Math.pow(2, 35);
-const N6 = Math.pow(2, 42);
-const N7 = Math.pow(2, 49);
-const N8 = Math.pow(2, 56);
-const N9 = Math.pow(2, 63);
-var encodingLength = (value) => (value < N1 ? 1
-    : value < N2 ? 2
-        : value < N3 ? 3
-            : value < N4 ? 4
-                : value < N5 ? 5
-                    : value < N6 ? 6
-                        : value < N7 ? 7
-                            : value < N8 ? 8
-                                : value < N9 ? 9
-                                    : 10);
-
-var index$4 = {
-    encode: encode$2,
-    decode: decode$3,
-    encodingLength
-};
+        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;
+}
 
-var index$3 = (input, prefix) => {
-    const encodedArray = [];
-    const length = input.reduce((total, current) => {
-        const encoded = index$4.encode(current.length);
-        encodedArray.push(encoded);
-        total += current.length + encoded.length;
-        return total;
-    }, 0);
-    const typedArray = new Uint8Array(length);
-    let currentIndex = 0;
-    let index = 0;
-    for (const source of input) {
-        typedArray.set(encodedArray[index], currentIndex);
-        currentIndex += encodedArray[index].length;
-        typedArray.set(source, currentIndex);
-        currentIndex += source.length;
-        index += 1;
-    }
-    return typedArray;
+const asBytes = (source) => {
+    if (source instanceof Uint8Array)
+        return source;
+    // Keep legacy ArrayLike coercion. Typed-array callers take the zero-copy path.
+    const bytes = new Uint8Array(source.length);
+    bytes.set(source);
+    return bytes;
 };
+var index$3 = (input, prefix) => encodeFrames(input.map(asBytes));
 
-var index$2 = (typedArray, prefix) => {
-    const set = [];
-    const varintAndSub = (typedArray) => {
-        const length = index$4.decode(typedArray);
-        // remove length
-        typedArray = typedArray.subarray(index$4.decode.bytes);
-        // push value
-        set.push(typedArray.subarray(0, length));
-        // remove value
-        typedArray = typedArray.subarray(length);
-        if (typedArray.length !== 0)
-            return varintAndSub(typedArray);
-        return set;
-    };
-    return varintAndSub(typedArray);
-};
+var index$2 = (typedArray, prefix) => decodeFrames(typedArray, 0, { canonical: false });
 
 const decode$2 = (multiWif, expectedVersion, expectedCodec) => {
     const decoded = base58$1.decode(multiWif);
@@ -741,176 +854,190 @@ var index$1$1 = {
  * * b = `7n` // equation param
  * * Gx, Gy are coordinates of Generator / base point
  */
+const freeze = Object.freeze;
+const P = 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2fn;
+const N = 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141n;
+const Gx = 0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798n;
+const Gy = 0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8n;
 // Mirror noble-curves: Point.CURVE() returns shared params, but those params must stay frozen so
 // callers cannot mutate them out from under the arithmetic constants captured below.
-const secp256k1_CURVE = Object.freeze({
-    p: 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2fn,
-    n: 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141n,
+const secp256k1_CURVE = freeze({
+    p: P,
+    n: N,
     h: 1n,
     a: 0n,
     b: 7n,
-    Gx: 0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798n,
-    Gy: 0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8n,
+    Gx,
+    Gy,
 });
-const { p: P, n: N, Gx, Gy, b: _b } = secp256k1_CURVE;
 // 32-byte field / scalar width, and the SHA-256 / HMAC-DRBG output width used
 // by the RFC6979 paths here.
 const L = 32;
-const L2 = 64; // 64-byte compact signatures, and 64 hex chars for zero-padded 32-byte scalars
-const lengths = {
-    publicKey: L + 1,
-    publicKeyUncompressed: L2 + 1,
-    // 48-byte keygen seed floor: 384 bits exceeds FIPS 186-5 Table A.2's
-    // 352-bit recommendation for 256-bit prime curves.
-    seed: L + L / 2,
-};
 // Helpers and Precomputes sections are reused between libraries
 // ## Helpers
 // ----------
-const err$1 = (message = '', E = Error) => {
-    const e = new E(message);
-    const { captureStackTrace } = Error;
-    if (typeof captureStackTrace === 'function')
-        captureStackTrace(e, err$1);
-    throw e;
+/** Checks if something is Uint8Array. Be careful: nodejs Buffer will return true. */
+const isBytes = (a) => {
+    // Plain `instanceof Uint8Array` is too strict for some Buffer / proxy / cross-realm cases.
+    // The fallback still requires a real ArrayBuffer view, so plain
+    // JSON-deserialized `{ constructor: ... }` spoofing is rejected, and
+    // `BYTES_PER_ELEMENT === 1` keeps the fallback on byte-oriented views.
+    return (a instanceof Uint8Array ||
+        (ArrayBuffer.isView(a) &&
+            a.constructor.name === 'Uint8Array' &&
+            a.BYTES_PER_ELEMENT === 1));
 };
-// Plain `instanceof Uint8Array` is too strict for some Buffer / proxy / cross-realm cases. The
-// fallback still requires a real ArrayBuffer view so plain JSON-deserialized `{ constructor: ... }`
-// spoofing is rejected, and `BYTES_PER_ELEMENT === 1` keeps the fallback on byte-oriented views.
-const isBytes = (a) => a instanceof Uint8Array ||
-    (ArrayBuffer.isView(a) &&
-        a.constructor.name === 'Uint8Array' &&
-        a.BYTES_PER_ELEMENT === 1);
-/** Asserts something is Bytes. */
+/** Asserts something is Uint8Array. */
 const abytes = (value, length, title = '') => {
+    // Success path first: this runs at the start of every update() / digestInto(), and the
+    // common `abytes(data)` form must not pay for length handling it does not use.
+    if (isBytes(value) && (length === undefined || value.length === length))
+        return value;
+    // Error path: recompute freely to build the exact message.
     const bytes = isBytes(value);
-    const len = value?.length;
-    const needsLen = length !== undefined;
-    if (!bytes || (needsLen && len !== length)) {
-        const prefix = title && `"${title}" `;
-        const ofLen = needsLen ? ` of length ${length}` : '';
-        const got = bytes ? `length=${len}` : `type=${typeof value}`;
-        const msg = prefix + 'expected Uint8Array' + ofLen + ', got ' + got;
-        return bytes ? err$1(msg, RangeError) : err$1(msg, TypeError);
-    }
-    return value;
+    const ofLen = length !== undefined ? ` of length ${length}` : '';
+    const got = bytes ? `length=${value.length}` : `type=${typeof value}`;
+    const message = (title ? `"${title}" ` : '') + 'expected Uint8Array' + ofLen + ', got ' + got;
+    if (!bytes)
+        throw new TypeError(message);
+    throw new RangeError(message);
 };
-/** create Uint8Array */
-const u8n = (len) => new Uint8Array(len);
+// Signing can retain the message across hash callbacks / awaits, and Schnorr hashes it more than
+// once. Take one owned snapshot so caller mutation cannot change the signing transcript.
+// cloneBytes expects an already-validated view; snapshotBytes validates, then copies.
+const cloneBytes = (value) => Uint8Array.from(value);
+const snapshotBytes = (value, title, length) => cloneBytes(abytes(value, length, title));
 // Callers keep values non-negative and within the requested width; padStart() won't truncate over-wide inputs.
 const padh = (n, pad) => n.toString(16).padStart(pad, '0');
-/** Render bytes as lowercase hex. */
-const bytesToHex = (b) => {
+/** Convert byte array to hex string. */
+const bytesToHex = (bytes) => {
     let hex = '';
-    for (const e of abytes(b))
-        hex += padh(e, 2);
+    for (const byte of abytes(bytes))
+        hex += padh(byte, 2);
     return hex;
 };
-const C = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 }; // ASCII characters
-// Strict ASCII nibble parser: non-ASCII hex lookalikes are rejected as undefined.
-// prettier-ignore
-const _ch = (ch) => ch >= C._0 && ch <= C._9 ? ch - C._0 // '2' => 50-48
-    : ch >= C.A && ch <= C.F ? ch - (C.A - 10) // 'B' => 66-(65-10)
-        : ch >= C.a && ch <= C.f ? ch - (C.a - 10) // 'b' => 98-(97-10)
-            : undefined;
+/** Convert hex string to byte array. */
 const hexToBytes = (hex) => {
-    const e = 'hex invalid'; // Strict ASCII hex only, with one generic error for type and parse failures.
+    const e = 'hex invalid'; // Strict ASCII hex only, with one generic error for parse failures.
     if (typeof hex !== 'string')
-        return err$1(e);
-    const hl = hex.length;
-    const al = hl / 2;
-    if (hl % 2)
-        return err$1(e);
-    const array = u8n(al);
-    for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
-        // treat each char as ASCII
-        const n1 = _ch(hex.charCodeAt(hi)); // parse first char, multiply it by 16
-        const n2 = _ch(hex.charCodeAt(hi + 1)); // parse second char
-        if (n1 === undefined || n2 === undefined)
-            return err$1(e);
-        array[ai] = n1 * 16 + n2; // example: 'A9' => 10*16 + 9
+        throw new TypeError(e);
+    if (hex.length % 2 || !/^[\da-f]*$/i.test(hex))
+        throw new RangeError(e);
+    const array = new Uint8Array(hex.length / 2);
+    for (let ai = 0, hi = 0; ai < array.length; ai++, hi += 2) {
+        const n1 = hex.charCodeAt(hi);
+        const n2 = hex.charCodeAt(hi + 1);
+        // Regex guarantees ASCII. For 0..9/A..F/a..f, this maps char codes to 0..15.
+        array[ai] = ((n1 & 15) + (n1 >> 6) * 9) * 16 + (n2 & 15) + (n2 >> 6) * 9;
     }
     return array;
 };
 // WebCrypto is available in all modern environments
-const subtle = () => globalThis?.crypto?.subtle ?? err$1('crypto.subtle must be defined, consider polyfill');
-// prettier-ignore
-const concatBytes = (...arrs) => {
-    let len = 0;
-    for (const a of arrs)
-        len += abytes(a).length; // validate every input and sum lengths before copying
-    const r = u8n(len);
-    let pad = 0; // walk through each array,
-    for (const a of arrs)
-        r.set(a, pad), pad += a.length; // ensure they have proper type
-    return r;
+const subtle = () => {
+    const s = globalThis?.crypto?.subtle;
+    if (s)
+        return s;
+    throw new Error('crypto.subtle must be defined, consider polyfill');
+};
+/** Copies several Uint8Arrays into one. */
+const concatBytes = (...arrays) => {
+    let sum = 0;
+    for (const a of arrays)
+        sum += abytes(a).length;
+    const res = new Uint8Array(sum);
+    let pad = 0;
+    for (const a of arrays) {
+        res.set(a, pad);
+        pad += a.length;
+    }
+    return res;
 };
 /**
  * WebCrypto OS-level CSPRNG (random number generator).
  * Will throw when not available; large-request ceilings are delegated to getRandomValues().
  */
-const randomBytes = (len = L) => (globalThis?.crypto).getRandomValues(u8n(len));
+const randomBytes = (len = L) => {
+    const c = globalThis?.crypto;
+    if (typeof c?.getRandomValues !== 'function')
+        throw new Error('crypto.getRandomValues must be defined, consider polyfill');
+    return c.getRandomValues(new Uint8Array(len));
+};
 const big = BigInt;
 const arange = (n, min, max, msg = 'bad number: out of range') => {
     if (typeof n !== 'bigint')
-        return err$1(msg, TypeError);
+        throw new TypeError(msg);
     if (min <= n && n < max)
         return n;
-    return err$1(msg, RangeError);
+    throw new RangeError(msg);
 };
 /** Canonical modular reduction. Callers must provide a positive modulus. */
-const M = (a, b = P) => {
-    const r = a % b;
-    return r >= 0n ? r : b + r;
-};
+const M = (a, b = P) => ((a %= b) >= 0n ? a : b + a);
 const modN = (a) => M(a, N);
-/** Modular inversion using eucledian GCD (non-CT). No negative exponent for now. */
-// prettier-ignore
-const invert = (num, md) => {
-    if (num === 0n || md <= 0n)
-        err$1('no inverse n=' + num + ' mod=' + md);
-    let a = M(num, md), b = md, x = 0n, u = 1n;
+/** Modular inversion using extended euclidean GCD. Variable-time (non-CT). */
+const invert = (number, modulo) => {
+    if (number === 0n)
+        throw new Error('invert: expected non-zero number');
+    // modulo = 1 is the zero ring: gcd(x, 1) = 1 makes the loop below "succeed" and return the
+    // useless inverse 0. Reject it.
+    if (modulo <= 1n)
+        throw new Error('invert: expected modulus > 1, got ' + modulo);
+    // This is variable-time: the loop count depends on `number`.
+    let a = M(number, modulo);
+    let b = modulo;
+    // Only the Bézout coefficient of `number` (x/u chain) is tracked; the coefficient of `modulo`
+    // never affects the output, so it is not computed.
+    // prettier-ignore
+    let x = 0n, u = 1n;
     while (a !== 0n) {
-        const q = b / a, r = b % a;
+        const q = b / a;
+        const r = b - a * q;
         const m = x - u * q;
+        // prettier-ignore
         b = a, a = r, x = u, u = m;
     }
-    return b === 1n ? M(x, md) : err$1('no inverse'); // b is gcd at this point
+    const gcd = b;
+    if (gcd !== 1n)
+        throw new Error('invert: does not exist');
+    return M(x, modulo);
 };
-const callHash = (name) => {
+const _hash = (name) => {
     // @ts-ignore
     const fn = hashes[name];
     if (typeof fn !== 'function')
-        err$1('hashes.' + name + ' not set');
+        throw new Error('hashes.' + name + ' not set');
     return fn;
 };
 // All exported provider slots are caller-configurable and may be unset or return arbitrary values,
 // so wrapper helpers must enforce the exact 32-byte digest contract instead of trusting providers.
-const gh = (name, a, b) => abytes(callHash(name)(a, b), L, 'digest');
-const gha = (name, a, b) => Promise.resolve(callHash(name)(a, b)).then((r) => abytes(r, L, 'digest'));
+const callHash = (name, a, b) => abytes(_hash(name)(a, b), L, 'digest');
+const callHashAsync = async (name, a, b) => abytes(await _hash(name)(a, b), L, 'digest');
 // also rejects structurally similar Point values from other realms / bundled copies
-const apoint = (p) => (p instanceof Point ? p : err$1('Point expected'));
+const apoint = (p) => {
+    if (p instanceof Point)
+        return p;
+    throw new TypeError('Point expected');
+};
 // ## End of Helpers
 // -----------------
+const E_BADPOINT = 'bad point: not on curve';
 /**
  * secp256k1 formula. Koblitz curves are subclass of weierstrass curves with a=0,
  * making it x³+b; callers validate x first.
  */
-const koblitz = (x) => M(M(x * x) * x + _b);
+const koblitz = (x) => M(M(x * x) * x + 7n);
 /** assert is element of field mod P (incl. 0 for projective infinity coordinates) */
 const FpIsValid = (n) => arange(n, 0n, P);
 /** assert is element of field mod P (excl. 0 where current callers need a non-zero coordinate) */
 const FpIsValidNot0 = (n) => arange(n, 1n, P);
-/** assert is element of field mod N (excl. 0), matching the shared BIP340 scalar-failure rule used here */
+/** assert is element of field mod N (excl. 0), matching the shared BIP340 scalar-failure rule used here.
+ * There is deliberately no FnIsValid: no caller accepts the scalar 0. */
 const FnIsValidNot0 = (n) => arange(n, 1n, N);
 // Shared parity primitive for BIP340 even-y checks and SEC 1 compressed prefixes.
 const isEven = (y) => !(y & 1n);
-/** create Uint8Array of byte n */
-const u8of = (n) => Uint8Array.of(n);
 /** SEC 1 compressed-prefix helper. Parity only: callers validate y before asking for the prefix byte. */
-const getPrefix = (y) => u8of(isEven(y) ? 0x02 : 0x03);
-/** lift_x from BIP340 returns the unique even square root for x³+7.
- * SEC 1 callers still flip it for the odd-prefix branch. */
+const getPrefix = (y) => Uint8Array.of(isEven(y) ? 0x02 : 0x03);
+/** lift_x from BIP340 returns the unique point with x and an even square root of x³+7.
+ * SEC 1 callers still negate it for the odd-prefix branch. */
 const lift_x = (x) => {
     // Let c = x³ + 7 mod p. Fail if x ≥ p. (also fail if x < 1)
     const c = koblitz(FpIsValidNot0(x));
@@ -926,8 +1053,8 @@ const lift_x = (x) => {
         num = (num * num) % P; // Not constant-time.
     }
     if (M(r * r) !== c)
-        err$1('sqrt invalid'); // check if result is valid
-    return isEven(r) ? r : M(-r);
+        throw new Error('sqrt invalid'); // check if result is valid
+    return new Point(x, isEven(r) ? r : M(-r), 1n);
 };
 /**
  * Point in 3d xyz projective coordinates. 3d takes less inversions than 2d.
@@ -951,7 +1078,7 @@ class Point {
         this.X = FpIsValid(X);
         this.Y = FpIsValidNot0(Y); // Y can't be 0 in Projective
         this.Z = FpIsValid(Z);
-        Object.freeze(this);
+        freeze(this);
     }
     /** Returns the shared curve metadata object by reference.
      * It is readonly only at type level, and mutating it won't retarget arithmetic,
@@ -967,30 +1094,31 @@ class Point {
     /** Convert Uint8Array or hex string to Point. */
     static fromBytes(bytes) {
         abytes(bytes);
-        const { publicKey: comp, publicKeyUncompressed: uncomp } = lengths; // e.g. for 32-byte: 33, 65
-        let p = undefined;
         const length = bytes.length;
         const head = bytes[0];
-        const tail = bytes.subarray(1);
-        const x = sliceBytesNumBE(tail, 0, L);
+        const x = sliceBytesNumBE(bytes, 1, 33);
         // SEC 1 defines the rare infinity encoding 0x00, but SEC 1 public-key validation rejects
         // infinity. We keep 0x00 rejected here because this parser is reused by verify(), ECDH,
         // and public-key validation helpers, so strict handling applies to all callers by default.
         // Local secp256k1 crosstests show OpenSSL raw point codecs accept 0x00 too.
-        // Parse SEC 1 compressed/uncompressed encodings, then finish with assertValidity() before returning.
-        if (length === comp && (head === 0x02 || head === 0x03)) {
-            // Equation is y² == x³ + ax + b. We calculate y from x.
-            // lift_x() returns the even root; SEC 1 0x03 still needs the odd root.
-            let y = lift_x(x);
-            if (head === 0x03)
-                y = M(-y);
-            p = new Point(x, y, 1n);
+        // Parse and validate SEC 1 compressed/uncompressed encodings before returning.
+        try {
+            if (length === 33 && (head === 0x02 || head === 0x03)) {
+                // Equation is y² == x³ + ax + b. We calculate y from x.
+                // lift_x() returns the even point; SEC 1 0x03 still needs the odd point.
+                const p = lift_x(x);
+                return head === 0x03 ? p.negate() : p;
+            }
+            // Uncompressed 65-byte point, 0x04 prefix
+            if (length === 65 && head === 0x04)
+                return new Point(x, sliceBytesNumBE(bytes, 33, 65), 1n).assertValidity();
         }
-        // Uncompressed 65-byte point, 0x04 prefix
-        if (length === uncomp && head === 0x04)
-            p = new Point(x, sliceBytesNumBE(tail, L, L2), 1n);
-        // Validate point
-        return p ? p.assertValidity() : err$1('bad point: not on curve');
+        catch (error) {
+            // Out-of-range coordinates and non-residue x report the same error as wrong
+            // prefixes / off-curve points, instead of generic range-check messages.
+            throw new Error(E_BADPOINT);
+        }
+        throw new Error(E_BADPOINT);
     }
     static fromHex(hex) {
         return Point.fromBytes(hexToBytes(hex));
@@ -1005,14 +1133,10 @@ class Point {
     equals(other) {
         const { X: X1, Y: Y1, Z: Z1 } = this;
         const { X: X2, Y: Y2, Z: Z2 } = apoint(other); // checks class equality
-        const X1Z2 = M(X1 * Z2);
-        const X2Z1 = M(X2 * Z1);
-        const Y1Z2 = M(Y1 * Z2);
-        const Y2Z1 = M(Y2 * Z1);
-        return X1Z2 === X2Z1 && Y1Z2 === Y2Z1;
+        return M(X1 * Z2) === M(X2 * Z1) && M(Y1 * Z2) === M(Y2 * Z1);
     }
     is0() {
-        return this.equals(I);
+        return this.Z === 0n;
     }
     /** Flip point over y coordinate. */
     negate() {
@@ -1032,7 +1156,7 @@ class Point {
         const { X: X1, Y: Y1, Z: Z1 } = this;
         const { X: X2, Y: Y2, Z: Z2 } = apoint(other);
         const a = 0n;
-        const b = _b;
+        const b = 7n;
         let X3 = 0n, Y3 = 0n, Z3 = 0n;
         const b3 = M(b * 3n);
         let t0 = M(X1 * X2), t1 = M(Y1 * Y2), t2 = M(Z1 * Z2), t3 = M(X1 + Y1); // step 1
@@ -1096,13 +1220,18 @@ class Point {
         // init result point & fake point
         let p = I;
         let f = G;
-        for (let d = this; n > 0n; d = d.double(), n >>= 1n) {
+        let d = this;
+        // Safe mode always runs 256 iterations so ladder length can't leak the scalar's
+        // leading zero bits; unsafe mode stops at the top set bit for speed.
+        for (let i = 0; safe ? i < 256 : n > 0n; i++) {
             // if bit is present, add to point
             // if not present, add to fake, for timing safety
             if (n & 1n)
                 p = p.add(d);
             else if (safe)
                 f = f.add(d);
+            d = d.double();
+            n >>= 1n;
         }
         return p;
     }
@@ -1113,14 +1242,14 @@ class Point {
     toAffine() {
         const { X: x, Y: y, Z: z } = this;
         // fast-paths for ZERO point OR Z=1
-        if (this.equals(I))
+        if (z === 0n)
             return { x: 0n, y: 0n };
         if (z === 1n)
             return { x, y };
         const iz = invert(z, P);
         // (Z * Z^-1) must be 1, otherwise bad math
         if (M(z * iz) !== 1n)
-            err$1('inverse invalid');
+            throw new Error('inverse invalid');
         // x = X*Z^-1; y = Y*Z^-1
         return { x: M(x * iz), y: M(y * iz) };
     }
@@ -1130,7 +1259,9 @@ class Point {
         FpIsValidNot0(x); // must be in range 1 <= x,y < P
         FpIsValidNot0(y);
         // y² == x³ + ax + b, equation sides must be equal
-        return M(y * y) === koblitz(x) ? this : err$1('bad point: not on curve');
+        if (M(y * y) !== koblitz(x))
+            throw new Error(E_BADPOINT);
+        return this;
     }
     /** Converts point to 33/65-byte Uint8Array. */
     toBytes(isCompressed = true) {
@@ -1140,7 +1271,7 @@ class Point {
         const x32b = numTo32b(x);
         if (isCompressed)
             return concatBytes(getPrefix(y), x32b);
-        return concatBytes(u8of(0x04), x32b, numTo32b(y));
+        return concatBytes(Uint8Array.of(0x04), x32b, numTo32b(y));
     }
     toHex(isCompressed) {
         return bytesToHex(this.toBytes(isCompressed));
@@ -1155,17 +1286,14 @@ Point.BASE = G;
 Point.ZERO = I;
 /** `Q = u1⋅G + u2⋅R`. Verifies Q is not ZERO. Unsafe: non-CT. */
 const doubleScalarMulUns = (R, u1, u2) => {
-    return G.multiply(u1, false)
-        .add(R.multiply(u2, false))
-        .assertValidity();
+    return G.multiply(u1, false).add(R.multiply(u2, false)).assertValidity();
 };
 // Inherits byte validation from bytesToHex(); the || '0' fallback keeps empty input mapped to 0n.
 const bytesToNumBE = (b) => big('0x' + (bytesToHex(b) || '0'));
 // Callers provide monotone slice bounds; subarray() would otherwise clamp or reinterpret them silently.
 const sliceBytesNumBE = (b, from, to) => bytesToNumBE(b.subarray(from, to));
-const B256 = 2n ** 256n; // secp256k1 is weierstrass curve. Equation is x³ + ax + b.
-/** Generic 32-byte big-endian encoder. Must be 0 <= num < B256; call sites need not be field/scalar elements. */
-const numTo32b = (num) => hexToBytes(padh(arange(num, 0n, B256), L2));
+/** Generic 32-byte big-endian encoder. Must be 0 <= num < 2²⁵⁶; call sites need not be field/scalar elements. */
+const numTo32b = (num) => hexToBytes(padh(arange(num, 0n, 2n ** 256n), L * 2)); // L*2 = 64 hex chars for a zero-padded 32-byte value
 /** Normalize private key to scalar (bigint). Verifies scalar is in range 1 <= d < N. */
 const secretKeyToScalar = (secretKey) => {
     const num = bytesToNumBE(abytes(secretKey, L, 'secret key'));
@@ -1196,12 +1324,11 @@ const isValidSecretKey = (secretKey) => {
     }
 };
 const isValidPublicKey = (publicKey, isCompressed) => {
-    const { publicKey: comp, publicKeyUncompressed } = lengths;
     try {
         const l = publicKey.length;
-        if (isCompressed === true && l !== comp)
+        if (isCompressed === true && l !== 33)
             return false;
-        if (isCompressed === false && l !== publicKeyUncompressed)
+        if (isCompressed === false && l !== 65)
             return false;
         return !!Point.fromBytes(publicKey);
     }
@@ -1229,12 +1356,11 @@ const _sha = 'SHA-256';
 const hashes = {
     hmacSha256Async: async (key, message) => {
         const s = subtle();
-        const name = 'HMAC';
-        const k = await s.importKey('raw', key, { name, hash: { name: _sha } }, false, ['sign']);
-        return u8n(await s.sign(name, k, message));
+        const k = await s.importKey('raw', key, { name: 'HMAC', hash: _sha }, false, ['sign']);
+        return new Uint8Array(await s.sign('HMAC', k, message));
     },
     hmacSha256: undefined,
-    sha256Async: async (msg) => u8n(await subtle().digest(_sha, msg)),
+    sha256Async: async (msg) => new Uint8Array(await subtle().digest(_sha, msg)),
     sha256: undefined,
 };
 /**
@@ -1261,20 +1387,17 @@ const getSharedSecret = (secretKeyA, publicKeyB, isCompressed = true) => {
 // FIPS 186-5 Appendix A.4.1 style key generation reduces a wide random integer mod (n - 1) and adds 1.
 // The 48-byte minimum keeps the secp256k1 bias bound below the appendix's epsilon <= 2^-64 target.
 const randomSecretKey = (seed) => {
-    seed = seed === undefined ? randomBytes(lengths.seed) : seed;
+    seed = seed === undefined ? randomBytes(48) : seed;
     abytes(seed);
     // Keep the public range text aligned with the enforced 48-byte FIPS floor.
-    if (seed.length < lengths.seed || seed.length > 1024)
-        return err$1('expected 48-1024b', RangeError);
+    if (seed.length < 48 || seed.length > 1024)
+        throw new RangeError('expected 48-1024b');
     const num = M(bytesToNumBE(seed), N - 1n);
     return numTo32b(num + 1n);
 };
 const createKeygen = (getPublicKey) => (seed) => {
     const secretKey = randomSecretKey(seed);
-    return {
-        secretKey,
-        publicKey: getPublicKey(secretKey),
-    };
+    return { secretKey, publicKey: getPublicKey(secretKey) };
 };
 /**
  * Math, hex, byte helpers. Not in `utils` because utils share API with noble-curves.
@@ -1285,17 +1408,17 @@ const createKeygen = (getPublicKey) => (seed) => {
  * const hex = etc.bytesToHex(new Uint8Array([1, 2, 3]));
  * ```
  */
-const etc = /* @__PURE__ */ Object.freeze({
+const etc = /* @__PURE__ */ freeze({
     hexToBytes,
     bytesToHex,
     concatBytes,
     bytesToNumberBE: bytesToNumBE,
     numberToBytesBE: numTo32b,
     mod: M,
-    invert: invert, // math utilities; keep public alias type aligned with runtime
+    invert,
     randomBytes,
-    secretKeyToScalar: secretKeyToScalar,
-    abytes: abytes,
+    secretKeyToScalar,
+    abytes,
 });
 /**
  * Curve-specific key utilities.
@@ -1307,26 +1430,23 @@ const etc = /* @__PURE__ */ Object.freeze({
  * const publicKey = secp.getPublicKey(secretKey);
  * ```
  */
-const utils$2 = /* @__PURE__ */ Object.freeze({
-    isValidSecretKey: isValidSecretKey,
-    isValidPublicKey: isValidPublicKey,
-    randomSecretKey: randomSecretKey, // preserve the optional seeded call
+const utils$2 = /* @__PURE__ */ freeze({
+    isValidSecretKey,
+    isValidPublicKey,
+    randomSecretKey,
 });
 // Schnorr signatures are superior to ECDSA from above. Below is Schnorr-specific BIP0340 code.
 // https://github.com/bitcoin/bips/blob/master/bip-0340.mediawiki
 // Internal BIP340 tag names are ASCII-only here, so charCodeAt() is enough; this is not a general UTF-8 encoder.
 const getTag = (tag) => Uint8Array.from('BIP0340/' + tag, (c) => c.charCodeAt(0));
-const T_AUX = 'aux';
-const T_NONCE = 'nonce';
-const T_CHALLENGE = 'challenge';
 // Both SHA-256 provider slots are configurable, so tag hashing still goes through the checked
 // wrappers even though the built-in defaults are deterministic and the tag bytes are ASCII-only.
 const taggedHash = (tag, ...messages) => {
-    const tagH = gh('sha256', getTag(tag));
-    return gh('sha256', concatBytes(tagH, tagH, ...messages));
+    const tagH = callHash('sha256', getTag(tag));
+    return callHash('sha256', concatBytes(tagH, tagH, ...messages));
 };
 // Async twin of taggedHash with the same checked provider boundary.
-const taggedHashAsync = (tag, ...messages) => gha('sha256Async', getTag(tag)).then((tagH) => gha('sha256Async', concatBytes(tagH, tagH, ...messages)));
+const taggedHashAsync = (tag, ...messages) => callHashAsync('sha256Async', getTag(tag)).then((tagH) => callHashAsync('sha256Async', concatBytes(tagH, tagH, ...messages)));
 // BIP340 PubKey(sk) = bytes(d'⋅G), where bytes(P) is bytes(x(P)); signing also normalizes
 // d to the equivalent scalar whose point has even y so the x-only public key stays canonical.
 const extpubSchnorr = (priv) => {
@@ -1338,8 +1458,8 @@ const extpubSchnorr = (priv) => {
     return { d, px };
 };
 const bytesModN = (bytes) => modN(bytesToNumBE(bytes));
-const challenge = (...args) => bytesModN(taggedHash(T_CHALLENGE, ...args));
-const challengeAsync = async (...args) => bytesModN(await taggedHashAsync(T_CHALLENGE, ...args));
+const challenge = (...args) => bytesModN(taggedHash('challenge', ...args));
+const challengeAsync = async (...args) => bytesModN(await taggedHashAsync('challenge', ...args));
 /** Schnorr public key is just `x` coordinate of Point as per BIP340. */
 const pubSchnorr = (secretKey) => {
     return extpubSchnorr(secretKey).px; // d'=int(sk). Fail if d'=0 or d'≥n. Ret bytes(d'⋅G)
@@ -1347,13 +1467,14 @@ const pubSchnorr = (secretKey) => {
 const keygenSchnorr = /* @__PURE__ */ createKeygen(pubSchnorr);
 // Common preparation fn for both sync and async signing
 const prepSigSchnorr = (message, secretKey, auxRand) => {
+    const m = snapshotBytes(message, 'message');
     const { px, d } = extpubSchnorr(secretKey);
-    return { m: abytes(message), px, d, a: abytes(auxRand, L) };
+    return { m, px, d, a: abytes(auxRand, L) };
 };
 const extractK = (rand) => {
     const k_ = bytesModN(rand); // Let k' = int(rand) mod n
     if (k_ === 0n)
-        err$1('sign failed: k is zero'); // Fail if k' = 0.
+        throw new Error('sign failed: k is zero'); // Fail if k' = 0.
     const { px, d } = extpubSchnorr(numTo32b(k_)); // Let R = k'⋅G.
     return { rx: px, k: d };
 };
@@ -1369,73 +1490,78 @@ const E_INVSIG = 'invalid signature produced';
  */
 const signSchnorr = (message, secretKey, auxRand = randomBytes(L)) => {
     const { m, px, d, a } = prepSigSchnorr(message, secretKey, auxRand);
-    const aux = taggedHash(T_AUX, a);
     // Let t be the byte-wise xor of bytes(d) and hash/aux(a)
-    const t = numTo32b(d ^ bytesToNumBE(aux));
+    const t = numTo32b(d ^ bytesToNumBE(taggedHash('aux', a)));
     // Let rand = hash/nonce(t || bytes(P) || m)
-    const rand = taggedHash(T_NONCE, t, px, m);
-    const { rx, k } = extractK(rand);
+    const { rx, k } = extractK(taggedHash('nonce', t, px, m));
     // Let e = int(hash/challenge(bytes(R) || bytes(P) || m)) mod n.
-    const e = challenge(rx, px, m);
-    const sig = createSigSchnorr(k, rx, e, d);
+    const sig = createSigSchnorr(k, rx, challenge(rx, px, m), d);
     // If Verify(bytes(P), m, sig) (see below) returns failure, abort
     if (!verifySchnorr(sig, m, px))
-        err$1(E_INVSIG);
+        throw new Error(E_INVSIG);
     return sig;
 };
 const signSchnorrAsync = async (message, secretKey, auxRand = randomBytes(L)) => {
     const { m, px, d, a } = prepSigSchnorr(message, secretKey, auxRand);
-    const aux = await taggedHashAsync(T_AUX, a);
     // Let t be the byte-wise xor of bytes(d) and hash/aux(a)
-    const t = numTo32b(d ^ bytesToNumBE(aux));
+    const t = numTo32b(d ^ bytesToNumBE(await taggedHashAsync('aux', a)));
     // Let rand = hash/nonce(t || bytes(P) || m)
-    const rand = await taggedHashAsync(T_NONCE, t, px, m);
-    const { rx, k } = extractK(rand);
+    const { rx, k } = extractK(await taggedHashAsync('nonce', t, px, m));
     // Let e = int(hash/challenge(bytes(R) || bytes(P) || m)) mod n.
-    const e = await challengeAsync(rx, px, m);
-    const sig = createSigSchnorr(k, rx, e, d);
+    const sig = createSigSchnorr(k, rx, await challengeAsync(rx, px, m), d);
     // If Verify(bytes(P), m, sig) (see below) returns failure, abort
     if (!(await verifySchnorrAsync(sig, m, px)))
-        err$1(E_INVSIG);
+        throw new Error(E_INVSIG);
     return sig;
 };
 const callSyncAsyncFn = (res, later) => {
     return res instanceof Promise ? res.then(later) : later(res);
 };
 const _verifSchnorr = (signature, message, publicKey, challengeFn) => {
-    const sig = abytes(signature, L2, 'signature');
+    const sig = abytes(signature, 64, 'signature');
     const msg = abytes(message, undefined, 'message');
     const pub = abytes(publicKey, L, 'publicKey');
+    let P_;
+    let r;
+    let s;
+    let chalInput; // challenge preimage bytes(r) || bytes(P) || m
     try {
         // lift_x from BIP340. Convert 32-byte x coordinate to elliptic curve point.
         // Fail if x ≥ p. Let c = x³ + 7 mod p.
         const x = bytesToNumBE(pub);
-        const y = lift_x(x); // lift_x already returns the unique even root required by BIP340.
-        const P_ = new Point(x, y, 1n).assertValidity();
-        const px = numTo32b(P_.toAffine().x);
+        P_ = lift_x(x); // lift_x returns the validated even-y point required by BIP340.
         // P = lift_x(int(pk)); fail if that fails
-        const r = sliceBytesNumBE(sig, 0, L); // Let r = int(sig[0:32]); fail if r ≥ p.
-        arange(r, 1n, P);
-        const s = sliceBytesNumBE(sig, L, L2); // Let s = int(sig[32:64]); fail if s ≥ n.
+        r = FpIsValidNot0(sliceBytesNumBE(sig, 0, L)); // Let r = int(sig[0:32]); fail if r ≥ p.
+        // Let s = int(sig[32:64]); fail if s ≥ n.
         // Stricter than BIP-340/libsecp256k1, which only reject s >= n. Honest signing reaches
         // s = 0 only with negligible probability (k + e*d ≡ 0 mod n), so treat zero-s inputs as
         // crafted edge cases and fail closed instead of carrying that extra verification surface.
-        arange(s, 1n, N);
-        const i = concatBytes(numTo32b(r), px, msg);
-        // int(challenge(bytes(r)||bytes(P)||m))%n
-        return callSyncAsyncFn(challengeFn(i), (e) => {
-            const { x, y } = doubleScalarMulUns(P_, s, modN(-e)).toAffine(); // R = s⋅G - e⋅P
-            if (!isEven(y) || x !== r)
-                return false; // -eP == (n-e)P
-            return true; // Fail if is_infinite(R) / not has_even_y(R) / x(R) ≠ r.
-        });
+        s = FnIsValidNot0(sliceBytesNumBE(sig, L, 64));
+        // lift_x validated x < P, so the 32-byte input encoding equals bytes(P.x) exactly.
+        chalInput = concatBytes(numTo32b(r), pub, msg);
     }
     catch (error) {
         return false;
     }
+    // Hash-provider errors (unset hashes.sha256, missing crypto.subtle, bad provider digests)
+    // stay outside the catch above: backend misconfiguration is not an "invalid signature"
+    // result, so it throws / rejects instead of becoming false.
+    // int(challenge(bytes(r)||bytes(P)||m))%n
+    return callSyncAsyncFn(challengeFn(chalInput), (e) => {
+        try {
+            const { x, y } = doubleScalarMulUns(P_, s, modN(-e)).toAffine(); // R = s⋅G - e⋅P
+            if (!isEven(y) || x !== r)
+                return false; // -eP == (n-e)P
+            return true; // Fail if is_infinite(R) / not has_even_y(R) / x(R) ≠ r.
+        }
+        catch (error) {
+            return false; // is_infinite(R) throws inside doubleScalarMulUns
+        }
+    });
 };
-/** Verifies Schnorr signature. Sync wrapper returns false for post-validation failures
- * after the initial byte checks. */
+/** Verifies Schnorr signature. Invalid points, scalars and failed curve checks return false;
+ * hash-backend misconfiguration (e.g. unset hashes.sha256) throws instead, since it is a
+ * runtime/backend error, not an "invalid signature" result. */
 const verifySchnorr = (s, m, p) => _verifSchnorr(s, m, p, challenge);
 /** Async Schnorr verification. Curve/encoding failures after the initial byte checks still
  * become false, but async backend failures reject the promise. Missing crypto.subtle is a
@@ -1457,7 +1583,7 @@ const verifySchnorrAsync = async (s, m, p) => _verifSchnorr(s, m, p, challengeAs
  * const isValid = secp.schnorr.verify(sig, message, publicKey);
  * ```
  */
-const schnorr = /* @__PURE__ */ Object.freeze({
+const schnorr = /* @__PURE__ */ freeze({
     keygen: keygenSchnorr,
     getPublicKey: pubSchnorr,
     sign: signSchnorr,
@@ -1467,18 +1593,14 @@ const schnorr = /* @__PURE__ */ Object.freeze({
 });
 // ## Precomputes
 // --------------
-const W = 8; // W is window size
-const scalarBits = 256;
-const pwindows = Math.ceil(scalarBits / W) + 1; // 33 for W=8, NOT 32 - see wNAF loop
-const pwindowSize = 2 ** (W - 1); // 128 for W=8
 const precompute = () => {
     const points = [];
     let p = G;
     let b = p;
-    for (let w = 0; w < pwindows; w++) {
+    for (let w = 0; w < 33; w++) {
         b = p;
         points.push(b);
-        for (let i = 1; i < pwindowSize; i++) {
+        for (let i = 1; i < 128; i++) {
             b = b.add(p);
             points.push(b);
         } // i=1, bc we skip 0
@@ -1507,37 +1629,32 @@ const wNAF = (n) => {
     const comp = Gpows || (Gpows = precompute());
     let p = I;
     let f = G; // f must be G, or could become I in the end
-    const pow_2_w = 2 ** W; // 256 for W=8
-    const maxNum = pow_2_w; // 256 for W=8
-    const mask = big(pow_2_w - 1); // 255 for W=8 == mask 0b11111111
-    const shiftBy = big(W); // 8 for W=8
-    for (let w = 0; w < pwindows; w++) {
-        let wbits = Number(n & mask); // extract W bits.
-        n >>= shiftBy; // shift number by W bits.
+    for (let w = 0; w < 33; w++) {
+        let wbits = Number(n & 255n); // extract W=8 bits.
+        n >>= 8n; // shift number by W=8 bits.
         // We use negative indexes to reduce size of precomputed table by 2x.
         // Instead of needing precomputes 0..256, we only calculate them for 0..128.
         // If an index > 128 is found, we do (256-index) - where 256 is next window.
         // Naive: index +127 => 127, +224 => 224
         // Optimized: index +127 => 127, +224 => 256-32
-        if (wbits > pwindowSize) {
-            wbits -= maxNum;
+        if (wbits > 128) {
+            wbits -= 256;
             n += 1n;
         }
-        const off = w * pwindowSize;
-        const offF = off; // offsets, evaluate both
+        const off = w * 128;
         const offP = off + Math.abs(wbits) - 1;
-        const isEven = w % 2 !== 0; // conditions, evaluate both
+        const isOddW = w % 2 !== 0; // conditions, evaluate both; alternates fake-add sign per window
         const isNeg = wbits < 0;
         if (wbits === 0) {
-            // off == I: can't add it. Adding random offF instead.
-            f = f.add(ctneg(isEven, comp[offF])); // bits are 0: add garbage to fake point
+            // off == I: can't add it. Add the first point in this window to the fake accumulator.
+            f = f.add(ctneg(isOddW, comp[off])); // bits are 0: add garbage to fake point
         }
         else {
             p = p.add(ctneg(isNeg, comp[offP])); // bits are 1: add to result point
         }
     }
     if (n !== 0n)
-        err$1('invalid wnaf');
+        throw new Error('invalid wnaf');
     return { p, f }; // return both real and fake points for JIT/leakage-shape symmetry
 };
 
@@ -2457,10 +2574,10 @@ class HdNode {
         return (async () => (await this.identifier).subarray(0, 4))();
     }
     async hash160(data) {
-        const hash = await createHash(data, 'SHA-256');
+        const hash = await createHash(data, "SHA-256");
         return (await createRIPEMD160())
             .update(new Uint8Array(hash))
-            .digest('binary');
+            .digest("binary");
     }
     get isNeutered() {
         return this.#privateKey === undefined;
@@ -2470,24 +2587,24 @@ class HdNode {
     }
     fromPrivateKey(privateKey, chainCode, network) {
         if (!privateKeyVerify(privateKey))
-            throw new TypeError('Private key not in range [1, n)');
+            throw new TypeError("Private key not in range [1, n)");
         const publicKey = publicKeyCreate(privateKey, true);
         return new HdNode(privateKey, publicKey, publicKey.slice(1), network);
     }
     fromPublicKey(publicKey, chainCode, network) {
         // verify the X coordinate is a point on the curve
         if (!publicKeyVerify(publicKey))
-            throw new TypeError('Point is not on the curve');
+            throw new TypeError("Point is not on the curve");
         return new HdNode(undefined, publicKey, chainCode, network);
     }
     async fromSeed(seed, network) {
         if (seed.length < 16)
-            throw new TypeError('Seed should be at least 128 bits');
+            throw new TypeError("Seed should be at least 128 bits");
         if (seed.length > 64)
-            throw new TypeError('Seed should be at most 512 bits');
-        let hash = (await createHMAC(createSHA512(), new TextEncoder().encode('Bitcoin seed')))
+            throw new TypeError("Seed should be at most 512 bits");
+        let hash = (await createHMAC(createSHA512(), new TextEncoder().encode("Bitcoin seed")))
             .update(seed)
-            .digest('binary');
+            .digest("binary");
         const privateKey = hash.subarray(0, 32);
         const chainCode = hash.subarray(32);
         return this.fromPrivateKey(privateKey, chainCode, network);
@@ -2505,7 +2622,7 @@ class HdNode {
             this.#chainCode,
         ];
         if (!this.isNeutered) {
-            set.push(new TextEncoder().encode('0'));
+            set.push(new TextEncoder().encode("0"));
             set.push(new Uint8Array(this.privateKey));
         }
         else {
@@ -2515,7 +2632,7 @@ class HdNode {
     }
     toWIF() {
         if (!this.#privateKey)
-            throw new TypeError('Missing private key');
+            throw new TypeError("Missing private key");
         return wif.encode(this.#network.wif, this.#privateKey, true);
     }
     // https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki#child-key-derivation-ckd-functions
@@ -2525,10 +2642,10 @@ class HdNode {
         // Hardened child
         if (isHardened) {
             if (this.isNeutered)
-                throw new TypeError('Missing private key for hardened child key');
+                throw new TypeError("Missing private key for hardened child key");
             // data = 0x00 || ser256(kpar) || ser32(index)
             data = index$3([
-                new TextEncoder().encode('0'),
+                new TextEncoder().encode("0"),
                 this.privateKey,
                 new TextEncoder().encode(index.toString()),
             ]);
@@ -2541,7 +2658,7 @@ class HdNode {
         }
         const hash = (await createHMAC(createSHA512(), this.#chainCode))
             .update(data)
-            .digest('binary');
+            .digest("binary");
         const privateKey = hash.subarray(0, 32);
         const chainCode = hash.subarray(32);
         // if parse256(privateKey) >= n, proceed with the next value for i
@@ -2568,10 +2685,10 @@ class HdNode {
         return this.derive(index + HIGHEST_BIT);
     }
     async derivePath(path) {
-        let splitPath = path.split('/');
-        if (splitPath[0] === 'm') {
+        let splitPath = path.split("/");
+        if (splitPath[0] === "m") {
             if (this.#parentFingerprint)
-                throw new TypeError('Expected master, got child');
+                throw new TypeError("Expected master, got child");
             splitPath = splitPath.slice(1);
         }
         let prevHd = this;
@@ -2603,16 +2720,16 @@ class HdNode {
         const k = privateKey ? 0 : result[5];
         const chainCode = result[4];
         if (version !== network.bip32.private && version !== network.bip32.public)
-            throw new TypeError('Invalid network version');
+            throw new TypeError("Invalid network version");
         if (depth === 0) {
             if (parentFingerprint !== 0)
-                throw new TypeError('Invalid parent fingerprint');
+                throw new TypeError("Invalid parent fingerprint");
         }
         if (depth === 0 && index !== 0)
-            throw new TypeError('Invalid index');
+            throw new TypeError("Invalid index");
         if (version === network.bip32.private) {
             if (k !== 0x00)
-                throw new TypeError('Invalid private key');
+                throw new TypeError("Invalid private key");
             return new HdNode(privateKey, undefined, chainCode, network, depth, index, parentFingerprint);
         }
         return new HdNode(undefined, 
@@ -4868,16 +4985,16 @@ const ALPHABET$2 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
 const ALPHABET_HEX = "0123456789ABCDEFGHIJKLMNOPQRSTUV";
 const base32 = base(ALPHABET$2);
 const base32Hex = base(ALPHABET_HEX);
-const decode$6 = base32.decode;
+const decode$5 = base32.decode;
 const decodeHex = base32Hex.decode;
-const encode$5 = base32.encode;
+const encode$4 = base32.encode;
 const encodeHex = base32Hex.encode;
 const isBase32 = (string, hex = false) => {
     try {
         if (hex)
             decodeHex(string);
         else
-            decode$6(string);
+            decode$5(string);
         return true;
     }
     catch (e) {
@@ -4887,9 +5004,9 @@ const isBase32 = (string, hex = false) => {
 const isBase32Hex = (string) => {
     return isBase32(string, true);
 };
-var index$5 = {
-    encode: encode$5,
-    decode: decode$6,
+var index$4 = {
+    encode: encode$4,
+    decode: decode$5,
     encodeHex,
     decodeHex,
     isBase32,
@@ -4964,11 +5081,8 @@ class MultiSignature {
         signature = signature || this.signature;
         if (!signature)
             throw ReferenceError("signature undefined");
-        this.#multiSignature = typedArrayConcat([
-            index$4.encode(this.version),
-            index$4.encode(this.multiCodec),
-            signature,
-        ]);
+        const writer = new BinaryWriter(varUintLength(this.version) + varUintLength(this.multiCodec) + signature.length);
+        this.#multiSignature = writer.writeVarUint(this.version).writeVarUint(this.multiCodec).writeBytes(signature).finish();
         return this.multiSignature;
     }
     /**
@@ -4981,12 +5095,11 @@ class MultiSignature {
             this.#multiSignature = multiSignature;
         if (!this.multiSignature)
             throw ReferenceError("multiSignature undefined");
-        let buffer = this.multiSignature;
-        const version = index$4.decode(buffer);
-        buffer = buffer.subarray(index$4.decode.bytes);
-        const codec = index$4.decode(buffer);
-        buffer = buffer.subarray(index$4.decode.bytes);
-        const signature = buffer.subarray(0, buffer.length);
+        const reader = new BinaryReader(this.multiSignature);
+        // Keep legacy padded-header acceptance; do not change signature wire rules.
+        const version = reader.readVarUint(false);
+        const codec = reader.readVarUint(false);
+        const signature = reader.readBytes(reader.remaining);
         console.log("[decode] extracted signature length:", signature.length);
         console.log("[decode] extracted signature (hex):", Buffer.from(signature).toString("hex"));
         if (version !== this.version)
@@ -5004,7 +5117,7 @@ class MultiSignature {
         return this.multiSignature.toString();
     }
     fromString(string) {
-        return this.decode(new Uint8Array(string.split(",")));
+        return this.decode(new Uint8Array(string.split(",").map(Number)));
     }
     toBs58() {
         return base58$1.encode(this.multiSignature);
@@ -5013,16 +5126,16 @@ class MultiSignature {
         return this.decode(base58$1.decode(string));
     }
     toBs32() {
-        return index$5.encode(this.multiSignature);
+        return index$4.encode(this.multiSignature);
     }
     fromBs32(string) {
-        return this.decode(index$5.decode(string));
+        return this.decode(index$4.decode(string));
     }
     toBs32Hex() {
-        return index$5.encodeHex(this.multiSignature);
+        return index$4.encodeHex(this.multiSignature);
     }
     fromBs32Hex(string) {
-        return this.decode(index$5.decodeHex(string));
+        return this.decode(index$4.decodeHex(string));
     }
     toBs58Hex() {
         return base58$1.encodeHex(this.multiSignature);
@@ -5079,17 +5192,26 @@ class MultiHDNode extends HDWallet {
     get id() {
         return base58check.encode(index$3([
             new TextEncoder().encode(this.version.toString()),
-            this.account(0).hdnode.neutered.publicKey
+            this.account(0).hdnode.neutered.publicKey,
         ]));
     }
     get multiWIF() {
         return this.toMultiWif();
     }
     async fromId(id) {
-        let buffer = (await base58check.decode(id)).data;
-        index$4.decode(buffer);
-        buffer = buffer.slice(index$4.decode.bytes);
-        this.fromPublicKey(buffer, null, this.networkName);
+        const buffer = (await base58check.decode(id)).data;
+        const reader = new BinaryReader(buffer);
+        // IDs contain two framed fields: textual version and compressed public key.
+        // Keep legacy padded length prefixes readable without changing generated IDs.
+        const version = reader.readFrame(false);
+        const publicKey = reader.readFrame(false);
+        const expectedVersion = new TextEncoder().encode(this.version.toString());
+        if (reader.remaining !== 0 ||
+            version.length !== expectedVersion.length ||
+            !version.every((byte, index) => byte === expectedVersion[index]) ||
+            publicKey.length !== 33)
+            throw new Error("invalid wallet ID");
+        await this.fromPublicKey(publicKey, null, this.networkName);
     }
     async import(password, encrypted) {
         const { prefix, data } = await base58check.decode(encrypted);
@@ -5118,22 +5240,20 @@ class MultiHDNode extends HDWallet {
                 return c.testnet;
             else
                 return p;
-        }, networks['leofcoin']);
+        }, networks["leofcoin"]);
         if (version !== this.network.version)
-            throw new Error('invalid version');
+            throw new Error("invalid version");
         return this.fromPrivateKey(privateKey, undefined, this.network);
     }
     toMultiWif() {
         return index$1$1.encode(this.network.version, this.network.multiCodec, this.privateKey);
     }
     sign(hash) {
-        return new MultiSignature(this.version, this.network.multiCodec)
-            .sign(hash, this.privateKey);
+        return new MultiSignature(this.version, this.network.multiCodec).sign(hash, this.privateKey);
     }
     verify(multiSignature, hash) {
         const publicKey = this.publicKey?.length === 33 ? this.publicKey.slice(1) : this.publicKey;
-        return new MultiSignature(this.version, this.network.multiCodec)
-            .verify(multiSignature, hash, publicKey);
+        return new MultiSignature(this.version, this.network.multiCodec).verify(multiSignature, hash, publicKey);
     }
 }
 
@@ -8390,7 +8510,7 @@ class Identity {
             this.selectedAccount = new TextDecoder().decode(selected);
         }
         else {
-            const importee = await import(/* webpackChunkName: "generate-account" */ './index-Bxr5Iztg-AmkW0EHS.js');
+            const importee = await import(/* webpackChunkName: "generate-account" */ './index-dTQVgkpf-CuHJWO2l.js');
             const { identity, accounts } = await importee.default(password, this.network);
             if (fresh) {
                 await globalThis.accountStore.clear();
@@ -15682,7 +15802,7 @@ const toHex = (bytes) => bytes.reduce((string, byte) => string + byte.toString(1
 const fromArrayLike = (array) => Uint8Array.from(array);
 const toBase58 = (uint8Array) => base58$1.encode(uint8Array);
 const fromBase58 = (string) => base58$1.decode(string);
-const toBase32 = (uint8Array) => index$5.encode(uint8Array);
+const toBase32 = (uint8Array) => index$4.encode(uint8Array);
 var index$1 = {
     toString: toString$1};
 
@@ -15782,13 +15902,13 @@ class BasicInterface {
                     this.fromBs58(value);
                 }
                 catch {
-                    if (index$5.isBase32(value))
+                    if (index$4.isBase32(value))
                         this.fromBs32(value);
                     else
                         throw new Error('Invalid base58/base32 input');
                 }
             }
-            else if (index$5.isBase32(value))
+            else if (index$4.isBase32(value))
                 this.fromBs32(value);
             else
                 this.fromString(value);
@@ -15856,13 +15976,13 @@ class BasicInterface {
         return isHex(string);
     }
     isBase32(string) {
-        return index$5.isBase32(string);
+        return index$4.isBase32(string);
     }
     isBase58(string) {
         return base58$1.isBase58(string);
     }
     fromBs32(encoded) {
-        return this.decode(index$5.decode(encoded));
+        return this.decode(index$4.decode(encoded));
     }
     fromBs58(encoded) {
         return this.decode(fromBase58(encoded));
@@ -16190,7 +16310,7 @@ let Codec$1 = class Codec extends BasicInterface {
         super();
         if (buffer) {
             if (buffer instanceof Uint8Array) {
-                const codec = index$4.decode(buffer);
+                const codec = new BinaryReader(buffer).readVarUint(false);
                 const name = this.getCodecName(codec);
                 if (name) {
                     this.name = name;
@@ -16202,11 +16322,12 @@ let Codec$1 = class Codec extends BasicInterface {
                 }
             }
             else if (buffer instanceof ArrayBuffer) {
-                const codec = index$4.decode(buffer);
+                const view = new Uint8Array(buffer);
+                const codec = new BinaryReader(view).readVarUint(false);
                 const name = this.getCodecName(codec);
                 if (name) {
                     this.name = name;
-                    this.decode(buffer);
+                    this.decode(view);
                 }
                 else {
                     this.encode(Number(new TextDecoder().decode(new Uint8Array(buffer))));
@@ -16231,7 +16352,7 @@ let Codec$1 = class Codec extends BasicInterface {
         }
     }
     fromEncoded(encoded) {
-        const codec = index$4.decode(encoded);
+        const codec = new BinaryReader(encoded).readVarUint(false);
         const name = this.getCodecName(codec);
         this.name = name;
         this.encoded = encoded;
@@ -16250,7 +16371,7 @@ let Codec$1 = class Codec extends BasicInterface {
         this.name = this.getCodecName(codec);
         this.hashAlg = this.getHashAlg(this.name);
         this.codec = this.getCodec(this.name);
-        this.codecBuffer = index$4.encode(this.codec);
+        this.codecBuffer = new BinaryWriter(varUintLength(this.codec)).writeVarUint(this.codec).finish();
         this.decoded = {
             name: this.name,
             hashAlg: this.hashAlg,
@@ -16263,7 +16384,7 @@ let Codec$1 = class Codec extends BasicInterface {
         this.name = name;
         this.codec = codec;
         this.hashAlg = this.getHashAlg(name);
-        this.codecBuffer = index$4.encode(this.codec);
+        this.codecBuffer = new BinaryWriter(varUintLength(this.codec)).writeVarUint(this.codec).finish();
         this.decoded = {
             name: this.name,
             hashAlg: this.hashAlg,
@@ -16273,13 +16394,13 @@ let Codec$1 = class Codec extends BasicInterface {
     }
     decode(encoded) {
         encoded = encoded || this.encoded;
-        const codec = index$4.decode(encoded);
+        const codec = new BinaryReader(encoded).readVarUint(false);
         this.fromCodec(codec);
         return this.decoded;
     }
     encode(codec) {
         codec = codec || this.codec;
-        this.encoded = index$4.encode(codec);
+        this.encoded = new BinaryWriter(varUintLength(codec)).writeVarUint(codec).finish();
         return this.encoded;
     }
 };
@@ -16308,10 +16429,37 @@ const digestBuffer = async (hashVariant, buffer) => {
     const digest = hasher.digest('binary');
     return digest instanceof Uint8Array ? digest : new Uint8Array(digest);
 };
+const hashHeader = (buffer) => {
+    if (!(buffer instanceof Uint8Array))
+        throw new TypeError('CodecHash only supports Uint8Array input');
+    const reader = new BinaryReader(buffer);
+    const codec = reader.readVarUint();
+    const name = utils.getCodecName(codec);
+    if (!name)
+        throw new Error('unknown hash codec');
+    const size = reader.readVarUint();
+    if (size !== reader.remaining)
+        throw new Error('hash length inconsistent');
+    return { name, size, offset: reader.position };
+};
+const hasHashHeader = (buffer) => {
+    const reader = new BinaryReader(buffer);
+    try {
+        // Recognition is deliberately separate from strict parsing: a padded known
+        // codec must reach decode() and fail, not silently become raw content.
+        return Boolean(utils.getCodecName(reader.readVarUint(false)));
+    }
+    catch (error) {
+        if (!(error instanceof RangeError))
+            throw error;
+        return false;
+    }
+};
 class CodecHash extends BasicInterface {
     codec;
     discoCodec;
     size;
+    digest;
     codecs;
     constructor(options = { name: 'disco-hash', codecs: {} }) {
         super();
@@ -16319,21 +16467,14 @@ class CodecHash extends BasicInterface {
             this.name = options.name;
         else
             this.name = 'disco-hash';
-        if (options?.codecs)
-            this.codecs = options.codecs;
+        this.codecs = options?.codecs ?? {};
     }
     async init(uint8Array) {
         if (uint8Array) {
             if (!(uint8Array instanceof Uint8Array)) {
                 throw new Error('CodecHash only supports Uint8Array input');
             }
-            // For large buffers, only check first bytes for codec prefix
-            // Codec prefixes are small (varint encoded), so 100 bytes is more than enough
-            const checkBuffer = uint8Array.length > 100 ? uint8Array.subarray(0, 100) : uint8Array;
-            this.discoCodec = new Codec$1(checkBuffer);
-            const name = this.discoCodec.name;
-            if (name) {
-                this.name = name;
+            if (hasHashHeader(uint8Array)) {
                 this.decode(uint8Array);
             }
             else {
@@ -16342,15 +16483,19 @@ class CodecHash extends BasicInterface {
         }
         return this;
     }
+    #clearEncodingCache() {
+        for (const key of ['_bs32', '_hex', '_string'])
+            delete this[key];
+    }
     get prefix() {
         const length = this.length;
         const uint8Array = new Uint8Array(length.length + this.discoCodec.codecBuffer.length);
-        uint8Array.set(length);
-        uint8Array.set(this.discoCodec.codecBuffer, length.length);
+        uint8Array.set(this.discoCodec.codecBuffer);
+        uint8Array.set(length, this.discoCodec.codecBuffer.length);
         return uint8Array;
     }
     get length() {
-        return index$4.encode(this.size);
+        return new BinaryWriter(varUintLength(this.size)).writeVarUint(this.size).finish();
     }
     get buffer() {
         return this.encoded;
@@ -16377,6 +16522,8 @@ class CodecHash extends BasicInterface {
         const uint8Array = new Uint8Array(this.digest.length + this.prefix.length);
         uint8Array.set(this.prefix);
         uint8Array.set(this.digest, this.prefix.length);
+        this.#clearEncodingCache();
+        this.decoded = undefined;
         this.encoded = uint8Array;
         return this.encoded;
     }
@@ -16384,35 +16531,30 @@ class CodecHash extends BasicInterface {
         if (!(buffer instanceof Uint8Array)) {
             throw new Error('CodecHash only supports Uint8Array input');
         }
-        const codec = index$4.decode(buffer);
-        if (this.codecs[codec]) {
-            this.decode(buffer);
-        }
-        else {
-            await this.encode(buffer);
-        }
+        await this.init(buffer);
     }
     decode(buffer) {
+        buffer = buffer ?? this.encoded;
+        // Validate completely before changing this instance, including cached encodings.
+        const header = hashHeader(buffer);
+        const codec = new Codec$1(header.name);
+        const digest = new Uint8Array(buffer.subarray(header.offset));
+        this.#clearEncodingCache();
         this.encoded = buffer;
-        const codec = index$4.decode(buffer);
-        this.discoCodec = new Codec$1(codec, this.codecs);
-        // TODO: validate codec
-        buffer = buffer.slice(index$4.decode.bytes);
-        this.size = index$4.decode(buffer);
-        this.digest = buffer.slice(index$4.decode.bytes);
-        if (this.digest.length !== this.size) {
-            throw new Error(`hash length inconsistent: 0x${this.encoded.toString()}`);
-        }
-        // const discoCodec = new Codec(codec, this.codecs)
-        this.name = this.discoCodec.name;
-        this.size = this.digest.length;
-        return {
+        this.discoCodec = codec;
+        this.codec = codec.codecBuffer;
+        this.name = header.name;
+        this.size = header.size;
+        this.digest = digest;
+        const decoded = {
             codec: this.codec,
             name: this.name,
             size: this.size,
             length: this.length,
             digest: this.digest
         };
+        this.decoded = decoded;
+        return decoded;
     }
 }
 
@@ -16525,13 +16667,14 @@ let FormatInterface$1 = class FormatInterface extends BasicInterface {
             !Object.prototype.hasOwnProperty.call(this.decoded, 'hash')) {
             // @ts-ignore
             const hash = new CodecHash({ name: this.name });
-            return hash.init(this.contentBytes);
+            // These are explicitly raw message bytes, even if they resemble a hash header.
+            return hash.encode(this.contentBytes).then(() => hash);
         }
         // Fallback: must re-encode without hash property
         const decoded = this.beforeHashing({ ...this.decoded });
         // @ts-ignore
         const hash = new CodecHash({ name: this.name });
-        return hash.init(decoded);
+        return hash.encode(this.protoEncode(decoded)).then(() => hash);
     }
     /**
      * @return {peernetHash}
@@ -16984,6 +17127,196 @@ let LeofcoinStorage$1 = class LeofcoinStorage {
     }
 };
 
+/** A resumable download. Completed chunks remain cached on the transfer instance. */
+class FileTransfer {
+    hash;
+    state = 'idle';
+    result;
+    error;
+    #fetch;
+    #decode;
+    #verify;
+    #pin;
+    #verifyManifest;
+    #concurrency;
+    #stopped = false;
+    #listeners = new Set();
+    #chunks = new Map();
+    #resumeWaiters = [];
+    #resolve;
+    #reject;
+    #totalChunks = 0;
+    #totalBytes = 0;
+    #started = false;
+    constructor(options) {
+        this.hash = options.hash;
+        this.#fetch = options.fetch;
+        this.#decode = options.decode;
+        this.#verify = options.verify;
+        this.#pin = options.pin;
+        this.#verifyManifest = options.verifyManifest !== false;
+        this.#concurrency = options.concurrency ?? 4;
+        if (!Number.isSafeInteger(this.#concurrency) || this.#concurrency <= 0)
+            throw new TypeError('concurrency must be a positive integer');
+        this.result = new Promise((resolve, reject) => {
+            this.#resolve = resolve;
+            this.#reject = reject;
+        });
+    }
+    get progress() {
+        let transferredBytes = 0;
+        for (const chunk of this.#chunks.values())
+            transferredBytes += chunk.length;
+        return {
+            hash: this.hash,
+            state: this.state,
+            completedChunks: this.#chunks.size,
+            totalChunks: this.#totalChunks,
+            transferredBytes,
+            totalBytes: this.#totalBytes
+        };
+    }
+    onProgress(listener) {
+        this.#listeners.add(listener);
+        listener(this.progress);
+        return () => this.#listeners.delete(listener);
+    }
+    start() {
+        if (!this.#started) {
+            this.#started = true;
+            this.state = 'running';
+            this.#emit();
+            void this.#run();
+        }
+        return this;
+    }
+    pause() {
+        if (this.state === 'running') {
+            this.state = 'paused';
+            this.#emit();
+        }
+    }
+    resume() {
+        if (this.state !== 'paused')
+            return;
+        this.state = 'running';
+        const waiters = this.#resumeWaiters.splice(0);
+        for (const resolve of waiters)
+            resolve();
+        this.#emit();
+    }
+    cancel() {
+        if (this.state === 'completed' || this.state === 'failed' || this.state === 'cancelled')
+            return;
+        this.state = 'cancelled';
+        this.#stopped = true;
+        const error = new Error(`Transfer ${this.hash} was cancelled`);
+        this.error = error;
+        const waiters = this.#resumeWaiters.splice(0);
+        for (const resolve of waiters)
+            resolve();
+        this.#reject(error);
+        this.#emit();
+    }
+    async #waitUntilRunning() {
+        if (this.state === 'paused')
+            await new Promise((resolve) => this.#resumeWaiters.push(resolve));
+        if (this.state === 'cancelled')
+            throw this.error;
+    }
+    async #run() {
+        try {
+            const manifestData = await this.#fetch(this.hash);
+            if (!manifestData)
+                throw new Error(`Unable to download ${this.hash}`);
+            if (this.#verifyManifest && !(await this.#verify(manifestData, this.hash)))
+                throw new Error(`Manifest hash mismatch for ${this.hash}`);
+            const manifest = await this.#decode(manifestData);
+            if (this.#pin)
+                await this.#pin(this.hash, manifestData);
+            if (!manifest.chunked) {
+                if (manifest.links?.length)
+                    throw new Error(`${this.hash} is a directory`);
+                const content = manifest.content || new Uint8Array();
+                this.#totalChunks = 1;
+                this.#totalBytes = content.length;
+                this.#chunks.set(0, content);
+                this.state = 'completed';
+                this.#resolve(content);
+                this.#emit();
+                return;
+            }
+            const links = manifest.links || [];
+            this.#totalChunks = links.length;
+            this.#totalBytes =
+                Number(manifest.size) || links.reduce((sum, link) => sum + (Number(link.size) || 0), 0);
+            this.#emit();
+            let nextIndex = 0;
+            const worker = async () => {
+                while (!this.#stopped) {
+                    await this.#waitUntilRunning();
+                    const index = nextIndex++;
+                    if (index >= links.length)
+                        return;
+                    if (this.#chunks.has(index))
+                        continue;
+                    const encoded = await this.#fetch(links[index].hash, index);
+                    if (this.#stopped)
+                        return;
+                    if (!encoded)
+                        throw new Error(`Missing chunk ${index + 1}/${links.length}`);
+                    if (!(await this.#verify(encoded, links[index].hash)))
+                        throw new Error(`Hash mismatch for chunk ${index + 1}`);
+                    const chunkNode = await this.#decode(encoded);
+                    const content = chunkNode.content || new Uint8Array();
+                    this.#chunks.set(index, content);
+                    if (this.#pin)
+                        await this.#pin(links[index].hash, encoded);
+                    this.#emit();
+                }
+            };
+            await Promise.all(Array.from({ length: Math.min(this.#concurrency, links.length) }, () => worker()));
+            const output = new Uint8Array(this.#totalBytes);
+            let offset = 0;
+            for (let index = 0; index < this.#totalChunks; index++) {
+                const chunk = this.#chunks.get(index);
+                if (!chunk)
+                    throw new Error(`Missing downloaded chunk ${index + 1}`);
+                output.set(chunk, offset);
+                offset += chunk.length;
+            }
+            this.state = 'completed';
+            this.#resolve(offset === output.length ? output : output.slice(0, offset));
+            this.#emit();
+        }
+        catch (error) {
+            if (this.state === 'cancelled')
+                return;
+            this.state = 'failed';
+            this.#stopped = true;
+            this.error = error;
+            this.#reject(error);
+            this.#emit();
+        }
+    }
+    #emit() {
+        const progress = this.progress;
+        for (const listener of this.#listeners)
+            listener(progress);
+    }
+}
+
+const DEFAULT_CHUNK_SIZE = 256 * 1024;
+const DEFAULT_BLOCK_CHUNK_SIZE = 256 * 1024;
+const DEFAULT_BLOCK_CHUNK_THRESHOLD = 1024 * 1024;
+const DEFAULT_TRANSFER_CONCURRENCY = 4;
+const adaptiveChunkSize = (size, minimum = DEFAULT_CHUNK_SIZE) => {
+    if (size >= 256 * 1024 * 1024)
+        return Math.max(minimum, 4 * 1024 * 1024);
+    if (size >= 32 * 1024 * 1024)
+        return Math.max(minimum, 1024 * 1024);
+    return minimum;
+};
 globalThis.LeofcoinStorage = LeofcoinStorage$1;
 globalThis.leofcoin = globalThis.leofcoin || {};
 globalThis.pubsub = globalThis.pubsub || new LittlePubSub();
@@ -17021,6 +17354,9 @@ class Peernet {
     _peerHandler;
     protos;
     version;
+    blockChunkSize;
+    blockChunkThreshold;
+    transferConcurrency;
     #peerAttempts = {};
     _inMemoryBroadcasts;
     /**
@@ -17047,6 +17383,15 @@ class Peernet {
         this.stars = options.stars;
         this.transport = options.transport;
         this.version = options.version;
+        this.blockChunkSize = options.blockChunkSize ?? DEFAULT_BLOCK_CHUNK_SIZE;
+        this.blockChunkThreshold = options.blockChunkThreshold ?? DEFAULT_BLOCK_CHUNK_THRESHOLD;
+        this.transferConcurrency = options.transferConcurrency ?? DEFAULT_TRANSFER_CONCURRENCY;
+        if (!Number.isSafeInteger(this.blockChunkSize) || this.blockChunkSize <= 0)
+            throw new TypeError('blockChunkSize must be a positive integer');
+        if (!Number.isSafeInteger(this.blockChunkThreshold) || this.blockChunkThreshold < 0)
+            throw new TypeError('blockChunkThreshold must be a non-negative integer');
+        if (!Number.isSafeInteger(this.transferConcurrency) || this.transferConcurrency <= 0)
+            throw new TypeError('transferConcurrency must be a positive integer');
         const parts = this.network.split(':');
         this.networkVersion = options.networkVersion || parts.length > 1 ? parts[1] : 'mainnet';
         if (!options.storePrefix)
@@ -17139,7 +17484,7 @@ class Peernet {
         await getAddress();
         this.storePrefix = options.storePrefix;
         this.root = options.root;
-        const { RequestMessage, ResponseMessage, PeerMessage, PeerMessageResponse, PeernetMessage, DHTMessage, DHTMessageResponse, DataMessage, DataMessageResponse, PsMessage, ChatMessage, PeernetFile } = await import(/* webpackChunkName: "messages" */ './messages-DH0tgNM9-CZwrcL37.js');
+        const { RequestMessage, ResponseMessage, PeerMessage, PeerMessageResponse, PeernetMessage, DHTMessage, DHTMessageResponse, DataMessage, DataMessageResponse, PsMessage, ChatMessage, PeernetFile } = await import(/* webpackChunkName: "messages" */ './messages-Dw86z0zq-DrPw_nlZ.js');
         /**
          * proto Object containing protos
          * @type {Object}
@@ -17186,7 +17531,7 @@ class Peernet {
         if (this.#starting || this.#started)
             return;
         this.#starting = true;
-        const importee = await import('./client-DDC8C510-CUi3_3uT.js');
+        const importee = await import('./client-CAC7RVMf-Dmz_2A_5.js');
         /**
          * @access public
          * @type {PeernetClient}
@@ -17275,12 +17620,34 @@ class Peernet {
    
      * @returns {Promise<string>} The hash that can be shared for direct download
      */
-    async broadcast(path, { content, links }) {
+    async broadcast(path, { content, links, chunkSize }) {
+        chunkSize = chunkSize ?? (content ? adaptiveChunkSize(content.length) : DEFAULT_CHUNK_SIZE);
+        if (!Number.isSafeInteger(chunkSize) || chunkSize <= 0)
+            throw new TypeError('chunkSize must be a positive integer');
         let protoInput;
-        if (content)
-            protoInput = { path, content };
+        if (content && content.length > chunkSize) {
+            const chunkLinks = [];
+            for (let offset = 0, index = 0; offset < content.length; offset += chunkSize, index++) {
+                const chunkNode = await new globalThis.peernet.protos['peernet-file']({
+                    path: `${path}.part-${index}`,
+                    content: content.slice(offset, Math.min(offset + chunkSize, content.length))
+                });
+                const chunkHash = await chunkNode.hash();
+                const chunkEncoded = await chunkNode.encoded;
+                if (!this._inMemoryBroadcasts)
+                    this._inMemoryBroadcasts = new Map();
+                this._inMemoryBroadcasts.set(chunkHash, chunkEncoded);
+                await shareStore.put(chunkHash, chunkEncoded);
+                chunkLinks.push({ hash: chunkHash, path: String(index), size: chunkNode.decoded.content.length });
+            }
+            protoInput = { path, links: chunkLinks, size: content.length, chunkSize, chunked: true };
+        }
+        else if (content)
+            protoInput = { path, content, size: content.length };
         else if (links)
             protoInput = { path, links };
+        else
+            throw new TypeError('broadcast requires content or links');
         const protoNode = await new globalThis.peernet.protos['peernet-file'](protoInput);
         const hash = await protoNode.hash();
         const encoded = await protoNode.encoded;
@@ -17292,6 +17659,46 @@ class Peernet {
         await this.publish('broadcast', { hash, from: this.id });
         return hash;
     }
+    /** Create and immediately start a resumable, integrity-checked file download. */
+    download(hash, options = {}) {
+        const FileProto = globalThis.peernet.protos['peernet-file'];
+        const transfer = new FileTransfer({
+            hash,
+            fetch: async (wantedHash, index) => {
+                if (wantedHash !== hash) {
+                    const providers = Object.values(this.dht.providersFor(hash) || {});
+                    for (const provider of providers)
+                        this.dht.addProvider(provider, wantedHash);
+                }
+                const store = await this.whichStore([...this.stores], wantedHash);
+                if (store && (await store.has(wantedHash)))
+                    return store.get(wantedHash);
+                const result = await this.requestData(wantedHash, undefined, { providerIndex: index });
+                return result;
+            },
+            decode: async (encoded) => {
+                const node = await new FileProto(encoded);
+                await node.decode();
+                if (node.decoded?.chunked) {
+                    const providers = Object.values(this.dht.providersFor(hash) || {});
+                    for (const link of node.decoded.links || []) {
+                        for (const provider of providers)
+                            this.dht.addProvider(provider, link.hash);
+                    }
+                }
+                return node.decoded;
+            },
+            concurrency: this.transferConcurrency,
+            verify: async (encoded, expectedHash) => {
+                const node = await new FileProto(encoded);
+                return (await node.hash()) === expectedHash;
+            },
+            pin: options.pin ? (chunkHash, encoded) => dataStore.put(chunkHash, encoded) : undefined
+        });
+        if (options.autoStart !== false)
+            transfer.start();
+        return transfer;
+    }
     async handleData(peer, id, proto) {
         let { hash, store } = proto.decoded;
         let data;
@@ -17302,15 +17709,9 @@ class Peernet {
                 if (typeof hash === 'function') {
                     resolvedHash = await hash();
                 }
-                // Decode the stored proto to extract the content or links
-                const FileProto = globalThis.peernet.protos['peernet-file'];
-                const fileProto = await new FileProto(data);
-                await fileProto.decode();
-                const { content, links } = fileProto.decoded;
-                console.log(links);
                 data = await new globalThis.peernet.protos['peernet-data-response']({
                     hash: resolvedHash,
-                    data: links || content
+                    data
                 });
                 const node = await this.prepareMessage(data);
                 await this.sendMessage(peer, id, node.encoded);
@@ -17466,19 +17867,93 @@ class Peernet {
     get block() {
         return {
             get: async (hash) => {
-                const data = await blockStore.has(hash);
-                if (data)
-                    return blockStore.get(hash);
-                return this.requestData(hash, 'block');
+                return this.#createBlockTransfer(hash).result;
             },
             put: async (hash, data) => {
                 if (await blockStore.has(hash))
                     return;
+                if (data.length > this.blockChunkThreshold)
+                    return this.#putChunkedBlock(hash, data);
                 return await blockStore.put(hash, data);
             },
-            has: async (hash) => await blockStore.has(hash)
+            has: async (hash) => await blockStore.has(hash),
+            download: (hash, options = {}) => this.#createBlockTransfer(hash, options)
         };
     }
+    async #putChunkedBlock(hash, data) {
+        const links = [];
+        const FileProto = globalThis.peernet.protos['peernet-file'];
+        const chunkSize = adaptiveChunkSize(data.length, this.blockChunkSize);
+        for (let offset = 0, index = 0; offset < data.length; offset += chunkSize, index++) {
+            const content = data.slice(offset, Math.min(offset + chunkSize, data.length));
+            const chunk = new FileProto({ path: `block-${hash}.part-${index}`, content });
+            const chunkHash = await chunk.hash();
+            await blockStore.put(chunkHash, chunk.encoded);
+            links.push({ hash: chunkHash, path: String(index).padStart(12, '0'), size: content.length });
+        }
+        const manifest = new FileProto({
+            path: `block-${hash}`,
+            links,
+            size: data.length,
+            chunkSize,
+            chunked: true,
+            kind: 'block',
+            blockHash: hash
+        });
+        return blockStore.put(hash, manifest.encoded);
+    }
+    #createBlockTransfer(hash, options = {}) {
+        const FileProto = globalThis.peernet.protos['peernet-file'];
+        const fetch = async (wantedHash, index) => {
+            if (wantedHash !== hash) {
+                const providers = Object.values(this.dht.providersFor(hash) || {});
+                for (const provider of providers)
+                    this.dht.addProvider(provider, wantedHash);
+            }
+            if (await blockStore.has(wantedHash))
+                return blockStore.get(wantedHash);
+            const result = await this.requestData(wantedHash, 'block', { providerIndex: index });
+            return result;
+        };
+        const transfer = new FileTransfer({
+            hash,
+            fetch,
+            decode: async (encoded) => {
+                let node;
+                try {
+                    node = new FileProto(encoded);
+                    await node.decode();
+                }
+                catch {
+                    // A normal block is intentionally not a peernet-file envelope.
+                    return { content: encoded };
+                }
+                if (node.decoded?.kind === 'block') {
+                    if (node.decoded.blockHash !== hash)
+                        throw new Error(`Block manifest hash mismatch for ${hash}`);
+                    const providers = Object.values(this.dht.providersFor(hash) || {});
+                    for (const link of node.decoded.links || []) {
+                        for (const provider of providers)
+                            this.dht.addProvider(provider, link.hash);
+                    }
+                    return node.decoded;
+                }
+                if (node.decoded?.path?.startsWith(`block-${hash}.part-`))
+                    return node.decoded;
+                return { content: encoded };
+            },
+            verify: async (encoded, expectedHash) => {
+                const node = new FileProto(encoded);
+                return (await node.hash()) === expectedHash;
+            },
+            verifyManifest: false,
+            concurrency: this.transferConcurrency,
+            pin: (wantedHash, encoded) => blockStore.put(wantedHash, encoded)
+        });
+        if (options.autoStart !== false)
+            transfer.start();
+        return transfer;
+    }
     get transaction() {
         return {
             get: async (hash) => {
@@ -17495,14 +17970,17 @@ class Peernet {
             has: async (hash) => await transactionStore.has(hash)
         };
     }
-    async requestData(hash, store) {
+    async requestData(hash, store, options = {}) {
         try {
             const providers = await this.providersFor(hash);
             if (!providers || (providers && Object.keys(providers).length === 0))
                 throw nothingFoundError(hash);
             debug(`found ${Object.keys(providers).length} provider(s) for ${hash}`);
             // get closest peer on earth
-            let closestPeer = await this.dht.closestPeer(Object.values(providers));
+            const providerValues = Object.values(providers);
+            let closestPeer = options.providerIndex === undefined
+                ? await this.dht.closestPeer(providerValues)
+                : providerValues[options.providerIndex % providerValues.length];
             // fallback to first provider if no closest peer found
             if (!closestPeer || !closestPeer.id)
                 closestPeer = Object.values(providers)[0];
@@ -17514,7 +17992,7 @@ class Peernet {
             const peer = this.connections[id];
             if (!peer || !peer?.connected) {
                 this.dht.removeProvider(id, hash);
-                return this.requestData(hash, store?.name || store);
+                return this.requestData(hash, store?.name || store, options);
             }
             let data = await new globalThis.peernet.protos['peernet-data']({
                 hash,
@@ -17557,7 +18035,7 @@ class Peernet {
                     if (this.#peerAttempts[id] === undefined)
                         this.#peerAttempts[id] = 0;
                     this.#peerAttempts[id]++;
-                    return this.requestData(hash, store?.name || store);
+                    return this.requestData(hash, store?.name || store, options);
                 }
                 // this.put(hash, proto.decoded.data)
             }
@@ -17734,18 +18212,8 @@ class Peernet {
         return paths;
     }
     async cat(hash, options) {
-        let data;
-        const has = await dataStore.has(hash);
-        data = has ? await dataStore.get(hash) : await this.requestData(hash, 'data');
-        if (!data)
-            throw nothingFoundError(hash);
-        const node = await new globalThis.peernet.protos['peernet-file'](data);
-        await node.decode();
-        if (node.decoded?.links.length > 0)
-            throw new Error(`${hash} is a directory`);
-        if (options?.pin)
-            await dataStore.put(hash, node.encoded);
-        return node.decoded.content;
+        const transfer = this.download(hash, { pin: options?.pin });
+        return transfer.result;
     }
     /**
      * goes trough given stores and tries to find data for given hash