@leofcoin/chain 1.2.0 → 1.3.0

package/dist/browser/workers/block-worker.js

@@ -12323,12 +12323,12 @@ function addSlice(array) {
     return array;
 }
 function isBytesLike(value) {
-    return ((lib_esm_isHexString(value) && !(value.length % 2)) || lib_esm_isBytes(value));
+    return ((isHexString(value) && !(value.length % 2)) || isBytes(value));
 }
 function isInteger(value) {
     return (typeof (value) === "number" && value == value && (value % 1) === 0);
 }
-function lib_esm_isBytes(value) {
+function isBytes(value) {
     if (value == null) {
         return false;
     }
@@ -12371,7 +12371,7 @@ function arrayify(value, options) {
     if (isHexable(value)) {
         value = value.toHexString();
     }
-    if (lib_esm_isHexString(value)) {
+    if (isHexString(value)) {
         let hex = value.substring(2);
         if (hex.length % 2) {
             if (options.hexPad === "left") {
@@ -12390,7 +12390,7 @@ function arrayify(value, options) {
         }
         return addSlice(new Uint8Array(result));
     }
-    if (lib_esm_isBytes(value)) {
+    if (isBytes(value)) {
         return addSlice(new Uint8Array(value));
     }
     return logger.throwArgumentError("invalid arrayify value", "value", value);
@@ -12430,7 +12430,7 @@ function zeroPad(value, length) {
     result.set(value, length - value.length);
     return addSlice(result);
 }
-function lib_esm_isHexString(value, length) {
+function isHexString(value, length) {
     if (typeof (value) !== "string" || !value.match(/^0x[0-9A-Fa-f]*$/)) {
         return false;
     }
@@ -12472,7 +12472,7 @@ function hexlify(value, options) {
     if (isHexable(value)) {
         return value.toHexString();
     }
-    if (lib_esm_isHexString(value)) {
+    if (isHexString(value)) {
         if (value.length % 2) {
             if (options.hexPad === "left") {
                 value = "0x0" + value.substring(2);
@@ -12486,7 +12486,7 @@ function hexlify(value, options) {
         }
         return value.toLowerCase();
     }
-    if (lib_esm_isBytes(value)) {
+    if (isBytes(value)) {
         let result = "0x";
         for (let i = 0; i < value.length; i++) {
             let v = value[i];
@@ -12508,7 +12508,7 @@ function hexDataLength(data) {
     if (typeof (data) !== "string") {
         data = hexlify(data);
     }
-    else if (!lib_esm_isHexString(data) || (data.length % 2)) {
+    else if (!isHexString(data) || (data.length % 2)) {
         return null;
     }
     return (data.length - 2) / 2;
@@ -12517,7 +12517,7 @@ function hexDataSlice(data, offset, endOffset) {
     if (typeof (data) !== "string") {
         data = hexlify(data);
     }
-    else if (!lib_esm_isHexString(data) || (data.length % 2)) {
+    else if (!isHexString(data) || (data.length % 2)) {
         logger.throwArgumentError("invalid hexData", "value", data);
     }
     offset = 2 + 2 * offset;
@@ -12544,7 +12544,7 @@ function hexStripZeros(value) {
     if (typeof (value) !== "string") {
         value = hexlify(value);
     }
-    if (!lib_esm_isHexString(value)) {
+    if (!isHexString(value)) {
         logger.throwArgumentError("invalid hex string", "value", value);
     }
     value = value.substring(2);
@@ -12558,7 +12558,7 @@ function hexZeroPad(value, length) {
     if (typeof (value) !== "string") {
         value = hexlify(value);
     }
-    else if (!lib_esm_isHexString(value)) {
+    else if (!isHexString(value)) {
         logger.throwArgumentError("invalid hex string", "value", value);
     }
     if (value.length > 2 * length + 2) {
@@ -12666,13 +12666,13 @@ function splitSignature(signature) {
                 }
             }
         }
-        if (result.r == null || !lib_esm_isHexString(result.r)) {
+        if (result.r == null || !isHexString(result.r)) {
             logger.throwArgumentError("signature missing or invalid r", "signature", signature);
         }
         else {
             result.r = hexZeroPad(result.r, 32);
         }
-        if (result.s == null || !lib_esm_isHexString(result.s)) {
+        if (result.s == null || !isHexString(result.s)) {
             logger.throwArgumentError("signature missing or invalid s", "signature", signature);
         }
         else {
@@ -12687,7 +12687,7 @@ function splitSignature(signature) {
         }
         const _vs = hexlify(vs);
         if (result._vs) {
-            if (!lib_esm_isHexString(result._vs)) {
+            if (!isHexString(result._vs)) {
                 logger.throwArgumentError("signature invalid _vs", "signature", signature);
             }
             result._vs = hexZeroPad(result._vs, 32);
@@ -12713,40 +12713,147 @@ function joinSignature(signature) {
     ]));
 }
 //# sourceMappingURL=index.js.map
-;// CONCATENATED MODULE: ./node_modules/@ethersproject/bignumber/lib.esm/_version.js
-const lib_esm_version_version = "bignumber/5.7.0";
-//# sourceMappingURL=_version.js.map
-;// CONCATENATED MODULE: ./node_modules/@ethersproject/bignumber/lib.esm/bignumber.js
+;// CONCATENATED MODULE: ./node_modules/@vandeurenglenn/easy-worker/src/worker.js
+/* provided dependency */ var process = __webpack_require__(155);
+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 __webpack_require__.e(/* import() */ 865).then(__webpack_require__.t.bind(__webpack_require__, 865, 23))  
+          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)
+    })    
+  }  
+}
+;// CONCATENATED MODULE: ./dist/module/workers/block-worker.js
 
-/**
- *  BigNumber
- *
- *  A wrapper around the BN.js object. We use the BN.js library
- *  because it is used by elliptic, so it is required regardless.
- *
- */
 
-var BN = (bn_default()).BN;
 
 
 
-const bignumber_logger = new Logger(lib_esm_version_version);
+
+
+var proto = `
+message ValidatorMessage {
+  required string address = 1;
+  required string reward = 2;
+}
+
+message Transaction {
+  required string hash = 1;
+  required uint64 timestamp = 2;
+  required string from = 3;
+  required string to = 4;
+  required uint64 nonce = 5;
+  required string method = 6;
+  repeated string params = 7;
+}
+
+message BlockMessage {
+  required uint64 index = 1;
+  required string previousHash = 3;
+  required uint64 timestamp = 4;
+  required uint64 reward = 5;
+  required string fees = 6;
+  repeated Transaction transactions = 7;
+  repeated ValidatorMessage validators = 8;
+}
+`;
+
+class BlockMessage extends src_FormatInterface {
+  get keys() {
+    return ['index', 'previousHash', 'timestamp', 'reward', 'fees', 'transactions', 'validators']
+  }
+
+  get messageName() {
+    return 'BlockMessage'
+  }
+
+  constructor(buffer) {
+    const name = 'block-message';
+    super(buffer, proto, {name});
+  }
+}
+
+const version$1 = "bignumber/5.6.2";
+
+var BN = (bn_default()).BN;
+const block_worker_logger = new Logger(version$1);
 const _constructorGuard = {};
 const MAX_SAFE = 0x1fffffffffffff;
-function isBigNumberish(value) {
-    return (value != null) && (BigNumber.isBigNumber(value) ||
-        (typeof (value) === "number" && (value % 1) === 0) ||
-        (typeof (value) === "string" && !!value.match(/^-?[0-9]+$/)) ||
-        isHexString(value) ||
-        (typeof (value) === "bigint") ||
-        isBytes(value));
-}
 // Only warn about passing 10 into radix once
 let _warnedToStringRadix = false;
 class BigNumber {
     constructor(constructorGuard, hex) {
         if (constructorGuard !== _constructorGuard) {
-            bignumber_logger.throwError("cannot call constructor directly; use BigNumber.from", Logger.errors.UNSUPPORTED_OPERATION, {
+            block_worker_logger.throwError("cannot call constructor directly; use BigNumber.from", Logger.errors.UNSUPPORTED_OPERATION, {
                 operation: "new (BigNumber)"
             });
         }
@@ -12870,7 +12977,7 @@ class BigNumber {
             return BigInt(this.toString());
         }
         catch (e) { }
-        return bignumber_logger.throwError("this platform does not support BigInt", Logger.errors.UNSUPPORTED_OPERATION, {
+        return block_worker_logger.throwError("this platform does not support BigInt", Logger.errors.UNSUPPORTED_OPERATION, {
             value: this.toString()
         });
     }
@@ -12880,14 +12987,14 @@ class BigNumber {
             if (arguments[0] === 10) {
                 if (!_warnedToStringRadix) {
                     _warnedToStringRadix = true;
-                    bignumber_logger.warn("BigNumber.toString does not accept any parameters; base-10 is assumed");
+                    block_worker_logger.warn("BigNumber.toString does not accept any parameters; base-10 is assumed");
                 }
             }
             else if (arguments[0] === 16) {
-                bignumber_logger.throwError("BigNumber.toString does not accept any parameters; use bigNumber.toHexString()", Logger.errors.UNEXPECTED_ARGUMENT, {});
+                block_worker_logger.throwError("BigNumber.toString does not accept any parameters; use bigNumber.toHexString()", Logger.errors.UNEXPECTED_ARGUMENT, {});
             }
             else {
-                bignumber_logger.throwError("BigNumber.toString does not accept parameters", Logger.errors.UNEXPECTED_ARGUMENT, {});
+                block_worker_logger.throwError("BigNumber.toString does not accept parameters", Logger.errors.UNEXPECTED_ARGUMENT, {});
             }
         }
         return toBN(this).toString(10);
@@ -12909,7 +13016,7 @@ class BigNumber {
             if (value.match(/^-?[0-9]+$/)) {
                 return new BigNumber(_constructorGuard, toHex(new BN(value)));
             }
-            return bignumber_logger.throwArgumentError("invalid BigNumber string", "value", value);
+            return block_worker_logger.throwArgumentError("invalid BigNumber string", "value", value);
         }
         if (typeof (value) === "number") {
             if (value % 1) {
@@ -12924,7 +13031,7 @@ class BigNumber {
         if (typeof (anyValue) === "bigint") {
             return BigNumber.from(anyValue.toString());
         }
-        if (lib_esm_isBytes(anyValue)) {
+        if (isBytes(anyValue)) {
             return BigNumber.from(hexlify(anyValue));
         }
         if (anyValue) {
@@ -12943,13 +13050,13 @@ class BigNumber {
                     hex = anyValue.hex;
                 }
                 if (typeof (hex) === "string") {
-                    if (lib_esm_isHexString(hex) || (hex[0] === "-" && lib_esm_isHexString(hex.substring(1)))) {
+                    if (isHexString(hex) || (hex[0] === "-" && isHexString(hex.substring(1)))) {
                         return BigNumber.from(hex);
                     }
                 }
             }
         }
-        return bignumber_logger.throwArgumentError("invalid BigNumber value", "value", value);
+        return block_worker_logger.throwArgumentError("invalid BigNumber value", "value", value);
     }
     static isBigNumber(value) {
         return !!(value && value._isBigNumber);
@@ -12967,7 +13074,7 @@ function toHex(value) {
         value = value.substring(1);
         // Cannot have multiple negative signs (e.g. "--0x04")
         if (value[0] === "-") {
-            bignumber_logger.throwArgumentError("invalid hex", "value", value);
+            block_worker_logger.throwArgumentError("invalid hex", "value", value);
         }
         // Call toHex on the positive component
         value = toHex(value);
@@ -13011,143 +13118,12 @@ function throwFault(fault, operation, value) {
     if (value != null) {
         params.value = value;
     }
-    return bignumber_logger.throwError(fault, Logger.errors.NUMERIC_FAULT, params);
-}
-// value should have no prefix
-function _base36To16(value) {
-    return (new BN(value, 36)).toString(16);
-}
-// value should have no prefix
-function _base16To36(value) {
-    return (new BN(value, 16)).toString(36);
+    return block_worker_logger.throwError(fault, Logger.errors.NUMERIC_FAULT, params);
 }
-//# sourceMappingURL=bignumber.js.map
-;// CONCATENATED MODULE: ./node_modules/@vandeurenglenn/easy-worker/src/worker.js
-/* provided dependency */ var process = __webpack_require__(155);
-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 __webpack_require__.e(/* import() */ 865).then(__webpack_require__.t.bind(__webpack_require__, 865, 23))  
-          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)
-    })    
-  }  
-}
-;// CONCATENATED MODULE: ./dist/module/workers/block-worker.js
-
-
-
-
 
-var proto = `
-message ValidatorMessage {
-  required string address = 1;
-  required string reward = 2;
-}
-
-message Transaction {
-  required string hash = 1;
-  required uint64 timestamp = 2;
-  required string from = 3;
-  required string to = 4;
-  required uint64 nonce = 5;
-  required string method = 6;
-  repeated string params = 7;
-}
-
-message BlockMessage {
-  required uint64 index = 1;
-  required string previousHash = 3;
-  required uint64 timestamp = 4;
-  required uint64 reward = 5;
-  required string fees = 6;
-  repeated Transaction transactions = 7;
-  repeated ValidatorMessage validators = 8;
-}
-`;
+const block_worker_version = "units/5.6.1";
 
-class BlockMessage extends src_FormatInterface {
-  get keys() {
-    return ['index', 'previousHash', 'timestamp', 'reward', 'fees', 'transactions', 'validators']
-  }
-
-  get messageName() {
-    return 'BlockMessage'
-  }
-
-  constructor(buffer) {
-    const name = 'block-message';
-    super(buffer, proto, {name});
-  }
-}
+new Logger(block_worker_version);
 
 const byteFormats = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];