@leofcoin/chain 1.8.30 → 1.9.2

package/exports/workers/{worker-iOnLaHA--iOnLaHA-.js → worker-BrtyXRJ7-BrtyXRJ7.js}

@@ -325,53 +325,6 @@ var index$3 = (input, prefix) => {
     return typedArray;
 };
 
-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);
-};
-
-const ALPHABET$1 = '0123456789ABCDEF';
-base(ALPHABET$1);
-
-const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
-base(ALPHABET);
-
-/**
- * Returns a Uint8Array as String
- * @param uint8Array Uint8Array to encode to String
- * @returns String
- */
-const toString$3 = (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'), '');
-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$3};
-
 /*! pako 2.1.0 https://github.com/nodeca/pako @license (MIT AND Zlib) */
 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
 // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
@@ -4101,7 +4054,7 @@ function ZStream() {
 
 var zstream = ZStream;
 
-const toString$1 = Object.prototype.toString;
+const toString$1$1 = Object.prototype.toString;
 
 /* Public constants ==========================================================*/
 /* ===========================================================================*/
@@ -4253,7 +4206,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.call(opt.dictionary) === '[object ArrayBuffer]') {
+    } else if (toString$1$1.call(opt.dictionary) === '[object ArrayBuffer]') {
       dict = new Uint8Array(opt.dictionary);
     } else {
       dict = opt.dictionary;
@@ -4305,7 +4258,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.call(data) === '[object ArrayBuffer]') {
+  } else if (toString$1$1.call(data) === '[object ArrayBuffer]') {
     strm.input = new Uint8Array(data);
   } else {
     strm.input = data;
@@ -7242,88 +7195,141 @@ var pako = {
 };
 
 const jsonStringifyBigInt$1 = (key, value) => (typeof value === 'bigint' ? { $bigint: value.toString() } : value);
-const jsonParseBigInt$1 = (key, value) => typeof value === 'object' && value.$bigint ? BigInt(value.$bigint) : value;
+const jsonParseBigInt$1 = (key, value) => typeof value === 'object' && value?.$bigint ? BigInt(value.$bigint) : value;
 
-const { toString } = index$1;
-const isString = (type) => type === 'string';
-const isNumber = (type) => type === 'number';
-const isBoolean = (type) => type === 'boolean';
-const isUint8Array = (type) => type === 'uint8Array';
-const isBigInt = (type) => type === 'bigint';
+const tokenCache = new WeakMap();
 const tokenize = (key, value) => {
     const optional = key.endsWith('?');
     let type = value === undefined ? key : value;
     if (type instanceof Uint8Array)
         type = 'uint8Array';
-    else if (type instanceof BigInt)
+    else if (typeof type === 'bigint')
         type = 'bigint';
     else
         type = Array.isArray(type) ? 'array' : typeof type;
     const parts = key.split('?');
-    const minimumLength = parts[2]?.includes('min') ? parts[2].split['min:'][1] : 0;
-    return { type, optional, key: parts[0], minimumLength };
+    const minimumLength = parts[2]?.includes('min') ? Number(parts[2].split('min:')[1]) : 0;
+    return { type, optional, key: parts[0], minimumLength, defaultValue: value };
 };
+const getTokens = (proto) => {
+    if (tokenCache.has(proto))
+        return tokenCache.get(proto);
+    const keys = Object.keys(proto);
+    const values = Object.values(proto);
+    const tokens = keys.map((k, i) => tokenize(k, values[i]));
+    tokenCache.set(proto, tokens);
+    return tokens;
+};
+
+const encoder = new TextEncoder();
 const toType = (data) => {
-    // always return uint8Arrays as they are
     if (data instanceof Uint8Array)
         return data;
-    // returns the ArrayBuffer as UintArray
     if (data instanceof ArrayBuffer)
         return new Uint8Array(data);
-    // returns the BigTnt string as UintArray
     if (typeof data === 'bigint')
-        return new TextEncoder().encode(data.toString());
-    // returns the string as UintArray
+        return encoder.encode(data.toString());
     if (typeof data === 'string')
-        return new TextEncoder().encode(data);
-    // returns the object as UintArray
+        return encoder.encode(data);
     if (typeof data === 'object')
-        return new TextEncoder().encode(JSON.stringify(data, jsonStringifyBigInt$1));
-    // returns the number as UintArray
+        return encoder.encode(JSON.stringify(data, jsonStringifyBigInt$1));
     if (typeof data === 'number' || typeof data === 'boolean')
-        return new TextEncoder().encode(data.toString());
+        return encoder.encode(data.toString());
     throw new Error(`unsuported type ${typeof data || data}`);
 };
 const encode = (proto, input, compress) => {
-    const keys = Object.keys(proto);
-    const values = Object.values(proto);
+    const tokens = getTokens(proto);
     const set = [];
-    for (let i = 0; i < values.length; i++) {
-        const token = tokenize(keys[i], values[i]);
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
         const data = input[token.key];
         if (!token.optional && data === undefined)
             throw new Error(`missing required property: ${token.key}`);
         if ((token.type === 'array' && token.minimumLength > data?.length) ||
             (token.type === 'object' && token.minimumLength > Object.keys(data).length))
             throw new Error(`minimumLength for ${token.key} is set to ${token.minimumLength} but got ${data.length}`);
-        // always push data to the set.
-        // when data is undefined push the default value of the proto
-        set.push(toType(data || values[i]));
+        set.push(toType(data !== undefined ? data : token.defaultValue));
     }
     return compress ? pako.deflate(index$3(set)) : index$3(set);
 };
+
+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);
+};
+
+const ALPHABET$1 = '0123456789ABCDEF';
+base(ALPHABET$1);
+
+const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+base(ALPHABET);
+
+/**
+ * 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 decoder = new TextDecoder();
 const decode = (proto, uint8Array, compressed) => {
     if (compressed)
         uint8Array = pako.inflate(uint8Array);
     let deconcated = index$2(uint8Array);
     const output = {};
-    const keys = Object.keys(proto);
-    const values = Object.values(proto);
-    if (keys.length !== deconcated.length)
-        console.warn(`length mismatch: expected  ${keys.length} got ${uint8Array.length}`);
-    for (let i = 0; i < values.length; i++) {
-        const token = tokenize(keys[i], values[i]);
-        if (isUint8Array(token.type))
+    const tokens = getTokens(proto);
+    if (tokens.length !== deconcated.length)
+        console.warn(`length mismatch: expected  ${tokens.length} got ${uint8Array.length}`);
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        if (token.type === 'uint8Array')
             output[token.key] = deconcated[i];
-        else if (isString(token.type))
+        else if (token.type === 'string')
             output[token.key] = toString(deconcated[i]);
-        else if (isBoolean(token.type))
-            output[token.key] = new TextDecoder().decode(deconcated[i]) === 'true';
-        else if (isNumber(token.type))
-            output[token.key] = Number(new TextDecoder().decode(deconcated[i]));
-        else if (isBigInt(token.type))
-            output[token.key] = BigInt(new TextDecoder().decode(deconcated[i]));
-        else output[token.key] = JSON.parse(new TextDecoder().decode(deconcated[i]), jsonParseBigInt$1);
+        else if (token.type === 'boolean')
+            output[token.key] = decoder.decode(deconcated[i]) === 'true';
+        else if (token.type === 'number')
+            output[token.key] = Number(decoder.decode(deconcated[i]));
+        else if (token.type === 'bigint')
+            output[token.key] = BigInt(decoder.decode(deconcated[i]));
+        else if (token.type === 'object' || token.type === 'array')
+            output[token.key] = JSON.parse(decoder.decode(deconcated[i]), jsonParseBigInt$1);
         if (token.optional) {
             if (!output[token.key] || output[token.key].length === 0)
                 delete output[token.key];
@@ -7333,10 +7339,8 @@ const decode = (proto, uint8Array, compressed) => {
     }
     return output;
 };
-var index = {
-    encode,
-    decode
-};
+
+var index = { encode, decode };
 
 const jsonStringifyBigInt = (key, value) => {
     if (typeof value === 'bigint')
@@ -7350,13 +7354,13 @@ const jsonParseBigInt = (key, value) => {
     }
     return value;
 };
-const _textEncoder = new TextEncoder();
-const _textDecoder = new TextDecoder();
 class BasicInterface {
     #encoded;
     #decoded;
     name;
     #proto;
+    textEncoder = new TextEncoder();
+    textDecoder = new TextDecoder();
     get keys() {
         // handles proto keys
         // protokey -> key
@@ -7384,11 +7388,42 @@ class BasicInterface {
     get proto() {
         return this.#proto;
     }
+    from(value) {
+        if (value instanceof Uint8Array)
+            this.fromUint8Array(value);
+        else if (value instanceof ArrayBuffer)
+            this.fromArrayBuffer(value);
+        else if (typeof value === 'string' && isHex(value)) {
+            this.fromHex(value);
+        }
+        else if (typeof value === 'string') {
+            if (base58$1.isBase58(value)) {
+                try {
+                    this.fromBs58(value);
+                }
+                catch {
+                    if (index$5.isBase32(value))
+                        this.fromBs32(value);
+                    else
+                        throw new Error('Invalid base58/base32 input');
+                }
+            }
+            else if (index$5.isBase32(value))
+                this.fromBs32(value);
+            else
+                this.fromString(value);
+        }
+        else if (Array.isArray(value))
+            this.fromArray(value);
+        else if (typeof value === 'object')
+            this.create(value);
+        return this;
+    }
     decode(encoded) {
         encoded = encoded || this.encoded;
         // Example: decode as JSON if possible (override in subclass)
         try {
-            return JSON.parse(_textDecoder.decode(encoded), jsonParseBigInt);
+            return JSON.parse(this.textDecoder.decode(encoded), jsonParseBigInt);
         }
         catch {
             return new Object();
@@ -7397,9 +7432,16 @@ class BasicInterface {
     encode(decoded) {
         decoded = decoded || this.decoded;
         // Example: encode as JSON (override in subclass)
-        return _textEncoder.encode(JSON.stringify(decoded, jsonStringifyBigInt));
+        return this.textEncoder.encode(JSON.stringify(decoded, jsonStringifyBigInt));
     }
     // get Codec(): Codec {}
+    create(options) {
+        for (const key of this.keys) {
+            if (options[key]) {
+                this[key] = options[key];
+            }
+        }
+    }
     // Cache proto keys/values for reuse
     static _protoCache = new WeakMap();
     protoEncode(data) {
@@ -7466,8 +7508,26 @@ class BasicInterface {
             return this.decode(array);
         return this.decode(Uint8Array.from(array));
     }
-    fromEncoded(encoded) {
-        return this.decode(encoded);
+    fromArrayBuffer(uint8Array) {
+        return fromArrayLike(new Uint8Array(uint8Array));
+    }
+    fromUint8Array(uint8Array) {
+        return fromArrayLike(uint8Array);
+    }
+    toUint8Array(format) {
+        if (format === 'bs32')
+            return toBase32(this.encoded);
+        if (format === 'bs58')
+            return toBase58(this.encoded);
+        if (format === 'hex')
+            return toHex(this.encoded);
+        if (format === 'utf8')
+            return this.encoded.toString();
+        if (format === 'uint8Array')
+            return this.encoded;
+        if (format === 'uint8ArrayString')
+            return this.encoded.toString();
+        throw new Error(`Unknown format: ${format}`);
     }
     toString() {
         if (!this.encoded)
@@ -8525,34 +8585,11 @@ let FormatInterface$1 = class FormatInterface extends BasicInterface {
     set encoded(value) {
         this.#encoded = value;
     }
-    init(buffer) {
-        if (buffer instanceof FormatInterface && buffer?.name === this.name) {
-            return buffer;
-        }
-        else if (buffer instanceof Uint8Array) {
-            this.fromUint8Array(buffer);
-        }
-        else if (buffer instanceof ArrayBuffer) {
-            this.fromArrayBuffer(buffer);
-        }
-        else if (typeof buffer === 'string') {
-            if (this.isHex(buffer))
-                this.fromHex(buffer);
-            else if (this.isBase58(buffer))
-                this.fromBs58(buffer);
-            else if (this.isBase32(buffer))
-                this.fromBs32(buffer);
-            else
-                this.fromString(buffer);
-        }
-        else if (typeof buffer === 'object' && buffer !== null) {
-            this.create(buffer);
+    init(value) {
+        if (value instanceof FormatInterface && value?.name === this.name) {
+            return value;
         }
-        else {
-            // Explicitly reject all other types (number, boolean, undefined, symbol, function, null)
-            throw new TypeError(`Invalid input type for FormatInterface: ${typeof buffer}`);
-        }
-        return this;
+        return this.from(value);
     }
     hasCodec() {
         if (!this.encoded)
@@ -8670,13 +8707,13 @@ let FormatInterface$1 = class FormatInterface extends BasicInterface {
         this.encoded = buffer;
         return this.hasCodec()
             ? this.decode()
-            : this.create(JSON.parse(BasicInterface._textDecoder.decode(this.encoded), jsonParseBigInt));
+            : this.create(JSON.parse(this.textDecoder.decode(this.encoded), jsonParseBigInt));
     }
     fromArrayBuffer(buffer) {
         this.encoded = new Uint8Array(buffer, buffer.byteOffset, buffer.byteLength);
         return this.hasCodec()
             ? this.decode()
-            : this.create(JSON.parse(BasicInterface._textDecoder.decode(this.encoded), jsonParseBigInt));
+            : this.create(JSON.parse(this.textDecoder.decode(this.encoded), jsonParseBigInt));
     }
     /**
      * @param {Object} data
@@ -8725,7 +8762,10 @@ var proto$2 = {
     reward: BigInt(0),
     fees: BigInt(0),
     transactions: Array(),
-    validators: new Uint8Array()
+    validators: new Uint8Array(),
+    producer: String(),
+    producerProof: String(),
+    protocolVersion: String()
 };
 
 class BlockMessage extends FormatInterface {
@@ -8816,82 +8856,121 @@ class TransactionMessage extends FormatInterface {
 ({
     params: Array()});
 
-class EasyWorker {
-  #messageEvent = 'message'
-  #errorEvent = 'error'
-  #isBrowser = false
-  #isWorker = false
-
-  get isWorker() {
-    return this.#isWorker
-  }
-  constructor(url, options) {
-    return this.#init(url, options)
-  }
-
-  #init(url, options = {}) {
-    if (url) {
-      if (globalThis.Worker) {
-        this.#isBrowser = true;
-        this.worker = new Worker(url, {...options});
-      } else {
-        return new Promise(async (resolve, reject) => {
-          const {fork} = await import('child_process');  
-          this.worker = fork(url, ['easy-worker-child'], options);
-          resolve(this);
-        })
-      }
-    } else {
-      this.#isWorker = true;
-      if (globalThis.process?.argv[2] === 'easy-worker-child') {
-        this.worker = process;
-      } else {
-        this.#isBrowser = true;
-        this.worker = globalThis;
-      }
-    }
-    
-    return this
-  }
-
-  onmessage(fn) {
-    if (this.#isBrowser) this.worker.onmessage = ({data}) => fn(data);
-    else this.worker.on(this.#messageEvent, fn);
-  }
-
-  postMessage(message) {
-    if (this.#isBrowser) this.worker.postMessage(message);
-    else this.worker.send(message);
-  }
-
-  terminate() {
-    if (this.#isBrowser) this.worker.terminate();
-    else this.worker.kill();
-  }
-
-  onerror(fn) {
-    if (this.#isBrowser) this.worker.onerror = fn;
-    else this.worker.on(this.#errorEvent, fn);
-  }
-
-  /**
-   * 
-   * @param {*} data 
-   * @returns {Promise} resolves result onmessage & rejects on error
-   */
-  once(data) {
-    return new Promise((resolve, reject) => {
-      this.onmessage(message => {
-        resolve(message);
-        this.terminate();
-      });
-      this.onerror(error => {
-        reject(error);
-        this.terminate();
-      });
-      this.postMessage(data);
-    })    
-  }  
+class EasyWorker {
+    #messageEvent = 'message';
+    #errorEvent = 'error';
+    #isBrowser = false;
+    #isWorker = false;
+    #messageHandler = null;
+    #errorHandler = null;
+    worker;
+    get isWorker() {
+        return this.#isWorker;
+    }
+    constructor(url, options) {
+        return this.#init(url, options);
+    }
+    #init(url, options = {}) {
+        if (url) {
+            if (globalThis.Worker) {
+                this.#isBrowser = true;
+                this.worker = new Worker(url, { ...options });
+            }
+            else {
+                return new Promise((resolve, reject) => {
+                    import('child_process').then(({ fork }) => {
+                        const child = fork(url, ['easy-worker-child'], options);
+                        child.once('error', reject);
+                        this.worker = child;
+                        resolve(this);
+                    }).catch(reject);
+                });
+            }
+        }
+        else {
+            this.#isWorker = true;
+            if (globalThis.process?.argv[2] === 'easy-worker-child') {
+                this.worker = process;
+            }
+            else {
+                this.#isBrowser = true;
+                this.worker = globalThis;
+            }
+        }
+        return this;
+    }
+    onmessage(fn) {
+        if (this.#isBrowser) {
+            this.worker.onmessage = ({ data }) => fn(data);
+        }
+        else {
+            if (this.#messageHandler)
+                this.worker.off(this.#messageEvent, this.#messageHandler);
+            this.#messageHandler = fn;
+            this.worker.on(this.#messageEvent, fn);
+        }
+    }
+    postMessage(message) {
+        if (this.#isBrowser)
+            this.worker.postMessage(message);
+        else
+            this.worker.send(message);
+    }
+    terminate() {
+        if (this.#isBrowser)
+            this.worker.terminate();
+        else
+            this.worker.kill();
+    }
+    onerror(fn) {
+        if (this.#isBrowser) {
+            this.worker.onerror = fn;
+        }
+        else {
+            if (this.#errorHandler)
+                this.worker.off(this.#errorEvent, this.#errorHandler);
+            this.#errorHandler = fn;
+            this.worker.on(this.#errorEvent, fn);
+        }
+    }
+    /**
+     *
+     * @param {*} data
+     * @returns {Promise} resolves result onmessage & rejects on error
+     */
+    once(data) {
+        return new Promise((resolve, reject) => {
+            if (this.#isBrowser) {
+                const handleMessage = ({ data: result }) => {
+                    this.worker.onerror = null;
+                    resolve(result);
+                    this.terminate();
+                };
+                const handleError = (error) => {
+                    this.worker.onmessage = null;
+                    reject(error);
+                    this.terminate();
+                };
+                this.worker.onmessage = handleMessage;
+                this.worker.onerror = handleError;
+            }
+            else {
+                const handleMessage = (result) => {
+                    this.worker.off(this.#errorEvent, handleError);
+                    resolve(result);
+                    this.terminate();
+                };
+                const handleError = (error) => {
+                    this.worker.off(this.#messageEvent, handleMessage);
+                    reject(error);
+                    this.terminate();
+                };
+                this.worker.once(this.#messageEvent, handleMessage);
+                this.worker.once(this.#errorEvent, handleError);
+            }
+            this.postMessage(data);
+        });
+    }
 }
 
 export { BlockMessage as B, ContractMessage as C, EasyWorker as E, TransactionMessage as T };