@leofcoin/chain 1.10.15 → 1.10.16

package/exports/browser/beacon-wire.js

@@ -1,6 +1,6 @@
-import { s as signTransaction, c as MultiWallet, d as createTransactionHash } from './index-Ccn5sExe.js';
+import { s as signTransaction, c as MultiWallet, d as createTransactionHash } from './index-BC-KRBgE.js';
 import { f as fromBase58 } from './index-CvKt4UDE.js';
-import './browser-crypto-B9N9KlL4.js';
+import './browser-crypto-CeE-yId5.js';
 import './sha2-piimb6xL.js';
 
 const validInteger = (value, minimum = 0n) => {

package/exports/browser/{browser-DvU1xNFS-DmmNUdE-.js → browser-CCfR9KOM-CvhDZrGu.js}

@@ -1,8 +1,8 @@
-import { g as getDefaultExportFromCjs } from './node-browser-BYi7D_oa.js';
-import './browser-crypto-B9N9KlL4.js';
+import { g as getDefaultExportFromCjs } from './node-browser-DWSdi-XP.js';
+import './browser-crypto-CeE-yId5.js';
 import './index-CvKt4UDE.js';
 import './sha2-piimb6xL.js';
-import './connection-monitor-GPztgSSJ.js';
+import './connection-monitor-Cmv00mwl.js';
 
 function _mergeNamespaces$1(n, m) {
 	m.forEach(function (e) {

package/exports/browser/{browser-crypto-B9N9KlL4.js → browser-crypto-CeE-yId5.js}

@@ -1,4 +1,4 @@
-import { a as index$4, b as base58$1, i as index$5, f as fromBase58, c as fromHex, d as fromArrayLike, e as toBase32, t as toBase58, g as toHex } from './index-CvKt4UDE.js';
+import { a as index$3, b as base58$1, i as index$4, f as fromBase58, c as fromHex, d as fromArrayLike, e as toBase32, t as toBase58, g as toHex } from './index-CvKt4UDE.js';
 import { s as sha256 } from './sha2-piimb6xL.js';
 
 var isHex = string => /^[A-F0-9]+$/i.test(
@@ -7,100 +7,217 @@ var isHex = string => /^[A-F0-9]+$/i.test(
   string
 );
 
-const MSB$1 = 0x80;
-const MSBALL = -128;
-const INT = Math.pow(2, 31);
-const encode$1 = (num, out, offset) => {
-    if (Number.MAX_SAFE_INTEGER && num > Number.MAX_SAFE_INTEGER) {
-        encode$1.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$1.bytes = offset - oldOffset + 1;
-    return out;
-};
-
-const MSB = 0x80;
-const REST = 0x7F;
-const decode$1 = (buf, offset) => {
-    offset = offset || 0;
-    const l = buf.length;
-    let counter = offset;
-    let result = 0;
-    let shift = 0;
-    let b;
+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;
+}
+class BinaryWriter {
+  #buffer;
+  #position = 0;
+  constructor(capacity = 64) {
+    if (typeof capacity === "number") {
+      size(capacity);
+      this.#buffer = new Uint8Array(capacity);
+    } else {
+      bytes(capacity);
+      this.#buffer = capacity;
+    }
+  }
+  get position() {
+    return this.#position;
+  }
+  get remaining() {
+    return this.#buffer.length - this.#position;
+  }
+  #require(length) {
+    size(length);
+    if (length > this.remaining)
+      throw new RangeError("Binary output buffer is too small");
+  }
+  writeVarUint(value) {
+    this.#require(varUintLength(value));
+    this.#writeVarUint(value);
+    return this;
+  }
+  #writeVarUint(value) {
+    while (value >= 128) {
+      this.#buffer[this.#position++] = value % 128 | 128;
+      value = Math.floor(value / 128);
+    }
+    this.#buffer[this.#position++] = value;
+  }
+  writeVarBigInt(value) {
+    this.#require(varBigIntLength(value));
     do {
-        if (counter >= l || shift > 49) {
-            decode$1.bytes = 0;
-            throw new RangeError('Could not decode varint');
-        }
-        b = buf[counter++];
-        result += shift < 28
-            ? (b & REST) << shift
-            : (b & REST) * Math.pow(2, shift);
-        shift += 7;
-    } while (b >= MSB);
-    decode$1.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$3 = {
-    encode: encode$1,
-    decode: decode$1,
-    encodingLength
-};
-
-var index$2 = (input, prefix) => {
-    const encodedArray = [];
-    const length = input.reduce((total, current) => {
-        const encoded = index$3.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 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);
+    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);
+    return copy ? new Uint8Array(result) : result;
+  }
+}
+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;
+    }
+  }
+}
+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();
+}
+function decodeFrames(buffer, prefixLength = 0, options = {}) {
+  const reader = new BinaryReader(buffer);
+  reader.readBytes(prefixLength);
+  const maxFrames = options.maxFrames ?? buffer.length;
+  size(maxFrames);
+  const frames = [];
+  while (reader.remaining) {
+    if (frames.length >= maxFrames)
+      throw new RangeError("Too many binary frames");
+    frames.push(reader.readFrame(options.canonical ?? true));
+  }
+  return frames;
+}
+
+const 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$2 = (input, prefix) => encodeFrames(input.map(asBytes));
 
 /*! pako 2.2.0 https://github.com/nodeca/pako @license (MIT AND Zlib) */
 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
@@ -7098,24 +7215,9 @@ const encode = (proto, input, compress) => {
     return compress ? pako.deflate(index$2(set)) : index$2(set);
 };
 
-var index$1 = (typedArray, prefix) => {
-    const set = [];
-    const varintAndSub = (typedArray) => {
-        const length = index$3.decode(typedArray);
-        // remove length
-        typedArray = typedArray.subarray(index$3.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);
-};
-
-const { toString } = index$4;
+var index$1 = (typedArray, prefix) => decodeFrames(typedArray, 0, { canonical: false });
+
+const { toString } = index$3;
 const decoder = new TextDecoder();
 const decode = (proto, uint8Array, compressed) => {
     if (compressed)
@@ -7211,13 +7313,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);
@@ -7285,13 +7387,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));
@@ -7634,7 +7736,7 @@ let Codec$1 = class Codec extends BasicInterface {
         super();
         if (buffer) {
             if (buffer instanceof Uint8Array) {
-                const codec = index$3.decode(buffer);
+                const codec = new BinaryReader(buffer).readVarUint(false);
                 const name = this.getCodecName(codec);
                 if (name) {
                     this.name = name;
@@ -7646,11 +7748,12 @@ let Codec$1 = class Codec extends BasicInterface {
                 }
             }
             else if (buffer instanceof ArrayBuffer) {
-                const codec = index$3.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))));
@@ -7675,7 +7778,7 @@ let Codec$1 = class Codec extends BasicInterface {
         }
     }
     fromEncoded(encoded) {
-        const codec = index$3.decode(encoded);
+        const codec = new BinaryReader(encoded).readVarUint(false);
         const name = this.getCodecName(codec);
         this.name = name;
         this.encoded = encoded;
@@ -7694,7 +7797,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$3.encode(this.codec);
+        this.codecBuffer = new BinaryWriter(varUintLength(this.codec)).writeVarUint(this.codec).finish();
         this.decoded = {
             name: this.name,
             hashAlg: this.hashAlg,
@@ -7707,7 +7810,7 @@ let Codec$1 = class Codec extends BasicInterface {
         this.name = name;
         this.codec = codec;
         this.hashAlg = this.getHashAlg(name);
-        this.codecBuffer = index$3.encode(this.codec);
+        this.codecBuffer = new BinaryWriter(varUintLength(this.codec)).writeVarUint(this.codec).finish();
         this.decoded = {
             name: this.name,
             hashAlg: this.hashAlg,
@@ -7717,13 +7820,13 @@ let Codec$1 = class Codec extends BasicInterface {
     }
     decode(encoded) {
         encoded = encoded || this.encoded;
-        const codec = index$3.decode(encoded);
+        const codec = new BinaryReader(encoded).readVarUint(false);
         this.fromCodec(codec);
         return this.decoded;
     }
     encode(codec) {
         codec = codec || this.codec;
-        this.encoded = index$3.encode(codec);
+        this.encoded = new BinaryWriter(varUintLength(codec)).writeVarUint(codec).finish();
         return this.encoded;
     }
 };
@@ -8469,10 +8572,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();
@@ -8480,21 +8610,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 {
@@ -8503,15 +8626,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$3.encode(this.size);
+        return new BinaryWriter(varUintLength(this.size)).writeVarUint(this.size).finish();
     }
     get buffer() {
         return this.encoded;
@@ -8538,6 +8665,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;
     }
@@ -8545,35 +8674,30 @@ class CodecHash extends BasicInterface {
         if (!(buffer instanceof Uint8Array)) {
             throw new Error('CodecHash only supports Uint8Array input');
         }
-        const codec = index$3.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$3.decode(buffer);
-        this.discoCodec = new Codec$1(codec, this.codecs);
-        // TODO: validate codec
-        buffer = buffer.slice(index$3.decode.bytes);
-        this.size = index$3.decode(buffer);
-        this.digest = buffer.slice(index$3.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;
     }
 }
 
@@ -8686,13 +8810,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}
@@ -8890,4 +9015,4 @@ const createHash = (algorithm) => {
   };
 };
 
-export { ContractMessage as C, FormatInterface as F, TransactionMessage as T, proto$1 as a, proto as b, jsonParseBigInt$1 as c, Codec as d, proto$3 as e, index$1 as f, createRIPEMD160 as g, createHMAC as h, index$2 as i, jsonStringifyBigInt$1 as j, createSHA512 as k, createKeccak as l, index$3 as m, createHash as n, proto$7 as o, proto$2 as p, proto$8 as q, proto$5 as r };
+export { BinaryWriter as B, ContractMessage as C, FormatInterface as F, TransactionMessage as T, proto$1 as a, proto as b, jsonParseBigInt$1 as c, Codec as d, proto$3 as e, index$1 as f, createRIPEMD160 as g, createHMAC as h, index$2 as i, jsonStringifyBigInt$1 as j, createSHA512 as k, createKeccak as l, BinaryReader as m, createHash as n, proto$7 as o, proto$2 as p, proto$8 as q, encodeFrames as r, decodeFrames as s, proto$5 as t, varUintLength as v };