@leofcoin/peernet 1.0.2 → 1.0.5

package/exports/peernet.js

@@ -4,989 +4,993 @@ import { Codec } from '@leofcoin/codec-format-interface';
 import LeofcoinStorage from '@leofcoin/storage';
 import { utils } from '@leofcoin/codecs';
 import MultiWallet from '@leofcoin/multi-wallet';
+import base58 from '@vandeurenglenn/base58';
+import { decrypt, encrypt } from '@leofcoin/identity-utils';
+import QrScanner from 'qr-scanner';
+import qrcode from 'qrcode';
+import { readFile } from 'fs/promises';
 
-const BufferToUint8Array = data => {
-    if (data.type === 'Buffer') {
-        data = new Uint8Array(data.data);
-    }
-    return data;
-};
-const protoFor = (message) => {
-    const codec = new Codec(message);
-    if (!codec.name)
-        throw new Error('proto not found');
-    const Proto = globalThis.peernet.protos[codec.name];
-    if (!Proto)
-        throw (new Error(`No proto defined for ${codec.name}`));
-    return new Proto(message);
-};
-/**
- * wether or not a peernet daemon is active
- * @return {Boolean}
- */
-const hasDaemon = async () => {
-    try {
-        let response = await fetch('http://127.0.0.1:1000/api/version');
-        response = await response.json();
-        return Boolean(response.client === '@peernet/api/http');
-    }
-    catch (e) {
-        return false;
-    }
-};
-const https = () => {
-    if (!globalThis.location)
-        return false;
-    return Boolean(globalThis.location.protocol === 'https:');
-};
-/**
- * Get current environment
- * @return {String} current environment [node, electron, browser]
- */
-const environment = () => {
-    const _navigator = globalThis.navigator;
-    if (!_navigator) {
-        return 'node';
-    }
-    else if (_navigator && /electron/i.test(_navigator.userAgent)) {
-        return 'electron';
-    }
-    else {
-        return 'browser';
-    }
-};
-/**
- * * Get current environment
- * @return {Object} result
- * @property {Boolean} reult.daemon whether or not daemon is running
- * @property {Boolean} reult.environment Current environment
- */
-const target = async () => {
-    let daemon = false;
-    if (!https())
-        daemon = await hasDaemon();
-    return { daemon, environment: environment() };
+const BufferToUint8Array = data => {
+    if (data.type === 'Buffer') {
+        data = new Uint8Array(data.data);
+    }
+    return data;
+};
+const protoFor = (message) => {
+    const codec = new Codec(message);
+    if (!codec.name)
+        throw new Error('proto not found');
+    const Proto = globalThis.peernet.protos[codec.name];
+    if (!Proto)
+        throw (new Error(`No proto defined for ${codec.name}`));
+    return new Proto(message);
+};
+/**
+ * wether or not a peernet daemon is active
+ * @return {Boolean}
+ */
+const hasDaemon = async () => {
+    try {
+        let response = await fetch('http://127.0.0.1:1000/api/version');
+        response = await response.json();
+        return Boolean(response.client === '@peernet/api/http');
+    }
+    catch (e) {
+        return false;
+    }
+};
+const https = () => {
+    if (!globalThis.location)
+        return false;
+    return Boolean(globalThis.location.protocol === 'https:');
+};
+/**
+ * Get current environment
+ * @return {String} current environment [node, electron, browser]
+ */
+const environment = () => {
+    const _navigator = globalThis.navigator;
+    if (!_navigator) {
+        return 'node';
+    }
+    else if (_navigator && /electron/i.test(_navigator.userAgent)) {
+        return 'electron';
+    }
+    else {
+        return 'browser';
+    }
+};
+/**
+ * * Get current environment
+ * @return {Object} result
+ * @property {Boolean} reult.daemon whether or not daemon is running
+ * @property {Boolean} reult.environment Current environment
+ */
+const target = async () => {
+    let daemon = false;
+    if (!https())
+        daemon = await hasDaemon();
+    return { daemon, environment: environment() };
 };
 
-class PeerDiscovery {
-    constructor(id) {
-        this.id = id;
-    }
-    _getPeerId(id) {
-        if (!peernet.peerMap || peernet.peerMap && peernet.peerMap.size === 0)
-            return false;
-        for (const entry of [...peernet.peerMap.entries()]) {
-            for (const _id of entry[1]) {
-                if (_id === id)
-                    return entry[0];
-            }
-        }
-    }
-    async discover(peer) {
-        let id = this._getPeerId(peer.id);
-        if (id)
-            return id;
-        const data = await new peernet.protos['peernet-peer']({ id: this.id });
-        const node = await peernet.prepareMessage(peer.id, data.encoded);
-        let response = await peer.request(node.encoded);
-        response = await protoFor(response);
-        response = await new peernet.protos['peernet-peer-response'](response.decoded.data);
-        id = response.decoded.id;
-        if (id === this.id)
-            return;
-        if (!peernet.peerMap.has(id))
-            peernet.peerMap.set(id, [peer.id]);
-        else {
-            const connections = peernet.peerMap.get(id);
-            if (connections.indexOf(peer.id) === -1) {
-                connections.push(peer.id);
-                peernet.peerMap.set(peer.id, connections);
-            }
-        }
-        return id;
-    }
-    async discoverHandler(message, peer) {
-        const { id, proto } = message;
-        // if (typeof message.data === 'string') message.data = Buffer.from(message.data)
-        if (proto.name === 'peernet-peer') {
-            const from = proto.decoded.id;
-            if (from === this.id)
-                return;
-            if (!peernet.peerMap.has(from))
-                peernet.peerMap.set(from, [peer.id]);
-            else {
-                const connections = peernet.peerMap.get(from);
-                if (connections.indexOf(peer.id) === -1) {
-                    connections.push(peer.id);
-                    peernet.peerMap.set(from, connections);
-                }
-            }
-            const data = await new peernet.protos['peernet-peer-response']({ id: this.id });
-            const node = await peernet.prepareMessage(from, data.encoded);
-            peer.write(Buffer.from(JSON.stringify({ id, data: node.encoded })));
-        }
-        else if (proto.name === 'peernet-peer-response') {
-            const from = proto.decoded.id;
-            if (from === this.id)
-                return;
-            if (!peernet.peerMap.has(from))
-                peernet.peerMap.set(from, [peer.id]);
-            else {
-                const connections = peernet.peerMap.get(from);
-                if (connections.indexOf(peer.id) === -1) {
-                    connections.push(peer.id);
-                    peernet.peerMap.set(from, connections);
-                }
-            }
-        }
-    }
+class PeerDiscovery {
+    constructor(id) {
+        this.id = id;
+    }
+    _getPeerId(id) {
+        if (!peernet.peerMap || peernet.peerMap && peernet.peerMap.size === 0)
+            return false;
+        for (const entry of [...peernet.peerMap.entries()]) {
+            for (const _id of entry[1]) {
+                if (_id === id)
+                    return entry[0];
+            }
+        }
+    }
+    async discover(peer) {
+        let id = this._getPeerId(peer.id);
+        if (id)
+            return id;
+        const data = await new peernet.protos['peernet-peer']({ id: this.id });
+        const node = await peernet.prepareMessage(peer.id, data.encoded);
+        let response = await peer.request(node.encoded);
+        response = await protoFor(response);
+        response = await new peernet.protos['peernet-peer-response'](response.decoded.data);
+        id = response.decoded.id;
+        if (id === this.id)
+            return;
+        if (!peernet.peerMap.has(id))
+            peernet.peerMap.set(id, [peer.id]);
+        else {
+            const connections = peernet.peerMap.get(id);
+            if (connections.indexOf(peer.id) === -1) {
+                connections.push(peer.id);
+                peernet.peerMap.set(peer.id, connections);
+            }
+        }
+        return id;
+    }
+    async discoverHandler(message, peer) {
+        const { id, proto } = message;
+        // if (typeof message.data === 'string') message.data = Buffer.from(message.data)
+        if (proto.name === 'peernet-peer') {
+            const from = proto.decoded.id;
+            if (from === this.id)
+                return;
+            if (!peernet.peerMap.has(from))
+                peernet.peerMap.set(from, [peer.id]);
+            else {
+                const connections = peernet.peerMap.get(from);
+                if (connections.indexOf(peer.id) === -1) {
+                    connections.push(peer.id);
+                    peernet.peerMap.set(from, connections);
+                }
+            }
+            const data = await new peernet.protos['peernet-peer-response']({ id: this.id });
+            const node = await peernet.prepareMessage(from, data.encoded);
+            peer.write(Buffer.from(JSON.stringify({ id, data: node.encoded })));
+        }
+        else if (proto.name === 'peernet-peer-response') {
+            const from = proto.decoded.id;
+            if (from === this.id)
+                return;
+            if (!peernet.peerMap.has(from))
+                peernet.peerMap.set(from, [peer.id]);
+            else {
+                const connections = peernet.peerMap.get(from);
+                if (connections.indexOf(peer.id) === -1) {
+                    connections.push(peer.id);
+                    peernet.peerMap.set(from, connections);
+                }
+            }
+        }
+    }
 }
 
-/**
- * Keep history of fetched address and ptr
- * @property {Object} address
- * @property {Object} ptr
- */
-const lastFetched = {
-    address: {
-        value: undefined,
-        timestamp: 0,
-    },
-    ptr: {
-        value: undefined,
-        timestamp: 0,
-    },
-};
-const getAddress = async () => {
-    const { address } = lastFetched;
-    const now = Math.round(new Date().getTime() / 1000);
-    if (now - address.timestamp > 1200000) {
-        address.value = await fetch('https://icanhazip.com/');
-        address.value = await address.value.text();
-        address.timestamp = Math.round(new Date().getTime() / 1000);
-        lastFetched.address = address;
-    }
-    return address.value;
-};
-const degreesToRadians = (degrees) => {
-    return degrees * Math.PI / 180;
-};
-const distanceInKmBetweenEarthCoordinates = (lat1, lon1, lat2, lon2) => {
-    const earthRadiusKm = 6371;
-    const dLat = degreesToRadians(lat2 - lat1);
-    const dLon = degreesToRadians(lon2 - lon1);
-    lat1 = degreesToRadians(lat1);
-    lat2 = degreesToRadians(lat2);
-    const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
-        Math.sin(dLon / 2) * Math.sin(dLon / 2) * Math.cos(lat1) * Math.cos(lat2);
-    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
-    return earthRadiusKm * c;
-};
-class DhtEarth {
-    /**
-     *
-     */
-    constructor() {
-        this.providerMap = new Map();
-    }
-    /**
-     * @param {Object} address
-     * @return {Object} {latitude: lat, longitude: lon}
-     */
-    async getCoordinates(address) {
-        // const {address} = parseAddress(provider)
-        const request = `https://whereis.leofcoin.org/?ip=${address}`;
-        let response = await fetch(request);
-        response = await response.json();
-        const { lat, lon } = response;
-        return { latitude: lat, longitude: lon };
-    }
-    /**
-     * @param {Object} peer
-     * @param {Object} provider
-     * @return {Object} {provider, distance}
-     */
-    async getDistance(peer, provider) {
-        const { latitude, longitude } = await this.getCoordinates(provider.address);
-        return { provider, distance: distanceInKmBetweenEarthCoordinates(peer.latitude, peer.longitude, latitude, longitude) };
-    }
-    /**
-     * @param {Array} providers
-     * @return {Object} closestPeer
-     */
-    async closestPeer(providers) {
-        let all = [];
-        const address = await getAddress();
-        const peerLoc = await this.getCoordinates(address);
-        for (const provider of providers) {
-            if (provider.address === '127.0.0.1')
-                all.push({ provider, distance: 0 });
-            else
-                all.push(this.getDistance(peerLoc, provider));
-        }
-        all = await Promise.all(all);
-        all = all.sort((previous, current) => previous.distance - current.distance);
-        return all[0].provider;
-    }
-    /**
-     * @param {String} hash
-     * @return {Array} providers
-     */
-    providersFor(hash) {
-        return this.providerMap.get(hash);
-    }
-    /**
-     * @param {String} address
-     * @param {String} hash
-     * @return {Array} providers
-     */
-    async addProvider(address, hash) {
-        let providers = [];
-        if (this.providerMap.has(hash))
-            providers = this.providerMap.get(hash);
-        providers = new Set([...providers, address]);
-        this.providerMap.set(hash, providers);
-        return providers;
-    }
+/**
+ * Keep history of fetched address and ptr
+ * @property {Object} address
+ * @property {Object} ptr
+ */
+const lastFetched = {
+    address: {
+        value: undefined,
+        timestamp: 0,
+    },
+    ptr: {
+        value: undefined,
+        timestamp: 0,
+    },
+};
+const getAddress = async () => {
+    const { address } = lastFetched;
+    const now = Math.round(new Date().getTime() / 1000);
+    if (now - address.timestamp > 1200000) {
+        address.value = await fetch('https://icanhazip.com/');
+        address.value = await address.value.text();
+        address.timestamp = Math.round(new Date().getTime() / 1000);
+        lastFetched.address = address;
+    }
+    return address.value;
+};
+const degreesToRadians = (degrees) => {
+    return degrees * Math.PI / 180;
+};
+const distanceInKmBetweenEarthCoordinates = (lat1, lon1, lat2, lon2) => {
+    const earthRadiusKm = 6371;
+    const dLat = degreesToRadians(lat2 - lat1);
+    const dLon = degreesToRadians(lon2 - lon1);
+    lat1 = degreesToRadians(lat1);
+    lat2 = degreesToRadians(lat2);
+    const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
+        Math.sin(dLon / 2) * Math.sin(dLon / 2) * Math.cos(lat1) * Math.cos(lat2);
+    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+    return earthRadiusKm * c;
+};
+class DhtEarth {
+    /**
+     *
+     */
+    constructor() {
+        this.providerMap = new Map();
+    }
+    /**
+     * @param {Object} address
+     * @return {Object} {latitude: lat, longitude: lon}
+     */
+    async getCoordinates(address) {
+        // const {address} = parseAddress(provider)
+        const request = `https://whereis.leofcoin.org/?ip=${address}`;
+        let response = await fetch(request);
+        response = await response.json();
+        const { lat, lon } = response;
+        return { latitude: lat, longitude: lon };
+    }
+    /**
+     * @param {Object} peer
+     * @param {Object} provider
+     * @return {Object} {provider, distance}
+     */
+    async getDistance(peer, provider) {
+        const { latitude, longitude } = await this.getCoordinates(provider.address);
+        return { provider, distance: distanceInKmBetweenEarthCoordinates(peer.latitude, peer.longitude, latitude, longitude) };
+    }
+    /**
+     * @param {Array} providers
+     * @return {Object} closestPeer
+     */
+    async closestPeer(providers) {
+        let all = [];
+        const address = await getAddress();
+        const peerLoc = await this.getCoordinates(address);
+        for (const provider of providers) {
+            if (provider.address === '127.0.0.1')
+                all.push({ provider, distance: 0 });
+            else
+                all.push(this.getDistance(peerLoc, provider));
+        }
+        all = await Promise.all(all);
+        all = all.sort((previous, current) => previous.distance - current.distance);
+        return all[0].provider;
+    }
+    /**
+     * @param {String} hash
+     * @return {Array} providers
+     */
+    providersFor(hash) {
+        return this.providerMap.get(hash);
+    }
+    /**
+     * @param {String} address
+     * @param {String} hash
+     * @return {Array} providers
+     */
+    async addProvider(address, hash) {
+        let providers = [];
+        if (this.providerMap.has(hash))
+            providers = this.providerMap.get(hash);
+        providers = new Set([...providers, address]);
+        this.providerMap.set(hash, providers);
+        return providers;
+    }
 }
 
-class MessageHandler {
-    constructor(network) {
-        this.network = network;
-    }
-    /**
-     * hash and sign message
-     *
-     * @param {object} message
-     * @param {Buffer} message.from peer id
-     * @param {Buffer} message.to peer id
-     * @param {string} message.data Peernet message
-     * (PeernetMessage excluded) encoded as a string
-     * @return message
-     */
-    async hashAndSignMessage(message) {
-        const hash = await message.peernetHash;
-        message.decoded.signature = globalThis.identity.sign(hash.buffer);
-        return message;
-    }
-    /**
-     * @param {String} from - peer id
-     * @param {String} to - peer id
-     * @param {String|PeernetMessage} data - data encoded message string
-     * or the messageNode itself
-     */
-    async prepareMessage(message) {
-        if (message.keys.includes('signature')) {
-            message = await this.hashAndSignMessage(message);
-        }
-        return message;
-    }
+class MessageHandler {
+    constructor(network) {
+        this.network = network;
+    }
+    /**
+     * hash and sign message
+     *
+     * @param {object} message
+     * @param {Buffer} message.from peer id
+     * @param {Buffer} message.to peer id
+     * @param {string} message.data Peernet message
+     * (PeernetMessage excluded) encoded as a string
+     * @return message
+     */
+    async hashAndSignMessage(message) {
+        const hash = await message.peernetHash;
+        message.decoded.signature = globalThis.identity.sign(hash.buffer);
+        return message;
+    }
+    /**
+     * @param {String} from - peer id
+     * @param {String} to - peer id
+     * @param {String|PeernetMessage} data - data encoded message string
+     * or the messageNode itself
+     */
+    async prepareMessage(message) {
+        if (message.keys.includes('signature')) {
+            message = await this.hashAndSignMessage(message);
+        }
+        return message;
+    }
 }
 
-const dataHandler = async (message) => {
-    if (!message)
-        return;
-    const { data, id, from } = message;
-    const proto = await protoFor(data);
-    peernet._protoHandler({ id, proto }, peernet.client.connections[from], from);
+const dataHandler = async (message) => {
+    if (!message)
+        return;
+    const { data, id, from } = message;
+    const proto = await protoFor(data);
+    peernet._protoHandler({ id, proto }, peernet.client.connections[from], from);
 };
 
-const dhtError = (proto) => {
-    const text = `Received proto ${proto.name} expected peernet-dht-response`;
-    return new Error(`Routing error: ${text}`);
-};
-const nothingFoundError = (hash) => {
-    return new Error(`nothing found for ${hash}`);
+const dhtError = (proto) => {
+    const text = `Received proto ${proto.name} expected peernet-dht-response`;
+    return new Error(`Routing error: ${text}`);
+};
+const nothingFoundError = (hash) => {
+    return new Error(`nothing found for ${hash}`);
 };
 
-class Identity {
-    #wallet;
-    network;
-    id;
-    constructor(network) {
-        this.network = network;
-    }
-    get accounts() {
-        return this.getAccounts();
-    }
-    async getAccounts() {
-        let accounts = await globalThis.walletStore.get('accounts');
-        accounts = new TextDecoder().decode(accounts);
-        return JSON.parse(accounts);
-    }
-    async load(password) {
-        if (!password) {
-            const importee = await import('./src/prompts/password.js');
-            password = await importee.default();
-        }
-        const accountExists = await globalThis.accountStore.has('public');
-        if (accountExists) {
-            const pub = await globalThis.accountStore.get('public');
-            this.id = JSON.parse(new TextDecoder().decode(pub)).walletId;
-            const selected = await globalThis.walletStore.get('selected-account');
-            globalThis.peernet.selectedAccount = new TextDecoder().decode(selected);
-        }
-        else {
-            const importee = await import(/* webpackChunkName: "generate-account" */ '@leofcoin/generate-account');
-            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));
-            await globalThis.walletStore.put('accounts', JSON.stringify(accounts));
-            await globalThis.walletStore.put('selected-account', accounts[0][1]);
-            await globalThis.walletStore.put('identity', JSON.stringify(identity));
-            globalThis.peernet.selectedAccount = accounts[0][1];
-            this.id = identity.walletId;
-        }
-        const identity = JSON.parse(new TextDecoder().decode(await globalThis.walletStore.get('identity')));
-        this.#wallet = new MultiWallet(this.network);
-        await this.#wallet.recover(identity.mnemonic, password, this.network);
-    }
-    sign(hash) {
-        return this.#wallet.sign(hash.subarray(0, 32));
-    }
-    async export(password) {
-        if (!password)
-            throw new Error('IdentityExportError: password required');
-        const identity = JSON.parse(new TextDecoder().decode(await globalThis.walletStore.get('identity')));
-        this.#wallet = new MultiWallet(this.network);
-        await this.#wallet.recover(identity.mnemonic, password, this.network);
-        return this.#wallet.toMultiWif();
-    }
-    async import(multiWIF) {
-        this.#wallet = new MultiWallet(this.network);
-        await this.#wallet.fromMultiWif(multiWIF);
-    }
-    async unlock({ key, iv, cipher }) {
-    }
-    /**
-     * Lock current wallet or import wallet using a MultiWIF and lock
-     *
-     * @param password
-     * @param multiWIF
-     */
-    async lock(password, multiWIF) {
-    }
+class Identity {
+    #wallet;
+    network;
+    id;
+    constructor(network) {
+        this.network = network;
+    }
+    get accounts() {
+        return this.getAccounts();
+    }
+    async getAccounts() {
+        let accounts = await globalThis.walletStore.get('accounts');
+        accounts = new TextDecoder().decode(accounts);
+        return JSON.parse(accounts);
+    }
+    async load(password) {
+        if (password && password.includes('.txt'))
+            password = (await readFile(password)).toString();
+        if (!password) {
+            const importee = await import('./src/prompts/password.js');
+            password = await importee.default();
+        }
+        const accountExists = await globalThis.accountStore.has('public');
+        if (accountExists) {
+            const pub = await globalThis.accountStore.get('public');
+            this.id = JSON.parse(new TextDecoder().decode(pub)).walletId;
+            const selected = await globalThis.walletStore.get('selected-account');
+            globalThis.peernet.selectedAccount = new TextDecoder().decode(selected);
+        }
+        else {
+            const importee = await import(/* webpackChunkName: "generate-account" */ '@leofcoin/generate-account');
+            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));
+            await globalThis.walletStore.put('accounts', JSON.stringify(accounts));
+            await globalThis.walletStore.put('selected-account', accounts[0][1]);
+            await globalThis.walletStore.put('identity', JSON.stringify(identity));
+            globalThis.peernet.selectedAccount = accounts[0][1];
+            this.id = identity.walletId;
+        }
+        const identity = JSON.parse(new TextDecoder().decode(await globalThis.walletStore.get('identity')));
+        this.#wallet = new MultiWallet(this.network);
+        const multiWIF = await decrypt(password, base58.decode(identity.multiWIF));
+        await this.#wallet.fromMultiWif(multiWIF);
+    }
+    sign(hash) {
+        return this.#wallet.sign(hash.subarray(0, 32));
+    }
+    async export(password) {
+        const multiWIF = this.#wallet.toMultiWif();
+        const encypted = await encrypt(password, multiWIF);
+        return base58.encode(encypted);
+    }
+    async import(password, encrypted) {
+        this.#wallet = new MultiWallet(this.network);
+        const decrypted = await decrypt(password, base58.decode(encrypted));
+        await this.#wallet.fromMultiWif(decrypted);
+    }
+    async exportQR(password) {
+        const exported = await this.export(password);
+        return globalThis.navigator ? await qrcode.toDataURL(exported) : await qrcode.toString(exported, { type: 'terminal' });
+    }
+    async importQR(image, password) {
+        const multiWIF = QrScanner.scanImage(image);
+        return this.import(password, multiWIF);
+    }
 }
 
-globalThis.LeofcoinStorage = LeofcoinStorage;
-globalThis.leofcoin = globalThis.leofcoin || {};
-globalThis.pubsub = globalThis.pubsub || new PubSub();
-globalThis.globalSub = globalThis.globalSub || new PubSub(true);
-/**
- * @access public
- * @example
- * const peernet = new Peernet();
- */
-class Peernet {
-    identity;
-    stores = [];
-    /**
-     * @type {Object}
-     * @property {Object} peer Instance of Peer
-     */
-    dht = new DhtEarth();
-    /** @leofcoin/peernet-swarm/client */
-    client;
-    network;
-    stars;
-    networkVersion;
-    bw;
-    /**
-     * @access public
-     * @param {Object} options
-     * @param {String} options.network - desired network
-     * @param {String} options.stars - star list for selected network (these should match, don't mix networks)
-     * @param {String} options.root - path to root directory
-     * @param {String} options.storePrefix - prefix for datatores (lfc)
-     *
-     * @return {Promise} instance of Peernet
-     *
-     * @example
-     * const peernet = new Peernet({network: 'leofcoin', root: '.leofcoin'});
-     */
-    constructor(options, password) {
-        /**
-         * @property {String} network - current network
-         */
-        this.network = options.network || 'leofcoin';
-        this.stars = options.stars;
-        const parts = this.network.split(':');
-        this.networkVersion = options.networkVersion || parts.length > 1 ? parts[1] : 'mainnet';
-        if (!options.storePrefix)
-            options.storePrefix = 'lfc';
-        if (!options.port)
-            options.port = 2000;
-        if (!options.root) {
-            parts[1] ? options.root = `.${parts[0]}/${parts[1]}` : options.root = `.${this.network}`;
-        }
-        globalThis.peernet = this;
-        this.bw = {
-            up: 0,
-            down: 0,
-        };
-        return this._init(options, password);
-    }
-    get id() {
-        return this.identity.id;
-    }
-    get accounts() {
-        return this.identity.accounts;
-    }
-    get defaultStores() {
-        return ['account', 'wallet', 'block', 'transaction', 'chain', 'data', 'message'];
-    }
-    addProto(name, proto) {
-        if (!globalThis.peernet.protos[name])
-            globalThis.peernet.protos[name] = proto;
-    }
-    addCodec(codec) {
-        return utils.addCodec(codec);
-    }
-    async addStore(name, prefix, root, isPrivate = true) {
-        if (name === 'block' || name === 'transaction' || name === 'chain' ||
-            name === 'data' || name === 'message')
-            isPrivate = false;
-        let Storage;
-        this.hasDaemon ? Storage = LeofcoinStorageClient : Storage = LeofcoinStorage;
-        if (!globalThis[`${name}Store`]) {
-            globalThis[`${name}Store`] = new Storage(name, root);
-            await globalThis[`${name}Store`].init();
-        }
-        globalThis[`${name}Store`].private = isPrivate;
-        if (!isPrivate)
-            this.stores.push(name);
-    }
-    /**
-     * @see MessageHandler
-     */
-    prepareMessage(data) {
-        return this._messageHandler.prepareMessage(data);
-    }
-    /**
-     * @access public
-     *
-     * @return {Array} peerId
-     */
-    get peers() {
-        return Object.keys(this.client.connections);
-    }
-    get connections() {
-        return Object.values(this.client.connections);
-    }
-    get peerEntries() {
-        return Object.entries(this.client.connections);
-    }
-    /**
-     * @return {String} id - peerId
-     */
-    getConnection(id) {
-        return this.client.connections[id];
-    }
-    /**
-     * @private
-     *
-     * @param {Object} options
-     * @param {String} options.root - path to root directory
-     *
-     * @return {Promise} instance of Peernet
-     */
-    async _init(options, password) {
-        this.requestProtos = {};
-        this.storePrefix = options.storePrefix;
-        this.root = options.root;
-        const { RequestMessage, ResponseMessage, PeerMessage, PeerMessageResponse, PeernetMessage, DHTMessage, DHTMessageResponse, DataMessage, DataMessageResponse, PsMessage, ChatMessage, PeernetFile
-        // FolderMessageResponse
-         } = await import(/* webpackChunkName: "messages" */ './messages-75fe56a4.js');
-        /**
-         * proto Object containing protos
-         * @type {Object}
-         * @property {PeernetMessage} protos[peernet-message] messageNode
-         * @property {DHTMessage} protos[peernet-dht] messageNode
-         * @property {DHTMessageResponse} protos[peernet-dht-response] messageNode
-         * @property {DataMessage} protos[peernet-data] messageNode
-         * @property {DataMessageResponse} protos[peernet-data-response] messageNode
-         */
-        globalThis.peernet.protos = {
-            'peernet-request': RequestMessage,
-            'peernet-response': ResponseMessage,
-            'peernet-peer': PeerMessage,
-            'peernet-peer-response': PeerMessageResponse,
-            'peernet-message': PeernetMessage,
-            'peernet-dht': DHTMessage,
-            'peernet-dht-response': DHTMessageResponse,
-            'peernet-data': DataMessage,
-            'peernet-data-response': DataMessageResponse,
-            'peernet-ps': PsMessage,
-            'chat-message': ChatMessage,
-            'peernet-file': PeernetFile
-        };
-        this._messageHandler = new MessageHandler(this.network);
-        const { daemon, environment } = await target();
-        this.hasDaemon = daemon;
-        for (const store of this.defaultStores) {
-            await this.addStore(store, options.storePrefix, options.root);
-        }
-        this.identity = new Identity(this.network);
-        await this.identity.load(password);
-        this._peerHandler = new PeerDiscovery(this.id);
-        this.peerId = this.id;
-        pubsub.subscribe('peer:connected', async (peer) => {
-            // console.log(peer);
-            // console.log({connected: peer.id, as: this._getPeerId(peer.id) });
-            // peer.on('peernet.data', async (message) => {
-            //   const id = message.id
-            //   message = new PeernetMessage(Buffer.from(message.data.data))
-            //   const proto = protoFor(message.decoded.data)
-            //   this._protoHandler({id, proto}, peer)
-            // })
-        });
-        /**
-         * converts data -> message -> proto
-         * @see DataHandler
-         */
-        pubsub.subscribe('peer:data', dataHandler);
-        const importee = await import('@leofcoin/peernet-swarm/client');
-        /**
-         * @access public
-         * @type {PeernetClient}
-         */
-        this.client = new importee.default(this.id, this.networkVersion, this.stars);
-        if (globalThis.navigator) {
-            globalThis.addEventListener('beforeunload', async () => this.client.close());
-        }
-        else {
-            process.on('SIGTERM', async () => {
-                process.stdin.resume();
-                await this.client.close();
-                process.exit();
-            });
-        }
-        return this;
-    }
-    addRequestHandler(name, method) {
-        this.requestProtos[name] = method;
-    }
-    sendMessage(peer, id, data) {
-        if (peer.readyState === 'open') {
-            peer.send(data, id);
-            this.bw.up += data.length;
-        }
-        else if (peer.readyState === 'closed') ;
-    }
-    async handleDHT(peer, id, proto) {
-        let { hash, store } = proto.decoded;
-        let has;
-        if (store) {
-            store = globalThis[`${store}Store`];
-            has = store.private ? false : await store.has(hash);
-        }
-        else {
-            has = await this.has(hash);
-        }
-        const data = await new globalThis.peernet.protos['peernet-dht-response']({ hash, has });
-        const node = await this.prepareMessage(data);
-        this.sendMessage(peer, id, node.encoded);
-    }
-    async handleData(peer, id, proto) {
-        let { hash, store } = proto.decoded;
-        let data;
-        store = globalThis[`${store}Store`] || await this.whichStore([...this.stores], hash);
-        if (store && !store.private) {
-            data = await store.get(hash);
-            if (data) {
-                data = await new globalThis.peernet.protos['peernet-data-response']({ hash, data });
-                const node = await this.prepareMessage(data);
-                this.sendMessage(peer, id, node.encoded);
-            }
-        }
-    }
-    async handleRequest(peer, id, proto) {
-        const method = this.requestProtos[proto.decoded.request];
-        if (method) {
-            const data = await method();
-            const node = await this.prepareMessage(data);
-            this.sendMessage(peer, id, node.encoded);
-        }
-    }
-    /**
-     * @private
-     *
-     * @param {Buffer} message - peernet message
-     * @param {PeernetPeer} peer - peernet peer
-     */
-    async _protoHandler(message, peer, from) {
-        const { id, proto } = message;
-        this.bw.down += proto.encoded.length;
-        switch (proto.name) {
-            case 'peernet-dht': {
-                this.handleDHT(peer, id, proto);
-                break;
-            }
-            case 'peernet-data': {
-                this.handleData(peer, id, proto);
-                break;
-            }
-            case 'peernet-request': {
-                this.handleRequest(peer, id, proto);
-            }
-            case 'peernet-ps': {
-                if (peer.peerId !== this.id)
-                    globalSub.publish(proto.decoded.topic, proto.decoded.data);
-            }
-        }
-    }
-    /**
-     * performs a walk and resolves first encounter
-     *
-     * @param {String} hash
-     */
-    async walk(hash) {
-        if (!hash)
-            throw new Error('hash expected, received undefined');
-        const data = await new globalThis.peernet.protos['peernet-dht']({ hash });
-        this.client.id;
-        const walk = async (peer) => {
-            const node = await this.prepareMessage(data);
-            let result = await peer.request(node.encoded);
-            result = new Uint8Array(Object.values(result));
-            const proto = await protoFor(result);
-            if (proto.name !== 'peernet-dht-response')
-                throw dhtError(proto.name);
-            // TODO: give ip and port (just used for location)
-            if (!peer.connection.remoteAddress || !peer.connection.localAddress) {
-                peer.connection.remoteFamily = 'ipv4';
-                peer.connection.remoteAddress = '127.0.0.1';
-                peer.connection.remotePort = '0000';
-            }
-            const peerInfo = {
-                family: peer.connection.remoteFamily || peer.connection.localFamily,
-                address: peer.connection.remoteAddress || peer.connection.localAddress,
-                port: peer.connection.remotePort || peer.connection.localPort,
-                id: peer.peerId,
-            };
-            if (proto.decoded.has)
-                this.dht.addProvider(peerInfo, proto.decoded.hash);
-        };
-        let walks = [];
-        for (const peer of this.connections) {
-            if (peer.peerId !== this.id) {
-                walks.push(walk(peer));
-            }
-        }
-        return Promise.all(walks);
-    }
-    /**
-     * Override DHT behavior, try's finding the content three times
-     *
-     * @param {String} hash
-     */
-    async providersFor(hash) {
-        let providers = await this.dht.providersFor(hash);
-        // walk the network to find a provider
-        if (!providers || providers.length === 0) {
-            await this.walk(hash);
-            providers = await this.dht.providersFor(hash);
-            // second walk the network to find a provider
-            if (!providers || providers.length === 0) {
-                await this.walk(hash);
-                providers = await this.dht.providersFor(hash);
-            }
-            // last walk
-            if (!providers || providers.length === 0) {
-                await this.walk(hash);
-                providers = await this.dht.providersFor(hash);
-            }
-        }
-        // undefined if no providers given
-        return providers;
-    }
-    get block() {
-        return {
-            get: async (hash) => {
-                const data = await blockStore.has(hash);
-                if (data)
-                    return blockStore.get(hash);
-                return this.requestData(hash, 'block');
-            },
-            put: async (hash, data) => {
-                if (await blockStore.has(hash))
-                    return;
-                return await blockStore.put(hash, data);
-            },
-            has: async (hash) => await blockStore.has(hash, 'block'),
-        };
-    }
-    get transaction() {
-        return {
-            get: async (hash) => {
-                const data = await transactionStore.has(hash);
-                if (data)
-                    return await transactionStore.get(hash);
-                return this.requestData(hash, 'transaction');
-            },
-            put: async (hash, data) => {
-                if (await transactionStore.has(hash))
-                    return;
-                return await transactionStore.put(hash, data);
-            },
-            has: async (hash) => await transactionStore.has(hash),
-        };
-    }
-    async requestData(hash, store) {
-        const providers = await this.providersFor(hash);
-        if (!providers || providers.size === 0)
-            throw nothingFoundError(hash);
-        debug(`found ${providers.size} provider(s) for ${hash}`);
-        // get closest peer on earth
-        const closestPeer = await this.dht.closestPeer(providers);
-        // get peer instance by id
-        if (!closestPeer || !closestPeer.id)
-            return this.requestData(hash, store?.name || store);
-        const id = closestPeer.id;
-        if (this.connections) {
-            let closest = this.connections.filter((peer) => {
-                if (peer.peerId === id)
-                    return peer;
-            });
-            let data = await new globalThis.peernet.protos['peernet-data']({ hash, store: store?.name || store });
-            const node = await this.prepareMessage(data);
-            if (closest[0])
-                data = await closest[0].request(node.encoded);
-            else {
-                closest = this.connections.filter((peer) => {
-                    if (peer.peerId === id)
-                        return peer;
-                });
-                if (closest[0])
-                    data = await closest[0].request(node.encoded);
-            }
-            const proto = await protoFor(data);
-            // TODO: store data automaticly or not
-            return BufferToUint8Array(proto.decoded.data);
-            // this.put(hash, proto.decoded.data)
-        }
-        return;
-    }
-    get message() {
-        return {
-            /**
-             * Get content for given message hash
-             *
-             * @param {String} hash
-             */
-            get: async (hash) => {
-                debug(`get message ${hash}`);
-                const message = await messageStore.has(hash);
-                if (message)
-                    return await messageStore.get(hash);
-                return this.requestData(hash, 'message');
-            },
-            /**
-             * put message content
-             *
-             * @param {String} hash
-             * @param {Buffer} message
-             */
-            put: async (hash, message) => await messageStore.put(hash, message),
-            /**
-             * @param {String} hash
-             * @return {Boolean}
-             */
-            has: async (hash) => await messageStore.has(hash),
-        };
-    }
-    get data() {
-        return {
-            /**
-             * Get content for given data hash
-             *
-             * @param {String} hash
-             */
-            get: async (hash) => {
-                debug(`get data ${hash}`);
-                const data = await dataStore.has(hash);
-                if (data)
-                    return await dataStore.get(hash);
-                return this.requestData(hash, 'data');
-            },
-            /**
-             * put data content
-             *
-             * @param {String} hash
-             * @param {Buffer} data
-             */
-            put: async (hash, data) => await dataStore.put(hash, data),
-            /**
-             * @param {String} hash
-             * @return {Boolean}
-             */
-            has: async (hash) => await dataStore.has(hash),
-        };
-    }
-    get folder() {
-        return {
-            /**
-             * Get content for given data hash
-             *
-             * @param {String} hash
-             */
-            get: async (hash) => {
-                debug(`get data ${hash}`);
-                const data = await dataStore.has(hash);
-                if (data)
-                    return await dataStore.get(hash);
-                return this.requestData(hash, 'data');
-            },
-            /**
-             * put data content
-             *
-             * @param {String} hash
-             * @param {Buffer} data
-             */
-            put: async (hash, data) => await dataStore.put(hash, data),
-            /**
-             * @param {String} hash
-             * @return {Boolean}
-             */
-            has: async (hash) => await dataStore.has(hash),
-        };
-    }
-    async addFolder(files) {
-        const links = [];
-        for (const file of files) {
-            const fileNode = await new globalThis.peernet.protos['peernet-file'](file);
-            const hash = await fileNode.hash;
-            await dataStore.put(hash, fileNode.encoded);
-            links.push({ hash, path: file.path });
-        }
-        const node = await new globalThis.peernet.protos['peernet-file']({ path: '/', links });
-        const hash = await node.hash;
-        await dataStore.put(hash, node.encoded);
-        return hash;
-    }
-    async ls(hash, options) {
-        let data;
-        const has = await dataStore.has(hash);
-        data = has ? await dataStore.get(hash) : await this.requestData(hash, 'data');
-        const node = await new peernet.protos['peernet-file'](data);
-        await node.decode();
-        console.log(data);
-        const paths = [];
-        if (node.decoded?.links.length === 0)
-            throw new Error(`${hash} is a file`);
-        for (const { path, hash } of node.decoded.links) {
-            paths.push({ path, hash });
-        }
-        if (options?.pin)
-            await dataStore.put(hash, node.encoded);
-        return paths;
-    }
-    async cat(hash, options) {
-        let data;
-        const has = await dataStore.has(hash);
-        data = has ? await dataStore.get(hash) : await this.requestData(hash, 'data');
-        const node = await new peernet.protos['peernet-file'](data);
-        if (node.decoded?.links.length > 0)
-            throw new Error(`${hash} is a directory`);
-        if (options?.pin)
-            await dataStore.put(hash, node.encoded);
-        return node.decoded.content;
-    }
-    /**
-     * goes trough given stores and tries to find data for given hash
-     * @param {Array} stores
-     * @param {string} hash
-     */
-    async whichStore(stores, hash) {
-        let store = stores.pop();
-        store = globalThis[`${store}Store`];
-        if (store) {
-            const has = await store.has(hash);
-            if (has)
-                return store;
-            if (stores.length > 0)
-                return this.whichStore(stores, hash);
-        }
-        else
-            return;
-    }
-    /**
-     * Get content for given hash
-     *
-     * @param {String} hash - the hash of the wanted data
-     * @param {String} store - storeName to access
-     */
-    async get(hash, store) {
-        debug(`get ${hash}`);
-        let data;
-        if (store)
-            store = globalThis[`${store}Store`];
-        if (!store)
-            store = await this.whichStore([...this.stores], hash);
-        if (store && await store.has(hash))
-            data = await store.get(hash);
-        if (data)
-            return data;
-        return this.requestData(hash, store?.name || store);
-    }
-    /**
-     * put content
-     *
-     * @param {String} hash
-     * @param {Buffer} data
-     * @param {String} store - storeName to access
-     */
-    async put(hash, data, store = 'data') {
-        store = globalThis[`${store}Store`];
-        return store.put(hash, data);
-    }
-    /**
-     * @param {String} hash
-     * @return {Boolean}
-     */
-    async has(hash) {
-        const store = await this.whichStore([...this.stores], hash);
-        if (store) {
-            return store.private ? false : true;
-        }
-        return false;
-    }
-    /**
-     *
-     * @param {String} topic
-     * @param {String|Object|Array|Boolean|Buffer} data
-     */
-    async publish(topic, data) {
-        // globalSub.publish(topic, data)
-        const id = Math.random().toString(36).slice(-12);
-        data = await new globalThis.peernet.protos['peernet-ps']({ data, topic });
-        for (const peer of this.connections) {
-            if (peer.peerId !== this.peerId) {
-                const node = await this.prepareMessage(data);
-                this.sendMessage(peer, id, node.encoded);
-            }
-            // TODO: if peer subscribed
-        }
-    }
-    createHash(data, name) {
-        return new CodeHash(data, { name });
-    }
-    /**
-     *
-     * @param {String} topic
-     * @param {Method} cb
-     */
-    async subscribe(topic, callback) {
-        // TODO: if peer subscribed
-        globalSub.subscribe(topic, callback);
-    }
-    async removePeer(peer) {
-        return this.client.removePeer(peer);
-    }
-    get Buffer() {
-        return Buffer;
-    }
-}
+globalThis.LeofcoinStorage = LeofcoinStorage;
+globalThis.leofcoin = globalThis.leofcoin || {};
+globalThis.pubsub = globalThis.pubsub || new PubSub();
+globalThis.globalSub = globalThis.globalSub || new PubSub(true);
+/**
+ * @access public
+ * @example
+ * const peernet = new Peernet();
+ */
+class Peernet {
+    identity;
+    stores = [];
+    /**
+     * @type {Object}
+     * @property {Object} peer Instance of Peer
+     */
+    dht = new DhtEarth();
+    /** @leofcoin/peernet-swarm/client */
+    client;
+    network;
+    stars;
+    networkVersion;
+    bw;
+    /**
+     * @access public
+     * @param {Object} options
+     * @param {String} options.network - desired network
+     * @param {String} options.stars - star list for selected network (these should match, don't mix networks)
+     * @param {String} options.root - path to root directory
+     * @param {String} options.storePrefix - prefix for datatores (lfc)
+     *
+     * @return {Promise} instance of Peernet
+     *
+     * @example
+     * const peernet = new Peernet({network: 'leofcoin', root: '.leofcoin'});
+     */
+    constructor(options, password) {
+        /**
+         * @property {String} network - current network
+         */
+        this.network = options.network || 'leofcoin';
+        this.stars = options.stars;
+        const parts = this.network.split(':');
+        this.networkVersion = options.networkVersion || parts.length > 1 ? parts[1] : 'mainnet';
+        if (!options.storePrefix)
+            options.storePrefix = 'lfc';
+        if (!options.port)
+            options.port = 2000;
+        if (!options.root) {
+            parts[1] ? options.root = `.${parts[0]}/${parts[1]}` : options.root = `.${this.network}`;
+        }
+        globalThis.peernet = this;
+        this.bw = {
+            up: 0,
+            down: 0,
+        };
+        return this._init(options, password);
+    }
+    get id() {
+        return this.identity.id;
+    }
+    get accounts() {
+        return this.identity.accounts;
+    }
+    get defaultStores() {
+        return ['account', 'wallet', 'block', 'transaction', 'chain', 'data', 'message'];
+    }
+    addProto(name, proto) {
+        if (!globalThis.peernet.protos[name])
+            globalThis.peernet.protos[name] = proto;
+    }
+    addCodec(codec) {
+        return utils.addCodec(codec);
+    }
+    async addStore(name, prefix, root, isPrivate = true) {
+        if (name === 'block' || name === 'transaction' || name === 'chain' ||
+            name === 'data' || name === 'message')
+            isPrivate = false;
+        let Storage;
+        this.hasDaemon ? Storage = LeofcoinStorageClient : Storage = LeofcoinStorage;
+        if (!globalThis[`${name}Store`]) {
+            globalThis[`${name}Store`] = new Storage(name, root);
+            await globalThis[`${name}Store`].init();
+        }
+        globalThis[`${name}Store`].private = isPrivate;
+        if (!isPrivate)
+            this.stores.push(name);
+    }
+    /**
+     * @see MessageHandler
+     */
+    prepareMessage(data) {
+        return this._messageHandler.prepareMessage(data);
+    }
+    /**
+     * @access public
+     *
+     * @return {Array} peerId
+     */
+    get peers() {
+        return Object.keys(this.client.connections);
+    }
+    get connections() {
+        return Object.values(this.client.connections);
+    }
+    get peerEntries() {
+        return Object.entries(this.client.connections);
+    }
+    /**
+     * @return {String} id - peerId
+     */
+    getConnection(id) {
+        return this.client.connections[id];
+    }
+    /**
+     * @private
+     *
+     * @param {Object} options
+     * @param {String} options.root - path to root directory
+     *
+     * @return {Promise} instance of Peernet
+     */
+    async _init(options, password) {
+        this.requestProtos = {};
+        this.storePrefix = options.storePrefix;
+        this.root = options.root;
+        const { RequestMessage, ResponseMessage, PeerMessage, PeerMessageResponse, PeernetMessage, DHTMessage, DHTMessageResponse, DataMessage, DataMessageResponse, PsMessage, ChatMessage, PeernetFile
+        // FolderMessageResponse
+         } = await import(/* webpackChunkName: "messages" */ './messages-65501ef9.js');
+        /**
+         * proto Object containing protos
+         * @type {Object}
+         * @property {PeernetMessage} protos[peernet-message] messageNode
+         * @property {DHTMessage} protos[peernet-dht] messageNode
+         * @property {DHTMessageResponse} protos[peernet-dht-response] messageNode
+         * @property {DataMessage} protos[peernet-data] messageNode
+         * @property {DataMessageResponse} protos[peernet-data-response] messageNode
+         */
+        globalThis.peernet.protos = {
+            'peernet-request': RequestMessage,
+            'peernet-response': ResponseMessage,
+            'peernet-peer': PeerMessage,
+            'peernet-peer-response': PeerMessageResponse,
+            'peernet-message': PeernetMessage,
+            'peernet-dht': DHTMessage,
+            'peernet-dht-response': DHTMessageResponse,
+            'peernet-data': DataMessage,
+            'peernet-data-response': DataMessageResponse,
+            'peernet-ps': PsMessage,
+            'chat-message': ChatMessage,
+            'peernet-file': PeernetFile
+        };
+        this._messageHandler = new MessageHandler(this.network);
+        const { daemon, environment } = await target();
+        this.hasDaemon = daemon;
+        for (const store of this.defaultStores) {
+            await this.addStore(store, options.storePrefix, options.root);
+        }
+        this.identity = new Identity(this.network);
+        await this.identity.load(password);
+        this._peerHandler = new PeerDiscovery(this.id);
+        this.peerId = this.id;
+        pubsub.subscribe('peer:connected', async (peer) => {
+            // console.log(peer);
+            // console.log({connected: peer.id, as: this._getPeerId(peer.id) });
+            // peer.on('peernet.data', async (message) => {
+            //   const id = message.id
+            //   message = new PeernetMessage(Buffer.from(message.data.data))
+            //   const proto = protoFor(message.decoded.data)
+            //   this._protoHandler({id, proto}, peer)
+            // })
+        });
+        /**
+         * converts data -> message -> proto
+         * @see DataHandler
+         */
+        pubsub.subscribe('peer:data', dataHandler);
+        const importee = await import('@leofcoin/peernet-swarm/client');
+        /**
+         * @access public
+         * @type {PeernetClient}
+         */
+        this.client = new importee.default(this.id, this.networkVersion, this.stars);
+        if (globalThis.navigator) {
+            globalThis.addEventListener('beforeunload', async () => this.client.close());
+        }
+        else {
+            process.on('SIGTERM', async () => {
+                process.stdin.resume();
+                await this.client.close();
+                process.exit();
+            });
+        }
+        return this;
+    }
+    addRequestHandler(name, method) {
+        this.requestProtos[name] = method;
+    }
+    sendMessage(peer, id, data) {
+        if (peer.readyState === 'open') {
+            peer.send(data, id);
+            this.bw.up += data.length;
+        }
+        else if (peer.readyState === 'closed') ;
+    }
+    async handleDHT(peer, id, proto) {
+        let { hash, store } = proto.decoded;
+        let has;
+        if (store) {
+            store = globalThis[`${store}Store`];
+            has = store.private ? false : await store.has(hash);
+        }
+        else {
+            has = await this.has(hash);
+        }
+        const data = await new globalThis.peernet.protos['peernet-dht-response']({ hash, has });
+        const node = await this.prepareMessage(data);
+        this.sendMessage(peer, id, node.encoded);
+    }
+    async handleData(peer, id, proto) {
+        let { hash, store } = proto.decoded;
+        let data;
+        store = globalThis[`${store}Store`] || await this.whichStore([...this.stores], hash);
+        if (store && !store.private) {
+            data = await store.get(hash);
+            if (data) {
+                data = await new globalThis.peernet.protos['peernet-data-response']({ hash, data });
+                const node = await this.prepareMessage(data);
+                this.sendMessage(peer, id, node.encoded);
+            }
+        }
+    }
+    async handleRequest(peer, id, proto) {
+        const method = this.requestProtos[proto.decoded.request];
+        if (method) {
+            const data = await method();
+            const node = await this.prepareMessage(data);
+            this.sendMessage(peer, id, node.encoded);
+        }
+    }
+    /**
+     * @private
+     *
+     * @param {Buffer} message - peernet message
+     * @param {PeernetPeer} peer - peernet peer
+     */
+    async _protoHandler(message, peer, from) {
+        const { id, proto } = message;
+        this.bw.down += proto.encoded.length;
+        switch (proto.name) {
+            case 'peernet-dht': {
+                this.handleDHT(peer, id, proto);
+                break;
+            }
+            case 'peernet-data': {
+                this.handleData(peer, id, proto);
+                break;
+            }
+            case 'peernet-request': {
+                this.handleRequest(peer, id, proto);
+            }
+            case 'peernet-ps': {
+                if (peer.peerId !== this.id)
+                    globalSub.publish(proto.decoded.topic, proto.decoded.data);
+            }
+        }
+    }
+    /**
+     * performs a walk and resolves first encounter
+     *
+     * @param {String} hash
+     */
+    async walk(hash) {
+        if (!hash)
+            throw new Error('hash expected, received undefined');
+        const data = await new globalThis.peernet.protos['peernet-dht']({ hash });
+        this.client.id;
+        const walk = async (peer) => {
+            const node = await this.prepareMessage(data);
+            let result = await peer.request(node.encoded);
+            result = new Uint8Array(Object.values(result));
+            const proto = await protoFor(result);
+            if (proto.name !== 'peernet-dht-response')
+                throw dhtError(proto.name);
+            // TODO: give ip and port (just used for location)
+            if (!peer.connection.remoteAddress || !peer.connection.localAddress) {
+                peer.connection.remoteFamily = 'ipv4';
+                peer.connection.remoteAddress = '127.0.0.1';
+                peer.connection.remotePort = '0000';
+            }
+            const peerInfo = {
+                family: peer.connection.remoteFamily || peer.connection.localFamily,
+                address: peer.connection.remoteAddress || peer.connection.localAddress,
+                port: peer.connection.remotePort || peer.connection.localPort,
+                id: peer.peerId,
+            };
+            if (proto.decoded.has)
+                this.dht.addProvider(peerInfo, proto.decoded.hash);
+        };
+        let walks = [];
+        for (const peer of this.connections) {
+            if (peer.peerId !== this.id) {
+                walks.push(walk(peer));
+            }
+        }
+        return Promise.all(walks);
+    }
+    /**
+     * Override DHT behavior, try's finding the content three times
+     *
+     * @param {String} hash
+     */
+    async providersFor(hash) {
+        let providers = await this.dht.providersFor(hash);
+        // walk the network to find a provider
+        if (!providers || providers.length === 0) {
+            await this.walk(hash);
+            providers = await this.dht.providersFor(hash);
+            // second walk the network to find a provider
+            if (!providers || providers.length === 0) {
+                await this.walk(hash);
+                providers = await this.dht.providersFor(hash);
+            }
+            // last walk
+            if (!providers || providers.length === 0) {
+                await this.walk(hash);
+                providers = await this.dht.providersFor(hash);
+            }
+        }
+        // undefined if no providers given
+        return providers;
+    }
+    get block() {
+        return {
+            get: async (hash) => {
+                const data = await blockStore.has(hash);
+                if (data)
+                    return blockStore.get(hash);
+                return this.requestData(hash, 'block');
+            },
+            put: async (hash, data) => {
+                if (await blockStore.has(hash))
+                    return;
+                return await blockStore.put(hash, data);
+            },
+            has: async (hash) => await blockStore.has(hash, 'block'),
+        };
+    }
+    get transaction() {
+        return {
+            get: async (hash) => {
+                const data = await transactionStore.has(hash);
+                if (data)
+                    return await transactionStore.get(hash);
+                return this.requestData(hash, 'transaction');
+            },
+            put: async (hash, data) => {
+                if (await transactionStore.has(hash))
+                    return;
+                return await transactionStore.put(hash, data);
+            },
+            has: async (hash) => await transactionStore.has(hash),
+        };
+    }
+    async requestData(hash, store) {
+        const providers = await this.providersFor(hash);
+        if (!providers || providers.size === 0)
+            throw nothingFoundError(hash);
+        debug(`found ${providers.size} provider(s) for ${hash}`);
+        // get closest peer on earth
+        const closestPeer = await this.dht.closestPeer(providers);
+        // get peer instance by id
+        if (!closestPeer || !closestPeer.id)
+            return this.requestData(hash, store?.name || store);
+        const id = closestPeer.id;
+        if (this.connections) {
+            let closest = this.connections.filter((peer) => {
+                if (peer.peerId === id)
+                    return peer;
+            });
+            let data = await new globalThis.peernet.protos['peernet-data']({ hash, store: store?.name || store });
+            const node = await this.prepareMessage(data);
+            if (closest[0])
+                data = await closest[0].request(node.encoded);
+            else {
+                closest = this.connections.filter((peer) => {
+                    if (peer.peerId === id)
+                        return peer;
+                });
+                if (closest[0])
+                    data = await closest[0].request(node.encoded);
+            }
+            const proto = await protoFor(data);
+            // TODO: store data automaticly or not
+            return BufferToUint8Array(proto.decoded.data);
+            // this.put(hash, proto.decoded.data)
+        }
+        return;
+    }
+    get message() {
+        return {
+            /**
+             * Get content for given message hash
+             *
+             * @param {String} hash
+             */
+            get: async (hash) => {
+                debug(`get message ${hash}`);
+                const message = await messageStore.has(hash);
+                if (message)
+                    return await messageStore.get(hash);
+                return this.requestData(hash, 'message');
+            },
+            /**
+             * put message content
+             *
+             * @param {String} hash
+             * @param {Buffer} message
+             */
+            put: async (hash, message) => await messageStore.put(hash, message),
+            /**
+             * @param {String} hash
+             * @return {Boolean}
+             */
+            has: async (hash) => await messageStore.has(hash),
+        };
+    }
+    get data() {
+        return {
+            /**
+             * Get content for given data hash
+             *
+             * @param {String} hash
+             */
+            get: async (hash) => {
+                debug(`get data ${hash}`);
+                const data = await dataStore.has(hash);
+                if (data)
+                    return await dataStore.get(hash);
+                return this.requestData(hash, 'data');
+            },
+            /**
+             * put data content
+             *
+             * @param {String} hash
+             * @param {Buffer} data
+             */
+            put: async (hash, data) => await dataStore.put(hash, data),
+            /**
+             * @param {String} hash
+             * @return {Boolean}
+             */
+            has: async (hash) => await dataStore.has(hash),
+        };
+    }
+    get folder() {
+        return {
+            /**
+             * Get content for given data hash
+             *
+             * @param {String} hash
+             */
+            get: async (hash) => {
+                debug(`get data ${hash}`);
+                const data = await dataStore.has(hash);
+                if (data)
+                    return await dataStore.get(hash);
+                return this.requestData(hash, 'data');
+            },
+            /**
+             * put data content
+             *
+             * @param {String} hash
+             * @param {Buffer} data
+             */
+            put: async (hash, data) => await dataStore.put(hash, data),
+            /**
+             * @param {String} hash
+             * @return {Boolean}
+             */
+            has: async (hash) => await dataStore.has(hash),
+        };
+    }
+    async addFolder(files) {
+        const links = [];
+        for (const file of files) {
+            const fileNode = await new globalThis.peernet.protos['peernet-file'](file);
+            const hash = await fileNode.hash;
+            await dataStore.put(hash, fileNode.encoded);
+            links.push({ hash, path: file.path });
+        }
+        const node = await new globalThis.peernet.protos['peernet-file']({ path: '/', links });
+        const hash = await node.hash;
+        await dataStore.put(hash, node.encoded);
+        return hash;
+    }
+    async ls(hash, options) {
+        let data;
+        const has = await dataStore.has(hash);
+        data = has ? await dataStore.get(hash) : await this.requestData(hash, 'data');
+        const node = await new peernet.protos['peernet-file'](data);
+        await node.decode();
+        console.log(data);
+        const paths = [];
+        if (node.decoded?.links.length === 0)
+            throw new Error(`${hash} is a file`);
+        for (const { path, hash } of node.decoded.links) {
+            paths.push({ path, hash });
+        }
+        if (options?.pin)
+            await dataStore.put(hash, node.encoded);
+        return paths;
+    }
+    async cat(hash, options) {
+        let data;
+        const has = await dataStore.has(hash);
+        data = has ? await dataStore.get(hash) : await this.requestData(hash, 'data');
+        const node = await new peernet.protos['peernet-file'](data);
+        if (node.decoded?.links.length > 0)
+            throw new Error(`${hash} is a directory`);
+        if (options?.pin)
+            await dataStore.put(hash, node.encoded);
+        return node.decoded.content;
+    }
+    /**
+     * goes trough given stores and tries to find data for given hash
+     * @param {Array} stores
+     * @param {string} hash
+     */
+    async whichStore(stores, hash) {
+        let store = stores.pop();
+        store = globalThis[`${store}Store`];
+        if (store) {
+            const has = await store.has(hash);
+            if (has)
+                return store;
+            if (stores.length > 0)
+                return this.whichStore(stores, hash);
+        }
+        else
+            return;
+    }
+    /**
+     * Get content for given hash
+     *
+     * @param {String} hash - the hash of the wanted data
+     * @param {String} store - storeName to access
+     */
+    async get(hash, store) {
+        debug(`get ${hash}`);
+        let data;
+        if (store)
+            store = globalThis[`${store}Store`];
+        if (!store)
+            store = await this.whichStore([...this.stores], hash);
+        if (store && await store.has(hash))
+            data = await store.get(hash);
+        if (data)
+            return data;
+        return this.requestData(hash, store?.name || store);
+    }
+    /**
+     * put content
+     *
+     * @param {String} hash
+     * @param {Buffer} data
+     * @param {String} store - storeName to access
+     */
+    async put(hash, data, store = 'data') {
+        store = globalThis[`${store}Store`];
+        return store.put(hash, data);
+    }
+    /**
+     * @param {String} hash
+     * @return {Boolean}
+     */
+    async has(hash) {
+        const store = await this.whichStore([...this.stores], hash);
+        if (store) {
+            return store.private ? false : true;
+        }
+        return false;
+    }
+    /**
+     *
+     * @param {String} topic
+     * @param {String|Object|Array|Boolean|Buffer} data
+     */
+    async publish(topic, data) {
+        // globalSub.publish(topic, data)
+        const id = Math.random().toString(36).slice(-12);
+        data = await new globalThis.peernet.protos['peernet-ps']({ data, topic });
+        for (const peer of this.connections) {
+            if (peer.peerId !== this.peerId) {
+                const node = await this.prepareMessage(data);
+                this.sendMessage(peer, id, node.encoded);
+            }
+            // TODO: if peer subscribed
+        }
+    }
+    createHash(data, name) {
+        return new CodeHash(data, { name });
+    }
+    /**
+     *
+     * @param {String} topic
+     * @param {Method} cb
+     */
+    async subscribe(topic, callback) {
+        // TODO: if peer subscribed
+        globalSub.subscribe(topic, callback);
+    }
+    async removePeer(peer) {
+        return this.client.removePeer(peer);
+    }
+    get Buffer() {
+        return Buffer;
+    }
+}
 globalThis.Peernet = Peernet;
 
 export { Peernet as default };