@leofcoin/peernet 0.16.6 → 0.17.0

package/dist/commonjs/peernet.js

@@ -1,1126 +0,0 @@
-'use strict';
-
-require('@vandeurenglenn/debug');
-var PubSub = require('@vandeurenglenn/little-pubsub');
-var codecFormatInterface = require('@leofcoin/codec-format-interface');
-var fetch$1 = require('node-fetch');
-var LeofcoinStorage = require('@leofcoin/storage/src/storage');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n["default"] = e;
-  return Object.freeze(n);
-}
-
-var PubSub__default = /*#__PURE__*/_interopDefaultLegacy(PubSub);
-var fetch__default = /*#__PURE__*/_interopDefaultLegacy(fetch$1);
-var LeofcoinStorage__default = /*#__PURE__*/_interopDefaultLegacy(LeofcoinStorage);
-
-const BufferToUint8Array = data => {
-  if (data.type === 'Buffer') {
-    data = new Uint8Array(data.data);
-  }
-  return data
-};
-
-const protoFor = (message) => {
-  const codec = new codecFormatInterface.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);
-        }
-      }
-    }
-  }
-}
-
-/**
- * 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__default["default"]('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__default["default"](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;
-  }
-}
-
-var codecs = {
-  // just a hash
-  'disco-hash': {
-    codec: parseInt('30', 16),
-    hashAlg: 'dbl-keccak-256', // ,
-    // testnet: 'olivia'
-  },
-  'peernet-peer-response': {
-    codec: parseInt('707072', 16),
-    hashAlg: 'keccak-256',
-  },
-  'peernet-peer': {
-    codec: parseInt('7070', 16),
-    hashAlg: 'keccak-256',
-  },
-  'peernet-dht': {
-    codec: parseInt('706468', 16),
-    hashAlg: 'keccak-256',
-  },
-  'peernet-dht-response': {
-    codec: parseInt('706472', 16),
-    hashAlg: 'keccak-256',
-  },
-  // data
-  'peernet-data': {
-    codec: parseInt('706461', 16),
-    hashAlg: 'keccak-256',
-  },
-  'peernet-data-response': {
-    codec: parseInt('70646172', 16),
-    hashAlg: 'keccak-256',
-  },
-  // message
-  'peernet-message': {
-    codec: parseInt('706d65', 16),
-    hashAlg: 'keccak-256',
-  },
-  // pubsub
-  'peernet-ps': {
-    codec: parseInt('707073', 16),
-    hashAlg: 'keccak-256',
-  },
-  'peernet-response': {
-    codec: parseInt('7072', 16),
-    hashAlg: 'keccak-256',
-  },
-  'peernet-request': {
-    codec: parseInt('707271', 16),
-    hashAlg: 'keccak-256',
-  },
-  // normal block
-  'leofcoin-block': {
-    codec: parseInt('6c62', 16),
-    hashAlg: 'dbl-keccak-512', // ,
-    // testnet: 'olivia'
-  },
-  'leofcoin-tx': {
-    codec: parseInt('6c74', 16),
-    hashAlg: 'dbl-keccak-512', // ,
-    // testnet: 'olivia'
-  },
-  // itx
-  'leofcoin-itx': {
-    codec: parseInt('6c69', 16),
-    hashAlg: 'keccak-512', // ,
-    // testnet: 'olivia'
-  },
-  // peer reputation
-  'leofcoin-pr': {
-    codec: parseInt('6c70', 16),
-    hashAlg: 'keccak-256', // ,
-    // testnet: 'olivia'
-  },
-  // chat message
-  'chat-message': {
-    codec: parseInt('70636d', 16),
-    hashAlg: 'dbl-keccak-256',
-  },
-  'peernet-file' : {
-    codec: parseInt('7066', 16),
-    hashAlg: 'keccak-256',
-  },
-  'peernet-file-response' : {
-    codec: parseInt('706672', 16),
-    hashAlg: 'keccak-256',
-  }
-};
-
-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) {
-    let identity = await walletStore.get('identity');
-    identity = JSON.parse(identity);
-    if (!globalThis.MultiWallet) {
-      const importee = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require(/* webpackChunkName: "multi-wallet" */ '@leofcoin/multi-wallet')); });
-      globalThis.MultiWallet = importee.default;
-    }
-    const wallet = new MultiWallet(this.network);
-    wallet.recover(identity.mnemonic);
-    message.decoded.signature = wallet.sign(Buffer.from(await message.hash).slice(0, 32));
-    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.indexOf('signature') !== -1) {
-      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 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}`)
-};
-
-globalThis.LeofcoinStorage = LeofcoinStorage__default["default"];
-  
-globalThis.leofcoin = globalThis.leofcoin || {};
-globalThis.pubsub = globalThis.pubsub || new PubSub__default["default"]();
-globalThis.globalSub = globalThis.globalSub || new PubSub__default["default"]({verbose: true});
-
-/**
- * @access public
- * @example
- * const peernet = new Peernet();
- */
-class Peernet {
-  /**
-   * @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 = {}) {
-    this._discovered = [];
-    /**
-     * @property {String} network - current network
-     */
-    this.network = options.network || 'leofcoin';
-    this.stars = options.stars;
-    const parts = this.network.split(':');
-    this.networkVersion = options.networkVersion ? options.networkVersion : parts.length > 1 ? parts[1] : 'mainnet';
-
-    if (!options.storePrefix) options.storePrefix = 'lfc';
-    if (!options.port) options.port = 2000;
-    if (!options.root) {
-      if (parts[1]) options.root = `.${parts[0]}/${parts[1]}`;
-      else options.root = `.${this.network}`;
-    }
-    
-    globalThis.peernet = this;
-    this.bw = {
-      up: 0,
-      down: 0,
-    };
-    return this._init(options)
-  }
-
-  get defaultStores() {
-    return ['account', 'wallet', 'block', 'transaction', 'chain', 'data', 'message']
-  }
-
-  get codecs() {
-    return codecs
-  }
-
-  addProto(name, proto) {
-    if (!globalThis.peernet.protos[name]) globalThis.peernet.protos[name] = proto;
-  }
-
-  addCodec(name, codec) {
-    if (!this.codecs[name]) this.codecs[name] = codec;
-  }
-
-  async addStore(name, prefix, root, isPrivate = true) {
-    if (name === 'block' || name === 'transaction' || name === 'chain' ||
-        name === 'data' || name === 'message') isPrivate = false;
-
-    let Storage;
-    if (this.hasDaemon) {
-      Storage = LeofcoinStorageClient;
-    } else {
-      Storage = LeofcoinStorage__default["default"];
-    }
-    globalThis[`${name}Store`] = globalThis[`${name}Store`] ||
-      await new Storage(name, root);
-
-    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) {
-    // peernetDHT aka closesPeer by coordinates
-    /**
-     * @type {Object}
-     * @property {Object} peer Instance of Peer
-     */
-    this.dht = new DhtEarth();
-    /**
-     * @type {Map}
-     * @property {Object} peer Instance of Peer
-     */
-    this.stores = [];
-    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 Promise.resolve().then(function () { return require(/* webpackChunkName: "messages" */ './messages-f46a3ca1.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);
-    }
-
-    const accountExists = await accountStore.has('public');
-    if (accountExists) {
-      const pub = await accountStore.get('public');
-      this.id = JSON.parse(new TextDecoder().decode(pub)).walletId;
-      let accounts = await walletStore.get('accounts');
-      accounts = new TextDecoder().decode(accounts);
-      const selected = await walletStore.get('selected-account');
-      globalThis.peernet.selectedAccount = new TextDecoder().decode(selected);
-
-      // fixing account issue (string while needs to be a JSON)
-      // TODO: remove when on mainnet
-      try {
-        this.accounts = JSON.parse(accounts);
-      } catch (e) {
-        this.accounts = [accounts.split(',')];
-      }
-    } else {
-      const importee = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require(/* webpackChunkName: "generate-account" */ '@leofcoin/generate-account')); });
-      const generateAccount = importee.default;
-      const {identity, accounts, config} = await generateAccount(this.network);
-      // await accountStore.put('config', JSON.stringify(config));
-      await accountStore.put('public', JSON.stringify({walletId: identity.walletId}));
-      
-      await walletStore.put('version', String(1));
-      await walletStore.put('accounts', JSON.stringify(accounts));
-      await walletStore.put('selected-account', accounts[0][1]);
-      await walletStore.put('identity', JSON.stringify(identity));
-
-      globalThis.peernet.selectedAccount = accounts[0][1];
-      this.id = identity.walletId;
-    }
-    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 Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require(/* webpackChunkName: "peernet-swarm" */ '@leofcoin/peernet-swarm')); });
-    /**
-     * @access public
-     * @type {PeernetClient}
-     */
-    this.client = new importee.default(this.id, this.networkVersion, this.stars);
-    if (globalThis.onbeforeunload) {
-      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') ;
-
-  }
-
-  /**
-   * @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;
-      if (proto.name === 'peernet-dht') {
-        let { hash, store } = proto.decoded;
-        let has;
-
-        if (!store) {
-          has = await this.has(hash);
-        } else {
-          store = globalThis[`${store}Store`];
-          if (store.private) has = false;
-          else has = await store.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);
-      } else if (proto.name === 'peernet-data') {
-        let { hash, store } = proto.decoded;
-        let data;
-        if (!store) {
-          store = await this.whichStore([...this.stores], hash);
-        } else {
-          store = globalThis[`${store}Store`];
-        }
-        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);
-          }
-        }
-
-      } else if (proto.name === 'peernet-request') {
-        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);
-        }
-      } else if (proto.name === 'peernet-ps' && 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?.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?.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);
-      }
-      data = new Uint8Array(Object.values(data));
-      const proto = await protoFor(data);
-      // TODO: store data automaticly or not
-      return BufferToUint8Array(proto.decoded.data)
-
-      // this.put(hash, proto.decoded.data)
-    }
-    return null
-  }
-
-
-  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);
-    if (has) data = await dataStore.get(hash);
-    else data = 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);
-    if (has) data = await dataStore.get(hash);
-    else data = 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 null
-  }
-
-  /**
-   * 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.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) {
-      if (store.private) return false
-      else return 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, cb) {
-    // TODO: if peer subscribed
-    globalSub.subscribe(topic, cb);
-  }
-
-  async removePeer(peer) {
-    return this.client.removePeer(peer)
-  }
-
-  get Buffer() {
-    return Buffer
-  }
-}
-globalThis.Peernet = Peernet;
-
-module.exports = Peernet;