@leofcoin/chain 1.7.68 → 1.7.70

package/exports/browser/{index-CM4QYC3g.js → index-DUfUgiQY.js}

@@ -145,16 +145,16 @@ const ALPHABET$3 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
 const ALPHABET_HEX$1 = "0123456789ABCDEFGHIJKLMNOPQRSTUV";
 const base32 = base(ALPHABET$3);
 const base32Hex = base(ALPHABET_HEX$1);
-const decode$5 = base32.decode;
+const decode$3 = base32.decode;
 const decodeHex$1 = base32Hex.decode;
-const encode$5 = base32.encode;
+const encode$3 = base32.encode;
 const encodeHex$1 = base32Hex.encode;
 const isBase32 = (string, hex = false) => {
     try {
         if (hex)
             decodeHex$1(string);
         else
-            decode$5(string);
+            decode$3(string);
         return true;
     }
     catch (e) {
@@ -164,9 +164,9 @@ const isBase32 = (string, hex = false) => {
 const isBase32Hex = (string) => {
     return isBase32(string, true);
 };
-var index$7 = {
-    encode: encode$5,
-    decode: decode$5,
+var index$5 = {
+    encode: encode$3,
+    decode: decode$3,
     encodeHex: encodeHex$1,
     decodeHex: decodeHex$1,
     isBase32,
@@ -177,13 +177,13 @@ const ALPHABET$2 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
 const ALPHABET_HEX = "0123456789ABCDEFGHJKLMNPQRSTUVabcdefghijklmnopqrstuv";
 const base58 = base(ALPHABET$2);
 const base58Hex = base(ALPHABET_HEX);
-const encode$4 = base58.encode;
-const decode$4 = base58.decode;
+const encode$2 = base58.encode;
+const decode$2 = base58.decode;
 const encodeHex = base58Hex.encode;
 const decodeHex = base58Hex.decode;
 const isBase58 = (string) => {
     try {
-        decode$4(string);
+        decode$2(string);
         return true;
     }
     catch (e) {
@@ -201,7 +201,7 @@ const isBase58Hex = (string) => {
 };
 const whatType = (string) => {
     try {
-        decode$4(string);
+        decode$2(string);
         return "base58";
     }
     catch (e) {
@@ -215,8 +215,8 @@ const whatType = (string) => {
     }
 };
 var base58$1 = {
-    encode: encode$4,
-    decode: decode$4,
+    encode: encode$2,
+    decode: decode$2,
     isBase58,
     isBase58Hex,
     encodeHex,
@@ -231,12 +231,11 @@ var isHex = string => /^[A-F0-9]+$/i.test(
 );
 
 const MSB$1 = 0x80;
-const REST$1 = 0x7F;
-const MSBALL = ~REST$1;
+const MSBALL = -128;
 const INT = Math.pow(2, 31);
-const encode$3 = (num, out, offset) => {
+const encode$1 = (num, out, offset) => {
     if (Number.MAX_SAFE_INTEGER && num > Number.MAX_SAFE_INTEGER) {
-        encode$3.bytes = 0;
+        encode$1.bytes = 0;
         throw new RangeError('Could not encode varint');
     }
     out = out || [];
@@ -251,13 +250,13 @@ const encode$3 = (num, out, offset) => {
         num >>>= 7;
     }
     out[offset] = num | 0;
-    encode$3.bytes = offset - oldOffset + 1;
+    encode$1.bytes = offset - oldOffset + 1;
     return out;
 };
 
 const MSB = 0x80;
 const REST = 0x7F;
-const decode$3 = (buf, offset) => {
+const decode$1 = (buf, offset) => {
     offset = offset || 0;
     const l = buf.length;
     let counter = offset;
@@ -266,7 +265,7 @@ const decode$3 = (buf, offset) => {
     let b;
     do {
         if (counter >= l || shift > 49) {
-            decode$3.bytes = 0;
+            decode$1.bytes = 0;
             throw new RangeError('Could not decode varint');
         }
         b = buf[counter++];
@@ -275,7 +274,7 @@ const decode$3 = (buf, offset) => {
             : (b & REST) * Math.pow(2, shift);
         shift += 7;
     } while (b >= MSB);
-    decode$3.bytes = counter - offset;
+    decode$1.bytes = counter - offset;
     return result;
 };
 
@@ -299,16 +298,16 @@ var encodingLength = (value) => (value < N1 ? 1
                                 : value < N9 ? 9
                                     : 10);
 
-var index$6 = {
-    encode: encode$3,
-    decode: decode$3,
+var index$4 = {
+    encode: encode$1,
+    decode: decode$1,
     encodingLength
 };
 
-var index$5 = (input, prefix) => {
+var index$3 = (input, prefix) => {
     const encodedArray = [];
     const length = input.reduce((total, current) => {
-        const encoded = index$6.encode(current.length);
+        const encoded = index$4.encode(current.length);
         encodedArray.push(encoded);
         total += current.length + encoded.length;
         return total;
@@ -326,12 +325,12 @@ var index$5 = (input, prefix) => {
     return typedArray;
 };
 
-var index$4 = (typedArray, prefix) => {
+var index$2 = (typedArray, prefix) => {
     const set = [];
     const varintAndSub = (typedArray) => {
-        const length = index$6.decode(typedArray);
+        const length = index$4.decode(typedArray);
         // remove length
-        typedArray = typedArray.subarray(index$6.decode.bytes);
+        typedArray = typedArray.subarray(index$4.decode.bytes);
         // push value
         set.push(typedArray.subarray(0, length));
         // remove value
@@ -344,87 +343,17 @@ var index$4 = (typedArray, prefix) => {
 };
 
 const ALPHABET$1 = '0123456789ABCDEF';
-const base16 = base(ALPHABET$1);
-const decode$2 = base16.decode;
-const encode$2 = base16.encode;
-const isBase16 = (string) => {
-    try {
-        decode$2(string);
-        return true;
-    }
-    catch (e) {
-        return false;
-    }
-};
-var index$3 = {
-    encode: encode$2,
-    decode: decode$2,
-    isBase16
-};
+base(ALPHABET$1);
 
 const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
-const base64 = base(ALPHABET);
-const decode$1 = base64.decode;
-const encode$1 = base64.encode;
-const isBase64 = (string) => {
-    try {
-        decode$1(string);
-        return true;
-    }
-    catch (e) {
-        return false;
-    }
-};
-var index$2 = {
-    encode: encode$1,
-    decode: decode$1,
-    isBase64
-};
+base(ALPHABET);
 
-/**
- * Returns a hex string as Binary string
- * @param string string to encode to binary
- * @returns binaryString
- */
-const hexToBinary = (hex) => (parseInt(hex, 16).toString(2)).padStart(8, '0');
-const isTypedArrayCompatible = (possibleUint8Array) => {
-    if (typeof possibleUint8Array === 'string') {
-        possibleUint8Array = possibleUint8Array.split(',').map(number => Number(number));
-        for (const number of possibleUint8Array) {
-            if (isNaN(number))
-                return false;
-        }
-    }
-    for (const number of possibleUint8Array) {
-        if (isNaN(number))
-            return false;
-    }
-    return true;
-};
-/**
- * Returns a String as Uint8Array
- * @param string string to encode to Uint8Array
- * @returns Uint8Array
- */
-const fromString$1 = (string) => new TextEncoder().encode(string);
 /**
  * Returns a Uint8Array as String
  * @param uint8Array Uint8Array to encode to String
  * @returns String
  */
 const toString$3 = (uint8Array) => new TextDecoder().decode(uint8Array);
-/**
- * Returns a String as Uint8Array
- * @param string string to encode to Uint8Array
- * @returns Uint8Array
- */
-const fromUintArrayString = (string) => Uint8Array.from(string.split(',').map(string => Number(string)));
-/**
- * Returns a Uint8Array as String
- * @param uint8Array Uint8Array to encode to String
- * @returns String
- */
-const toUintArrayString = (uint8Array) => uint8Array.toString();
 /**
  * hexString -> uint8Array
  * @param string hex encoded string
@@ -437,151 +366,11 @@ const fromHex = (string) => Uint8Array.from(string.match(/.{1,2}/g).map((byte) =
  * @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);
-/**
- * Uint8Array -> number[]
- * @param uint8Array Uint8Array
- * @returns Uint8Array
- */
-const toArrayLike = (uint8Array) => [...uint8Array.values()];
-/**
-* object -> Uint8Array
-* @param object any
-* @returns Uint8Array
-*/
-const fromObject = (object) => new TextEncoder().encode(JSON.stringify(object));
-/**
- * Uint8Array -> Object
- * @param uint8Array Uint8Array
- * @returns Object
- */
-const toObject = (uint8Array) => JSON.parse(new TextDecoder().decode(uint8Array));
-const fromBinary = (string) => fromHex(parseInt(string, 2).toString(16).toUpperCase());
-const toBinary = (uint8Array) => hexToBinary(toHex(uint8Array));
-const toBase64 = (uint8Array) => index$2.encode(uint8Array);
-const fromBase64 = (string) => index$2.decode(string);
 const toBase58 = (uint8Array) => base58$1.encode(uint8Array);
 const fromBase58 = (string) => base58$1.decode(string);
-const toBase32 = (uint8Array) => index$7.encode(uint8Array);
-const fromBase32 = (string) => index$7.decode(string);
-const toBase16 = (uint8Array) => index$3.encode(uint8Array);
-const fromBase16 = (string) => index$3.decode(string);
-let FormatInterface$2 = class FormatInterface {
-    encoded;
-    decoded;
-    constructor(input) {
-        if (input) {
-            if (index$3.isBase16(input))
-                this.encoded = this.fromBase16(input);
-            else if (index$7.isBase32(input))
-                this.encoded = this.fromBase32(input);
-            else if (base58$1.isBase58(input))
-                this.encoded = this.fromBase58(input);
-            else if (index$2.isBase64(input))
-                this.encoded = this.fromBase64(input);
-            else if (typeof input === 'string') {
-                let isCompatible = isTypedArrayCompatible(input);
-                if (isCompatible)
-                    this.encoded = fromUintArrayString(input);
-                else
-                    this.encoded = this.fromString(input); // normal string
-            }
-            else if (typeof input === 'object')
-                this.encoded = this.fromObject(input);
-            else if (input instanceof Uint8Array)
-                this.encoded = input;
-            else if (Array.isArray(input) && isTypedArrayCompatible(input))
-                this.encoded = this.fromArrayLike(input);
-        }
-    }
-    /**
-   * Returns a String as Uint8Array
-   * @param string string to encode to Uint8Array
-   * @returns Uint8Array
-   */
-    fromString = (string) => this.encoded = fromString$1(string);
-    /**
-     * Returns a Uint8Array as String
-     * @param uint8Array Uint8Array to encode to String
-     * @returns String
-     */
-    toString = (uint8Array) => this.decoded = toString$3(uint8Array);
-    /**
-     * Returns a String as Uint8Array
-     * @param string string to encode to Uint8Array
-     * @returns Uint8Array
-     */
-    fromUintArrayString = (string) => this.encoded = fromUintArrayString(string);
-    /**
-     * Returns a Uint8Array as String
-     * @param uint8Array Uint8Array to encode to String
-     * @returns String
-     */
-    toUintArrayString = (uint8Array) => this.decoded = uint8Array.toString();
-    /**
-     * hexString -> uint8Array
-     * @param string hex encoded string
-     * @returns UintArray
-     */
-    fromHex = (string) => this.encoded = fromHex(string);
-    /**
-     * uint8Array -> hexString
-     * @param bytes ArrayLike
-     * @returns hexString
-     */
-    toHex = (arrayLike) => this.decoded = toHex(arrayLike);
-    /**
-     * number[] -> Uint8Array
-     * @param array number[]
-     * @returns Uint8Array
-     */
-    fromArrayLike = (array) => this.encoded = Uint8Array.from(array);
-    /**
-     * Uint8Array -> number[]
-     * @param uint8Array Uint8Array
-     * @returns Uint8Array
-     */
-    toArrayLike = (uint8Array) => this.decoded = [...uint8Array.values()];
-    fromObject = (object) => this.encoded = fromObject(object);
-    toBinary = (uint8Array) => this.decoded = hexToBinary(toHex(uint8Array));
-    fromBinary = (binary) => this.encoded = fromBinary(binary);
-    toObject = (uint8Array) => this.decoded = toObject(uint8Array);
-    toBase64 = (uint8Array) => this.decoded = index$2.encode(uint8Array);
-    fromBase64 = (string) => this.encoded = index$2.decode(string);
-    toBase58 = (uint8Array) => this.decoded = base58$1.encode(uint8Array);
-    fromBase58 = (string) => this.encoded = base58$1.decode(string);
-    toBase32 = (uint8Array) => this.decoded = index$7.encode(uint8Array);
-    fromBase32 = (string) => this.encoded = index$7.decode(string);
-    toBase16 = (uint8Array) => this.decoded = index$3.encode(uint8Array);
-    fromBase16 = (string) => this.decoded = index$3.decode(string);
-};
+const toBase32 = (uint8Array) => index$5.encode(uint8Array);
 var index$1 = {
-    fromString: fromString$1,
-    toString: toString$3,
-    fromHex,
-    toHex,
-    fromArrayLike,
-    toArrayLike,
-    fromUintArrayString,
-    toUintArrayString,
-    toObject,
-    toBinary,
-    fromBinary,
-    toBase64,
-    fromBase64,
-    toBase58,
-    fromBase58,
-    toBase32,
-    fromBase32,
-    toBase16,
-    fromBase16,
-    FormatInterface: FormatInterface$2
-};
+    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
@@ -4682,15 +4471,12 @@ var Deflate_1$1 = Deflate$1;
 var deflate_2 = deflate$1;
 var deflateRaw_1$1 = deflateRaw$1;
 var gzip_1$1 = gzip$1;
-var constants$1 = constants$2;
 
 var deflate_1$1 = {
 	Deflate: Deflate_1$1,
 	deflate: deflate_2,
 	deflateRaw: deflateRaw_1$1,
-	gzip: gzip_1$1,
-	constants: constants$1
-};
+	gzip: gzip_1$1};
 
 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
 // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
@@ -7420,15 +7206,12 @@ var Inflate_1$1 = Inflate$1;
 var inflate_2 = inflate$1;
 var inflateRaw_1$1 = inflateRaw$1;
 var ungzip$1 = inflate$1;
-var constants = constants$2;
 
 var inflate_1$1 = {
 	Inflate: Inflate_1$1,
 	inflate: inflate_2,
 	inflateRaw: inflateRaw_1$1,
-	ungzip: ungzip$1,
-	constants: constants
-};
+	ungzip: ungzip$1};
 
 const { Deflate, deflate, deflateRaw, gzip } = deflate_1$1;
 
@@ -7461,8 +7244,7 @@ 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 { fromString, toString } = index$1;
-const isJson = (type) => type === 'object' || 'array';
+const { toString } = index$1;
 const isString = (type) => type === 'string';
 const isNumber = (type) => type === 'number';
 const isBoolean = (type) => type === 'boolean';
@@ -7518,12 +7300,12 @@ const encode = (proto, input, compress) => {
         // when data is undefined push the default value of the proto
         set.push(toType(data || values[i]));
     }
-    return compress ? pako.deflate(index$5(set)) : index$5(set);
+    return compress ? pako.deflate(index$3(set)) : index$3(set);
 };
 const decode = (proto, uint8Array, compressed) => {
     if (compressed)
         uint8Array = pako.inflate(uint8Array);
-    let deconcated = index$4(uint8Array);
+    let deconcated = index$2(uint8Array);
     const output = {};
     const keys = Object.keys(proto);
     const values = Object.values(proto);
@@ -7541,8 +7323,7 @@ const decode = (proto, uint8Array, compressed) => {
             output[token.key] = Number(new TextDecoder().decode(deconcated[i]));
         else if (isBigInt(token.type))
             output[token.key] = BigInt(new TextDecoder().decode(deconcated[i]));
-        else if (isJson(token.type))
-            output[token.key] = JSON.parse(new TextDecoder().decode(deconcated[i]), jsonParseBigInt$1);
+        else output[token.key] = JSON.parse(new TextDecoder().decode(deconcated[i]), jsonParseBigInt$1);
         if (token.optional) {
             if (!output[token.key] || output[token.key].length === 0)
                 delete output[token.key];
@@ -7612,13 +7393,13 @@ class BasicInterface {
         return isHex(string);
     }
     isBase32(string) {
-        return index$7.isBase32(string);
+        return index$5.isBase32(string);
     }
     isBase58(string) {
         return base58$1.isBase58(string);
     }
     fromBs32(encoded) {
-        return this.decode(index$7.decode(encoded));
+        return this.decode(index$5.decode(encoded));
     }
     fromBs58(encoded) {
         return this.decode(fromBase58(encoded));
@@ -7888,7 +7669,7 @@ class Codec extends BasicInterface {
         super();
         if (buffer) {
             if (buffer instanceof Uint8Array) {
-                const codec = index$6.decode(buffer);
+                const codec = index$4.decode(buffer);
                 const name = this.getCodecName(codec);
                 if (name) {
                     this.name = name;
@@ -7900,7 +7681,7 @@ class Codec extends BasicInterface {
                 }
             }
             else if (buffer instanceof ArrayBuffer) {
-                const codec = index$6.decode(buffer);
+                const codec = index$4.decode(buffer);
                 const name = this.getCodecName(codec);
                 if (name) {
                     this.name = name;
@@ -7928,7 +7709,7 @@ class Codec extends BasicInterface {
         }
     }
     fromEncoded(encoded) {
-        const codec = index$6.decode(encoded);
+        const codec = index$4.decode(encoded);
         const name = this.getCodecName(codec);
         this.name = name;
         this.encoded = encoded;
@@ -7947,7 +7728,7 @@ class Codec extends BasicInterface {
         this.name = this.getCodecName(codec);
         this.hashAlg = this.getHashAlg(this.name);
         this.codec = this.getCodec(this.name);
-        this.codecBuffer = index$6.encode(this.codec);
+        this.codecBuffer = index$4.encode(this.codec);
         this.decoded = {
             name: this.name,
             hashAlg: this.hashAlg,
@@ -7960,7 +7741,7 @@ class Codec extends BasicInterface {
         this.name = name;
         this.codec = codec;
         this.hashAlg = this.getHashAlg(name);
-        this.codecBuffer = index$6.encode(this.codec);
+        this.codecBuffer = index$4.encode(this.codec);
         this.decoded = {
             name: this.name,
             hashAlg: this.hashAlg,
@@ -7970,13 +7751,13 @@ class Codec extends BasicInterface {
     }
     decode(encoded) {
         encoded = encoded || this.encoded;
-        const codec = index$6.decode(encoded);
+        const codec = index$4.decode(encoded);
         this.fromCodec(codec);
         return this.decoded;
     }
     encode(codec) {
         codec = codec || this.codec;
-        this.encoded = index$6.encode(codec);
+        this.encoded = index$4.encode(codec);
         return this.encoded;
     }
 }
@@ -8031,7 +7812,7 @@ class CodecHash extends BasicInterface {
         return uint8Array;
     }
     get length() {
-        return index$6.encode(this.size);
+        return index$4.encode(this.size);
     }
     get buffer() {
         return this.encoded;
@@ -8078,7 +7859,7 @@ class CodecHash extends BasicInterface {
     }
     async validate(buffer) {
         if (Buffer.isBuffer(buffer)) {
-            const codec = index$6.decode(buffer);
+            const codec = index$4.decode(buffer);
             if (this.codecs[codec]) {
                 this.decode(buffer);
             }
@@ -8097,12 +7878,12 @@ class CodecHash extends BasicInterface {
     }
     decode(buffer) {
         this.encoded = buffer;
-        const codec = index$6.decode(buffer);
+        const codec = index$4.decode(buffer);
         this.discoCodec = new Codec(codec, this.codecs);
         // TODO: validate codec
-        buffer = buffer.slice(index$6.decode.bytes);
-        this.size = index$6.decode(buffer);
-        this.digest = buffer.slice(index$6.decode.bytes);
+        buffer = buffer.slice(index$4.decode.bytes);
+        this.size = index$4.decode(buffer);
+        this.digest = buffer.slice(index$4.decode.bytes);
         if (this.digest.length !== this.size) {
             throw new Error(`hash length inconsistent: 0x${this.encoded.toString('hex')}`);
         }
@@ -8314,14 +8095,14 @@ class BlockMessage extends FormatInterface {
         }
         return super.encode({
             ...decoded,
-            validators: index$5(validators)
+            validators: index$3(validators)
         });
     }
     decode(encoded) {
         encoded = encoded || this.encoded;
         super.decode(encoded);
         // @ts-ignore
-        this.decoded.validators = index$4(this.decoded.validators).map((validator) => new ValidatorMessage(validator).decoded);
+        this.decoded.validators = index$2(this.decoded.validators).map((validator) => new ValidatorMessage(validator).decoded);
         return this.decoded;
     }
 }
@@ -8375,7 +8156,6 @@ class ContractMessage extends FormatInterface {
 }
 
 ({
-    hash: String(),
     index: BigInt(0)
 });