@leofcoin/peernet 1.1.54 → 1.1.56

package/exports/browser/{peernet-9d77bc59.js → peernet-2797014a.js}

@@ -209,16 +209,16 @@ const ALPHABET$3 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
 const ALPHABET_HEX$1 = '0123456789ABCDEFGHIJKLMNOPQRSTUV';
 const base32 = base$1(ALPHABET$3);
 const base32Hex = base$1(ALPHABET_HEX$1);
-const decode$8 = base32.decode;
-const decodeHex$2 = base32Hex.decode;
-const encode$7 = base32.encode;
-const encodeHex$2 = base32Hex.encode;
+const decode$a = base32.decode;
+const decodeHex$3 = base32Hex.decode;
+const encode$9 = base32.encode;
+const encodeHex$3 = base32Hex.encode;
 const isBase32 = (string, hex = false) => {
     try {
         if (hex)
-            decodeHex$2(string);
+            decodeHex$3(string);
         else
-            decode$8(string);
+            decode$a(string);
         return true;
     }
     catch (e) {
@@ -228,11 +228,11 @@ const isBase32 = (string, hex = false) => {
 const isBase32Hex = (string) => {
     return isBase32(string, true);
 };
-var index$8 = {
-    encode: encode$7,
-    decode: decode$8,
-    encodeHex: encodeHex$2,
-    decodeHex: decodeHex$2,
+var index$9 = {
+    encode: encode$9,
+    decode: decode$a,
+    encodeHex: encodeHex$3,
+    decodeHex: decodeHex$3,
     isBase32,
     isBase32Hex
 };
@@ -241,13 +241,13 @@ var ALPHABET$2 = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
 var ALPHABET_HEX = '0123456789ABCDEFGHJKLMNPQRSTUVabcdefghijklmnopqrstuv';
 var base58 = base$1(ALPHABET$2);
 var base58Hex = base$1(ALPHABET_HEX);
-var encode$6 = base58.encode;
-var decode$7 = base58.decode;
-var encodeHex$1 = base58Hex.encode;
-var decodeHex$1 = base58Hex.decode;
+var encode$8 = base58.encode;
+var decode$9 = base58.decode;
+var encodeHex$2 = base58Hex.encode;
+var decodeHex$2 = base58Hex.decode;
 var isBase58 = function (string) {
     try {
-        decode$7(string);
+        decode$9(string);
         return true;
     }
     catch (e) {
@@ -256,7 +256,7 @@ var isBase58 = function (string) {
 };
 var isBase58Hex = function (string) {
     try {
-        decodeHex$1(string);
+        decodeHex$2(string);
         return true;
     }
     catch (e) {
@@ -265,12 +265,12 @@ var isBase58Hex = function (string) {
 };
 var whatType = function (string) {
     try {
-        decode$7(string);
+        decode$9(string);
         return 'base58';
     }
     catch (e) {
         try {
-            decodeHex$1(string);
+            decodeHex$2(string);
             return 'base58Hex';
         }
         catch (_a) {
@@ -278,36 +278,36 @@ var whatType = function (string) {
         }
     }
 };
-var base58$1 = { encode: encode$6, decode: decode$7, isBase58: isBase58, isBase58Hex: isBase58Hex, encodeHex: encodeHex$1, decodeHex: decodeHex$1, whatType: whatType };
+var base58$1 = { encode: encode$8, decode: decode$9, isBase58: isBase58, isBase58Hex: isBase58Hex, encodeHex: encodeHex$2, decodeHex: decodeHex$2, whatType: whatType };
 
-const MSB$1 = 0x80;
-const REST$1 = 0x7F;
-const MSBALL = ~REST$1;
-const INT = Math.pow(2, 31);
-const encode$5 = (num, out, offset) => {
+const MSB$3 = 0x80;
+const REST$3 = 0x7F;
+const MSBALL$1 = ~REST$3;
+const INT$1 = Math.pow(2, 31);
+const encode$7 = (num, out, offset) => {
     if (Number.MAX_SAFE_INTEGER && num > Number.MAX_SAFE_INTEGER) {
-        encode$5.bytes = 0;
+        encode$7.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;
+    while (num >= INT$1) {
+        out[offset++] = (num & 0xFF) | MSB$3;
         num /= 128;
     }
-    while (num & MSBALL) {
-        out[offset++] = (num & 0xFF) | MSB$1;
+    while (num & MSBALL$1) {
+        out[offset++] = (num & 0xFF) | MSB$3;
         num >>>= 7;
     }
     out[offset] = num | 0;
-    encode$5.bytes = offset - oldOffset + 1;
+    encode$7.bytes = offset - oldOffset + 1;
     return out;
 };
 
-const MSB = 0x80;
-const REST = 0x7F;
-const decode$6 = (buf, offset) => {
+const MSB$2 = 0x80;
+const REST$2 = 0x7F;
+const decode$8 = (buf, offset) => {
     offset = offset || 0;
     const l = buf.length;
     let counter = offset;
@@ -316,49 +316,49 @@ const decode$6 = (buf, offset) => {
     let b;
     do {
         if (counter >= l || shift > 49) {
-            decode$6.bytes = 0;
+            decode$8.bytes = 0;
             throw new RangeError('Could not decode varint');
         }
         b = buf[counter++];
         result += shift < 28
-            ? (b & REST) << shift
-            : (b & REST) * Math.pow(2, shift);
+            ? (b & REST$2) << shift
+            : (b & REST$2) * Math.pow(2, shift);
         shift += 7;
-    } while (b >= MSB);
-    decode$6.bytes = counter - offset;
+    } while (b >= MSB$2);
+    decode$8.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
+const N1$1 = Math.pow(2, 7);
+const N2$1 = Math.pow(2, 14);
+const N3$1 = Math.pow(2, 21);
+const N4$1 = Math.pow(2, 28);
+const N5$1 = Math.pow(2, 35);
+const N6$1 = Math.pow(2, 42);
+const N7$1 = Math.pow(2, 49);
+const N8$1 = Math.pow(2, 56);
+const N9$1 = Math.pow(2, 63);
+var encodingLength$1 = (value) => (value < N1$1 ? 1
+    : value < N2$1 ? 2
+        : value < N3$1 ? 3
+            : value < N4$1 ? 4
+                : value < N5$1 ? 5
+                    : value < N6$1 ? 6
+                        : value < N7$1 ? 7
+                            : value < N8$1 ? 8
+                                : value < N9$1 ? 9
                                     : 10);
 
-var index$7 = {
-    encode: encode$5,
-    decode: decode$6,
-    encodingLength
+var index$8 = {
+    encode: encode$7,
+    decode: decode$8,
+    encodingLength: encodingLength$1
 };
 
-var index$6 = (input, prefix) => {
+var index$7 = (input, prefix) => {
     const encodedArray = [];
     const length = input.reduce((total, current) => {
-        const encoded = index$7.encode(current.length);
+        const encoded = index$8.encode(current.length);
         encodedArray.push(encoded);
         total += current.length + encoded.length;
         return total;
@@ -380,14 +380,14 @@ var index$6 = (input, prefix) => {
     return typedArray;
 };
 
-var index$5 = (typedArray, prefix) => {
+var index$6 = (typedArray, prefix) => {
     const set = [];
     if (prefix)
         typedArray = typedArray.subarray(prefix.length);
     const varintAndSub = (typedArray) => {
-        const length = index$7.decode(typedArray);
+        const length = index$8.decode(typedArray);
         // remove length
-        typedArray = typedArray.subarray(index$7.decode.bytes);
+        typedArray = typedArray.subarray(index$8.decode.bytes);
         // push value
         set.push(typedArray.subarray(0, length));
         // remove value
@@ -401,39 +401,39 @@ var index$5 = (typedArray, prefix) => {
 
 const ALPHABET$1 = '0123456789ABCDEF';
 const base16 = base$1(ALPHABET$1);
-const decode$5 = base16.decode;
-const encode$4 = base16.encode;
+const decode$7 = base16.decode;
+const encode$6 = base16.encode;
 const isBase16 = (string) => {
     try {
-        decode$5(string);
+        decode$7(string);
         return true;
     }
     catch (e) {
         return false;
     }
 };
-var index$4 = {
-    encode: encode$4,
-    decode: decode$5,
+var index$5 = {
+    encode: encode$6,
+    decode: decode$7,
     isBase16
 };
 
 const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
 const base64 = base$1(ALPHABET);
-const decode$4 = base64.decode;
-const encode$3 = base64.encode;
+const decode$6 = base64.decode;
+const encode$5 = base64.encode;
 const isBase64 = (string) => {
     try {
-        decode$4(string);
+        decode$6(string);
         return true;
     }
     catch (e) {
         return false;
     }
 };
-var index$3 = {
-    encode: encode$3,
-    decode: decode$4,
+var index$4 = {
+    encode: encode$5,
+    decode: decode$6,
     isBase64
 };
 
@@ -519,26 +519,26 @@ const fromObject = (object) => new TextEncoder().encode(JSON.stringify(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$2(uint8Array));
-const toBase64 = (uint8Array) => index$3.encode(uint8Array);
-const fromBase64 = (string) => index$3.decode(string);
+const toBase64 = (uint8Array) => index$4.encode(uint8Array);
+const fromBase64 = (string) => index$4.decode(string);
 const toBase58 = (uint8Array) => base58$1.encode(uint8Array);
 const fromBase58 = (string) => base58$1.decode(string);
-const toBase32 = (uint8Array) => index$8.encode(uint8Array);
-const fromBase32 = (string) => index$8.decode(string);
-const toBase16 = (uint8Array) => index$4.encode(uint8Array);
-const fromBase16 = (string) => index$4.decode(string);
+const toBase32 = (uint8Array) => index$9.encode(uint8Array);
+const fromBase32 = (string) => index$9.decode(string);
+const toBase16 = (uint8Array) => index$5.encode(uint8Array);
+const fromBase16 = (string) => index$5.decode(string);
 let FormatInterface$2 = class FormatInterface {
     encoded;
     decoded;
     constructor(input) {
         if (input) {
-            if (index$4.isBase16(input))
+            if (index$5.isBase16(input))
                 this.encoded = this.fromBase16(input);
-            else if (index$8.isBase32(input))
+            else if (index$9.isBase32(input))
                 this.encoded = this.fromBase32(input);
             else if (base58$1.isBase58(input))
                 this.encoded = this.fromBase58(input);
-            else if (index$3.isBase64(input))
+            else if (index$4.isBase64(input))
                 this.encoded = this.fromBase64(input);
             else if (typeof input === 'string') {
                 let isCompatible = isTypedArrayCompatible(input);
@@ -607,16 +607,16 @@ let FormatInterface$2 = class FormatInterface {
     toBinary = (uint8Array) => this.decoded = hexToBinary(toHex$2(uint8Array));
     fromBinary = (binary) => this.encoded = fromBinary(binary);
     toObject = (uint8Array) => this.decoded = toObject(uint8Array);
-    toBase64 = (uint8Array) => this.decoded = index$3.encode(uint8Array);
-    fromBase64 = (string) => this.encoded = index$3.decode(string);
+    toBase64 = (uint8Array) => this.decoded = index$4.encode(uint8Array);
+    fromBase64 = (string) => this.encoded = index$4.decode(string);
     toBase58 = (uint8Array) => this.decoded = base58$1.encode(uint8Array);
     fromBase58 = (string) => this.encoded = base58$1.decode(string);
-    toBase32 = (uint8Array) => this.decoded = index$8.encode(uint8Array);
-    fromBase32 = (string) => this.encoded = index$8.decode(string);
-    toBase16 = (uint8Array) => this.decoded = index$4.encode(uint8Array);
-    fromBase16 = (string) => this.decoded = index$4.decode(string);
+    toBase32 = (uint8Array) => this.decoded = index$9.encode(uint8Array);
+    fromBase32 = (string) => this.encoded = index$9.decode(string);
+    toBase16 = (uint8Array) => this.decoded = index$5.encode(uint8Array);
+    fromBase16 = (string) => this.decoded = index$5.decode(string);
 };
-var index$2 = {
+var index$3 = {
     fromString: fromString$1,
     toString: toString$1,
     fromHex,
@@ -4768,7 +4768,7 @@ function throwFault(fault, operation, value) {
     return logger.throwError(fault, Logger.errors.NUMERIC_FAULT, params);
 }
 
-const { fromString, toString } = index$2;
+const { fromString, toString } = index$3;
 const isJson = (type) => type === 'object' || 'array';
 const isString = (type) => type === 'string';
 const isNumber = (type) => type === 'number';
@@ -4809,7 +4809,7 @@ const toType = (data) => {
         return new TextEncoder().encode(data.toString());
     throw new Error(`unsuported type ${typeof data || data}`);
 };
-const encode$2 = (proto, input, compress) => {
+const encode$4 = (proto, input, compress) => {
     const keys = Object.keys(proto);
     const values = Object.values(proto);
     const set = [];
@@ -4824,10 +4824,10 @@ const encode$2 = (proto, input, compress) => {
         // when data is undefined push the default value of the proto
         set.push(toType(data || values[i]));
     }
-    return index$6(set);
+    return index$7(set);
 };
-const decode$3 = (proto, uint8Array, compressed) => {
-    let deconcated = index$5(uint8Array);
+const decode$5 = (proto, uint8Array, compressed) => {
+    let deconcated = index$6(uint8Array);
     const output = {};
     const keys = Object.keys(proto);
     const values = Object.values(proto);
@@ -4856,9 +4856,9 @@ const decode$3 = (proto, uint8Array, compressed) => {
     }
     return output;
 };
-var index$1 = {
-    encode: encode$2,
-    decode: decode$3
+var index$2 = {
+    encode: encode$4,
+    decode: decode$5
 };
 
 /*!
@@ -5629,23 +5629,23 @@ let BasicInterface$1 = class BasicInterface {
     // get Codec(): Codec {}
     protoEncode(data) {
         // check schema
-        return index$1.encode(this.proto, data, false);
+        return index$2.encode(this.proto, data, false);
     }
     protoDecode(data) {
         // check schema
-        return index$1.decode(this.proto, data, false);
+        return index$2.decode(this.proto, data, false);
     }
     isHex(string) {
         return isHex(string);
     }
     isBase32(string) {
-        return index$8.isBase32(string);
+        return index$9.isBase32(string);
     }
     isBase58(string) {
         return base58$1.isBase58(string);
     }
     fromBs32(encoded) {
-        return this.decode(index$8.decode(encoded));
+        return this.decode(index$9.decode(encoded));
     }
     fromBs58(encoded) {
         return this.decode(fromBase58(encoded));
@@ -5707,7 +5707,7 @@ let Codec$1 = class Codec extends BasicInterface$1 {
         super();
         if (buffer) {
             if (buffer instanceof Uint8Array) {
-                const codec = index$7.decode(buffer);
+                const codec = index$8.decode(buffer);
                 const name = this.getCodecName(codec);
                 if (name) {
                     this.name = name;
@@ -5719,7 +5719,7 @@ let Codec$1 = class Codec extends BasicInterface$1 {
                 }
             }
             else if (buffer instanceof ArrayBuffer) {
-                const codec = index$7.decode(new Uint8Array(buffer));
+                const codec = index$8.decode(new Uint8Array(buffer));
                 const name = this.getCodecName(codec);
                 if (name) {
                     this.name = name;
@@ -5747,7 +5747,7 @@ let Codec$1 = class Codec extends BasicInterface$1 {
         }
     }
     fromEncoded(encoded) {
-        const codec = index$7.decode(encoded);
+        const codec = index$8.decode(encoded);
         const name = this.getCodecName(codec);
         this.name = name;
         this.encoded = encoded;
@@ -5766,24 +5766,24 @@ let Codec$1 = class Codec extends BasicInterface$1 {
         this.name = this.getCodecName(codec);
         this.hashAlg = this.getHashAlg(this.name);
         this.codec = this.getCodec(this.name);
-        this.codecBuffer = index$7.encode(this.codec);
+        this.codecBuffer = index$8.encode(this.codec);
     }
     fromName(name) {
         const codec = this.getCodec(name);
         this.name = name;
         this.codec = codec;
         this.hashAlg = this.getHashAlg(name);
-        this.codecBuffer = index$7.encode(this.codec);
+        this.codecBuffer = index$8.encode(this.codec);
     }
     decode(encoded) {
         encoded = encoded || this.encoded;
-        const codec = index$7.decode(encoded);
+        const codec = index$8.decode(encoded);
         this.fromCodec(codec);
         return this.decoded;
     }
     encode(codec) {
         codec = codec || this.codec;
-        this.encoded = index$7.encode(codec);
+        this.encoded = index$8.encode(codec);
         return this.encoded;
     }
 };
@@ -5839,7 +5839,7 @@ let CodecHash$1 = class CodecHash extends BasicInterface$1 {
         return uint8Array;
     }
     get length() {
-        return index$7.encode(this.size);
+        return index$8.encode(this.size);
     }
     get buffer() {
         return this.encoded;
@@ -5879,7 +5879,7 @@ let CodecHash$1 = class CodecHash extends BasicInterface$1 {
     }
     async validate(buffer) {
         if (Buffer.isBuffer(buffer)) {
-            const codec = index$7.decode(buffer);
+            const codec = index$8.decode(buffer);
             if (this.codecs[codec]) {
                 this.decode(buffer);
             }
@@ -5898,12 +5898,12 @@ let CodecHash$1 = class CodecHash extends BasicInterface$1 {
     }
     decode(buffer) {
         this.encoded = buffer;
-        const codec = index$7.decode(buffer);
+        const codec = index$8.decode(buffer);
         this.codec = new Codec$1(codec);
         // TODO: validate codec
-        buffer = buffer.slice(index$7.decode.bytes);
-        this.size = index$7.decode(buffer);
-        this.digest = buffer.slice(index$7.decode.bytes);
+        buffer = buffer.slice(index$8.decode.bytes);
+        this.size = index$8.decode(buffer);
+        this.digest = buffer.slice(index$8.decode.bytes);
         if (this.digest.length !== this.size) {
             throw new Error(`hash length inconsistent: ${this.encoded.toString()}`);
         }
@@ -6459,66 +6459,6 @@ const pbkdf2 = async (password, salt, iterations = 4096, length = 64, hash = 'SH
   }, key, length)
 };
 
-const generateAesKey = async (length = 256) => {
-  const key = await subtle.generateKey({
-    name: 'AES-CBC',
-    length
-  }, true, ['encrypt', 'decrypt']);
-
-  return key;
-};
-
-const importAesKey = async (exported, format = 'raw', length = 256) => {
-  return await subtle.importKey(format, exported, {
-    name: 'AES-CBC',
-    length
-  }, true, ['encrypt', 'decrypt'])
-};
-
-const exportAesKey = async (key, format = 'raw') => {
-  return await subtle.exportKey(format, key)
-};
-
-const encryptAes = async (uint8Array, key, iv) => subtle.encrypt({
-    name: 'AES-CBC',
-    iv,
-  }, key, uint8Array);
-
-const decryptAes = async (uint8Array, key, iv) => subtle.decrypt({
-    name: 'AES-CBC',
-    iv,
-  }, key, uint8Array);
-
-const uint8ArrayToHex = uint8Array =>
-  [...uint8Array].map(x => x.toString(16).padStart(2, '0')).join('');
-
-const arrayBufferToHex = arrayBuffer =>
-  uint8ArrayToHex(new Uint8Array(arrayBuffer));
-
-const hexToUint8Array = hex =>
-  new Uint8Array(hex.match(/[\da-f]{2}/gi).map(x => parseInt(x, 16)));
-
-const encrypt$1 = async string => {
-  const key = await generateAesKey();
-  const iv = randombytes(16);
-  const ciphertext = await encryptAes(new TextEncoder().encode(string), key, iv);
-  const exported = await exportAesKey(key);
-  return {
-    key: arrayBufferToHex(exported),
-    iv: uint8ArrayToHex(iv),
-    cipher: arrayBufferToHex(ciphertext)
-  }
-};
-
-const decrypt$1 = async ({cipher, key, iv}) => {
-  if (!key.type) key = await importAesKey(hexToUint8Array(key));
-  cipher = new Uint8Array(hexToUint8Array(cipher));
-  iv = new Uint8Array(hexToUint8Array(iv));
-
-  const plaintext = await decryptAes(cipher, key, iv);
-  return new TextDecoder().decode(plaintext);
-};
-
 var typedArrayConcat = (input, options = {length: undefined, seperator: undefined}) => {
   if (!options) options = {};
   
@@ -6548,15 +6488,15 @@ var typedArrayConcat = (input, options = {length: undefined, seperator: undefine
   return typedArray
 };
 
-const concatAndDoubleHash = async (input) => {
+const concatAndDoubleHash$1 = async (input) => {
     return new Uint8Array(await createDoubleHash(typedArrayConcat(input), 'SHA-256'));
 };
 
-const encode$1 = async (source, prefix = new TextEncoder().encode('00'), hex) => {
+const encode$3 = async (source, prefix = new TextEncoder().encode('00'), hex) => {
     if (!(source instanceof Uint8Array) || !(prefix instanceof Uint8Array)) {
         throw new TypeError('Expected Uint8Array');
     }
-    const hash = await concatAndDoubleHash([
+    const hash = await concatAndDoubleHash$1([
         prefix,
         source
     ]);
@@ -6569,11 +6509,11 @@ const encode$1 = async (source, prefix = new TextEncoder().encode('00'), hex) =>
         return base58$1.encodeHex(uint8Array);
     return base58$1.encode(uint8Array);
 };
-const decode$2 = async (string, hex) => {
+const decode$4 = async (string, hex) => {
     let uint8Array = hex ? base58$1.decodeHex(string) : base58$1.decode(string);
     const prefix = uint8Array.subarray(0, 2);
     const source = uint8Array.subarray(2, -4);
-    const hash = await concatAndDoubleHash([
+    const hash = await concatAndDoubleHash$1([
         prefix,
         source
     ]);
@@ -6587,23 +6527,23 @@ const decode$2 = async (string, hex) => {
     }
     return { prefix, data: source };
 };
-const isBase58check = (string, hex) => {
+const isBase58check$1 = (string, hex) => {
     try {
-        hex ? decode$2(string, true) : decode$2(string);
+        hex ? decode$4(string, true) : decode$4(string);
         return true;
     }
     catch (e) {
         return false;
     }
 };
-const encodeHex = (uint8Array, prefix = new TextEncoder().encode('00')) => encode$1(uint8Array, prefix, true);
-const decodeHex = (string) => decode$2(string, true);
-const isBase58checkHex = (string) => isBase58check(string, true);
-var base58check = { encode: encode$1, decode: decode$2, encodeHex, decodeHex, isBase58check, isBase58checkHex };
+const encodeHex$1 = (uint8Array, prefix = new TextEncoder().encode('00')) => encode$3(uint8Array, prefix, true);
+const decodeHex$1 = (string) => decode$4(string, true);
+const isBase58checkHex$1 = (string) => isBase58check$1(string, true);
+var base58check$1 = { encode: encode$3, decode: decode$4, encodeHex: encodeHex$1, decodeHex: decodeHex$1, isBase58check: isBase58check$1, isBase58checkHex: isBase58checkHex$1 };
 
-const decode$1 = (multiWif, expectedVersion, expectedCodec) => {
+const decode$3 = (multiWif, expectedVersion, expectedCodec) => {
     const decoded = base58$1.decode(multiWif);
-    let [version, codec, privateKey] = index$5(decoded);
+    let [version, codec, privateKey] = index$6(decoded);
     version = Number(new TextDecoder().decode(version));
     codec = Number(new TextDecoder().decode(codec));
     if (expectedVersion && version !== expectedVersion)
@@ -6612,18 +6552,18 @@ const decode$1 = (multiWif, expectedVersion, expectedCodec) => {
         throw new Error(`invalid codec: expected ${expectedCodec} but got ${codec}`);
     return { version, codec, privateKey };
 };
-var index = {
+var index$1 = {
     encode: (version, codec, privateKey) => {
-        return base58$1.encode(index$6([
+        return base58$1.encode(index$7([
             new TextEncoder().encode(version.toString()),
             new TextEncoder().encode(codec.toString()),
             privateKey
         ]));
     },
-    decode: decode$1,
+    decode: decode$3,
     isMultiWif: (multiWif) => {
         try {
-            const { version, codec, privateKey } = decode$1(multiWif);
+            const { version, codec, privateKey } = decode$3(multiWif);
             if (version === undefined)
                 return false;
             if (codec === undefined)
@@ -16285,110 +16225,166 @@ var elliptic = lib(elliptic$1);
 
 var secp256k1 = /*@__PURE__*/getDefaultExportFromCjs(elliptic);
 
-const leofcoinOlivia = {
-    messagePrefix: '\u0019Leofcoin Signed Message:',
-    version: 1,
-    pubKeyHash: 0x73,
-    scriptHash: 0x76,
-    multiTxHash: 0x8b4125,
-    payments: {
-        version: 0,
-        unspent: 0x1fa443d7 // ounsp
-    },
-    wif: 0x7D,
-    multiCodec: 0x7c4,
-    bip32: { public: 0x13BBF2D5, private: 0x13BBCBC5 }
-};
-const bitcoinTestnet = {
-    messagePrefix: '\x18Bitcoin Signed Message:\n',
-    version: 1,
-    bech32: 'tb',
-    pubKeyHash: 0x6f,
-    scriptHash: 0xc4,
-    wif: 0xef,
-    bip32: {
-        public: 0x043587cf,
-        private: 0x04358394
-    },
-    multiCodec: 0
-};
-var testnets = {
-    'leofcoin:olivia': leofcoinOlivia,
-    'bitcoin:testnet': bitcoinTestnet
+const leofcoinOlivia = {
+    messagePrefix: '\u0019Leofcoin Signed Message:',
+    version: 1,
+    pubKeyHash: 0x73,
+    scriptHash: 0x76,
+    multiTxHash: 0x8b4125,
+    payments: {
+        version: 0,
+        unspent: 0x1fa443d7 // ounsp
+    },
+    wif: 0x7D,
+    multiCodec: 0x7c4,
+    bip32: { public: 0x13BBF2D5, private: 0x13BBCBC5 }
+};
+const bitcoinTestnet = {
+    messagePrefix: '\x18Bitcoin Signed Message:\n',
+    version: 1,
+    bech32: 'tb',
+    pubKeyHash: 0x6f,
+    scriptHash: 0xc4,
+    wif: 0xef,
+    bip32: {
+        public: 0x043587cf,
+        private: 0x04358394
+    },
+    multiCodec: 0
+};
+var testnets = {
+    'leofcoin:olivia': leofcoinOlivia,
+    'bitcoin:testnet': bitcoinTestnet
 };
 
-// https://en.bitcoin.it/wiki/List_of_address_prefixes
-/**
- * Main network
- * @return {messagePrefix, pubKeyHash, scriptHash, wif, bip32}
- */
-const leofcoin = {
-    messagePrefix: '\u0019Leofcoin Signed Message:',
-    version: 1,
-    pubKeyHash: 0x30,
-    scriptHash: 0x37,
-    multiTxHash: 0x3adeed,
-    payments: {
-        version: 0,
-        unspent: 0x0d6e0327 // Lunsp
-    },
-    coin_type: 640,
-    wif: 0x3F,
-    multiCodec: 0x3c4,
-    bip32: { public: 0x13BBF2D4, private: 0x13BBCBC4 },
-    testnet: testnets['leofcoin:olivia']
+// https://en.bitcoin.it/wiki/List_of_address_prefixes
+// usage:
+// networks['bitcoin']['testnet']
+// networks.bitcoin.testnet
+/**
+ * Main network
+ * @return {messagePrefix, pubKeyHash, scriptHash, wif, bip32}
+ */
+const leofcoin = {
+    messagePrefix: '\u0019Leofcoin Signed Message:',
+    version: 1,
+    pubKeyHash: 0x30,
+    scriptHash: 0x37,
+    multiTxHash: 0x3adeed,
+    payments: {
+        version: 0,
+        unspent: 0x0d6e0327 // Lunsp
+    },
+    coin_type: 640,
+    wif: 0x3F,
+    multiCodec: 0x3c4,
+    bip32: { public: 0x13BBF2D4, private: 0x13BBCBC4 },
+    testnet: testnets['leofcoin:olivia']
+};
+const bitcoin = {
+    messagePrefix: '\x18Bitcoin Signed Message:\n',
+    version: 1,
+    bech32: 'bc',
+    pubKeyHash: 0x00,
+    multiCodec: 0x00,
+    scriptHash: 0x05,
+    wif: 0x80,
+    coin_type: 0,
+    bip32: {
+        public: 0x0488b21e, private: 0x0488ade4
+    },
+    testnet: testnets['bitcoin:testnet']
+};
+const litecoin = {
+    messagePrefix: '\x19Litecoin Signed Message:\n',
+    version: 1,
+    pubKeyHash: 0x30,
+    scriptHash: 0x32,
+    wif: 0xb0,
+    bip32: {
+        public: 0x019da462,
+        private: 0x019d9cfe
+    },
+    bech32: '',
+    multiCodec: 0
+};
+const ethereum = {
+    messagePrefix: '\x19Ethereum Signed Message:\n',
+    version: 1,
+    pubKeyHash: 0x30,
+    scriptHash: 0x32,
+    bip32: {
+        private: 0x0488ADE4, public: 0x0488B21E
+    },
+    coin_type: 60,
+    wif: 0x45,
+    multiCodec: 0x3c5
+};
+/**
+ * Our & supported networks
+ * @return {leofcoin, olivia}
+ */
+var networks = {
+    leofcoin,
+    bitcoin,
+    litecoin,
+    ethereum
+};
+
+const concatAndDoubleHash = async (input) => {
+    return new Uint8Array(await createDoubleHash(typedArrayConcat(input), 'SHA-256'));
 };
-const bitcoin = {
-    messagePrefix: '\x18Bitcoin Signed Message:\n',
-    version: 1,
-    bech32: 'bc',
-    pubKeyHash: 0x00,
-    multiCodec: 0x00,
-    scriptHash: 0x05,
-    wif: 0x80,
-    coin_type: 0,
-    bip32: {
-        public: 0x0488b21e, private: 0x0488ade4
-    },
-    testnet: testnets['bitcoin:testnet']
+
+const encode$2 = async (source, prefix = new TextEncoder().encode('00'), hex) => {
+    if (!(source instanceof Uint8Array) || !(prefix instanceof Uint8Array)) {
+        throw new TypeError('Expected Uint8Array');
+    }
+    const hash = await concatAndDoubleHash([
+        prefix,
+        source
+    ]);
+    const uint8Array = typedArrayConcat([
+        prefix,
+        source,
+        hash.subarray(0, 4)
+    ]);
+    if (hex)
+        return base58$1.encodeHex(uint8Array);
+    return base58$1.encode(uint8Array);
 };
-const litecoin = {
-    messagePrefix: '\x19Litecoin Signed Message:\n',
-    version: 1,
-    pubKeyHash: 0x30,
-    scriptHash: 0x32,
-    wif: 0xb0,
-    bip32: {
-        public: 0x019da462,
-        private: 0x019d9cfe
-    },
-    bech32: '',
-    multiCodec: 0
+const decode$2 = async (string, hex) => {
+    let uint8Array = hex ? base58$1.decodeHex(string) : base58$1.decode(string);
+    const prefix = uint8Array.subarray(0, 2);
+    const source = uint8Array.subarray(2, -4);
+    const hash = await concatAndDoubleHash([
+        prefix,
+        source
+    ]);
+    let index = 0;
+    const slice = uint8Array.subarray(-4);
+    for (const check of slice) {
+        if (check !== hash[index]) {
+            throw new Error('Invalid checksum');
+        }
+        index++;
+    }
+    return { prefix, data: source };
 };
-const ethereum = {
-    messagePrefix: '\x19Ethereum Signed Message:\n',
-    version: 1,
-    pubKeyHash: 0x30,
-    scriptHash: 0x32,
-    bip32: {
-        private: 0x0488ADE4, public: 0x0488B21E
-    },
-    coin_type: 60,
-    wif: 0x45,
-    multiCodec: 0x3c5
+const isBase58check = (string, hex) => {
+    try {
+        hex ? decode$2(string, true) : decode$2(string);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
 };
-/**
- * Our & supported networks
- * @return {leofcoin, olivia}
- */
-var networks = {
-    leofcoin,
-    bitcoin,
-    litecoin,
-    ethereum
-};
+const encodeHex = (uint8Array, prefix = new TextEncoder().encode('00')) => encode$2(uint8Array, prefix, true);
+const decodeHex = (string) => decode$2(string, true);
+const isBase58checkHex = (string) => isBase58check(string, true);
+var base58check = { encode: encode$2, decode: decode$2, encodeHex, decodeHex, isBase58check, isBase58checkHex };
 
-const encode = (version, privateKey, compressed) => {
+const encode$1 = (version, privateKey, compressed) => {
     if (privateKey.length !== 32)
         throw new TypeError(`Invalid privateKey length: expected 32 got ${privateKey.length}`);
     const uint8Array = new Uint8Array(compressed ? 34 : 33);
@@ -16399,7 +16395,7 @@ const encode = (version, privateKey, compressed) => {
     }
     return base58check.encode(uint8Array);
 };
-const decode = async (wif, version) => {
+const decode$1 = async (wif, version) => {
     wif = (await base58check.decode(wif)).data;
     if (version && wif[0] !== version)
         throw new Error('Invalid network version');
@@ -16414,207 +16410,208 @@ const decode = async (wif, version) => {
         compressed: wif.length === 33 ? false : true
     };
 };
-var wif = { encode, decode };
-
-const HIGHEST_BIT = 0x80000000;
-const { publicKeyCreate, publicKeyVerify, privateKeyVerify, privateKeyTweakAdd, ecdh } = secp256k1;
-class HdNode {
-    #privateKey;
-    #publicKey;
-    #chainCode;
-    #network;
-    #depth;
-    #index;
-    #parentFingerprint;
-    constructor(privateKey, publicKey, chainCode, network, depth = 0, index = 0, parentFingerprint = 0x00000000) {
-        this.init(privateKey, publicKey, chainCode, network, depth, index, parentFingerprint);
-    }
-    init(privateKey, publicKey, chainCode, network, depth = 0, index = 0, parentFingerprint = 0x00000000) {
-        this.#privateKey = privateKey;
-        this.#publicKey = publicKey;
-        this.#chainCode = chainCode;
-        this.#network = network || networks.leofcoin;
-        this.#depth = depth;
-        this.#index = index;
-        this.#parentFingerprint = parentFingerprint;
-    }
-    get network() {
-        return this.#network;
-    }
-    get publicKey() {
-        this.#publicKey = this.#publicKey || publicKeyCreate(this.#privateKey, true);
-        return this.#publicKey;
-    }
-    get privateKey() {
-        return this.#privateKey;
-    }
-    get identifier() {
-        return this.hash160(this.publicKey);
-    }
-    get fingerprint() {
-        return (async () => (await this.identifier).subarray(0, 4))();
-    }
-    async hash160(data) {
-        const hash = await createHash(data, 'SHA-256');
-        return (await createRIPEMD160()).update(new Uint8Array(hash)).digest('binary');
-    }
-    get isNeutered() {
-        return this.#privateKey === undefined;
-    }
-    get neutered() {
-        return new HdNode(undefined, this.#publicKey, this.#chainCode, this.#network, this.#depth, this.#index, this.#parentFingerprint);
-    }
-    fromPrivateKey(privateKey, chainCode, network) {
-        if (!privateKeyVerify(privateKey))
-            throw new TypeError('Private key not in range [1, n)');
-        return new HdNode(privateKey, publicKeyCreate(privateKey, true), chainCode, network);
-    }
-    fromPublicKey(publicKey, chainCode, network) {
-        // verify the X coordinate is a point on the curve
-        if (!publicKeyVerify(publicKey))
-            throw new TypeError('Point is not on the curve');
-        return new HdNode(undefined, publicKey, chainCode, network);
-    }
-    async fromSeed(seed, network) {
-        if (seed.length < 16)
-            throw new TypeError('Seed should be at least 128 bits');
-        if (seed.length > 64)
-            throw new TypeError('Seed should be at most 512 bits');
-        let hash = (await createHMAC(createSHA512(), new TextEncoder().encode('Bitcoin seed')))
-            .update(seed)
-            .digest('binary');
-        const privateKey = hash.subarray(0, 32);
-        const chainCode = hash.subarray(32);
-        return this.fromPrivateKey(privateKey, chainCode, network);
-    }
-    async toBase58() {
-        const network = this.#network || networks.leofcoin;
-        let version = !this.isNeutered
-            ? network.bip32.private
-            : network.bip32.public;
-        const set = [
-            new TextEncoder().encode(version.toString()),
-            new TextEncoder().encode(this.#depth.toString()),
-            new TextEncoder().encode(this.#parentFingerprint.toString()),
-            new TextEncoder().encode(this.#index.toString()),
-            this.#chainCode
-        ];
-        if (!this.isNeutered) {
-            set.push(new TextEncoder().encode('0'));
-            set.push(new Uint8Array(this.privateKey));
-        }
-        else {
-            set.push(new Uint8Array(this.publicKey));
-        }
-        return base58check.encode(index$6(set));
-    }
-    toWIF() {
-        if (!this.#privateKey)
-            throw new TypeError('Missing private key');
-        return wif.encode(this.#network.wif, this.#privateKey, true);
-    }
-    // https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki#child-key-derivation-ckd-functions
-    async derive(index) {
-        const isHardened = index >= HIGHEST_BIT;
-        let data;
-        // Hardened child
-        if (isHardened) {
-            if (this.isNeutered)
-                throw new TypeError('Missing private key for hardened child key');
-            // data = 0x00 || ser256(kpar) || ser32(index)
-            data = index$6([
-                new TextEncoder().encode('0'),
-                this.privateKey,
-                new TextEncoder().encode(index.toString())
-            ]);
-        }
-        else {
-            data = index$6([
-                this.publicKey,
-                new TextEncoder().encode(index.toString())
-            ]);
-        }
-        const hash = (await createHMAC(createSHA512(), this.#chainCode))
-            .update(data)
-            .digest('binary');
-        const privateKey = hash.subarray(0, 32);
-        const chainCode = hash.subarray(32);
-        // if parse256(privateKey) >= n, proceed with the next value for i
-        if (!privateKeyVerify(privateKey))
-            return this.derive(index + 1);
-        // Private parent key -> private child key
-        if (!this.isNeutered) {
-            // ki = parse256(privateKey) + kpar (mod n)                
-            const ki = privateKeyTweakAdd(this.privateKey, privateKey);
-            // In case ki == 0, proceed with the next value for i
-            if (ki == null)
-                return this.derive(index + 1);
-            return new HdNode(ki, null, chainCode, this.#network, this.#depth + 1, index, (await this.fingerprint)[0]);
-        }
-        function hashfn(x, y) {
-            const pubKey = new Uint8Array(33);
-            pubKey[0] = (y[31] & 1) === 0 ? 0x02 : 0x03;
-            pubKey.set(x, 1);
-            return pubKey;
-        }
-        const Ki = ecdh(this.publicKey, chainCode, { hashfn }, new Uint8Array(33));
-        // const Ki = new Uint8Array(ecc.pointAddScalar(this.publicKey, IL, true));
-        // In case Ki is the point at infinity, proceed with the next value for i
-        if (Ki === null)
-            return this.derive(index + 1);
-        return new HdNode(undefined, Ki, chainCode, this.#network, this.#depth + 1, index, (await this.fingerprint)[0]);
-    }
-    deriveHardened(index) {
-        // Only derives hardened private keys by default
-        return this.derive(index + HIGHEST_BIT);
-    }
-    async derivePath(path) {
-        let splitPath = path.split('/');
-        if (splitPath[0] === 'm') {
-            if (this.#parentFingerprint)
-                throw new TypeError('Expected master, got child');
-            splitPath = splitPath.slice(1);
-        }
-        let prevHd = this;
-        for (const indexString of splitPath) {
-            let index;
-            if (indexString.slice(-1) === `'`) {
-                index = parseInt(indexString.slice(0, -1), 10);
-                prevHd = await prevHd.deriveHardened(index);
-            }
-            else {
-                index = parseInt(indexString, 10);
-                prevHd = await prevHd.derive(index);
-            }
-        }
-        return prevHd;
-    }
-    async fromBase58(string, network) {
-        let buffer = (await base58check.decode(string)).data;
-        network = network || networks.leofcoin;
-        // 4 bytes: version bytes
-        let [version, depth, parentFingerprint, index, chainCode, k, privateKey] = index$5(buffer);
-        version = Number(new TextDecoder().decode(version));
-        depth = Number(new TextDecoder().decode(depth));
-        parentFingerprint = Number(new TextDecoder().decode(parentFingerprint));
-        index = Number(new TextDecoder().decode(index));
-        k = privateKey ? 0 : k;
-        if (version !== network.bip32.private && version !== network.bip32.public)
-            throw new TypeError('Invalid network version');
-        if (depth === 0) {
-            if (parentFingerprint !== 0)
-                throw new TypeError('Invalid parent fingerprint');
-        }
-        if (depth === 0 && index !== 0)
-            throw new TypeError('Invalid index');
-        if (version === network.bip32.private) {
-            if (k !== 0x00)
-                throw new TypeError('Invalid private key');
-            return new HdNode(privateKey, undefined, chainCode, network, depth, index, parentFingerprint);
-        }
-        this.init(undefined, k, chainCode, network, depth, index, parentFingerprint);
-        return new HdNode(undefined, k, chainCode, network, depth, index, parentFingerprint);
-    }
+var wif = { encode: encode$1, decode: decode$1 };
+
+const HIGHEST_BIT = 0x80000000;
+const { publicKeyCreate, publicKeyVerify, privateKeyVerify, privateKeyTweakAdd, ecdh } = secp256k1;
+class HdNode {
+    #privateKey;
+    #publicKey;
+    #chainCode;
+    #network;
+    #depth;
+    #index;
+    #parentFingerprint;
+    constructor(privateKey, publicKey, chainCode, network, depth = 0, index = 0, parentFingerprint = 0x00000000) {
+        this.init(privateKey, publicKey, chainCode, network, depth, index, parentFingerprint);
+    }
+    init(privateKey, publicKey, chainCode, network, depth = 0, index = 0, parentFingerprint = 0x00000000) {
+        this.#privateKey = privateKey;
+        this.#publicKey = publicKey;
+        this.#chainCode = chainCode;
+        this.#network = network || networks.leofcoin;
+        this.#depth = depth;
+        this.#index = index;
+        this.#parentFingerprint = parentFingerprint;
+    }
+    get network() {
+        return this.#network;
+    }
+    get publicKey() {
+        this.#publicKey = this.#publicKey || publicKeyCreate(this.#privateKey, true);
+        return this.#publicKey;
+    }
+    get privateKey() {
+        return this.#privateKey;
+    }
+    get identifier() {
+        return this.hash160(this.publicKey);
+    }
+    get fingerprint() {
+        return (async () => (await this.identifier).subarray(0, 4))();
+    }
+    async hash160(data) {
+        const hash = await createHash(data, 'SHA-256');
+        return (await createRIPEMD160()).update(new Uint8Array(hash)).digest('binary');
+    }
+    get isNeutered() {
+        return this.#privateKey === undefined;
+    }
+    get neutered() {
+        return new HdNode(undefined, this.#publicKey, this.#chainCode, this.#network, this.#depth, this.#index, this.#parentFingerprint);
+    }
+    fromPrivateKey(privateKey, chainCode, network) {
+        if (!privateKeyVerify(privateKey))
+            throw new TypeError('Private key not in range [1, n)');
+        const publicKey = publicKeyCreate(privateKey, true);
+        return new HdNode(privateKey, publicKey, publicKey.slice(1), network);
+    }
+    fromPublicKey(publicKey, chainCode, network) {
+        // verify the X coordinate is a point on the curve
+        if (!publicKeyVerify(publicKey))
+            throw new TypeError('Point is not on the curve');
+        return new HdNode(undefined, publicKey, chainCode, network);
+    }
+    async fromSeed(seed, network) {
+        if (seed.length < 16)
+            throw new TypeError('Seed should be at least 128 bits');
+        if (seed.length > 64)
+            throw new TypeError('Seed should be at most 512 bits');
+        let hash = (await createHMAC(createSHA512(), new TextEncoder().encode('Bitcoin seed')))
+            .update(seed)
+            .digest('binary');
+        const privateKey = hash.subarray(0, 32);
+        const chainCode = hash.subarray(32);
+        return this.fromPrivateKey(privateKey, chainCode, network);
+    }
+    async toBase58() {
+        const network = this.#network || networks.leofcoin;
+        let version = !this.isNeutered
+            ? network.bip32.private
+            : network.bip32.public;
+        const set = [
+            new TextEncoder().encode(version.toString()),
+            new TextEncoder().encode(this.#depth.toString()),
+            new TextEncoder().encode(this.#parentFingerprint.toString()),
+            new TextEncoder().encode(this.#index.toString()),
+            this.#chainCode
+        ];
+        if (!this.isNeutered) {
+            set.push(new TextEncoder().encode('0'));
+            set.push(new Uint8Array(this.privateKey));
+        }
+        else {
+            set.push(new Uint8Array(this.publicKey));
+        }
+        return base58check$1.encode(index$7(set));
+    }
+    toWIF() {
+        if (!this.#privateKey)
+            throw new TypeError('Missing private key');
+        return wif.encode(this.#network.wif, this.#privateKey, true);
+    }
+    // https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki#child-key-derivation-ckd-functions
+    async derive(index) {
+        const isHardened = index >= HIGHEST_BIT;
+        let data;
+        // Hardened child
+        if (isHardened) {
+            if (this.isNeutered)
+                throw new TypeError('Missing private key for hardened child key');
+            // data = 0x00 || ser256(kpar) || ser32(index)
+            data = index$7([
+                new TextEncoder().encode('0'),
+                this.privateKey,
+                new TextEncoder().encode(index.toString())
+            ]);
+        }
+        else {
+            data = index$7([
+                this.publicKey,
+                new TextEncoder().encode(index.toString())
+            ]);
+        }
+        const hash = (await createHMAC(createSHA512(), this.#chainCode))
+            .update(data)
+            .digest('binary');
+        const privateKey = hash.subarray(0, 32);
+        const chainCode = hash.subarray(32);
+        // if parse256(privateKey) >= n, proceed with the next value for i
+        if (!privateKeyVerify(privateKey))
+            return this.derive(index + 1);
+        // Private parent key -> private child key
+        if (!this.isNeutered) {
+            // ki = parse256(privateKey) + kpar (mod n)                
+            const ki = privateKeyTweakAdd(this.privateKey, privateKey);
+            // In case ki == 0, proceed with the next value for i
+            if (ki == null)
+                return this.derive(index + 1);
+            return new HdNode(ki, null, chainCode, this.#network, this.#depth + 1, index, (await this.fingerprint)[0]);
+        }
+        function hashfn(x, y) {
+            const pubKey = new Uint8Array(33);
+            pubKey[0] = (y[31] & 1) === 0 ? 0x02 : 0x03;
+            pubKey.set(x, 1);
+            return pubKey;
+        }
+        const Ki = ecdh(this.publicKey, chainCode, { hashfn }, new Uint8Array(33));
+        // const Ki = new Uint8Array(ecc.pointAddScalar(this.publicKey, IL, true));
+        // In case Ki is the point at infinity, proceed with the next value for i
+        if (Ki === null)
+            return this.derive(index + 1);
+        return new HdNode(undefined, Ki, chainCode, this.#network, this.#depth + 1, index, (await this.fingerprint)[0]);
+    }
+    deriveHardened(index) {
+        // Only derives hardened private keys by default
+        return this.derive(index + HIGHEST_BIT);
+    }
+    async derivePath(path) {
+        let splitPath = path.split('/');
+        if (splitPath[0] === 'm') {
+            if (this.#parentFingerprint)
+                throw new TypeError('Expected master, got child');
+            splitPath = splitPath.slice(1);
+        }
+        let prevHd = this;
+        for (const indexString of splitPath) {
+            let index;
+            if (indexString.slice(-1) === `'`) {
+                index = parseInt(indexString.slice(0, -1), 10);
+                prevHd = await prevHd.deriveHardened(index);
+            }
+            else {
+                index = parseInt(indexString, 10);
+                prevHd = await prevHd.derive(index);
+            }
+        }
+        return prevHd;
+    }
+    async fromBase58(string, network) {
+        let buffer = (await base58check$1.decode(string)).data;
+        network = network || networks.leofcoin;
+        // 4 bytes: version bytes
+        let [version, depth, parentFingerprint, index, chainCode, k, privateKey] = index$6(buffer);
+        version = Number(new TextDecoder().decode(version));
+        depth = Number(new TextDecoder().decode(depth));
+        parentFingerprint = Number(new TextDecoder().decode(parentFingerprint));
+        index = Number(new TextDecoder().decode(index));
+        k = privateKey ? 0 : k;
+        if (version !== network.bip32.private && version !== network.bip32.public)
+            throw new TypeError('Invalid network version');
+        if (depth === 0) {
+            if (parentFingerprint !== 0)
+                throw new TypeError('Invalid parent fingerprint');
+        }
+        if (depth === 0 && index !== 0)
+            throw new TypeError('Invalid index');
+        if (version === network.bip32.private) {
+            if (k !== 0x00)
+                throw new TypeError('Invalid private key');
+            return new HdNode(privateKey, undefined, chainCode, network, depth, index, parentFingerprint);
+        }
+        this.init(undefined, k, chainCode, network, depth, index, parentFingerprint);
+        return new HdNode(undefined, k, chainCode, network, depth, index, parentFingerprint);
+    }
 }
 
 // see https://github.com/bitcoin/bips/blob/master/bip-0039/english.txt
@@ -16667,144 +16664,145 @@ class Mnemonic {
     }
 }
 
-const fromNetworkString = network => {
-    const parts = network.split(':');
-    network = networks[parts[0]];
-    if (parts[1]) {
-        if (network[parts[1]])
-            network = network[parts[1]];
-        network.coin_type = 1;
-    }
-    return network;
-};
-const publicKeyToEthereumAddress = async (publicKeyBuffer) => {
-    const hasher = await createKeccak(256);
-    hasher.update(publicKeyBuffer);
-    const hash = hasher.digest();
-    return `0x${hash.slice(-40).toString()}`;
-};
-class HDWallet {
-    hdnode;
-    networkName;
-    version;
-    locked;
-    network;
-    multiCodec;
-    get privateKey() {
-        return this.ifNotLocked(() => this.hdnode.privateKey);
-    }
-    get publicKey() {
-        return this.hdnode.publicKey;
-    }
-    async ethereumAddress() {
-        const address = await publicKeyToEthereumAddress(this.publicKey);
-        return address;
-    }
-    leofcoinAddress() {
-        return base58check.encode(this.publicKey);
-    }
-    get address() {
-        return this.getAddressForCoin();
-    }
-    async getAddressForCoin(coin_type) {
-        if (!coin_type)
-            coin_type = this.network.coin_type;
-        if (coin_type === 1) {
-            if (this.networkName?.split(':')[0] === 'ethereum')
-                coin_type = 60;
-            if (this.networkName?.split(':')[0] === 'leofcoin')
-                coin_type = 640;
-        }
-        // if (coin_type === 0) return this.bitcoinAddress
-        if (coin_type === 60)
-            return this.ethereumAddress();
-        if (coin_type === 640)
-            return this.leofcoinAddress();
-    }
-    get accountAddress() {
-        return this.ifNotLocked(async () => base58check.encode(this.hdnode.publicKey));
-    }
-    get isTestnet() {
-        return this.network.coin_type === 1;
-    }
-    constructor(network, hdnode) {
-        if (typeof network === 'string') {
-            this.networkName = network;
-            this.network = fromNetworkString(network);
-        }
-        else if (typeof network === 'object')
-            this.network = network;
-        this.multiCodec = this.network.multiCodec;
-        this.version = 0x00;
-        if (hdnode)
-            this.defineHDNode(hdnode);
-    }
-    ifNotLocked(fn, params) {
-        if (this.locked)
-            return;
-        return params ? fn(...params) : fn();
-    }
-    async defineHDNode(value) {
-        Object.defineProperty(this, 'hdnode', {
-            configurable: false,
-            writable: false,
-            value: await value
-        });
-    }
-    validateNetwork(network) {
-        if (!network && !this.network)
-            return console.error(`expected network to be defined`);
-        if (!network && this.network)
-            network = this.network;
-        if (typeof network === 'string')
-            network = fromNetworkString(network);
-        if (typeof network !== 'object')
-            return console.error('network not found');
-        return network;
-    }
-    async generate(password, network) {
-        network = this.validateNetwork(network);
-        const mnemonic = await new Mnemonic().generate(512);
-        const seed = await new Mnemonic().seedFromMnemonic(mnemonic, password, 512);
-        await this.defineHDNode(await (new HdNode()).fromSeed(new Uint8Array(seed), network));
-        return mnemonic;
-    }
-    /**
-   * recover using mnemonic (recovery word list)
-   */
-    async recover(mnemonic, password, network) {
-        network = this.validateNetwork(network || password);
-        const seed = await new Mnemonic().seedFromMnemonic(mnemonic, password, 512);
-        let node = new HdNode();
-        node = await node.fromSeed(new Uint8Array(seed), network);
-        await this.defineHDNode(await node.fromSeed(new Uint8Array(seed), network));
-    }
-    async load(base58, network) {
-        network = this.validateNetwork(network);
-        await this.defineHDNode(await (new HdNode()).fromBase58(base58, network));
-    }
-    save() {
-        return this.hdnode.toBase58();
-    }
-    async fromAddress(address, chainCode, network) {
-        network = this.validateNetwork(network);
-        address = (await base58check.decode(address)).data;
-        if (!chainCode || chainCode && !Buffer.isBuffer(chainCode))
-            chainCode = address.slice(1);
-        await this.defineHDNode(await (new HdNode()).fromPublicKey(address, chainCode, network));
-    }
-    async fromPublicKey(hex, chainCode, network) {
-        network = this.validateNetwork(network);
-        if (!chainCode || chainCode)
-            chainCode = hex.slice(1);
-        let node = new HdNode();
-        node = await node.fromPublicKey(hex, chainCode, network);
-        await this.defineHDNode(node);
-        return this;
-    }
-    async fromPrivateKey(privateKey, chainCode, network) {
-        await this.defineHDNode(await (new HdNode()).fromPrivateKey(privateKey, chainCode, network));
-    }
+const fromNetworkString = network => {
+    const parts = network.split(':');
+    network = networks[parts[0]];
+    if (parts[1]) {
+        if (network[parts[1]])
+            network = network[parts[1]];
+        network.coin_type = 1;
+    }
+    return network;
+};
+const publicKeyToEthereumAddress = async (publicKeyBuffer) => {
+    const hasher = await createKeccak(256);
+    hasher.update(publicKeyBuffer);
+    const hash = hasher.digest();
+    return `0x${hash.slice(-40).toString()}`;
+};
+class HDWallet {
+    hdnode;
+    networkName;
+    version;
+    locked;
+    network;
+    multiCodec;
+    get privateKey() {
+        return this.ifNotLocked(() => this.hdnode.privateKey);
+    }
+    get publicKey() {
+        return this.hdnode.publicKey;
+    }
+    async ethereumAddress() {
+        const address = await publicKeyToEthereumAddress(this.publicKey);
+        return address;
+    }
+    leofcoinAddress() {
+        return base58check$1.encode(this.publicKey);
+    }
+    get address() {
+        return this.getAddressForCoin();
+    }
+    async getAddressForCoin(coin_type) {
+        if (!coin_type)
+            coin_type = this.network.coin_type;
+        if (coin_type === 1) {
+            if (this.networkName?.split(':')[0] === 'ethereum')
+                coin_type = 60;
+            if (this.networkName?.split(':')[0] === 'leofcoin')
+                coin_type = 640;
+        }
+        // if (coin_type === 0) return this.bitcoinAddress
+        if (coin_type === 60)
+            return this.ethereumAddress();
+        if (coin_type === 640)
+            return this.leofcoinAddress();
+        // if (coin_type === 0) return this.bitcoinAddress()
+    }
+    get accountAddress() {
+        return this.ifNotLocked(async () => base58check$1.encode(this.hdnode.publicKey));
+    }
+    get isTestnet() {
+        return this.network.coin_type === 1;
+    }
+    constructor(network, hdnode) {
+        if (typeof network === 'string') {
+            this.networkName = network;
+            this.network = fromNetworkString(network);
+        }
+        else if (typeof network === 'object')
+            this.network = network;
+        this.multiCodec = this.network.multiCodec;
+        this.version = 0x00;
+        if (hdnode)
+            this.defineHDNode(hdnode);
+    }
+    ifNotLocked(fn, params) {
+        if (this.locked)
+            return;
+        return params ? fn(...params) : fn();
+    }
+    async defineHDNode(value) {
+        Object.defineProperty(this, 'hdnode', {
+            configurable: false,
+            writable: false,
+            value: await value
+        });
+    }
+    validateNetwork(network) {
+        if (!network && !this.network)
+            return console.error(`expected network to be defined`);
+        if (!network && this.network)
+            network = this.network;
+        if (typeof network === 'string')
+            network = fromNetworkString(network);
+        if (typeof network !== 'object')
+            return console.error('network not found');
+        return network;
+    }
+    async generate(password, network) {
+        network = this.validateNetwork(network);
+        const mnemonic = await new Mnemonic().generate(512);
+        const seed = await new Mnemonic().seedFromMnemonic(mnemonic, password, 512);
+        await this.defineHDNode(await (new HdNode()).fromSeed(new Uint8Array(seed), network));
+        return mnemonic;
+    }
+    /**
+   * recover using mnemonic (recovery word list)
+   */
+    async recover(mnemonic, password, network) {
+        network = this.validateNetwork(network || password);
+        const seed = await new Mnemonic().seedFromMnemonic(mnemonic, password, 512);
+        let node = new HdNode();
+        node = await node.fromSeed(new Uint8Array(seed), network);
+        await this.defineHDNode(await node.fromSeed(new Uint8Array(seed), network));
+    }
+    async load(base58, network) {
+        network = this.validateNetwork(network);
+        await this.defineHDNode(await (new HdNode()).fromBase58(base58, network));
+    }
+    save() {
+        return this.hdnode.toBase58();
+    }
+    async fromAddress(address, chainCode, network) {
+        network = this.validateNetwork(network);
+        address = (await base58check$1.decode(address)).data;
+        if (!chainCode || chainCode && !Buffer.isBuffer(chainCode))
+            chainCode = address.slice(1);
+        await this.defineHDNode(await (new HdNode()).fromPublicKey(address, chainCode, network));
+    }
+    async fromPublicKey(hex, chainCode, network) {
+        network = this.validateNetwork(network);
+        if (!chainCode || chainCode)
+            chainCode = hex.slice(1);
+        let node = new HdNode();
+        node = await node.fromPublicKey(hex, chainCode, network);
+        await this.defineHDNode(node);
+        return this;
+    }
+    async fromPrivateKey(privateKey, chainCode, network) {
+        await this.defineHDNode(await (new HdNode()).fromPrivateKey(privateKey, chainCode, network));
+    }
 }
 
 class MultiSignature {
@@ -16862,8 +16860,8 @@ class MultiSignature {
         if (!signature)
             throw ReferenceError('signature undefined');
         this.#multiSignature = typedArrayConcat([
-            index$7.encode(this.version),
-            index$7.encode(this.multiCodec),
+            index$8.encode(this.version),
+            index$8.encode(this.multiCodec),
             signature
         ]);
         return this.multiSignature;
@@ -16879,10 +16877,10 @@ class MultiSignature {
         if (!this.multiSignature)
             throw ReferenceError('multiSignature undefined');
         let buffer = this.multiSignature;
-        const version = index$7.decode(buffer);
-        buffer = buffer.subarray(index$7.decode.bytes);
-        const codec = index$7.decode(buffer);
-        buffer = buffer.subarray(index$7.decode.bytes);
+        const version = index$8.decode(buffer);
+        buffer = buffer.subarray(index$8.decode.bytes);
+        const codec = index$8.decode(buffer);
+        buffer = buffer.subarray(index$8.decode.bytes);
         const signature = buffer.subarray(0, buffer.length);
         if (version !== this.version)
             throw TypeError('Invalid version');
@@ -16908,16 +16906,16 @@ class MultiSignature {
         return this.decode(base58$1.decode(string));
     }
     toBs32() {
-        return index$8.encode(this.multiSignature);
+        return index$9.encode(this.multiSignature);
     }
     fromBs32(string) {
-        return this.decode(index$8.decode(string));
+        return this.decode(index$9.decode(string));
     }
     toBs32Hex() {
-        return index$8.encodeHex(this.multiSignature);
+        return index$9.encodeHex(this.multiSignature);
     }
     fromBs32Hex(string) {
-        return this.decode(index$8.decodeHex(string));
+        return this.decode(index$9.decodeHex(string));
     }
     toBs58Hex() {
         return base58$1.encodeHex(this.multiSignature);
@@ -16927,132 +16925,6 @@ class MultiSignature {
     }
 }
 
-class MultiHDNode extends HDWallet {
-    #encrypted;
-    constructor(network, hdnode) {
-        super(network, hdnode);
-    }
-    get id() {
-        return base58check.encode(index$6([
-            new TextEncoder().encode(this.version.toString()),
-            this.account(0).hdnode.neutered.publicKey
-        ]));
-    }
-    get multiWIF() {
-        return this.toMultiWif();
-    }
-    async fromId(id) {
-        let buffer = (await base58check.decode(id)).data;
-        index$7.decode(buffer);
-        buffer = buffer.slice(index$7.decode.bytes);
-        this.fromPublicKey(buffer, null, this.networkName);
-    }
-    async lock(multiWIF) {
-        if (!multiWIF)
-            multiWIF = this.multiWIF;
-        this.#encrypted = await encrypt$1(multiWIF);
-        this.locked = true;
-        return this.#encrypted;
-    }
-    async unlock({ key, iv, cipher }) {
-        const decrypted = await decrypt$1({ cipher, key, iv });
-        await this.fromMultiWif(new TextDecoder().decode(decrypted));
-        this.locked = false;
-    }
-    fromMultiWif(string) {
-        const { version, codec, privateKey } = index.decode(string);
-        this.network = Object.values(networks).reduce((p, c) => {
-            if (c.multiCodec === codec)
-                return c;
-            else if (c.testnet && c.testnet.multiCodec === codec)
-                return c.testnet;
-            else
-                return p;
-        }, networks['leofcoin']);
-        if (version !== this.network.version)
-            throw new Error('invalid version');
-        return this.fromPrivateKey(privateKey, undefined, this.network);
-    }
-    toMultiWif() {
-        return index.encode(this.network.version, this.network.multiCodec, this.privateKey);
-    }
-    sign(hash) {
-        return new MultiSignature(this.version, this.network.multiCodec)
-            .sign(hash, this.privateKey);
-    }
-    verify(multiSignature, hash) {
-        return new MultiSignature(this.version, this.network.multiCodec)
-            .verify(multiSignature, hash, this.publicKey);
-    }
-}
-
-class HDAccount extends MultiHDNode {
-    /**
-     * @param {number} depth - acount depth
-     */
-    constructor(network, hdnode, depth = 0) {
-        super(network, hdnode);
-        this.hdnode = hdnode;
-        this.depth = depth;
-        this._prefix = `m/44'/${hdnode.network.coin_type}'/${depth}'/`;
-    }
-    get neutered() {
-        return this.hdnode.neutered;
-    }
-    /**
-     * @param {number} index - address index
-     */
-    async internal(index = 0) {
-        return this.hdnode.derivePath(`${this._prefix}1/${index}`);
-    }
-    /**
-     * @param {number} index - address index
-     */
-    async external(index = 0) {
-        return this.hdnode.derivePath(`${this._prefix}0/${index}`);
-    }
-}
-
-class MultiWallet extends MultiHDNode {
-    constructor(network, hdnode) {
-        super(network, hdnode);
-    }
-    get id() {
-        return base58check.encode(index$6([
-            new TextEncoder().encode(this.version.toString()),
-            this.account(0).hdnode.neutered.publicKey
-        ]));
-    }
-    get multiWIF() {
-        return this.toMultiWif();
-    }
-    get neutered() {
-        return new HDAccount(this.networkName, this, this.hdnode.depth);
-    }
-    /**
-     * @param {number} account - account to return chain for
-     * @return internal(addressIndex), external(addressIndex)
-     */
-    account(index) {
-        return new HDAccount(this.networkName, this, index);
-    }
-    async fromAccount(privateKey, depth, network) {
-        const node = await new MultiWallet(network).fromPrivateKey(privateKey);
-        return new HDAccount(node, depth);
-    }
-    /**
-     * m / purpose' / coin_type' / account' / change / aadress_index
-     *
-     * see https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki
-     */
-    async derivePath(path) {
-        return new MultiWallet(this.networkName, await this.hdnode.derivePath(path));
-    }
-    async derive(index) {
-        return new MultiWallet(this.networkName, await this.hdnode.derive(index));
-    }
-}
-
 var passwordToKey = (password) => globalThis.crypto.subtle.importKey('raw', new TextEncoder().encode(password), 'PBKDF2', false, ['deriveKey']);
 
 var deriveKey = (key, salt, iterations = 250000, hashAlgorithm = 'SHA-512') => globalThis.crypto.subtle.deriveKey({
@@ -17074,11 +16946,11 @@ var encrypt = async (password, data, version = new TextEncoder().encode('1')) =>
         name: 'AES-GCM',
         iv
     }, key, new TextEncoder().encode(data));
-    return index$6([version, salt, iv, new Uint8Array(encrypted)]);
+    return index$7([version, salt, iv, new Uint8Array(encrypted)]);
 };
 
 var decrypt = async (password, concatecated) => {
-    const [version, salt, iv, cipher] = index$5(concatecated);
+    const [version, salt, iv, cipher] = index$6(concatecated);
     let iterations;
     if (new TextDecoder().decode(version) === '1') {
         iterations = 250000;
@@ -17092,6 +16964,213 @@ var decrypt = async (password, concatecated) => {
     return new TextDecoder().decode(decrypted);
 };
 
+const MSB$1 = 0x80;
+const REST$1 = 0x7F;
+const MSBALL = ~REST$1;
+const INT = Math.pow(2, 31);
+const encode = (num, out, offset) => {
+    if (Number.MAX_SAFE_INTEGER && num > Number.MAX_SAFE_INTEGER) {
+        encode.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.bytes = offset - oldOffset + 1;
+    return out;
+};
+
+const MSB = 0x80;
+const REST = 0x7F;
+const decode = (buf, offset) => {
+    offset = offset || 0;
+    const l = buf.length;
+    let counter = offset;
+    let result = 0;
+    let shift = 0;
+    let b;
+    do {
+        if (counter >= l || shift > 49) {
+            decode.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.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 = {
+    encode,
+    decode,
+    encodingLength
+};
+
+class MultiHDNode extends HDWallet {
+    #encrypted;
+    constructor(network, hdnode) {
+        super(network, hdnode);
+    }
+    get id() {
+        return base58check$1.encode(index$7([
+            new TextEncoder().encode(this.version.toString()),
+            this.account(0).hdnode.neutered.publicKey
+        ]));
+    }
+    get multiWIF() {
+        return this.toMultiWif();
+    }
+    async fromId(id) {
+        let buffer = (await base58check$1.decode(id)).data;
+        index.decode(buffer);
+        buffer = buffer.slice(index.decode.bytes);
+        this.fromPublicKey(buffer, null, this.networkName);
+    }
+    async import(password, encrypted) {
+        const { prefix, data } = await base58check$1.decode(encrypted);
+        const decrypted = await decrypt(password, data);
+        await this.fromMultiWif(decrypted);
+    }
+    async export(password) {
+        return base58check$1.encode(await encrypt(password, await this.toMultiWif()));
+    }
+    async lock(password) {
+        // todo redefine hdnode
+        this.#encrypted = await this.export(password);
+        this.locked = true;
+    }
+    async unlock(password) {
+        const { prefix, data } = await base58check$1.decode(this.#encrypted);
+        await decrypt(password, data);
+        this.locked = false;
+    }
+    fromMultiWif(string) {
+        const { version, codec, privateKey } = index$1.decode(string);
+        this.network = Object.values(networks).reduce((p, c) => {
+            if (c.multiCodec === codec)
+                return c;
+            else if (c.testnet && c.testnet.multiCodec === codec)
+                return c.testnet;
+            else
+                return p;
+        }, networks['leofcoin']);
+        if (version !== this.network.version)
+            throw new Error('invalid version');
+        return this.fromPrivateKey(privateKey, undefined, this.network);
+    }
+    toMultiWif() {
+        return index$1.encode(this.network.version, this.network.multiCodec, this.privateKey);
+    }
+    sign(hash) {
+        return new MultiSignature(this.version, this.network.multiCodec)
+            .sign(hash, this.privateKey);
+    }
+    verify(multiSignature, hash) {
+        return new MultiSignature(this.version, this.network.multiCodec)
+            .verify(multiSignature, hash, this.publicKey);
+    }
+}
+
+class HDAccount extends MultiHDNode {
+    /**
+     * @param {number} depth - acount depth
+     */
+    constructor(network, hdnode, depth = 0) {
+        super(network, hdnode);
+        this.hdnode = hdnode;
+        this.depth = depth;
+        this._prefix = `m/44'/${hdnode.network.coin_type}'/${depth}'/`;
+    }
+    get neutered() {
+        return this.hdnode.neutered;
+    }
+    /**
+     * @param {number} index - address index
+     */
+    async internal(index = 0) {
+        return this.hdnode.derivePath(`${this._prefix}1/${index}`);
+    }
+    /**
+     * @param {number} index - address index
+     */
+    async external(index = 0) {
+        return this.hdnode.derivePath(`${this._prefix}0/${index}`);
+    }
+}
+
+class MultiWallet extends MultiHDNode {
+    constructor(network, hdnode) {
+        super(network, hdnode);
+    }
+    get id() {
+        return base58check$1.encode(index$7([
+            new TextEncoder().encode(this.version.toString()),
+            this.account(0).hdnode.neutered.publicKey
+        ]));
+    }
+    get multiWIF() {
+        return this.toMultiWif();
+    }
+    get neutered() {
+        return new HDAccount(this.networkName, this, this.hdnode.depth);
+    }
+    /**
+     * @param {number} account - account to return chain for
+     * @return internal(addressIndex), external(addressIndex)
+     */
+    account(index) {
+        return new HDAccount(this.networkName, this, index);
+    }
+    async fromAccount(privateKey, depth, network) {
+        const node = await new MultiWallet(network).fromPrivateKey(privateKey);
+        return new HDAccount(node, depth);
+    }
+    /**
+     * m / purpose' / coin_type' / account' / change / aadress_index
+     *
+     * see https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki
+     */
+    async derivePath(path) {
+        return new MultiWallet(this.networkName, await this.hdnode.derivePath(path));
+    }
+    async derive(index) {
+        return new MultiWallet(this.networkName, await this.hdnode.derive(index));
+    }
+}
+
 class e{constructor(a,b,c,d,f){this._legacyCanvasSize=e.DEFAULT_CANVAS_SIZE;this._preferredCamera="environment";this._maxScansPerSecond=25;this._lastScanTimestamp=-1;this._destroyed=this._flashOn=this._paused=this._active=!1;this.$video=a;this.$canvas=document.createElement("canvas");c&&"object"===typeof c?this._onDecode=b:(c||d||f?console.warn("You're using a deprecated version of the QrScanner constructor which will be removed in the future"):console.warn("Note that the type of the scan result passed to onDecode will change in the future. To already switch to the new api today, you can pass returnDetailedScanResult: true."),
 this._legacyOnDecode=b);b="object"===typeof c?c:{};this._onDecodeError=b.onDecodeError||("function"===typeof c?c:this._onDecodeError);this._calculateScanRegion=b.calculateScanRegion||("function"===typeof d?d:this._calculateScanRegion);this._preferredCamera=b.preferredCamera||f||this._preferredCamera;this._legacyCanvasSize="number"===typeof c?c:"number"===typeof d?d:this._legacyCanvasSize;this._maxScansPerSecond=b.maxScansPerSecond||this._maxScansPerSecond;this._onPlay=this._onPlay.bind(this);this._onLoadedMetaData=
 this._onLoadedMetaData.bind(this);this._onVisibilityChange=this._onVisibilityChange.bind(this);this._updateOverlay=this._updateOverlay.bind(this);a.disablePictureInPicture=!0;a.playsInline=!0;a.muted=!0;let h=!1;a.hidden&&(a.hidden=!1,h=!0);document.body.contains(a)||(document.body.appendChild(a),h=!0);c=a.parentElement;if(b.highlightScanRegion||b.highlightCodeOutline){d=!!b.overlay;this.$overlay=b.overlay||document.createElement("div");f=this.$overlay.style;f.position="absolute";f.display="none";
@@ -20081,7 +20160,7 @@ class Identity {
             globalThis.peernet.selectedAccount = new TextDecoder().decode(selected);
         }
         else {
-            const importee = await import(/* webpackChunkName: "generate-account" */ './index-ff6a68c3.js');
+            const importee = await import(/* webpackChunkName: "generate-account" */ './index-9c85cd32.js');
             const { identity, accounts } = await importee.default(password, this.network);
             await globalThis.accountStore.put('public', JSON.stringify({ walletId: identity.walletId }));
             await globalThis.walletStore.put('version', String(1));
@@ -20099,15 +20178,17 @@ class Identity {
     sign(hash) {
         return this.#wallet.sign(hash.subarray(0, 32));
     }
+    lock(password) {
+        this.#wallet.lock(password);
+    }
+    unlock(password) {
+        this.#wallet.unlock(password);
+    }
     async export(password) {
-        const multiWIF = this.#wallet.toMultiWif();
-        const encypted = await encrypt(password, multiWIF);
-        return base58$1.encode(encypted);
+        return this.#wallet.export(password);
     }
     async import(password, encrypted) {
-        this.#wallet = new MultiWallet(this.network);
-        const decrypted = await decrypt(password, base58$1.decode(encrypted));
-        await this.#wallet.fromMultiWif(decrypted);
+        await this.#wallet.import(password, encrypted);
     }
     async exportQR(password) {
         const exported = await this.export(password);
@@ -20260,7 +20341,7 @@ class Peernet {
         this.root = options.root;
         const { RequestMessage, ResponseMessage, PeerMessage, PeerMessageResponse, PeernetMessage, DHTMessage, DHTMessageResponse, DataMessage, DataMessageResponse, PsMessage, ChatMessage, PeernetFile
         // FolderMessageResponse
-         } = await import(/* webpackChunkName: "messages" */ './messages-7a0e14b4.js');
+         } = await import(/* webpackChunkName: "messages" */ './messages-b66f5393.js');
         /**
          * proto Object containing protos
          * @type {Object}
@@ -20518,7 +20599,7 @@ class Peernet {
     }
     async requestData(hash, store) {
         const providers = await this.providersFor(hash);
-        if (!providers || Object.keys(providers).length === 0)
+        if (!providers || providers && Object.keys(providers).length === 0)
             throw nothingFoundError(hash);
         debug(`found ${Object.keys(providers).length} provider(s) for ${hash}`);
         // get closest peer on earth