@leofcoin/chain 1.10.9 → 1.10.11

package/exports/browser/{constants-gMYZLHKp.js → proposal.proto-BcUgd885.js}

@@ -1,425 +1,4 @@
-// base-x encoding / decoding
-// Copyright (c) 2018 base-x contributors
-// Copyright (c) 2014-2018 The Bitcoin Core developers (base58.cpp)
-// Copyright (c) 2026 Vandeuren Glenn
-// Distributed under the MIT software license, see the accompanying
-// file LICENSE or http://www.opensource.org/licenses/mit-license.php.
-const base = (ALPHABET, options = {}) => {
-    if (ALPHABET.length >= 255) {
-        throw new TypeError("Alphabet too long");
-    }
-    const BASE_MAP = new Uint8Array(256);
-    for (let j = 0; j < BASE_MAP.length; j++) {
-        BASE_MAP[j] = 255;
-    }
-    for (let i = 0; i < ALPHABET.length; i++) {
-        const x = ALPHABET.charAt(i);
-        const xc = x.charCodeAt(0);
-        if (BASE_MAP[xc] !== 255) {
-            throw new TypeError(x + " is ambiguous");
-        }
-        BASE_MAP[xc] = i;
-    }
-    const BASE = ALPHABET.length;
-    const LEADER = ALPHABET.charAt(0);
-    const LEADER_CODE = ALPHABET.charCodeAt(0);
-    const FACTOR = Math.log(BASE) / Math.log(256); // log(BASE) / log(256), rounded up
-    const iFACTOR = Math.log(256) / Math.log(BASE); // log(256) / log(BASE), rounded up
-    // Optimization: If BASE is a power of 2, we can use bitwise operations
-    // This is much faster than the generic algorithm (approx 10x-20x)
-    const isPowerOfTwo = (BASE & (BASE - 1)) === 0;
-    if (isPowerOfTwo) {
-        const k = Math.log2(BASE);
-        const mask = (1 << k) - 1;
-        if (options.rfc4648) {
-            // RFC 4648 Mode
-            const encode = (source) => {
-                if (source instanceof Uint8Array) ;
-                else if (ArrayBuffer.isView(source)) {
-                    source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
-                }
-                else if (Array.isArray(source)) {
-                    source = Uint8Array.from(source);
-                }
-                if (!(source instanceof Uint8Array)) {
-                    throw new TypeError("Expected Uint8Array");
-                }
-                if (source.length === 0) {
-                    return "";
-                }
-                let str = "";
-                let currentValue = 0;
-                let currentBits = 0;
-                for (let i = 0; i < source.length; i++) {
-                    currentValue = (currentValue << 8) | source[i];
-                    currentBits += 8;
-                    while (currentBits >= k) {
-                        currentBits -= k;
-                        str += ALPHABET.charAt((currentValue >>> currentBits) & mask);
-                    }
-                }
-                // Leftover bits (padding logic for the last character)
-                if (currentBits > 0) {
-                    str += ALPHABET.charAt((currentValue << (k - currentBits)) & mask);
-                }
-                // Add padding chars '=' if required
-                while ((str.length * k) % 8 !== 0) {
-                    str += "=";
-                }
-                return str;
-            };
-            const decodeUnsafe = (source) => {
-                if (typeof source !== "string") {
-                    throw new TypeError("Expected String");
-                }
-                if (source.length === 0) {
-                    return new Uint8Array();
-                }
-                // Strip padding
-                let end = source.length;
-                while (end > 0 && source[end - 1] === "=") {
-                    end--;
-                }
-                source = source.substring(0, end);
-                let currentValue = 0;
-                let currentBits = 0;
-                // Estimate size: source.length * k / 8
-                const buffer = new Uint8Array((source.length * k) >>> 3);
-                let ptr = 0;
-                for (let i = 0; i < source.length; i++) {
-                    const char = source.charCodeAt(i);
-                    const val = BASE_MAP[char];
-                    if (val === 255)
-                        return undefined;
-                    currentValue = (currentValue << k) | val;
-                    currentBits += k;
-                    if (currentBits >= 8) {
-                        currentBits -= 8;
-                        buffer[ptr++] = (currentValue >>> currentBits) & 0xff;
-                    }
-                }
-                return buffer;
-            };
-            const decode = (string) => {
-                const buffer = decodeUnsafe(string);
-                if (buffer)
-                    return buffer;
-                throw new Error("Non-base" + BASE + " character");
-            };
-            return { encode, decodeUnsafe, decode };
-        }
-        // Standard Mode (Bitwise)
-        const encode = (source) => {
-            if (source instanceof Uint8Array) ;
-            else if (ArrayBuffer.isView(source)) {
-                source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
-            }
-            else if (Array.isArray(source)) {
-                source = Uint8Array.from(source);
-            }
-            if (!(source instanceof Uint8Array)) {
-                throw new TypeError("Expected Uint8Array");
-            }
-            if (source.length === 0) {
-                return "";
-            }
-            let zeroes = 0;
-            let pbegin = 0;
-            const pend = source.length;
-            while (pbegin !== pend && source[pbegin] === 0) {
-                pbegin++;
-                zeroes++;
-            }
-            let str = LEADER.repeat(zeroes);
-            if (pbegin === pend)
-                return str;
-            // Bitwise conversion
-            let currentValue = 0;
-            let currentBits = 0;
-            const totalBits = (pend - pbegin) * 8;
-            let remainder = totalBits % k;
-            // Handling the initial alignment to the most significant bits
-            // If total bits isn't divisible by k, the first digit uses 'remainder' bits
-            if (remainder === 0)
-                remainder = k; // effectively divisible, treating first k bits normally
-            let seenNonZero = false;
-            let firstChunk = true;
-            for (let i = pbegin; i < pend; i++) {
-                currentValue = (currentValue << 8) | source[i];
-                currentBits += 8;
-                while (currentBits >= k || (firstChunk && currentBits >= remainder)) {
-                    let bitsToExtract = k;
-                    if (firstChunk) {
-                        if (totalBits % k !== 0) {
-                            bitsToExtract = totalBits % k;
-                        }
-                        firstChunk = false;
-                    }
-                    const shift = currentBits - bitsToExtract;
-                    const digit = (currentValue >>> shift) & ((1 << bitsToExtract) - 1);
-                    currentBits -= bitsToExtract;
-                    if (seenNonZero || digit !== 0) {
-                        str += ALPHABET.charAt(digit);
-                        seenNonZero = true;
-                    }
-                }
-            }
-            return str;
-        };
-        const decodeUnsafe = (source) => {
-            if (typeof source !== "string") {
-                throw new TypeError("Expected String");
-            }
-            if (source.length === 0) {
-                return new Uint8Array();
-            }
-            let psz = 0;
-            let zeroes = 0;
-            while (source.charCodeAt(psz) === LEADER_CODE) {
-                zeroes++;
-                psz++;
-            }
-            // Accumulate bits
-            // We must handle alignment.
-            const length = source.length - psz;
-            const totalBits = length * k;
-            let currentBits = (8 - (totalBits % 8)) % 8; // align to byte boundary
-            const result = new Uint8Array((totalBits + 7) >>> 3); // (totalBits + 7) / 8
-            let rIdx = 0;
-            let currentValue = 0;
-            for (let i = psz; i < source.length; i++) {
-                const char = source.charCodeAt(i);
-                const val = BASE_MAP[char];
-                if (val === 255)
-                    return;
-                currentValue = (currentValue << k) | val;
-                currentBits += k;
-                if (currentBits >= 8) {
-                    const shift = currentBits - 8;
-                    result[rIdx++] = (currentValue >>> shift) & 0xff;
-                    currentBits -= 8;
-                    // Keep only the remaining bits to avoid overflow
-                    currentValue &= (1 << currentBits) - 1;
-                }
-            }
-            // Skip leading zeroes in result buffer
-            let skip = 0;
-            while (skip < rIdx && result[skip] === 0) {
-                skip++;
-            }
-            // Combine with zeroes
-            const final = new Uint8Array(zeroes + (rIdx - skip));
-            // zeroes are 0, so just copy result
-            final.set(result.subarray(skip, rIdx), zeroes);
-            return final;
-        };
-        const decode = (string) => {
-            const buffer = decodeUnsafe(string);
-            if (buffer)
-                return buffer;
-            throw new Error("Non-base" + BASE + " character");
-        };
-        return { encode, decodeUnsafe, decode };
-    }
-    const encode = (source) => {
-        if (source instanceof Uint8Array) ;
-        else if (ArrayBuffer.isView(source)) {
-            source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
-        }
-        else if (Array.isArray(source)) {
-            source = Uint8Array.from(source);
-        }
-        if (!(source instanceof Uint8Array)) {
-            throw new TypeError("Expected Uint8Array");
-        }
-        if (source.length === 0) {
-            return "";
-        }
-        // Skip & count leading zeroes.
-        let zeroes = 0;
-        let length = 0;
-        let pbegin = 0;
-        const pend = source.length;
-        while (pbegin !== pend && source[pbegin] === 0) {
-            pbegin++;
-            zeroes++;
-        }
-        // Allocate enough space in big-endian base58 representation.
-        const size = ((pend - pbegin) * iFACTOR + 1) >>> 0;
-        const b58 = new Uint8Array(size);
-        // Process the bytes.
-        while (pbegin !== pend) {
-            let carry = source[pbegin];
-            // Apply "b58 = b58 * 256 + ch".
-            let i = 0;
-            for (let it1 = size - 1; (carry !== 0 || i < length) && it1 !== -1; it1--, i++) {
-                carry += (b58[it1] << 8) >>> 0;
-                b58[it1] = (carry % BASE) >>> 0;
-                carry = (carry / BASE) >>> 0;
-            }
-            if (carry !== 0) {
-                throw new Error("Non-zero carry");
-            }
-            length = i;
-            pbegin++;
-        }
-        // Skip leading zeroes in base58 result.
-        let it2 = size - length;
-        while (it2 !== size && b58[it2] === 0) {
-            it2++;
-        }
-        // Translate the result into a string.
-        let str = LEADER.repeat(zeroes);
-        for (; it2 < size; ++it2) {
-            str += ALPHABET.charAt(b58[it2]);
-        }
-        return str;
-    };
-    const decodeUnsafe = (source) => {
-        if (typeof source !== "string") {
-            throw new TypeError("Expected String");
-        }
-        if (source.length === 0) {
-            return new Uint8Array();
-        }
-        let psz = 0;
-        // Skip and count leading '1's.
-        let zeroes = 0;
-        let length = 0;
-        while (source.charCodeAt(psz) === LEADER_CODE) {
-            zeroes++;
-            psz++;
-        }
-        // Allocate enough space in big-endian base256 representation.
-        const size = ((source.length - psz) * FACTOR + 1) >>> 0; // log(58) / log(256), rounded up.
-        let b256 = new Uint8Array(size);
-        // Process the characters.
-        for (; psz < source.length; psz++) {
-            // Decode character
-            let carry = BASE_MAP[source.charCodeAt(psz)];
-            // Invalid character
-            if (carry === 255) {
-                return;
-            }
-            let i = 0;
-            for (let it3 = size - 1; (carry !== 0 || i < length) && it3 !== -1; it3--, i++) {
-                carry += (BASE * b256[it3]) >>> 0;
-                b256[it3] = (carry & 0xff) >>> 0;
-                carry = (carry >> 8) >>> 0;
-            }
-            if (carry !== 0) {
-                throw new Error("Non-zero carry");
-            }
-            length = i;
-        }
-        // Skip leading zeroes in b256.
-        let it4 = size - length;
-        while (it4 !== size && b256[it4] === 0) {
-            it4++;
-        }
-        let vch = new Uint8Array(zeroes + (size - it4));
-        let j = zeroes;
-        while (it4 !== size) {
-            vch[j++] = b256[it4++];
-        }
-        return vch;
-    };
-    const decode = (string) => {
-        const buffer = decodeUnsafe(string);
-        if (buffer) {
-            return buffer;
-        }
-        throw new Error("Non-base" + BASE + " character");
-    };
-    return {
-        encode,
-        decodeUnsafe,
-        decode,
-    };
-};
-
-const ALPHABET$3 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
-const ALPHABET_HEX$1 = "0123456789ABCDEFGHIJKLMNOPQRSTUV";
-const base32 = base(ALPHABET$3);
-const base32Hex = base(ALPHABET_HEX$1);
-const decode$3 = base32.decode;
-const decodeHex$1 = base32Hex.decode;
-const encode$3 = base32.encode;
-const encodeHex$1 = base32Hex.encode;
-const isBase32 = (string, hex = false) => {
-    try {
-        if (hex)
-            decodeHex$1(string);
-        else
-            decode$3(string);
-        return true;
-    }
-    catch (e) {
-        return false;
-    }
-};
-const isBase32Hex = (string) => {
-    return isBase32(string, true);
-};
-var index$5 = {
-    encode: encode$3,
-    decode: decode$3,
-    encodeHex: encodeHex$1,
-    decodeHex: decodeHex$1,
-    isBase32,
-    isBase32Hex,
-};
-
-const ALPHABET$2 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
-const ALPHABET_HEX = "0123456789ABCDEFGHJKLMNPQRSTUVabcdefghijklmnopqrstuv";
-const base58 = base(ALPHABET$2);
-const base58Hex = base(ALPHABET_HEX);
-const encode$2 = base58.encode;
-const decode$2 = base58.decode;
-const encodeHex = base58Hex.encode;
-const decodeHex = base58Hex.decode;
-const isBase58 = (string) => {
-    try {
-        decode$2(string);
-        return true;
-    }
-    catch (e) {
-        return false;
-    }
-};
-const isBase58Hex = (string) => {
-    try {
-        decodeHex(string);
-        return true;
-    }
-    catch (e) {
-        return false;
-    }
-};
-const whatType = (string) => {
-    try {
-        decode$2(string);
-        return "base58";
-    }
-    catch (e) {
-        try {
-            decodeHex(string);
-            return "base58Hex";
-        }
-        catch {
-            return;
-        }
-    }
-};
-var base58$1 = {
-    encode: encode$2,
-    decode: decode$2,
-    isBase58,
-    isBase58Hex,
-    encodeHex,
-    decodeHex,
-    whatType,
-};
+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';
 
 var isHex = string => /^[A-F0-9]+$/i.test(
   string.startsWith('0x') ?
@@ -495,16 +74,16 @@ var encodingLength = (value) => (value < N1 ? 1
                                 : value < N9 ? 9
                                     : 10);
 
-var index$4 = {
+var index$3 = {
     encode: encode$1,
     decode: decode$1,
     encodingLength
 };
 
-var index$3 = (input, prefix) => {
+var index$2 = (input, prefix) => {
     const encodedArray = [];
     const length = input.reduce((total, current) => {
-        const encoded = index$4.encode(current.length);
+        const encoded = index$3.encode(current.length);
         encodedArray.push(encoded);
         total += current.length + encoded.length;
         return total;
@@ -4272,7 +3851,7 @@ function ZStream() {
 
 var zstream = ZStream;
 
-const toString$1$1 = Object.prototype.toString;
+const toString$1 = Object.prototype.toString;
 
 /* Public constants ==========================================================*/
 /* ===========================================================================*/
@@ -4431,7 +4010,7 @@ function Deflate$1(options) {
     if (typeof opt.dictionary === 'string') {
       // If we need to compress text, change encoding to utf8.
       dict = strings.string2buf(opt.dictionary);
-    } else if (toString$1$1.call(opt.dictionary) === '[object ArrayBuffer]') {
+    } else if (toString$1.call(opt.dictionary) === '[object ArrayBuffer]') {
       dict = new Uint8Array(opt.dictionary);
     } else {
       dict = opt.dictionary;
@@ -4483,7 +4062,7 @@ Deflate$1.prototype.push = function (data, flush_mode) {
   if (typeof data === 'string') {
     // If we need to compress text, change encoding to utf8.
     strm.input = strings.string2buf(data);
-  } else if (toString$1$1.call(data) === '[object ArrayBuffer]') {
+  } else if (toString$1.call(data) === '[object ArrayBuffer]') {
     strm.input = new Uint8Array(data);
   } else {
     strm.input = data;
@@ -7515,15 +7094,15 @@ const encode = (proto, input, compress) => {
             throw new Error(`minimumLength for ${token.key} is set to ${token.minimumLength} but got ${data.length}`);
         set.push(toType(data !== undefined ? data : token.defaultValue));
     }
-    return compress ? pako.deflate(index$3(set)) : index$3(set);
+    return compress ? pako.deflate(index$2(set)) : index$2(set);
 };
 
-var index$2 = (typedArray, prefix) => {
+var index$1 = (typedArray, prefix) => {
     const set = [];
     const varintAndSub = (typedArray) => {
-        const length = index$4.decode(typedArray);
+        const length = index$3.decode(typedArray);
         // remove length
-        typedArray = typedArray.subarray(index$4.decode.bytes);
+        typedArray = typedArray.subarray(index$3.decode.bytes);
         // push value
         set.push(typedArray.subarray(0, length));
         // remove value
@@ -7535,52 +7114,12 @@ var index$2 = (typedArray, prefix) => {
     return varintAndSub(typedArray);
 };
 
-const ALPHABET$1 = '0123456789ABCDEF';
-const base16 = base(ALPHABET$1);
-base16.decode;
-base16.encode;
-
-const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
-const base64 = base(ALPHABET);
-base64.decode;
-base64.encode;
-
-/**
- * Returns a Uint8Array as String
- * @param uint8Array Uint8Array to encode to String
- * @returns String
- */
-const toString$1 = (uint8Array) => new TextDecoder().decode(uint8Array);
-/**
- * hexString -> uint8Array
- * @param string hex encoded string
- * @returns UintArray
- */
-const fromHex = (string) => Uint8Array.from(string.match(/.{1,2}/g).map((byte) => parseInt(byte, 16)));
-/**
- * uint8Array -> hexString
- * @param bytes number[]
- * @returns hexString
- */
-const toHex = (bytes) => bytes.reduce((string, byte) => string + byte.toString(16).padStart(2, '0'), '');
-/**
- * number[] -> Uint8Array
- * @param array number[]
- * @returns Uint8Array
- */
-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);
-var index$1 = {
-    toString: toString$1};
-
-const { toString } = index$1;
+const { toString } = index$4;
 const decoder = new TextDecoder();
 const decode = (proto, uint8Array, compressed) => {
     if (compressed)
         uint8Array = pako.inflate(uint8Array);
-    let deconcated = index$2(uint8Array);
+    let deconcated = index$1(uint8Array);
     const output = {};
     const tokens = getTokens(proto);
     if (tokens.length !== deconcated.length)
@@ -7916,6 +7455,21 @@ const blockchainCodecs = [
   }
 ];
 const consensusCodecs = [
+  {
+    name: "beacon-activation-message",
+    codec: "0x62616d",
+    hashAlg: "keccak-256"
+  },
+  {
+    name: "beacon-commitment-message",
+    codec: "0x62636d",
+    hashAlg: "keccak-256"
+  },
+  {
+    name: "beacon-share-message",
+    codec: "0x62736d",
+    hashAlg: "keccak-256"
+  },
   {
     name: "proposal-message",
     codec: "0x70726d",
@@ -8079,7 +7633,7 @@ let Codec$1 = class Codec extends BasicInterface {
         super();
         if (buffer) {
             if (buffer instanceof Uint8Array) {
-                const codec = index$4.decode(buffer);
+                const codec = index$3.decode(buffer);
                 const name = this.getCodecName(codec);
                 if (name) {
                     this.name = name;
@@ -8091,7 +7645,7 @@ let Codec$1 = class Codec extends BasicInterface {
                 }
             }
             else if (buffer instanceof ArrayBuffer) {
-                const codec = index$4.decode(buffer);
+                const codec = index$3.decode(buffer);
                 const name = this.getCodecName(codec);
                 if (name) {
                     this.name = name;
@@ -8120,7 +7674,7 @@ let Codec$1 = class Codec extends BasicInterface {
         }
     }
     fromEncoded(encoded) {
-        const codec = index$4.decode(encoded);
+        const codec = index$3.decode(encoded);
         const name = this.getCodecName(codec);
         this.name = name;
         this.encoded = encoded;
@@ -8139,7 +7693,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 = index$3.encode(this.codec);
         this.decoded = {
             name: this.name,
             hashAlg: this.hashAlg,
@@ -8152,7 +7706,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 = index$3.encode(this.codec);
         this.decoded = {
             name: this.name,
             hashAlg: this.hashAlg,
@@ -8162,13 +7716,13 @@ let Codec$1 = class Codec extends BasicInterface {
     }
     decode(encoded) {
         encoded = encoded || this.encoded;
-        const codec = index$4.decode(encoded);
+        const codec = index$3.decode(encoded);
         this.fromCodec(codec);
         return this.decoded;
     }
     encode(codec) {
         codec = codec || this.codec;
-        this.encoded = index$4.encode(codec);
+        this.encoded = index$3.encode(codec);
         return this.encoded;
     }
 };
@@ -8956,7 +8510,7 @@ class CodecHash extends BasicInterface {
         return uint8Array;
     }
     get length() {
-        return index$4.encode(this.size);
+        return index$3.encode(this.size);
     }
     get buffer() {
         return this.encoded;
@@ -8990,7 +8544,7 @@ class CodecHash extends BasicInterface {
         if (!(buffer instanceof Uint8Array)) {
             throw new Error('CodecHash only supports Uint8Array input');
         }
-        const codec = index$4.decode(buffer);
+        const codec = index$3.decode(buffer);
         if (this.codecs[codec]) {
             this.decode(buffer);
         }
@@ -9000,12 +8554,12 @@ class CodecHash extends BasicInterface {
     }
     decode(buffer) {
         this.encoded = buffer;
-        const codec = index$4.decode(buffer);
+        const codec = index$3.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);
+        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()}`);
         }
@@ -9189,7 +8743,7 @@ const FormatInterface = FormatInterface$1;
  */
 const Codec = Codec$1;
 
-var proto$a = {
+var proto$8 = {
   index: BigInt(0),
   previousHash: String(),
   timestamp: Number(),
@@ -9202,73 +8756,26 @@ var proto$a = {
   protocolVersion: String()
 };
 
-var proto$9 = {
+var proto$7 = {
   address: String(),
   reward: BigInt(0)
 };
 
-class ValidatorMessage extends FormatInterface {
-  get messageName() {
-    return "ValidatorMessage";
-  }
-  constructor(buffer) {
-    if (buffer instanceof ValidatorMessage)
-      return buffer;
-    const name = "validator-message";
-    super(buffer, proto$9, { name });
-  }
-}
+({
+  epoch: BigInt(0)});
 
-class BlockMessage extends FormatInterface {
-  get messageName() {
-    return "BlockMessage";
-  }
-  constructor(buffer) {
-    if (buffer instanceof BlockMessage)
-      return buffer;
-    const name = "block-message";
-    super(buffer, proto$a, { name });
-  }
-  encode(decoded) {
-    decoded = decoded || this.decoded;
-    const validators = [];
-    for (const validator of decoded.validators) {
-      if (validator instanceof ValidatorMessage)
-        validators.push(validator.encode());
-      else
-        validators.push(new ValidatorMessage(validator).encode());
-    }
-    return super.encode({
-      ...decoded,
-      validators: index$3(validators)
-    });
-  }
-  decode(encoded) {
-    encoded = encoded || this.encoded;
-    super.decode(encoded);
-    this.decoded.validators = index$2(this.decoded.validators).map((validator) => new ValidatorMessage(validator).decoded);
-    return this.decoded;
-  }
-}
-
-var proto$8 = {
-  up: Number(),
-  down: Number()
-};
+({
+  epoch: BigInt(0),
+  threshold: BigInt(0),
+  participant: BigInt(0),
+  commitments: Array()});
 
-class BWMessage extends FormatInterface {
-  get messageName() {
-    return "BWMessage";
-  }
-  constructor(buffer) {
-    if (buffer instanceof BWMessage)
-      return buffer;
-    const name = "bw-message";
-    super(buffer, proto$8, { name });
-  }
-}
+({
+  epoch: BigInt(0),
+  round: BigInt(0),
+  participant: BigInt(0)});
 
-var proto$7 = {
+var proto$6 = {
   creator: String(),
   contract: new Uint8Array(),
   constructorParameters: Array()
@@ -9281,28 +8788,16 @@ class ContractMessage extends FormatInterface {
   constructor(buffer) {
     if (buffer instanceof ContractMessage)
       return buffer;
-    super(buffer, proto$7, { name: "contract-message" });
+    super(buffer, proto$6, { name: "contract-message" });
   }
 }
 
-var proto$6 = {
+var proto$5 = {
   hash: String(),
   index: BigInt(0)
 };
 
-class LastBlockMessage extends FormatInterface {
-  get messageName() {
-    return "LastBlockMessage";
-  }
-  constructor(buffer) {
-    if (buffer instanceof LastBlockMessage)
-      return buffer;
-    const name = "last-block-message";
-    super(buffer, proto$6, { name });
-  }
-}
-
-var proto$5 = {
+var proto$4 = {
   timestamp: Number(),
   from: String(),
   to: String(),
@@ -9322,7 +8817,7 @@ class TransactionMessage extends FormatInterface {
     if (buffer instanceof TransactionMessage)
       return buffer;
     const name = "transaction-message";
-    super(buffer, proto$5, { name });
+    super(buffer, proto$4, { name });
   }
   beforeHashing(decoded) {
     decoded = super.beforeHashing(decoded);
@@ -9333,7 +8828,7 @@ class TransactionMessage extends FormatInterface {
   }
 }
 
-var proto$4 = {
+var proto$3 = {
   timestamp: Number(),
   from: String(),
   to: String(),
@@ -9342,23 +8837,6 @@ var proto$4 = {
   "nonce?": Number()
 };
 
-var proto$3 = {
-  lastblock: Object(),
-  values: Object()
-};
-
-class StateMessage extends FormatInterface {
-  get messageName() {
-    return "StateMessage";
-  }
-  constructor(buffer) {
-    if (buffer instanceof StateMessage)
-      return buffer;
-    const name = "state-message";
-    super(buffer, proto$3, { name });
-  }
-}
-
 var proto$2 = {
   blockHash: String(),
   index: BigInt(0),
@@ -9383,41 +8861,4 @@ var proto = {
   signature: String()
 };
 
-var networks = {
-  leofcoin: {
-    mainnet: {
-      // ports don't really matter since it is favorable to have it begind a ngninx proxy but if we change something to the proto it's easier maybe?
-      port: 44444,
-      // todo a versionhash would be nice to have as a double check?
-      versionHash: "0",
-      // a short description identifying the version
-      description: "Main net current version",
-      stars: ["wss://star.leofcoin.org"]
-      // todo webrtc and bittorent stars
-    },
-    peach: {
-      port: 44444,
-      description: "Main testnet: latest step before merging into main",
-      versionHash: "1",
-      stars: ["wss://star.leofcoin.org"]
-      // todo webrtc and bittorent stars
-    }
-  }
-};
-
-var networks$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    default: networks
-});
-
-const PROTOCOL_VERSION = "0.2.0";
-const REACHED_ONE_ZERO_ZERO = false;
-const DEFAULT_NODE_OPTIONS = {
-  autoStart: false,
-  network: "leofcoin:peach",
-  networkVersion: "peach",
-  version: PROTOCOL_VERSION,
-  stars: networks.leofcoin.peach.stars
-};
-
-export { BlockMessage as B, ContractMessage as C, DEFAULT_NODE_OPTIONS as D, FormatInterface as F, LastBlockMessage as L, PROTOCOL_VERSION as P, REACHED_ONE_ZERO_ZERO as R, StateMessage as S, TransactionMessage as T, ValidatorMessage as V, proto$2 as a, proto$1 as b, proto as c, base58$1 as d, index$2 as e, createRIPEMD160 as f, createHMAC as g, createSHA512 as h, index$3 as i, createKeccak as j, index$4 as k, index$5 as l, fromBase58 as m, jsonStringifyBigInt$1 as n, jsonParseBigInt$1 as o, proto$4 as p, Codec as q, BWMessage as r, networks$1 as s, toBase58 as t };
+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, proto$7 as n, proto$8 as o, proto$2 as p, proto$5 as q };