@leofcoin/peernet 1.0.3 → 1.0.6

package/exports/browser/{client-471408b6.js → client-cbaadd55.js}

@@ -1,4 +1,4 @@
-import { L as LittlePubSub } from './peernet-e1e0a046.js';
+import { L as LittlePubSub } from './peernet-6a78293a.js';
 import './value-157ab062.js';
 
 var clientApi = _pubsub => {

package/exports/browser/{index-601960df.js → index-88c7fc2e.js}

@@ -1,27 +1,6 @@
-import { M as MultiWallet, b as base58$1, r as randombytes, i as index$1 } from './peernet-e1e0a046.js';
+import { M as MultiWallet, e as encrypt, b as base58$1 } from './peernet-6a78293a.js';
 import './value-157ab062.js';
 
-const passwordToKey = (password) => globalThis.crypto.subtle.importKey('raw', password, 'PBKDF2', false, ['deriveKey']);
-const deriveKey = (key, salt, iterations = 250000, hashAlgorithm = 'SHA-512') => globalThis.crypto.subtle.deriveKey({
-    name: 'PBKDF2',
-    salt,
-    iterations,
-    hash: hashAlgorithm
-}, key, {
-    name: 'AES-GCM',
-    length: 256
-}, false, ['encrypt', 'decrypt']);
-const encrypt = async (password, data, version = new TextEncoder().encode('1')) => {
-    const passwordKey = await passwordToKey(new TextEncoder().encode(password));
-    const salt = randombytes(16);
-    const iv = randombytes(16);
-    const key = await deriveKey(passwordKey, salt);
-    const encrypted = await globalThis.crypto.subtle.encrypt({
-        name: 'AES-GCM',
-        iv
-    }, key, new TextEncoder().encode(data));
-    return index$1([version, salt, iv, new Uint8Array(encrypted)]);
-};
 /**
  * @params {String} network
  * @return {object} { identity, accounts, config }

package/exports/browser/{messages-cf68bfb3.js → messages-ba0fcf7e.js}

@@ -1,4 +1,4 @@
-import { F as FormatInterface } from './peernet-e1e0a046.js';
+import { F as FormatInterface } from './peernet-6a78293a.js';
 import './value-157ab062.js';
 
 var proto$b = {

package/exports/browser/{peernet-e1e0a046.js → peernet-6a78293a.js}

@@ -1467,444 +1467,446 @@ var utils$p = {
  */
 var isHex = (function (string) { return /^[A-F0-9]+$/i.test(string); });
 
-let BasicInterface$1 = class BasicInterface {
-    encoded;
-    decoded;
-    keys;
-    name;
-    #proto;
-    set proto(value) {
-        this.#proto = value;
-        this.keys = Object.keys(value);
-    }
-    get proto() {
-        return this.#proto;
-    }
-    decode(encoded) {
-        encoded = encoded || this.encoded;
-        return new Object();
-    }
-    encode(decoded) {
-        decoded = decoded || this.decoded;
-        return new Uint8Array();
-    }
-    // get Codec(): Codec {}
-    protoEncode(data) {
-        // check schema
-        return index$1.encode(this.proto, data);
-    }
-    protoDecode(data) {
-        // check schema
-        return index$1.decode(this.proto, data);
-    }
-    isHex(string) {
-        return isHex(string);
-    }
-    isBase32(string) {
-        return index$8.isBase32(string);
-    }
-    isBase58(string) {
-        return base58$1.isBase58(string);
-    }
-    fromBs32(encoded) {
-        return this.decode(index$8.decode(encoded));
-    }
-    fromBs58(encoded) {
-        return this.decode(fromBase58(encoded));
-    }
-    async toArray() {
-        const array = [];
-        for await (const value of this.encoded.values()) {
-            array.push(value);
-        }
-        return array;
-    }
-    fromString(string) {
-        const array = string.split(',');
-        const arrayLike = array.map(string => Number(string));
-        return this.decode(Uint8Array.from(arrayLike));
-    }
-    fromHex(string) {
-        return this.decode(fromHex(string));
-    }
-    fromArray(array) {
-        return this.decode(Uint8Array.from([...array]));
-    }
-    fromEncoded(encoded) {
-        return this.decode(encoded);
-    }
-    toString() {
-        if (!this.encoded)
-            this.encode();
-        return this.encoded.toString();
-    }
-    toHex() {
-        if (!this.encoded)
-            this.encode();
-        return toHex$1(this.encoded.toString().split(',').map(number => Number(number)));
-    }
-    /**
-     * @return {String} encoded
-     */
-    toBs32() {
-        if (!this.encoded)
-            this.encode();
-        return toBase32(this.encoded);
-    }
-    /**
-     * @return {String} encoded
-     */
-    toBs58() {
-        if (!this.encoded)
-            this.encode();
-        return toBase58(this.encoded);
-    }
+let BasicInterface$1 = class BasicInterface {
+    encoded;
+    decoded;
+    keys;
+    name;
+    #proto;
+    set proto(value) {
+        this.#proto = value;
+        this.keys = Object.keys(value);
+    }
+    get proto() {
+        return this.#proto;
+    }
+    decode(encoded) {
+        encoded = encoded || this.encoded;
+        return new Object();
+    }
+    encode(decoded) {
+        decoded = decoded || this.decoded;
+        return new Uint8Array();
+    }
+    // get Codec(): Codec {}
+    protoEncode(data) {
+        // check schema
+        return index$1.encode(this.proto, data);
+    }
+    protoDecode(data) {
+        // check schema
+        return index$1.decode(this.proto, data);
+    }
+    isHex(string) {
+        return isHex(string);
+    }
+    isBase32(string) {
+        return index$8.isBase32(string);
+    }
+    isBase58(string) {
+        return base58$1.isBase58(string);
+    }
+    fromBs32(encoded) {
+        return this.decode(index$8.decode(encoded));
+    }
+    fromBs58(encoded) {
+        return this.decode(fromBase58(encoded));
+    }
+    async toArray() {
+        const array = [];
+        for await (const value of this.encoded.values()) {
+            array.push(value);
+        }
+        return array;
+    }
+    fromString(string) {
+        const array = string.split(',');
+        const arrayLike = array.map(string => Number(string));
+        return this.decode(Uint8Array.from(arrayLike));
+    }
+    fromHex(string) {
+        return this.decode(fromHex(string));
+    }
+    fromArray(array) {
+        return this.decode(Uint8Array.from([...array]));
+    }
+    fromEncoded(encoded) {
+        return this.decode(encoded);
+    }
+    toString() {
+        if (!this.encoded)
+            this.encode();
+        return this.encoded.toString();
+    }
+    toHex() {
+        if (!this.encoded)
+            this.encode();
+        return toHex$1(this.encoded.toString().split(',').map(number => Number(number)));
+    }
+    /**
+     * @return {String} encoded
+     */
+    toBs32() {
+        if (!this.encoded)
+            this.encode();
+        return toBase32(this.encoded);
+    }
+    /**
+     * @return {String} encoded
+     */
+    toBs58() {
+        if (!this.encoded)
+            this.encode();
+        return toBase58(this.encoded);
+    }
 };
 
-let Codec$1 = class Codec extends BasicInterface$1 {
-    codecBuffer;
-    codec;
-    hashAlg;
-    constructor(buffer) {
-        super();
-        if (buffer) {
-            if (buffer instanceof Uint8Array) {
-                const codec = index$7.decode(buffer);
-                const name = this.getCodecName(codec);
-                if (name) {
-                    this.name = name;
-                    this.encoded = buffer;
-                    this.decode(buffer);
-                }
-                else {
-                    this.encode(Number(new TextDecoder().decode(buffer)));
-                }
-            }
-            else if (buffer instanceof ArrayBuffer) {
-                const codec = index$7.decode(buffer);
-                const name = this.getCodecName(codec);
-                if (name) {
-                    this.name = name;
-                    this.decode(buffer);
-                }
-                else {
-                    this.encode(Number(new TextDecoder().decode(new Uint8Array(buffer))));
-                }
-            }
-            else if (typeof buffer === 'string') {
-                if (utils$p.getCodec(buffer))
-                    this.fromName(buffer);
-                else if (this.isHex(buffer))
-                    this.fromHex(buffer);
-                else if (this.isBase32(buffer))
-                    this.fromBs32(buffer);
-                else if (this.isBase58(buffer))
-                    this.fromBs58(buffer);
-                else
-                    this.fromString(buffer);
-            }
-            if (!isNaN(buffer))
-                if (utils$p.getCodec(buffer))
-                    this.fromCodec(buffer);
-        }
-    }
-    fromEncoded(encoded) {
-        const codec = index$7.decode(encoded);
-        const name = this.getCodecName(codec);
-        this.name = name;
-        this.encoded = encoded;
-        return this.decode(encoded);
-    }
-    getCodec(name) {
-        return utils$p.getCodec(name);
-    }
-    getCodecName(codec) {
-        return utils$p.getCodecName(codec);
-    }
-    getHashAlg(name) {
-        return utils$p.getHashAlg(name);
-    }
-    fromCodec(codec) {
-        this.name = this.getCodecName(codec);
-        this.hashAlg = this.getHashAlg(this.name);
-        this.codec = this.getCodec(this.name);
-        this.codecBuffer = index$7.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);
-    }
-    decode(encoded) {
-        encoded = encoded || this.encoded;
-        const codec = index$7.decode(encoded);
-        this.fromCodec(codec);
-        return this.decoded;
-    }
-    encode(codec) {
-        codec = codec || this.codec;
-        this.encoded = index$7.encode(codec);
-        return this.encoded;
-    }
+let Codec$1 = class Codec extends BasicInterface$1 {
+    codecBuffer;
+    codec;
+    hashAlg;
+    constructor(buffer) {
+        super();
+        if (buffer) {
+            if (buffer instanceof Uint8Array) {
+                const codec = index$7.decode(buffer);
+                const name = this.getCodecName(codec);
+                if (name) {
+                    this.name = name;
+                    this.encoded = buffer;
+                    this.decode(buffer);
+                }
+                else {
+                    this.encode(Number(new TextDecoder().decode(buffer)));
+                }
+            }
+            else if (buffer instanceof ArrayBuffer) {
+                const codec = index$7.decode(new Uint8Array(buffer));
+                const name = this.getCodecName(codec);
+                if (name) {
+                    this.name = name;
+                    this.decode(buffer);
+                }
+                else {
+                    this.encode(Number(new TextDecoder().decode(new Uint8Array(buffer))));
+                }
+            }
+            else if (typeof buffer === 'string') {
+                if (utils$p.getCodec(buffer))
+                    this.fromName(buffer);
+                else if (this.isHex(buffer))
+                    this.fromHex(buffer);
+                else if (this.isBase32(buffer))
+                    this.fromBs32(buffer);
+                else if (this.isBase58(buffer))
+                    this.fromBs58(buffer);
+                else
+                    this.fromString(buffer);
+            }
+            if (!isNaN(buffer))
+                if (utils$p.getCodec(buffer))
+                    this.fromCodec(buffer);
+        }
+    }
+    fromEncoded(encoded) {
+        const codec = index$7.decode(encoded);
+        const name = this.getCodecName(codec);
+        this.name = name;
+        this.encoded = encoded;
+        return this.decode(encoded);
+    }
+    getCodec(name) {
+        return utils$p.getCodec(name);
+    }
+    getCodecName(codec) {
+        return utils$p.getCodecName(codec);
+    }
+    getHashAlg(name) {
+        return utils$p.getHashAlg(name);
+    }
+    fromCodec(codec) {
+        this.name = this.getCodecName(codec);
+        this.hashAlg = this.getHashAlg(this.name);
+        this.codec = this.getCodec(this.name);
+        this.codecBuffer = index$7.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);
+    }
+    decode(encoded) {
+        encoded = encoded || this.encoded;
+        const codec = index$7.decode(encoded);
+        this.fromCodec(codec);
+        return this.decoded;
+    }
+    encode(codec) {
+        codec = codec || this.codec;
+        this.encoded = index$7.encode(codec);
+        return this.encoded;
+    }
 };
 
-let CodecHash$1 = class CodecHash extends BasicInterface$1 {
-    constructor(buffer, options = {}) {
-        super();
-        if (options.name)
-            this.name = options.name;
-        else
-            this.name = 'disco-hash';
-        if (options.codecs)
-            this.codecs = options.codecs;
-        return this.init(buffer);
-    }
-    async init(uint8Array) {
-        if (uint8Array) {
-            if (uint8Array instanceof Uint8Array) {
-                this.discoCodec = new Codec$1(uint8Array, this.codecs);
-                const name = this.discoCodec.name;
-                if (name) {
-                    this.name = name;
-                    this.decode(uint8Array);
-                }
-                else {
-                    await this.encode(uint8Array);
-                }
-            }
-            if (typeof uint8Array === 'string') {
-                if (this.isHex(uint8Array))
-                    await this.fromHex(uint8Array);
-                if (this.isBase32(uint8Array))
-                    await this.fromBs32(uint8Array);
-                else if (this.isBase58(uint8Array))
-                    await this.fromBs58(uint8Array);
-                else
-                    throw new Error(`unsupported string ${uint8Array}`);
-            }
-            else if (typeof uint8Array === 'object')
-                await this.fromJSON(uint8Array);
-        }
-        return this;
-    }
-    get prefix() {
-        const length = this.length;
-        const uint8Array = new Uint8Array(length.length + this.discoCodec.codecBuffer.length);
-        uint8Array.set(length);
-        uint8Array.set(this.discoCodec.codecBuffer, length.length);
-        return uint8Array;
-    }
-    get length() {
-        return index$7.encode(this.size);
-    }
-    get buffer() {
-        return this.encoded;
-    }
-    get hash() {
-        return this.encoded;
-    }
-    fromJSON(json) {
-        return this.encode(Buffer.from(JSON.stringify(json)));
-    }
-    async encode(buffer, name) {
-        if (!this.name && name)
-            this.name = name;
-        if (!buffer)
-            buffer = this.buffer;
-        this.discoCodec = new Codec$1(this.name, this.codecs);
-        this.discoCodec.fromName(this.name);
-        let hashAlg = this.discoCodec.hashAlg;
-        const hashVariant = Number(hashAlg.split('-')[hashAlg.split('-').length - 1]);
-        if (hashAlg.includes('dbl')) {
-            hashAlg = hashAlg.replace('dbl-', '');
-            const hasher = await createKeccak(hashVariant);
-            await hasher.init();
-            hasher.update(buffer);
-            buffer = hasher.digest('binary');
-        }
-        const hasher = await createKeccak(hashVariant);
-        await hasher.init();
-        hasher.update(buffer);
-        this.digest = hasher.digest('binary');
-        this.size = this.digest.length;
-        this.codec = this.discoCodec.encode();
-        this.codec = this.discoCodec.codecBuffer;
-        const uint8Array = new Uint8Array(this.digest.length + this.prefix.length);
-        uint8Array.set(this.prefix);
-        uint8Array.set(this.digest, this.prefix.length);
-        this.encoded = uint8Array;
-        return this.encoded;
-    }
-    async validate(buffer) {
-        if (Buffer.isBuffer(buffer)) {
-            const codec = index$7.decode(buffer);
-            if (this.codecs[codec]) {
-                this.decode(buffer);
-            }
-            else {
-                await this.encode(buffer);
-            }
-        }
-        if (typeof buffer === 'string') {
-            if (this.isHex(buffer))
-                this.fromHex(buffer);
-            if (this.isBase32(buffer))
-                this.fromBs32(buffer);
-        }
-        if (typeof buffer === 'object')
-            this.fromJSON(buffer);
-    }
-    decode(buffer) {
-        this.encoded = buffer;
-        const codec = index$7.decode(buffer);
-        this.discoCodec = new Codec$1(codec, this.codecs);
-        // TODO: validate codec
-        buffer = buffer.slice(index$7.decode.bytes);
-        this.size = index$7.decode(buffer);
-        this.digest = buffer.slice(index$7.decode.bytes);
-        if (this.digest.length !== this.size) {
-            throw new Error(`hash length inconsistent: 0x${this.encoded.toString('hex')}`);
-        }
-        // const discoCodec = new Codec(codec, this.codecs)
-        this.name = this.discoCodec.name;
-        this.size = this.digest.length;
-        return {
-            codec: this.codec,
-            name: this.name,
-            size: this.size,
-            length: this.length,
-            digest: this.digest,
-        };
-    }
+let CodecHash$1 = class CodecHash extends BasicInterface$1 {
+    codec;
+    codecs;
+    digest;
+    size;
+    constructor(buffer, options) {
+        super();
+        if (options.name)
+            this.name = options.name;
+        else
+            this.name = 'disco-hash';
+        if (options.codecs)
+            this.codecs = options.codecs;
+        return this.init(buffer);
+    }
+    async init(uint8Array) {
+        if (uint8Array) {
+            if (uint8Array instanceof Uint8Array) {
+                this.codec = new Codec$1(uint8Array);
+                const name = this.codec.name;
+                if (name) {
+                    this.name = name;
+                    this.decode(uint8Array);
+                }
+                else {
+                    await this.encode(uint8Array);
+                }
+            }
+            if (typeof uint8Array === 'string') {
+                if (this.isHex(uint8Array))
+                    await this.fromHex(uint8Array);
+                if (this.isBase32(uint8Array))
+                    await this.fromBs32(uint8Array);
+                else if (this.isBase58(uint8Array))
+                    await this.fromBs58(uint8Array);
+                else
+                    throw new Error(`unsupported string ${uint8Array}`);
+            }
+            else if (typeof uint8Array === 'object')
+                await this.fromJSON(uint8Array);
+        }
+        return this;
+    }
+    get prefix() {
+        const length = this.length;
+        const uint8Array = new Uint8Array(length.length + this.codec.codecBuffer.length);
+        uint8Array.set(length);
+        uint8Array.set(this.codec.codecBuffer, length.length);
+        return uint8Array;
+    }
+    get length() {
+        return index$7.encode(this.size);
+    }
+    get buffer() {
+        return this.encoded;
+    }
+    get hash() {
+        return this.encoded;
+    }
+    fromJSON(json) {
+        return this.encode(new TextEncoder().encode(JSON.stringify(json)));
+    }
+    async encode(buffer, name) {
+        if (!this.name && name)
+            this.name = name;
+        if (!buffer)
+            buffer = this.buffer;
+        this.codec = new Codec$1(this.name);
+        this.codec.fromName(this.name);
+        let hashAlg = this.codec.hashAlg;
+        const hashVariant = Number(hashAlg.split('-')[hashAlg.split('-').length - 1]);
+        if (hashAlg.includes('dbl')) {
+            hashAlg = hashAlg.replace('dbl-', '');
+            const hasher = await createKeccak(hashVariant);
+            await hasher.init();
+            hasher.update(buffer);
+            buffer = hasher.digest('binary');
+        }
+        const hasher = await createKeccak(hashVariant);
+        await hasher.init();
+        hasher.update(buffer);
+        this.digest = hasher.digest('binary');
+        this.size = this.digest.length;
+        const uint8Array = new Uint8Array(this.digest.length + this.prefix.length);
+        uint8Array.set(this.prefix);
+        uint8Array.set(this.digest, this.prefix.length);
+        this.encoded = uint8Array;
+        return this.encoded;
+    }
+    async validate(buffer) {
+        if (Buffer.isBuffer(buffer)) {
+            const codec = index$7.decode(buffer);
+            if (this.codecs[codec]) {
+                this.decode(buffer);
+            }
+            else {
+                await this.encode(buffer);
+            }
+        }
+        if (typeof buffer === 'string') {
+            if (this.isHex(buffer))
+                this.fromHex(buffer);
+            if (this.isBase32(buffer))
+                this.fromBs32(buffer);
+        }
+        if (typeof buffer === 'object')
+            this.fromJSON(buffer);
+    }
+    decode(buffer) {
+        this.encoded = buffer;
+        const codec = index$7.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);
+        if (this.digest.length !== this.size) {
+            throw new Error(`hash length inconsistent: ${this.encoded.toString()}`);
+        }
+        // const codec = new Codec(codec, this.codecs)
+        this.name = this.codec.name;
+        this.size = this.digest.length;
+        return {
+            codec: this.codec,
+            name: this.name,
+            size: this.size,
+            length: this.length,
+            digest: this.digest,
+        };
+    }
 };
 
-let FormatInterface$1 = class FormatInterface extends BasicInterface$1 {
-    hashFormat;
-    init(buffer) {
-        if (buffer instanceof Uint8Array)
-            this.fromUint8Array(buffer);
-        else if (buffer instanceof ArrayBuffer)
-            this.fromArrayBuffer(buffer);
-        else if (buffer instanceof FormatInterface$1 && buffer?.name === this.name)
-            return buffer;
-        else if (typeof buffer === 'string') {
-            if (this.isHex(buffer))
-                this.fromHex(buffer);
-            else if (this.isBase58(buffer))
-                this.fromBs58(buffer);
-            else if (this.isBase32(buffer))
-                this.fromBs32(buffer);
-            else
-                this.fromString(buffer);
-        }
-        else {
-            this.create(buffer);
-        }
-        return this;
-    }
-    hasCodec() {
-        if (!this.encoded)
-            return false;
-        const codec = new Codec$1(this.encoded);
-        if (codec.name)
-            return true;
-    }
-    decode(encoded) {
-        encoded = encoded || this.encoded;
-        const codec = new Codec$1(this.encoded);
-        if (codec.codecBuffer) {
-            encoded = encoded.slice(codec.codecBuffer.length);
-            this.name = codec.name;
-            this.decoded = this.protoDecode(encoded);
-            // try {
-            //   this.decoded = JSON.parse(this.decoded)
-            // } catch {
-            // }
-        }
-        else {
-            throw new Error(`no codec found`);
-        }
-        return this.decoded;
-    }
-    encode(decoded) {
-        let encoded;
-        if (!decoded)
-            decoded = this.decoded;
-        const codec = new Codec$1(this.name);
-        if (decoded instanceof Uint8Array)
-            encoded = decoded;
-        else
-            encoded = this.protoEncode(decoded);
-        if (codec.codecBuffer) {
-            const uint8Array = new Uint8Array(encoded.length + codec.codecBuffer.length);
-            uint8Array.set(codec.codecBuffer);
-            uint8Array.set(encoded, codec.codecBuffer.length);
-            this.encoded = uint8Array;
-        }
-        else {
-            throw new Error(`invalid codec`);
-        }
-        return this.encoded;
-    }
-    /**
-     * @param {Buffer|String|Object} buffer - data - The data needed to create the desired message
-     * @param {Object} proto - {protoObject}
-     * @param {Object} options - {hashFormat, name}
-     */
-    constructor(buffer, proto, options) {
-        super();
-        this.proto = proto;
-        this.hashFormat = options?.hashFormat ? options.hashFormat : 'bs32';
-        if (options?.name)
-            this.name = options.name;
-        this.init(buffer);
-    }
-    /**
-     * @return {PeernetHash}
-     */
-    get peernetHash() {
-        return new CodecHash$1(this.decoded, { name: this.name });
-    }
-    /**
-     * @return {peernetHash}
-     */
-    async hash() {
-        const upper = this.hashFormat.charAt(0).toUpperCase();
-        const format = `${upper}${this.hashFormat.substring(1, this.hashFormat.length)}`;
-        return (await this.peernetHash)[`to${format}`]();
-    }
-    fromUint8Array(buffer) {
-        this.encoded = buffer;
-        return this.hasCodec() ? this.decode() : this.create(JSON.parse(new TextDecoder().decode(this.encoded)));
-    }
-    fromArrayBuffer(buffer) {
-        this.encoded = new Uint8Array(buffer, buffer.byteOffset, buffer.byteLength);
-        return this.hasCodec() ? this.decode() : this.create(JSON.parse(new TextDecoder().decode(this.encoded)));
-    }
-    /**
-     * @param {Object} data
-     */
-    create(data) {
-        const decoded = {};
-        if (this.keys?.length > 0) {
-            for (const key of this.keys) {
-                Object.defineProperties(decoded, {
-                    [key]: {
-                        enumerable: true,
-                        configurable: true,
-                        set: (value) => data[key],
-                        get: () => data[key]
-                    }
-                });
-            }
-            this.decoded = decoded;
-            return this.encode(decoded);
-        }
-    }
+let FormatInterface$1 = class FormatInterface extends BasicInterface$1 {
+    hashFormat;
+    init(buffer) {
+        if (buffer instanceof Uint8Array)
+            this.fromUint8Array(buffer);
+        else if (buffer instanceof ArrayBuffer)
+            this.fromArrayBuffer(buffer);
+        else if (buffer instanceof FormatInterface$1 && buffer?.name === this.name)
+            return buffer;
+        else if (typeof buffer === 'string') {
+            if (this.isHex(buffer))
+                this.fromHex(buffer);
+            else if (this.isBase58(buffer))
+                this.fromBs58(buffer);
+            else if (this.isBase32(buffer))
+                this.fromBs32(buffer);
+            else
+                this.fromString(buffer);
+        }
+        else {
+            this.create(buffer);
+        }
+        return this;
+    }
+    hasCodec() {
+        if (!this.encoded)
+            return false;
+        const codec = new Codec$1(this.encoded);
+        if (codec.name)
+            return true;
+    }
+    decode(encoded) {
+        encoded = encoded || this.encoded;
+        const codec = new Codec$1(this.encoded);
+        if (codec.codecBuffer) {
+            encoded = encoded.slice(codec.codecBuffer.length);
+            this.name = codec.name;
+            this.decoded = this.protoDecode(encoded);
+            // try {
+            //   this.decoded = JSON.parse(this.decoded)
+            // } catch {
+            // }
+        }
+        else {
+            throw new Error(`no codec found`);
+        }
+        return this.decoded;
+    }
+    encode(decoded) {
+        let encoded;
+        if (!decoded)
+            decoded = this.decoded;
+        const codec = new Codec$1(this.name);
+        if (decoded instanceof Uint8Array)
+            encoded = decoded;
+        else
+            encoded = this.protoEncode(decoded);
+        if (codec.codecBuffer) {
+            const uint8Array = new Uint8Array(encoded.length + codec.codecBuffer.length);
+            uint8Array.set(codec.codecBuffer);
+            uint8Array.set(encoded, codec.codecBuffer.length);
+            this.encoded = uint8Array;
+        }
+        else {
+            throw new Error(`invalid codec`);
+        }
+        return this.encoded;
+    }
+    /**
+     * @param {Buffer|String|Object} buffer - data - The data needed to create the desired message
+     * @param {Object} proto - {protoObject}
+     * @param {Object} options - {hashFormat, name}
+     */
+    constructor(buffer, proto, options) {
+        super();
+        this.proto = proto;
+        this.hashFormat = options?.hashFormat ? options.hashFormat : 'bs32';
+        if (options?.name)
+            this.name = options.name;
+        this.init(buffer);
+    }
+    /**
+     * @return {PeernetHash}
+     */
+    get peernetHash() {
+        return new CodecHash$1(this.decoded, { name: this.name });
+    }
+    /**
+     * @return {peernetHash}
+     */
+    async hash() {
+        const upper = this.hashFormat.charAt(0).toUpperCase();
+        const format = `${upper}${this.hashFormat.substring(1, this.hashFormat.length)}`;
+        return (await this.peernetHash)[`to${format}`]();
+    }
+    fromUint8Array(buffer) {
+        this.encoded = buffer;
+        return this.hasCodec() ? this.decode() : this.create(JSON.parse(new TextDecoder().decode(this.encoded)));
+    }
+    fromArrayBuffer(buffer) {
+        this.encoded = new Uint8Array(buffer, buffer.byteOffset, buffer.byteLength);
+        return this.hasCodec() ? this.decode() : this.create(JSON.parse(new TextDecoder().decode(this.encoded)));
+    }
+    /**
+     * @param {Object} data
+     */
+    create(data) {
+        const decoded = {};
+        if (this.keys?.length > 0) {
+            for (const key of this.keys) {
+                Object.defineProperties(decoded, {
+                    [key]: {
+                        enumerable: true,
+                        configurable: true,
+                        set: (value) => data[key],
+                        get: () => data[key]
+                    }
+                });
+            }
+            this.decoded = decoded;
+            return this.encode(decoded);
+        }
+    }
 };
-const FormatInterface = FormatInterface$1;
+const FormatInterface = FormatInterface$1;
 const Codec = Codec$1;
 
 const BufferToUint8Array = data => {
@@ -16059,6 +16061,15 @@ class Identity {
         return JSON.parse(accounts);
     }
     async load(password) {
+        if (password && password.includes('.txt')) {
+            const { readFile } = await import('fs/promises');
+            try {
+                password = (await readFile(password)).toString();
+            }
+            catch (error) {
+                console.error(error);
+            }
+        }
         if (!password) {
             const importee = await import('./src/prompts/password.js');
             password = await importee.default();
@@ -16071,7 +16082,7 @@ class Identity {
             globalThis.peernet.selectedAccount = new TextDecoder().decode(selected);
         }
         else {
-            const importee = await import(/* webpackChunkName: "generate-account" */ './index-601960df.js');
+            const importee = await import(/* webpackChunkName: "generate-account" */ './index-88c7fc2e.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));
@@ -16237,7 +16248,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-cf68bfb3.js');
+         } = await import(/* webpackChunkName: "messages" */ './messages-ba0fcf7e.js');
         /**
          * proto Object containing protos
          * @type {Object}
@@ -16286,7 +16297,7 @@ class Peernet {
          * @see DataHandler
          */
         pubsub.subscribe('peer:data', dataHandler);
-        const importee = await import('./client-471408b6.js');
+        const importee = await import('./client-cbaadd55.js');
         /**
          * @access public
          * @type {PeernetClient}
@@ -16730,4 +16741,4 @@ class Peernet {
 }
 globalThis.Peernet = Peernet;
 
-export { FormatInterface as F, LittlePubSub as L, MultiWallet as M, Peernet as P, base58$1 as b, index$6 as i, randombytes as r };
+export { FormatInterface as F, LittlePubSub as L, MultiWallet as M, Peernet as P, base58$1 as b, encrypt as e };

package/exports/browser/peernet.js

@@ -1,2 +1,2 @@
-export { P as default } from './peernet-e1e0a046.js';
+export { P as default } from './peernet-6a78293a.js';
 import './value-157ab062.js';

package/exports/peernet.js

@@ -319,6 +319,15 @@ class Identity {
         return JSON.parse(accounts);
     }
     async load(password) {
+        if (password && password.includes('.txt')) {
+            const { readFile } = await import('fs/promises');
+            try {
+                password = (await readFile(password)).toString();
+            }
+            catch (error) {
+                console.error(error);
+            }
+        }
         if (!password) {
             const importee = await import('./src/prompts/password.js');
             password = await importee.default();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/peernet",
-  "version": "1.0.3",
+  "version": "1.0.6",
   "description": "",
   "main": "src/peernet.js",
   "exports": {

package/src/identity.ts

@@ -23,7 +23,16 @@ export default class Identity {
     return JSON.parse(accounts)
   }
 
-  async load(password?: string): Promise<void> {    
+  async load(password?: string): Promise<void> {
+    if (password && password.includes('.txt')) {
+
+      const { readFile } = await import('fs/promises')
+      try {
+        password = (await readFile(password)).toString()
+      } catch (error) {
+        console.error(error)
+      }
+    } 
     if (!password) {
       const importee: { default: () => Promise<string> } = await import('./prompts/password.js')
       password = await importee.default()