@leofcoin/peernet 0.11.24 → 0.11.25

package/dist/browser/peernet.js

@@ -13,17 +13,15 @@ __webpack_require__(307);
 var pako = __webpack_require__(9591);
 var LeofcoinStorage = __webpack_require__(1116);
 var protons = __webpack_require__(7160);
-var bs32 = __webpack_require__(103);
-var bs58 = __webpack_require__(158);
-var isHex = __webpack_require__(6187);
-var varint = __webpack_require__(4676);
-var createKeccakHash = __webpack_require__(5811);
+var codecFormatInterface = __webpack_require__(5698);
 var MultiWallet$1 = __webpack_require__(9755);
 var bs58check = __webpack_require__(8334);
 var bip32 = __webpack_require__(7786);
+var createKeccakHash = __webpack_require__(5811);
 var ecc = __webpack_require__(5892);
 var Mnemonic = __webpack_require__(4911);
 var MultiSignature = __webpack_require__(6697);
+var varint = __webpack_require__(4676);
 var randombytes = __webpack_require__(1798);
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
@@ -49,18 +47,15 @@ function _interopNamespace(e) {
 var pako__default = /*#__PURE__*/_interopDefaultLegacy(pako);
 var LeofcoinStorage__default = /*#__PURE__*/_interopDefaultLegacy(LeofcoinStorage);
 var protons__default = /*#__PURE__*/_interopDefaultLegacy(protons);
-var bs32__default = /*#__PURE__*/_interopDefaultLegacy(bs32);
-var bs58__default = /*#__PURE__*/_interopDefaultLegacy(bs58);
-var isHex__default = /*#__PURE__*/_interopDefaultLegacy(isHex);
-var varint__default = /*#__PURE__*/_interopDefaultLegacy(varint);
-var createKeccakHash__default = /*#__PURE__*/_interopDefaultLegacy(createKeccakHash);
 var MultiWallet__default = /*#__PURE__*/_interopDefaultLegacy(MultiWallet$1);
 var bs58check__default = /*#__PURE__*/_interopDefaultLegacy(bs58check);
 var bs58check__namespace = /*#__PURE__*/_interopNamespace(bs58check);
 var bip32__namespace = /*#__PURE__*/_interopNamespace(bip32);
+var createKeccakHash__default = /*#__PURE__*/_interopDefaultLegacy(createKeccakHash);
 var ecc__default = /*#__PURE__*/_interopDefaultLegacy(ecc);
 var Mnemonic__default = /*#__PURE__*/_interopDefaultLegacy(Mnemonic);
 var MultiSignature__default = /*#__PURE__*/_interopDefaultLegacy(MultiSignature);
+var varint__default = /*#__PURE__*/_interopDefaultLegacy(varint);
 var randombytes__default = /*#__PURE__*/_interopDefaultLegacy(randombytes);
 
 /* socket-request-client version 1.6.3 */
@@ -771,1425 +766,891 @@ message PeernetMessage {
   optional string id = 5;
 }`;
 
-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('636d', 16),
-    hashAlg: 'dbl-keccak-256',
-  },
-};
-
-class PeernetCodec {
-  get codecs() {
-    return {...globalThis.peernet.codecs, ...codecs}
+class PeernetMessage extends codecFormatInterface.FormatInterface {
+  get keys() {
+    return ['data', 'signature', 'from', 'to', 'id']
   }
-  constructor(buffer) {
-    if (buffer) {
-      if (buffer instanceof Uint8Array) {
-        const codec = varint__default["default"].decode(buffer);
-        const name = this.getCodecName(codec);
-        if (name) {
-          this.name = name;
-          this.encoded = buffer;
-          this.decode(buffer);
-        } else {
-          this.encode(buffer);
-        }
-      } else if (buffer instanceof ArrayBuffer) {
-        const encoded = new Uint8Array(buffer.byteLength);
 
-        for (let i = 0; i < buffer.byteLength; i++) {
-          encoded[i] = buffer[i];
-        }
-        this.encoded = encoded;
-        // this.encoded = new Uint8Array(buffer, buffer.byteOffset, buffer.byteLength)
-        this.decode(buffer);
-        return
-      }
-      if (typeof buffer === 'string') {
-        if (this.codecs[buffer]) this.fromName(buffer);
-        else if (isHex__default["default"](buffer)) this.fromHex(buffer);
-        else if (bs32__default["default"].isBase32(buffer)) this.fromBs32(buffer);
-        else if (bs58__default["default"].isBase58(buffer)) this.fromBs58(buffer);
-        else throw new Error(`unsupported string ${buffer}`)
-      }
-      if (!isNaN(buffer)) if (this.codecs[this.getCodecName(buffer)]) this.fromCodec(buffer);
-    }
+  constructor(buffer) {
+    const name = 'peernet-message';
+    super(buffer, protons__default["default"](proto$a).PeernetMessage, {name});
   }
-
-  fromEncoded(encoded) {
-    const codec = varint__default["default"].decode(encoded);
-    const name = this.getCodecName(codec);
-    this.name = name;
-    this.encoded = encoded;
-    this.decode(encoded);
+}
+
+var proto$9 = `
+// PeernetDHTMessage
+message PeernetDHTMessage {
+  required string hash = 1;
+  optional string store = 2;
+}
+`;
+
+/**
+ * @example `
+   new DHTMessage(hash, store)
+   // store = optional if not set, peernet checks every store
+   let message = new DHTMessage('hashmvbs124xcfd...', 'transaction')
+   message = new DHTMessage('hashmvbs124xcfd...', 'block')
+ `
+ */
+class DHTMessage extends codecFormatInterface.FormatInterface {
+  /**
+   *
+   */
+  get keys() {
+    return ['hash', 'store']
   }
 
-  fromHex(hex) {
-    this.encoded = Buffer.from(hex, 'hex');
-    this.decode();
+  constructor(data) {
+    const name = 'peernet-dht';
+    super(data, protons__default["default"](proto$9).PeernetDHTMessage, {name});
   }
-
-  fromBs32(input) {
-    this.encoded = bs32__default["default"].decode(input);
-    this.decode();
+}
+
+var proto$8 = `
+// PeernetDHTMessageResponse
+message PeernetDHTMessageResponse {
+  required string hash = 1;
+  required bool has = 2;
+}
+`;
+
+class DHTMessageResponse extends codecFormatInterface.FormatInterface {
+  get keys() {
+    return ['hash', 'has']
   }
 
-  fromBs58(input) {
-    this.encoded = bs58__default["default"].decode(input);
-    this.decode();
+  constructor(data) {
+    const name = 'peernet-dht-response';
+    super(data, protons__default["default"](proto$8).PeernetDHTMessageResponse, {name});
   }
-
-  getCodec(name) {
-    return this.codecs[name].codec
+}
+
+var proto$7 = `
+// PeernetDataMessage
+message PeernetDataMessage {
+  required string hash = 1;
+  optional string store = 2;
+}
+`;
+
+/**
+ * @extends {CodecFormat}
+ */
+class DataMessage extends codecFormatInterface.FormatInterface {
+  get keys() {
+    return ['hash', 'store']
   }
-
-  getCodecName(codec) {
-    return Object.keys(this.codecs).reduce((p, c) => {
-      const item = this.codecs[c];
-      if (item.codec === codec) return c;
-      else return p;
-    }, undefined)
+  /**
+   * @param {Buffer|String|Object|DataMessage} data - The data needed to create the DataMessage
+   */
+  constructor(data) {
+    super(data, protons__default["default"](proto$7).PeernetDataMessage, {name: 'peernet-data'});
   }
-
-  getHashAlg(name) {
-    return this.codecs[name].hashAlg
+}
+
+var proto$6 = `
+// PsMessage
+message PsMessage {
+  required bytes data = 1;
+  required bytes topic = 2;
+}`;
+
+class PsMessage extends codecFormatInterface.FormatInterface {
+  get keys() {
+    return ['data', 'topic']
   }
 
-  fromCodec(codec) {
-    this.name = this.getCodecName(codec);
-    this.hashAlg = this.getHashAlg(this.name);
-
-    this.codec = this.getCodec(this.name);
-    this.codecBuffer = varint__default["default"].encode(codec);
+  constructor(buffer) {
+    const name = 'peernet-ps';
+    super(buffer, protons__default["default"](proto$6).PsMessage, {name});
   }
-
-  fromName(name) {
-    const codec = this.getCodec(name);
-    this.name = name;
-    this.codec = codec;
-    this.hashAlg = this.getHashAlg(name);
-    this.codecBuffer = varint__default["default"].encode(codec);
+}
+
+var proto$5 = `
+// PeernetPeerMessage
+message PeernetPeerMessage {
+  required string id = 1;
+}
+`;
+
+class PeerMessage extends codecFormatInterface.FormatInterface {
+  get keys() {
+    return ['id']
   }
 
-  toBs32() {
-    this.encode();
-    return bs32__default["default"].encode(this.encoded)
+  constructor(data) {
+    const name = 'peernet-peer';
+    super(data, protons__default["default"](proto$5).PeernetPeerMessage, {name});
   }
-
-  toBs58() {
-    this.encode();
-    return bs58__default["default"].encode(this.encoded)
+}
+
+var proto$4 = `
+// PeernetRequestMessage
+message PeernetRequestMessage {
+  required string request = 1;
+}
+`;
+
+class RequestMessage extends codecFormatInterface.FormatInterface {
+  get keys() {
+    return ['request']
   }
 
-  toHex() {
-    return this.encoded.toString('hex')
+  constructor(data) {
+    const name = 'peernet-request';
+    super(data, protons__default["default"](proto$4).PeernetRequestMessage, {name});
   }
-
-  decode() {
-    const codec = varint__default["default"].decode(this.encoded);
-    this.fromCodec(codec);
+}
+
+var proto$3 = `
+// PeernetResponseMessage
+message PeernetResponseMessage {
+  required bytes response = 1;
+}
+`;
+
+class ResponseMessage extends codecFormatInterface.FormatInterface {
+  get keys() {
+    return ['response']
   }
 
-  encode() {
-    const codec = varint__default["default"].encode(this.decoded);
-    this.encoded = codec;
-    return this.encoded
+  constructor(data) {
+    const name = 'peernet-response';
+    super(data, protons__default["default"](proto$3).PeernetResponseMessage, {name});
   }
 }
 
-class PeernetHash {
-  constructor(buffer, options = {}) {
-    if (options.name) this.name = options.name;
-    else this.name = 'disco-hash';
-    if (options.codecs) this.codecs = options.codecs;
-    if (buffer) {
-      if (buffer instanceof Uint8Array) {
-        this.discoCodec = new PeernetCodec(buffer, this.codecs);
-        const name = this.discoCodec.name;
-
-        if (name) {
-          this.name = name;
-          this.decode(buffer);
-        } else {
-          this.encode(buffer);
-        }
-      }
-
-      if (typeof buffer === 'string') {
-        if (isHex__default["default"](buffer)) this.fromHex(buffer);
-        if (bs32__default["default"].isBase32(buffer)) this.fromBs32(buffer);
-        else if (bs58__default["default"].isBase58(buffer)) this.fromBs58(buffer);
-        else throw new Error(`unsupported string ${buffer}`)
-      } else if (typeof buffer === 'object') this.fromJSON(buffer);
-    }
+var proto$2 = `
+// PeernetPeerMessageResponse
+message PeernetPeerMessageResponse {
+  required string id = 1;
+}
+`;
+
+class PeerMessageResponse extends codecFormatInterface.FormatInterface {
+  get keys() {
+    return ['id']
   }
 
-  get prefix() {
-    const length = this.length;
-    const uint8Array = new Uint8Array(length.length + this.discoCodec.codecBuffer.length);
-    uint8Array.set(length);
-    uint8Array.set(this.discoCodec.codecBuffer, length.length);
-
-    return uint8Array
+  constructor(data) {
+    const name = 'peernet-peer-response';
+    super(data, protons__default["default"](proto$2).PeernetPeerMessageResponse, {name});
   }
-
-  get length() {
-    return varint__default["default"].encode(this.size)
+}
+
+var proto$1 = `
+// PeernetDataMessageResponse
+message PeernetDataMessageResponse {
+  required string hash = 1;
+  required bytes data = 2;
+}
+`;
+
+class DataMessageResponse extends codecFormatInterface.FormatInterface {
+  get keys() {
+    return ['hash', 'data']
   }
 
-  get buffer() {
-    return this.hash
+  constructor(data) {
+    const name = 'peernet-data-response';
+    super(data, protons__default["default"](proto$1).PeernetDataMessageResponse, {name});
   }
-
-  toHex() {
-    return this.hash.toString('hex')
+}
+
+var proto = `
+message ChatMessage {
+  required string value = 1;
+  required string author = 2;
+  required uint64 timestamp = 3;
+  repeated string files = 4;
+}`;
+
+class ChatMessage extends codecFormatInterface.FormatInterface {
+  get keys() {
+    return ['author', 'value', 'timestamp', 'files']
   }
 
-  fromHex(hex) {
-    return this.decode(Buffer.from(hex, 'hex'))
+  constructor(buffer) {
+    const name = 'chat-message';
+    super(buffer, protons__default["default"](proto).ChatMessage, {name});
   }
+}
+
+const protoFor = (data) => {
+  if (!Buffer.isBuffer(data)) data = Buffer.from(data);
+  const codec = new codecFormatInterface.Codec(data);
+  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(data)
+};
 
-  fromJSON(json) {
-    return this.encode(Buffer.from(JSON.stringify(json)))
+/**
+ * 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
   }
+};
 
-  toBs32() {
-    return bs32__default["default"].encode(this.hash)
-  }
+const https = () => {
+  if (!globalThis.location) return false;
+  return Boolean(globalThis.location.protocol === 'https:')
+};
 
-  fromBs32(bs) {
-    return this.decode(bs32__default["default"].decode(bs))
+/**
+ * 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'
   }
+};
 
-  toBs58() {
-    return bs58__default["default"].encode(this.hash)
-  }
+/**
+ * * 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;
+  const env = await environment();
+  if (!https()) daemon = await hasDaemon();
 
-  fromBs58(bs) {
-    return this.decode(bs58__default["default"].decode(bs))
+  return {daemon, environment: env}
+};
+
+class PeerDiscovery {
+  constructor(id) {
+    this.id = id;
   }
 
-  toString(encoding = 'utf8') {
-    return this.hash.toString(encoding)
-  }
+  _getPeerId(id) {
+    if (!peernet.peerMap || peernet.peerMap && peernet.peerMap.size === 0) return false
 
-  encode(buffer, name) {
-    if (!this.name && name) this.name = name;
-    if (!buffer) buffer = this.buffer;
-    this.discoCodec = new PeernetCodec(this.name, this.codecs);
-    this.discoCodec.fromName(this.name);
-    let hashAlg = this.discoCodec.hashAlg;
-    if (hashAlg.includes('dbl')) {
-      hashAlg = hashAlg.replace('dbl-', '');
-      buffer = createKeccakHash__default["default"](hashAlg.replace('-', '')).update(buffer).digest();
+    for (const entry of [...peernet.peerMap.entries()]) {
+      for (const _id of entry[1]) {
+        if (_id === id) return entry[0]
+      }
     }
-    this.digest = createKeccakHash__default["default"](hashAlg.replace('-', '')).update(buffer).digest();
-    this.size = this.digest.length;
+  }
 
-    this.codec = this.discoCodec.encode();
-    this.codec = this.discoCodec.codecBuffer;
-    const uint8Array = new Uint8Array(this.digest.length + this.prefix.length);
-    uint8Array.set(this.prefix);
-    uint8Array.set(this.digest, this.prefix.length);
+  async discover(peer) {
+    let id = this._getPeerId(peer.id);
+    if (id) return id
+    const data = new peernet.protos['peernet-peer']({id: this.id});
+    const node = await peernet.prepareMessage(peer.id, data.encoded);
 
-    this.hash = uint8Array;
+    let response = await peer.request(node.encoded);
+    response = protoFor(response);
+    response = new peernet.protos['peernet-peer-response'](response.decoded.data);
 
-    return this.hash
-  }
+    id = response.decoded.id;
+    if (id === this.id) return;
 
-  validate(buffer) {
-    if (Buffer.isBuffer(buffer)) {
-      const codec = varint__default["default"].decode(buffer);
-      if (this.codecs[codec]) {
-        this.decode(buffer);
-      } else {
-        this.encode(buffer);
+    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);
       }
     }
-    if (typeof buffer === 'string') {
-      if (isHex__default["default"](buffer)) this.fromHex(buffer);
-      if (bs32__default["default"].test(buffer)) this.fromBs32(buffer);
-    }
-    if (typeof buffer === 'object') this.fromJSON(buffer);
+    return id
   }
 
-  decode(buffer) {
-    this.hash = buffer;
-    const codec = varint__default["default"].decode(buffer);
-
-    this.discoCodec = new PeernetCodec(codec, this.codecs);
-    // TODO: validate codec
-    buffer = buffer.slice(varint__default["default"].decode.bytes);
-    this.size = varint__default["default"].decode(buffer);
-    this.digest = buffer.slice(varint__default["default"].decode.bytes);
-    if (this.digest.length !== this.size) {
-      throw new Error(`hash length inconsistent: 0x${this.hash.toString('hex')}`)
-    }
-
-    // const discoCodec = new Codec(codec, this.codecs)
-
-    this.name = this.discoCodec.name;
+  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 = new peernet.protos['peernet-peer-response']({id: this.id});
+      const node = await peernet.prepareMessage(from, data.encoded);
 
-    this.size = this.digest.length;
+      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;
 
-    return {
-      codec: this.codec,
-      name: this.name,
-      size: this.size,
-      length: this.length,
-      digest: this.digest,
+      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 FormatInterface {
-  /**
-   * @param {Buffer|String|Object} buffer - data - The data needed to create the desired message
-   * @param {Object} proto - {encode, decode}
-   * @param {Object} options - {hashFormat, name}
-   */
-  constructor(buffer, proto, options = {}) {
-    this.protoEncode = proto.encode;
-    this.protoDecode = proto.decode;
-    this.hashFormat = options.hashFormat || 'bs32';
-    if (options.name) this.name = options.name;
-    if (buffer instanceof Uint8Array) this.fromUint8Array(buffer);
-    else if (buffer instanceof ArrayBuffer) this.fromArrayBuffer(buffer);
-    else if (buffer.name === options.name) return buffer
-    else if (buffer instanceof String) {
-      if (isHex__default["default"](buffer)) this.fromHex(buffer);
-      else if (bs32__default["default"].isBase32(buffer)) this.fromBs32(buffer);
-      else if (bs58__default["default"].isBase58(buffer)) this.fromBs58(buffer);
-      else throw new Error(`unsupported string ${buffer}`)
-    } else {
-      this.create(buffer);
-    }
-  }
+/**
+ * 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,
+  },
+};
 
-  /**
-   * @return {PeernetHash}
-   */
-  get peernetHash() {
-    return new PeernetHash(this.decoded, {name: this.name})
+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 {peernetHash}
-   */
-  get hash() {
-    const upper = this.hashFormat.charAt(0).toUpperCase();
-    const format = `${upper}${this.hashFormat.substring(1, this.hashFormat.length)}`;
-    return this.peernetHash[`to${format}`]()
-  }
+  return address.value
+};
 
-  /**
-   * @return {Object}
-   */
-  decode() {
-    let encoded = this.encoded;
-    const discoCodec = new PeernetCodec(this.encoded);
-    encoded = encoded.slice(discoCodec.codecBuffer.length);
-    this.name = discoCodec.name;
-    this.decoded = this.protoDecode(encoded);
-    return this.decoded
-  }
+const degreesToRadians = (degrees) => {
+  return degrees * Math.PI / 180;
+};
 
-  /**
-   * @return {Buffer}
-   */
-  encode(decoded) {
-    if (!decoded) decoded = this.decoded;
-    const codec = new PeernetCodec(this.name);
-    const encoded = this.protoEncode(decoded);
-    const uint8Array = new Uint8Array(encoded.length + codec.codecBuffer.length);
-    uint8Array.set(codec.codecBuffer);
-    uint8Array.set(encoded, codec.codecBuffer.length);
-    this.encoded = uint8Array;
-    return this.encoded
-  }
-
-  hasCodec() {
-    if (!this.encoded) return false
-    const codec = new PeernetCodec(this.encoded);
-    if (codec.name) return true
-  }
-
-  fromUint8Array(buffer) {
-    this.encoded = buffer;
-    if (!this.hasCodec()) this.create(
-      JSON.parse(new TextDecoder().decode(this.encoded))
-    );
-    else this.decode();
-  }
-
-  fromArrayBuffer(buffer) {
-    this.encoded = new Uint8Array(buffer, buffer.byteOffset, buffer.byteLength);
-    if (!this.hasCodec()) this.create(
-      JSON.parse(new TextDecoder().decode(this.encoded))
-    );
-    else this.decode();
-  }
-
-  toString() {
-    return this.encoded.toString()
-  }
-
-  async toArray() {
-    const array = [];
-    for await (const value of this.encoded.values()) {
-      array.push(value);
-    }
-    return array
-  }
+const distanceInKmBetweenEarthCoordinates = (lat1, lon1, lat2, lon2) => {
+  const earthRadiusKm = 6371;
 
-  fromString(string) {
-    this.encoded = new Uint8Array(string.split(','));
-    this.decode();
-  }
+  const dLat = degreesToRadians(lat2-lat1);
+  const dLon = degreesToRadians(lon2-lon1);
 
-  fromArray(array) {
-    this.encoded = new Uint8Array([...array]);
-    this.decode();
-  }
+  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 {
   /**
-   * @param {Buffer} encoded
+   *
    */
-  fromEncoded(encoded) {
-    this.encoded = encoded;
-    this.decode();
+  constructor() {
+    this.providerMap = new Map();
   }
 
   /**
-   * @param {String} encoded
+   * @param {Object} address
+   * @return {Object} {latitude: lat, longitude: lon}
    */
-  fromHex(encoded) {
-    this.encoded = Buffer.from(encoded, 'hex');
-    this.decode();
+  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 {String} encoded
+   * @param {Object} peer
+   * @param {Object} provider
+   * @return {Object} {provider, distance}
    */
-  fromBs32(encoded) {
-    this.encoded = bs32__default["default"].decode(encoded);
-    this.decode();
+  async getDistance(peer, provider) {
+    const {latitude, longitude} = await this.getCoordinates(provider.address);
+    return {provider, distance: distanceInKmBetweenEarthCoordinates(peer.latitude, peer.longitude, latitude, longitude)}
   }
 
   /**
-   * @param {String} encoded
+   * @param {Array} providers
+   * @return {Object} closestPeer
    */
-  fromBs58(encoded) {
-    this.encoded = bs58__default["default"].decode(encoded);
-    this.decode();
-  }
+  async closestPeer(providers) {
+    let all = [];
+    const address = await getAddress();
+    const peerLoc = await this.getCoordinates(address);
 
-  /**
-   * @return {String} encoded
-   */
-  toHex() {
-    if (!this.encoded) this.encode();
-    return this.encoded.toString('hex')
-  }
+    for (const provider of providers) {
+      if (provider.address === '127.0.0.1') all.push({provider, distance: 0});
+      else all.push(this.getDistance(peerLoc, provider));
+    }
 
-  /**
-   * @return {String} encoded
-   */
-  toBs32() {
-    if (!this.encoded) this.encode();
-    return bs32__default["default"].encode(this.encoded)
+    all = await Promise.all(all);
+    all = all.sort((previous, current) => previous.distance - current.distance);
+    return all[0].provider;
   }
 
   /**
-   * @return {String} encoded
+   * @param {String} hash
+   * @return {Array} providers
    */
-  toBs58() {
-    if (!this.encoded) this.encode();
-    return bs58__default["default"].encode(this.encoded)
+  providersFor(hash) {
+    return this.providerMap.get(hash);
   }
 
   /**
-   * @param {Object} data
+   * @param {String} address
+   * @param {String} hash
+   * @return {Array} providers
    */
-  create(data) {
-    const decoded = {};
-    if (this.keys?.length > 0) {
-      for (const key of this.keys) {
-        Object.defineProperties(decoded, {
-          [key]: {
-            enumerable: true,
-            configurable: true,
-            set: (val) => value = data[key],
-            get: () => data[key]
-          }
-        });
-      }
-
-      this.decoded = decoded;
-      this.encode();
-    }
-  }
-}
-
-class PeernetMessage extends FormatInterface {
-  get keys() {
-    return ['data', 'signature', 'from', 'to', 'id']
-  }
+  async addProvider(address, hash) {
+    let providers = [];
+    if (this.providerMap.has(hash)) providers = this.providerMap.get(hash);
 
-  constructor(buffer) {
-    const name = 'peernet-message';
-    super(buffer, protons__default["default"](proto$a).PeernetMessage, {name});
+    providers = new Set([...providers, address]);
+    this.providerMap.set(hash, providers);
+    return providers;
   }
 }
 
-var proto$9 = `
-// PeernetDHTMessage
-message PeernetDHTMessage {
-  required string hash = 1;
-  optional string store = 2;
-}
-`;
-
 /**
- * @example `
-   new DHTMessage(hash, store)
-   // store = optional if not set, peernet checks every store
-   let message = new DHTMessage('hashmvbs124xcfd...', 'transaction')
-   message = new DHTMessage('hashmvbs124xcfd...', 'block')
- `
+ * @params {String} network
+ * @return {object} { identity, accounts, config }
  */
-class DHTMessage extends FormatInterface {
-  /**
-   *
-   */
-  get keys() {
-    return ['hash', 'store']
-  }
+var generateAccount = async network => {
+    let wallet = new MultiWallet__default["default"](network);
+    /**
+     * @type {string}
+     */
+    const mnemonic = await wallet.generate();
 
-  constructor(data) {
-    const name = 'peernet-dht';
-    super(data, protons__default["default"](proto$9).PeernetDHTMessage, {name});
-  }
-}
-
-var proto$8 = `
-// PeernetDHTMessageResponse
-message PeernetDHTMessageResponse {
-  required string hash = 1;
-  required bool has = 2;
-}
-`;
+    wallet = new MultiWallet__default["default"](network);
+    await wallet.recover(mnemonic, network);
+    /**
+     * @type {object}
+     */
+    const account = wallet.account(0);
+    /**
+     * @type {object}
+     */
+    const external = account.external(0);
+    const internal = account.internal(0);
+
+    return {
+      identity: {
+        mnemonic,
+        // multiWIF: wallet.export(),
+        publicKey: external.publicKey,
+        privateKey: external.privateKey,
+        walletId: external.id
+      },
+      accounts: [['main account', external.address, internal.address]]
+      // config: {
+      //  }
+    }
+  };
 
-class DHTMessageResponse extends FormatInterface {
-  get keys() {
-    return ['hash', 'has']
+var testnets = {
+  'leofcoin:olivia': {
+  	messagePrefix: '\u0019Leofcoin Signed Message:',
+  	pubKeyHash: 0x73, // o
+  	scriptHash: 0x76, // p
+    multiTxHash: 0x8b4125, // omtx
+  	payments: {
+      version: 0,
+      unspent: 0x1fa443d7 // ounsp
+    },
+  	wif: 0x7D, // s
+  	multiCodec: 0x7c4,
+  	bip32: { public: 0x13BBF2D5, private: 0x13BBCBC5 }
+  },
+  'bitcoin:testnet': {
+  	messagePrefix: '\x18Bitcoin Signed Message:\n',
+  	bech32: 'tb',
+  	pubKeyHash: 0x6f,
+  	scriptHash: 0xc4,
+  	wif: 0xef,
+  	bip32: {
+  		public: 0x043587cf,
+  		private: 0x04358394
+  	}
   }
 
-  constructor(data) {
-    const name = 'peernet-dht-response';
-    super(data, protons__default["default"](proto$8).PeernetDHTMessageResponse, {name});
-  }
-}
-
-var proto$7 = `
-// PeernetDataMessage
-message PeernetDataMessage {
-  required string hash = 1;
-  optional string store = 2;
-}
-`;
+};
 
+// https://en.bitcoin.it/wiki/List_of_address_prefixes
 /**
- * @extends {CodecFormat}
+ * Main network
+ * @return {messagePrefix, pubKeyHash, scriptHash, wif, bip32}
  */
-class DataMessage extends FormatInterface {
-  get keys() {
-    return ['hash', 'store']
-  }
-  /**
-   * @param {Buffer|String|Object|DataMessage} data - The data needed to create the DataMessage
-   */
-  constructor(data) {
-    super(data, protons__default["default"](proto$7).PeernetDataMessage, {name: 'peernet-data'});
-  }
-}
-
-var proto$6 = `
-// PsMessage
-message PsMessage {
-  required bytes data = 1;
-  required bytes topic = 2;
-}`;
-
-class PsMessage extends FormatInterface {
-  get keys() {
-    return ['data', 'topic']
-  }
-
-  constructor(buffer) {
-    const name = 'peernet-ps';
-    super(buffer, protons__default["default"](proto$6).PsMessage, {name});
-  }
-}
-
-var proto$5 = `
-// PeernetPeerMessage
-message PeernetPeerMessage {
-  required string id = 1;
-}
-`;
-
-class PeerMessage extends FormatInterface {
-  get keys() {
-    return ['id']
-  }
-
-  constructor(data) {
-    const name = 'peernet-peer';
-    super(data, protons__default["default"](proto$5).PeernetPeerMessage, {name});
-  }
-}
-
-var proto$4 = `
-// PeernetRequestMessage
-message PeernetRequestMessage {
-  required string request = 1;
-}
-`;
-
-class RequestMessage extends FormatInterface {
-  get keys() {
-    return ['request']
-  }
-
-  constructor(data) {
-    const name = 'peernet-request';
-    super(data, protons__default["default"](proto$4).PeernetRequestMessage, {name});
-  }
-}
-
-var proto$3 = `
-// PeernetResponseMessage
-message PeernetResponseMessage {
-  required bytes response = 1;
-}
-`;
-
-class ResponseMessage extends FormatInterface {
-  get keys() {
-    return ['response']
-  }
-
-  constructor(data) {
-    const name = 'peernet-response';
-    super(data, protons__default["default"](proto$3).PeernetResponseMessage, {name});
-  }
-}
-
-var proto$2 = `
-// PeernetPeerMessageResponse
-message PeernetPeerMessageResponse {
-  required string id = 1;
-}
-`;
-
-class PeerMessageResponse extends FormatInterface {
-  get keys() {
-    return ['id']
-  }
-
-  constructor(data) {
-    const name = 'peernet-peer-response';
-    super(data, protons__default["default"](proto$2).PeernetPeerMessageResponse, {name});
-  }
-}
-
-var proto$1 = `
-// PeernetDataMessageResponse
-message PeernetDataMessageResponse {
-  required string hash = 1;
-  required bytes data = 2;
-}
-`;
-
-class DataMessageResponse extends FormatInterface {
-  get keys() {
-    return ['hash', 'data']
-  }
-
-  constructor(data) {
-    const name = 'peernet-data-response';
-    super(data, protons__default["default"](proto$1).PeernetDataMessageResponse, {name});
-  }
-}
-
-var proto = `
-message ChatMessage {
-  required string value = 1;
-  required string author = 2;
-  required uint64 timestamp = 3;
-  repeated string files = 4;
-}`;
-
-class ChatMessage extends FormatInterface {
-  get keys() {
-    return ['author', 'value', 'timestamp', 'files']
-  }
-
-  constructor(buffer) {
-    const name = 'chat-message';
-    super(buffer, protons__default["default"](proto).ChatMessage, {name});
-  }
-}
-
-const protoFor = (data) => {
-  if (!Buffer.isBuffer(data)) data = Buffer.from(data);
-  const codec = new PeernetCodec(data);
-  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(data)
+const leofcoin = {
+	messagePrefix: '\u0019Leofcoin Signed Message:',
+	pubKeyHash: 0x30, // L
+	scriptHash: 0x37, // P
+	multiTxHash: 0x3adeed, // Lmtx
+	payments: {
+		version: 0,
+		unspent: 0x0d6e0327 // Lunsp
+	},
+	coin_type: 640,
+	wif: 0x3F, // S
+	multiCodec: 0x3c4,
+	bip32: { public: 0x13BBF2D4, private: 0x13BBCBC4 },
+	testnet: testnets['leofcoin:olivia']
 };
 
-/**
- * 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 bitcoin = {
+	messagePrefix: '\x18Bitcoin Signed Message:\n',
+	bech32: 'bc',
+	pubKeyHash: 0x00,
+	multiCodec: 0x00,
+	scriptHash: 0x05,
+	wif: 0x80,
+	coin_type: 0,
+	bip32: {
+		public: 0x0488b21e, private: 0x0488ade4
+	},
+	testnet: testnets['bitcoin:testnet']
 };
 
-const https = () => {
-  if (!globalThis.location) return false;
-  return Boolean(globalThis.location.protocol === 'https:')
+const litecoin = {
+	messagePrefix: '\x19Litecoin Signed Message:\n',
+	pubKeyHash: 0x30,
+	scriptHash: 0x32,
+	wif: 0xb0,
+	bip32: {
+		public: 0x019da462,
+		private: 0x019d9cfe
+	}
 };
 
-/**
- * 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'
-  }
+const ethereum = {
+	messagePrefix: '\x19Ethereum Signed Message:\n',
+	pubKeyHash: 0x30,
+	scriptHash: 0x32,
+	bip32: {
+		private: 0x0488ADE4, public: 0x0488B21E
+	},
+	coin_type: 60,
+	wif: 0x45,//E
+	multiCodec: 0x3c5
 };
 
 /**
- * * Get current environment
- * @return {Object} result
- * @property {Boolean} reult.daemon whether or not daemon is running
- * @property {Boolean} reult.environment Current environment
+ * Our & supported networks
+ * @return {leofcoin, olivia}
  */
-const target = async () => {
-  let daemon = false;
-  const env = await environment();
-  if (!https()) daemon = await hasDaemon();
-
-  return {daemon, environment: env}
+var networks = {
+	leofcoin,
+	bitcoin,
+	litecoin,
+	ethereum
 };
 
-class PeerDiscovery {
-  constructor(id) {
-    this.id = id;
-  }
-
-  _getPeerId(id) {
-    if (!peernet.peerMap || peernet.peerMap && peernet.peerMap.size === 0) return false
+const fromNetworkString = network => {
+  const parts = network.split(':');
+  network = networks[parts[0]];
+  if (parts[1]) {
+    if (network[parts[1]]) network = network[parts[1]];
 
-    for (const entry of [...peernet.peerMap.entries()]) {
-      for (const _id of entry[1]) {
-        if (_id === id) return entry[0]
-      }
-    }
+    network.coin_type = 1;
   }
+	return network;
+};
+
+// import { createHash } from 'crypto'
+// import { createHash as _createHash } from './hash'
 
-  async discover(peer) {
-    let id = this._getPeerId(peer.id);
-    if (id) return id
-    const data = new peernet.protos['peernet-peer']({id: this.id});
-    const node = await peernet.prepareMessage(peer.id, data.encoded);
+const { encode: encode$1, decode: decode$1 } = bs58check__default["default"];
+class HDWallet {
 
-    let response = await peer.request(node.encoded);
-    response = protoFor(response);
-    response = new peernet.protos['peernet-peer-response'](response.decoded.data);
+	get chainCodeBuffer() {
+		return this.ifNotLocked(() => this.hdnode.chainCode)
+	}
 
-    id = response.decoded.id;
-    if (id === this.id) return;
+	get chainCode() {
+		return this.ifNotLocked(() => this.chainCodeBuffer.toString('hex'))
+	}
 
-    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
-  }
+	get privateKeyBuffer() {
+		return this.ifNotLocked(() => this.hdnode.privateKey)
+	}
 
-  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;
+	get privateKey() {
+		return this.ifNotLocked(() => this.privateKeyBuffer.toString('hex'))
+	}
 
-      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 = new peernet.protos['peernet-peer-response']({id: this.id});
-      const node = await peernet.prepareMessage(from, data.encoded);
+	get publicKeyBuffer() {
+		return this.ifNotLocked(() => this.hdnode.publicKey)
+	}
 
-      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;
+	get publicKey() {
+		return this.ifNotLocked(() => this.publicKeyBuffer.toString('hex'))
+	}
 
-      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,
-  },
-};
+	get ethereumAddress() {
+		const buffer = ecc__default["default"].pointFromScalar(this.hdnode.__D, false);
+		let hash = createKeccakHash__default["default"]('keccak256').update(buffer.slice(1)).digest();
+		return `0x${hash.slice(-20).toString('hex')}`
+	}
 
-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;
-  }
+	// async bitcoinAddress() {
+	// 	const chainCode = this.privateKeyBuffer
+	//
+	// 	const node = bip32.fromPrivateKey(this.privateKeyBuffer, chainCode, networks['bitcoin'])
+	// 	let buffer = await _createHash(node.publicKey, 'SHA-256')
+	// 	buffer = createHash('ripemd160').update(buffer).digest()
+	// 	// buffer = Buffer.from(`0x00${buffer.toString('hex')}`, 'hex')
+	// 	// buffer = createHash('sha256').update(buffer).digest()
+	// 	// const mainHash = buffer
+	// 	// buffer = createHash('sha256').update(buffer).digest()
+	// 	// const checksum = buffer.toString('hex').substring(0, 8)
+	// 	// return base58.encode(Buffer.concat([mainHash, Buffer.from(checksum, 'hex')]))
+	// 	const payload = Buffer.allocUnsafe(21)
+	//   payload.writeUInt8(networks['bitcoin'].pubKeyHash, 0)
+	//   buffer.copy(payload, 1)
+	//
+  // 	return encode(payload)
+	// }
 
-  return address.value
-};
+	get leofcoinAddress() {
+		return encode$1(this.neutered.publicKeyBuffer)
+	}
 
-const degreesToRadians = (degrees) => {
-  return degrees * Math.PI / 180;
-};
+	get address() {
+		return this.getAddressForCoin()
+	}
 
-const distanceInKmBetweenEarthCoordinates = (lat1, lon1, lat2, lon2) => {
-  const earthRadiusKm = 6371;
+	getAddressForCoin(coin_type) {
+		if (!coin_type) coin_type = this.hdnode.network.coin_type;
+		if (coin_type === 1) {
+			if (this.networkName?.split(':')[0] === 'ethereum') coin_type = 60;
+			if (this.networkName?.split(':')[0] === 'leofcoin') coin_type = 640;
+		}
+		// if (coin_type === 0) return this.bitcoinAddress
+		if (coin_type === 60) return this.ethereumAddress
+		if (coin_type === 640) return this.leofcoinAddress
+	}
 
-  const dLat = degreesToRadians(lat2-lat1);
-  const dLon = degreesToRadians(lon2-lon1);
+	get accountAddress() {
+		return this.ifNotLocked(() => encode$1(this.hdnode.publicKeyBuffer))
+	}
 
-  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;
-};
+	get isTestnet() {
+		if (typeof network === 'string')
+			this.hdnode.network = fromNetworkString(network);
 
-class DhtEarth {
-  /**
-   *
-   */
-  constructor() {
-    this.providerMap = new Map();
-  }
+		return Boolean(this.hdnode.network.coin_type === 1)
+	}
 
-  /**
-   * @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}
-  }
+	constructor(network, hdnode) {
+		if (typeof network === 'string') {
+			this.networkName = network;
+			this.network = fromNetworkString(network);
+		} else if (typeof network === 'object')
+      this.network = network;
 
-  /**
-   * @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)}
-  }
+    if (hdnode) this.defineHDNode(hdnode);
+	}
 
-  /**
-   * @param {Array} providers
-   * @return {Object} closestPeer
-   */
-  async closestPeer(providers) {
-    let all = [];
-    const address = await getAddress();
-    const peerLoc = await this.getCoordinates(address);
+	ifNotLocked(fn, params) {
+		if (!this.locked) return fn(params);
+		return null
+	}
 
-    for (const provider of providers) {
-      if (provider.address === '127.0.0.1') all.push({provider, distance: 0});
-      else all.push(this.getDistance(peerLoc, provider));
-    }
+	defineHDNode(value) {
+		Object.defineProperty(this, 'hdnode', {
+			configurable: false,
+			writable: false,
+			value: value
+		});
+	}
 
-    all = await Promise.all(all);
-    all = all.sort((previous, current) => previous.distance - current.distance);
-    return all[0].provider;
-  }
+	validateNetwork(network) {
+		if (!network && !this.network) return console.error(`expected network to be defined`);
+		if (!network && this.network) network = this.network;
+		if (typeof network === 'string') network = fromNetworkString(network);
+		if (typeof network !== 'object') return console.error('network not found');
+		return network;
+	}
 
-  /**
-   * @param {String} hash
-   * @return {Array} providers
-   */
-  providersFor(hash) {
-    return this.providerMap.get(hash);
-  }
+	async generate(password, network) {
+		network = this.validateNetwork(network);
+		const mnemonic = new Mnemonic__default["default"]().generate();
+		const seed = new Mnemonic__default["default"]().seedFromMnemonic(mnemonic, password);
+		this.defineHDNode(bip32__namespace.fromSeed(seed, network));
+		return mnemonic;
+	}
 
-  /**
-   * @param {String} address
-   * @param {String} hash
-   * @return {Array} providers
+	/**
+   * recover using mnemonic (recovery word list)
    */
-  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;
-  }
-}
-
-/**
- * @params {String} network
- * @return {object} { identity, accounts, config }
- */
-var generateAccount = async network => {
-    let wallet = new MultiWallet__default["default"](network);
-    /**
-     * @type {string}
-     */
-    const mnemonic = await wallet.generate();
+	async recover(mnemonic, password, network) {
+		network = this.validateNetwork(network, password);
+		const seed = new Mnemonic__default["default"]().seedFromMnemonic(mnemonic, password);
+		this.defineHDNode(bip32__namespace.fromSeed(seed, network));
+	}
 
-    wallet = new MultiWallet__default["default"](network);
-    await wallet.recover(mnemonic, network);
-    /**
-     * @type {object}
-     */
-    const account = wallet.account(0);
-    /**
-     * @type {object}
-     */
-    const external = account.external(0);
-    const internal = account.internal(0);
+	load(base58, network) {
+		network = this.validateNetwork(network);
+		this.defineHDNode(bip32__namespace.fromBase58(base58, network));
+	}
 
-    return {
-      identity: {
-        mnemonic,
-        // multiWIF: wallet.export(),
-        publicKey: external.publicKey,
-        privateKey: external.privateKey,
-        walletId: external.id
-      },
-      accounts: [['main account', external.address, internal.address]]
-      // config: {
-      //  }
-    }
-  };
-
-var testnets = {
-  'leofcoin:olivia': {
-  	messagePrefix: '\u0019Leofcoin Signed Message:',
-  	pubKeyHash: 0x73, // o
-  	scriptHash: 0x76, // p
-    multiTxHash: 0x8b4125, // omtx
-  	payments: {
-      version: 0,
-      unspent: 0x1fa443d7 // ounsp
-    },
-  	wif: 0x7D, // s
-  	multiCodec: 0x7c4,
-  	bip32: { public: 0x13BBF2D5, private: 0x13BBCBC5 }
-  },
-  'bitcoin:testnet': {
-  	messagePrefix: '\x18Bitcoin Signed Message:\n',
-  	bech32: 'tb',
-  	pubKeyHash: 0x6f,
-  	scriptHash: 0xc4,
-  	wif: 0xef,
-  	bip32: {
-  		public: 0x043587cf,
-  		private: 0x04358394
-  	}
-  }
+	save() {
+		return this.hdnode.toBase58();
+	}
 
-};
+	fromAddress(address, chainCode, network) {
+		network = this.validateNetwork(network);
+		// if (network.coin_type === 60) {
+		// 	address = Buffer.from(address, 'hex')
+		// } else {
+			address = decode$1(address);
+		// }
+
+		if (!chainCode || chainCode && !Buffer.isBuffer(chainCode)) chainCode = address.slice(1);
+		this.defineHDNode(bip32__namespace.fromPublicKey(address, chainCode, network));
+	}
+
+	fromPublicKey(hex, chainCode, network) {
+		network = this.validateNetwork(network);
+		if (!Buffer.isBuffer(hex)) hex = Buffer.from(hex, 'hex');
+		if (!chainCode || chainCode && !Buffer.isBuffer(chainCode)) chainCode = hex.slice(1);
+		this.defineHDNode(bip32__namespace.fromPublicKey(hex, chainCode, network));
+	}
+}
 
-// https://en.bitcoin.it/wiki/List_of_address_prefixes
-/**
- * Main network
- * @return {messagePrefix, pubKeyHash, scriptHash, wif, bip32}
- */
-const leofcoin = {
-	messagePrefix: '\u0019Leofcoin Signed Message:',
-	pubKeyHash: 0x30, // L
-	scriptHash: 0x37, // P
-	multiTxHash: 0x3adeed, // Lmtx
-	payments: {
-		version: 0,
-		unspent: 0x0d6e0327 // Lunsp
-	},
-	coin_type: 640,
-	wif: 0x3F, // S
-	multiCodec: 0x3c4,
-	bip32: { public: 0x13BBF2D4, private: 0x13BBCBC4 },
-	testnet: testnets['leofcoin:olivia']
-};
+const { subtle } = crypto;
 
-const bitcoin = {
-	messagePrefix: '\x18Bitcoin Signed Message:\n',
-	bech32: 'bc',
-	pubKeyHash: 0x00,
-	multiCodec: 0x00,
-	scriptHash: 0x05,
-	wif: 0x80,
-	coin_type: 0,
-	bip32: {
-		public: 0x0488b21e, private: 0x0488ade4
-	},
-	testnet: testnets['bitcoin:testnet']
+const generateAesKey = async (length = 256) => {
+  const key = await subtle.generateKey({
+    name: 'AES-CBC',
+    length
+  }, true, ['encrypt', 'decrypt']);
+
+  return key;
 };
 
-const litecoin = {
-	messagePrefix: '\x19Litecoin Signed Message:\n',
-	pubKeyHash: 0x30,
-	scriptHash: 0x32,
-	wif: 0xb0,
-	bip32: {
-		public: 0x019da462,
-		private: 0x019d9cfe
-	}
+const importAesKey = async (exported, format = 'raw', length = 256) => {
+  return await subtle.importKey(format, exported, {
+    name: 'AES-CBC',
+    length
+  }, true, ['encrypt', 'decrypt'])
 };
 
-const ethereum = {
-	messagePrefix: '\x19Ethereum Signed Message:\n',
-	pubKeyHash: 0x30,
-	scriptHash: 0x32,
-	bip32: {
-		private: 0x0488ADE4, public: 0x0488B21E
-	},
-	coin_type: 60,
-	wif: 0x45,//E
-	multiCodec: 0x3c5
+const exportAesKey = async (key, format = 'raw') => {
+  return await subtle.exportKey(format, key)
 };
 
-/**
- * Our & supported networks
- * @return {leofcoin, olivia}
- */
-var networks = {
-	leofcoin,
-	bitcoin,
-	litecoin,
-	ethereum
-};
-
-const fromNetworkString = network => {
-  const parts = network.split(':');
-  network = networks[parts[0]];
-  if (parts[1]) {
-    if (network[parts[1]]) network = network[parts[1]];
+const encryptAes = async (uint8Array, key, iv) => subtle.encrypt({
+    name: 'AES-CBC',
+    iv,
+  }, key, uint8Array);
 
-    network.coin_type = 1;
+const uint8ArrayToHex = uint8Array =>
+  [...uint8Array].map(x => x.toString(16).padStart(2, '0')).join('');
+
+const arrayBufferToHex = arrayBuffer =>
+  uint8ArrayToHex(new Uint8Array(arrayBuffer));
+
+const hexToUint8Array = hex =>
+  new Uint8Array(hex.match(/[\da-f]{2}/gi).map(x => parseInt(x, 16)));
+
+const encrypt = async string => {
+  const ec = new TextEncoder();
+  const key = await generateAesKey();
+  const iv = await randombytes__default["default"](16);
+
+  const ciphertext = await encryptAes(ec.encode(string), key, iv);
+  const exported = await exportAesKey(key);
+
+  return {
+    key: arrayBufferToHex(exported),
+    iv: iv.toString('hex'),
+    cipher: arrayBufferToHex(ciphertext)
   }
-	return network;
+};
+
+const decrypt = async (cipher, key, iv) => {
+  if (!key.type) key = await importAesKey(hexToUint8Array(key));
+  cipher = new Uint8Array(hexToUint8Array(cipher));
+  iv = new Uint8Array(hexToUint8Array(iv));
+
+  const dec = new TextDecoder();
+  const plaintext = await subtle.decrypt({
+   name: 'AES-CBC',
+   iv,
+  }, key, cipher);
+
+  return dec.decode(plaintext);
 };
 
-// import { createHash } from 'crypto'
-// import { createHash as _createHash } from './hash'
+const { encode, decode } = bs58check__namespace;
 
-const { encode: encode$1, decode: decode$1 } = bs58check__default["default"];
-class HDWallet {
+// TODO: multihash addresses
+class HDAccount {
+	/**
+	 * @param {number} depth - acount depth
+	 */
+	constructor(node, depth = 0) {
+		this.node = node;
+		this.depth = depth;
+		this._prefix = `m/44'/${node.network.coin_type}'/${depth}'/`;
+	}
 
-	get chainCodeBuffer() {
-		return this.ifNotLocked(() => this.hdnode.chainCode)
+	/**
+	 * @param {number} index - address index
+	 */
+	internal(index = 0) {
+		return this.node.derivePath(`${this._prefix}1/${index}`)
 	}
 
-	get chainCode() {
-		return this.ifNotLocked(() => this.chainCodeBuffer.toString('hex'))
+	/**
+	 * @param {number} index - address index
+	 */
+	external(index = 0) {
+		return this.node.derivePath(`${this._prefix}0/${index}`)
 	}
+}
 
-	get privateKeyBuffer() {
-		return this.ifNotLocked(() => this.hdnode.privateKey)
+class MultiWallet extends HDWallet {
+	constructor(network, hdnode) {
+		super(network, hdnode);
+		this.multiCodec = this.network.multiCodec;
+		this.version = 0x00;
 	}
 
-	get privateKey() {
-		return this.ifNotLocked(() => this.privateKeyBuffer.toString('hex'))
+	get id() {
+		const buffer = Buffer.concat([
+			Buffer.from(varint__default["default"].encode(this.multiCodec)),
+			Buffer.from(this.account(0).node.neutered.publicKey, 'hex')
+		]);
+		return encode(buffer)
 	}
 
-	get publicKeyBuffer() {
-		return this.ifNotLocked(() => this.hdnode.publicKey)
+	get multiWIF() {
+		return this.ifNotLocked(() => this.encode())
 	}
 
-	get publicKey() {
-		return this.ifNotLocked(() => this.publicKeyBuffer.toString('hex'))
-	}
-
-	get ethereumAddress() {
-		const buffer = ecc__default["default"].pointFromScalar(this.hdnode.__D, false);
-		let hash = createKeccakHash__default["default"]('keccak256').update(buffer.slice(1)).digest();
-		return `0x${hash.slice(-20).toString('hex')}`
-	}
-
-	// async bitcoinAddress() {
-	// 	const chainCode = this.privateKeyBuffer
-	//
-	// 	const node = bip32.fromPrivateKey(this.privateKeyBuffer, chainCode, networks['bitcoin'])
-	// 	let buffer = await _createHash(node.publicKey, 'SHA-256')
-	// 	buffer = createHash('ripemd160').update(buffer).digest()
-	// 	// buffer = Buffer.from(`0x00${buffer.toString('hex')}`, 'hex')
-	// 	// buffer = createHash('sha256').update(buffer).digest()
-	// 	// const mainHash = buffer
-	// 	// buffer = createHash('sha256').update(buffer).digest()
-	// 	// const checksum = buffer.toString('hex').substring(0, 8)
-	// 	// return base58.encode(Buffer.concat([mainHash, Buffer.from(checksum, 'hex')]))
-	// 	const payload = Buffer.allocUnsafe(21)
-	//   payload.writeUInt8(networks['bitcoin'].pubKeyHash, 0)
-	//   buffer.copy(payload, 1)
-	//
-  // 	return encode(payload)
-	// }
-
-	get leofcoinAddress() {
-		return encode$1(this.neutered.publicKeyBuffer)
-	}
-
-	get address() {
-		return this.getAddressForCoin()
-	}
-
-	getAddressForCoin(coin_type) {
-		if (!coin_type) coin_type = this.hdnode.network.coin_type;
-		if (coin_type === 1) {
-			if (this.networkName?.split(':')[0] === 'ethereum') coin_type = 60;
-			if (this.networkName?.split(':')[0] === 'leofcoin') coin_type = 640;
-		}
-		// if (coin_type === 0) return this.bitcoinAddress
-		if (coin_type === 60) return this.ethereumAddress
-		if (coin_type === 640) return this.leofcoinAddress
-	}
-
-	get accountAddress() {
-		return this.ifNotLocked(() => encode$1(this.hdnode.publicKeyBuffer))
-	}
-
-	get isTestnet() {
-		if (typeof network === 'string')
-			this.hdnode.network = fromNetworkString(network);
-
-		return Boolean(this.hdnode.network.coin_type === 1)
-	}
-
-	constructor(network, hdnode) {
-		if (typeof network === 'string') {
-			this.networkName = network;
-			this.network = fromNetworkString(network);
-		} else if (typeof network === 'object')
-      this.network = network;
-
-    if (hdnode) this.defineHDNode(hdnode);
-	}
-
-	ifNotLocked(fn, params) {
-		if (!this.locked) return fn(params);
-		return null
-	}
-
-	defineHDNode(value) {
-		Object.defineProperty(this, 'hdnode', {
-			configurable: false,
-			writable: false,
-			value: value
-		});
-	}
-
-	validateNetwork(network) {
-		if (!network && !this.network) return console.error(`expected network to be defined`);
-		if (!network && this.network) network = this.network;
-		if (typeof network === 'string') network = fromNetworkString(network);
-		if (typeof network !== 'object') return console.error('network not found');
-		return network;
-	}
-
-	async generate(password, network) {
-		network = this.validateNetwork(network);
-		const mnemonic = new Mnemonic__default["default"]().generate();
-		const seed = new Mnemonic__default["default"]().seedFromMnemonic(mnemonic, password);
-		this.defineHDNode(bip32__namespace.fromSeed(seed, network));
-		return mnemonic;
-	}
-
-	/**
-   * recover using mnemonic (recovery word list)
-   */
-	async recover(mnemonic, password, network) {
-		network = this.validateNetwork(network, password);
-		const seed = new Mnemonic__default["default"]().seedFromMnemonic(mnemonic, password);
-		this.defineHDNode(bip32__namespace.fromSeed(seed, network));
-	}
-
-	load(base58, network) {
-		network = this.validateNetwork(network);
-		this.defineHDNode(bip32__namespace.fromBase58(base58, network));
-	}
-
-	save() {
-		return this.hdnode.toBase58();
-	}
-
-	fromAddress(address, chainCode, network) {
-		network = this.validateNetwork(network);
-		// if (network.coin_type === 60) {
-		// 	address = Buffer.from(address, 'hex')
-		// } else {
-			address = decode$1(address);
-		// }
-
-		if (!chainCode || chainCode && !Buffer.isBuffer(chainCode)) chainCode = address.slice(1);
-		this.defineHDNode(bip32__namespace.fromPublicKey(address, chainCode, network));
-	}
-
-	fromPublicKey(hex, chainCode, network) {
-		network = this.validateNetwork(network);
-		if (!Buffer.isBuffer(hex)) hex = Buffer.from(hex, 'hex');
-		if (!chainCode || chainCode && !Buffer.isBuffer(chainCode)) chainCode = hex.slice(1);
-		this.defineHDNode(bip32__namespace.fromPublicKey(hex, chainCode, network));
-	}
-}
-
-const { subtle } = crypto;
-
-const generateAesKey = async (length = 256) => {
-  const key = await subtle.generateKey({
-    name: 'AES-CBC',
-    length
-  }, true, ['encrypt', 'decrypt']);
-
-  return key;
-};
-
-const importAesKey = async (exported, format = 'raw', length = 256) => {
-  return await subtle.importKey(format, exported, {
-    name: 'AES-CBC',
-    length
-  }, true, ['encrypt', 'decrypt'])
-};
-
-const exportAesKey = async (key, format = 'raw') => {
-  return await subtle.exportKey(format, key)
-};
-
-const encryptAes = async (uint8Array, key, iv) => subtle.encrypt({
-    name: 'AES-CBC',
-    iv,
-  }, key, uint8Array);
-
-const uint8ArrayToHex = uint8Array =>
-  [...uint8Array].map(x => x.toString(16).padStart(2, '0')).join('');
-
-const arrayBufferToHex = arrayBuffer =>
-  uint8ArrayToHex(new Uint8Array(arrayBuffer));
-
-const hexToUint8Array = hex =>
-  new Uint8Array(hex.match(/[\da-f]{2}/gi).map(x => parseInt(x, 16)));
-
-const encrypt = async string => {
-  const ec = new TextEncoder();
-  const key = await generateAesKey();
-  const iv = await randombytes__default["default"](16);
-
-  const ciphertext = await encryptAes(ec.encode(string), key, iv);
-  const exported = await exportAesKey(key);
-
-  return {
-    key: arrayBufferToHex(exported),
-    iv: iv.toString('hex'),
-    cipher: arrayBufferToHex(ciphertext)
-  }
-};
-
-const decrypt = async (cipher, key, iv) => {
-  if (!key.type) key = await importAesKey(hexToUint8Array(key));
-  cipher = new Uint8Array(hexToUint8Array(cipher));
-  iv = new Uint8Array(hexToUint8Array(iv));
-
-  const dec = new TextDecoder();
-  const plaintext = await subtle.decrypt({
-   name: 'AES-CBC',
-   iv,
-  }, key, cipher);
-
-  return dec.decode(plaintext);
-};
-
-const { encode, decode } = bs58check__namespace;
-
-// TODO: multihash addresses
-class HDAccount {
-	/**
-	 * @param {number} depth - acount depth
-	 */
-	constructor(node, depth = 0) {
-		this.node = node;
-		this.depth = depth;
-		this._prefix = `m/44'/${node.network.coin_type}'/${depth}'/`;
-	}
-
-	/**
-	 * @param {number} index - address index
-	 */
-	internal(index = 0) {
-		return this.node.derivePath(`${this._prefix}1/${index}`)
-	}
-
-	/**
-	 * @param {number} index - address index
-	 */
-	external(index = 0) {
-		return this.node.derivePath(`${this._prefix}0/${index}`)
-	}
-}
-
-class MultiWallet extends HDWallet {
-	constructor(network, hdnode) {
-		super(network, hdnode);
-		this.multiCodec = this.network.multiCodec;
-		this.version = 0x00;
-	}
-
-	get id() {
-		const buffer = Buffer.concat([
-			Buffer.from(varint__default["default"].encode(this.multiCodec)),
-			Buffer.from(this.account(0).node.neutered.publicKey, 'hex')
-		]);
-		return encode(buffer)
-	}
-
-	get multiWIF() {
-		return this.ifNotLocked(() => this.encode())
-	}
-
-	get neutered() {
-		const neutered = this.ifNotLocked(() => new MultiWallet(this.networkName, this.hdnode.neutered()));
-		if (neutered) this._neutered = neutered;
-		return this._neutered
+	get neutered() {
+		const neutered = this.ifNotLocked(() => new MultiWallet(this.networkName, this.hdnode.neutered()));
+		if (neutered) this._neutered = neutered;
+		return this._neutered
 	}
 
 	fromId(id) {
@@ -2243,707 +1704,1272 @@ class MultiWallet extends HDWallet {
 		return encode(buffer);
 	}
 
-	decode(bs58) {
-		let buffer = decode(bs58);
-		const version = varint__default["default"].decode(buffer);
-		buffer = buffer.slice(varint__default["default"].decode.bytes);
-		const multiCodec = varint__default["default"].decode(buffer);
-		buffer = buffer.slice(varint__default["default"].decode.bytes);
-		bs58 = encode(buffer);
-		if (version !== this.version) throw TypeError('Invalid version');
-		if (this.multiCodec !== multiCodec) throw TypeError('Invalid multiCodec');
-		return { version, multiCodec, bs58 };
-	}
+	decode(bs58) {
+		let buffer = decode(bs58);
+		const version = varint__default["default"].decode(buffer);
+		buffer = buffer.slice(varint__default["default"].decode.bytes);
+		const multiCodec = varint__default["default"].decode(buffer);
+		buffer = buffer.slice(varint__default["default"].decode.bytes);
+		bs58 = encode(buffer);
+		if (version !== this.version) throw TypeError('Invalid version');
+		if (this.multiCodec !== multiCodec) throw TypeError('Invalid multiCodec');
+		return { version, multiCodec, bs58 };
+	}
+
+	sign(hash) {
+		return new MultiSignature__default["default"](this.version, this.network.multiCodec)
+			.sign(hash, this.privateKeyBuffer);
+
+	}
+
+	verify(multiSignature, hash) {
+		return new MultiSignature__default["default"](this.version, this.network.multiCodec)
+			.verify(multiSignature, hash, this.publicKeyBuffer)
+	}
+
+	/**
+	 * @param {number} account - account to return chain for
+	 * @return { internal(addressIndex), external(addressIndex) }
+	 */
+	account(index) {
+		return new HDAccount(new MultiWallet(this.networkName, this.hdnode), index);
+	}
+
+	/**
+	 * m / purpose' / coin_type' / account' / change / aadress_index
+	 *
+	 * see https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki
+	 */
+	derivePath(path) {
+		return new MultiWallet(this.networkName, this.hdnode.derivePath(path))
+	}
+
+	derive(index) {
+		return new MultiWallet(this.networkName, this.hdnode.derive(index));
+	}
+}
+
+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 signature
+   */
+  async hashAndSignMessage(message) {
+    const hasher = new codecFormatInterface.CodecHash(message, {name: 'peernet-message'});
+    let identity = await walletStore.get('identity');
+    identity = JSON.parse(new TextDecoder().decode(identity));
+    const wallet = new MultiWallet(this.network);
+    wallet.recover(identity.mnemonic);
+    return wallet.sign(Buffer.from(hasher.hash).slice(0, 32))
+  }
+
+  /**
+   * @param {String} from - peer id
+   * @param {String} to - peer id
+   * @param {String|PeernetMessage} data - data encoded message string
+   * or the messageNode itself
+   */
+  async prepareMessage(from, to, data, id) {
+    if (data.encoded) data = data.encoded;
+
+    const message = {
+      from,
+      to,
+      data,
+    };
+    const signature = await this.hashAndSignMessage(message);
+    const node = new PeernetMessage({
+      ...message,
+      signature,
+    });
+
+    return node
+  }
+}
+
+const dataHandler = async message => {
+  if (!message) return
+
+  const {data, id} = message;
+
+  message = protoFor(data);
+  const proto = protoFor(message.decoded.data);
+  const from = message.decoded.from;
+
+  peernet._protoHandler({id, proto}, peernet.client.connections[from], from);
+};
+
+const encapsulatedError = () => {
+  return new Error('Nodes/Data should be send encapsulated by peernet-message')
+};
+
+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.leofcoin = globalThis.leofcoin || {};
+globalThis.globalSub = globalThis.globalSub || new PubSub({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.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';
+    const parts = this.network.split(':');
+
+    if (!options.storePrefix) options.storePrefix = 'lfc';
+    if (!options.port) options.port = 2000;
+    if (!options.root) {
+      if (parts[1]) options.root = `.${parts[0]}/peernet/${parts[1]}`;
+      else options.root = `.${this.network}/peernet`;
+    }
+    globalThis.peernet = this;
+    this.bw = {
+      up: 0,
+      down: 0,
+    };
+    return this._init(options)
+  }
+
+  get defaultStores() {
+    return ['account', 'wallet', 'block', 'transaction', 'chain', 'data', 'message']
+  }
+
+  addProto(name, proto) {
+    if (!this.protos[name]) this.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 = globalThis.LeofcoinStorage?.default ? globalThis.LeofcoinStorage.default : 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(to, data) {
+    return this._messageHandler.prepareMessage(this.id, to, 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;
+
+    /**
+     * 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,
+    };
+
+    this.protos = globalThis.peernet.protos;
+    this.codecs = codecFormatInterface.codecs;
+
+    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);
+    }
+
+    try {
+      const pub = await accountStore.get('public');
+      this.id = JSON.parse(new TextDecoder().decode(pub)).walletId;
+    } catch (e) {
+      if (e.code === 'ERR_NOT_FOUND') {
+        const {identity, accounts, config} = await generateAccount(this.network);
+        walletStore.put('version', new TextEncoder().encode(1));
+        walletStore.put('accounts', new TextEncoder().encode(accounts));
+        walletStore.put('identity', new TextEncoder().encode(JSON.stringify(identity)));
+        await accountStore.put('config', new TextEncoder().encode(JSON.stringify(config)));
+        await accountStore.put('public', new TextEncoder().encode(JSON.stringify({walletId: identity.walletId})));
+
+        this.id = identity.walletId;
+      } else {
+        throw e
+      }
+    }
+    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);
+
+    /**
+     * @access public
+     * @type {PeernetClient}
+     */
+    this.client = new Client(this.id);
+    if (globalThis.onbeforeunload) {
+      globalThis.addEventListener('beforeunload', async () => this.client.close());
+    }
+    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 = new DHTMessageResponse({hash, has});
+        const node = await this.prepareMessage(from, data.encoded);
+
+        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 = new DataMessageResponse({hash, data});
+
+            const node = await this.prepareMessage(from, data.encoded);
+            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(from, data.encoded);
+          this.sendMessage(peer, id, node.encoded);
+        }
+      } else if (proto.name === 'peernet-ps' && peer.peerId !== this.id) {
+        globalSub.publish(new TextDecoder().decode(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 = new DHTMessage({hash});
+    this.client.id;
+    const walk = async peer => {
+      const node = await this.prepareMessage(peer.peerId, data.encoded);
+      let result = await peer.request(node.encoded);
+      result = new Uint8Array(Object.values(result));
+      let proto = protoFor(result);
+      if (proto.name !== 'peernet-message') throw encapsulatedError()
+      const from = proto.decoded.from;
+      proto = protoFor(proto.decoded.data);
+      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: from,
+      };
+
+      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 await 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
+      });
 
-	sign(hash) {
-		return new MultiSignature__default["default"](this.version, this.network.multiCodec)
-			.sign(hash, this.privateKeyBuffer);
+      let data = new DataMessage({hash, store: store?.name ? store?.name : store});
 
-	}
+      const node = await this.prepareMessage(id, data.encoded);
+      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));
+      let proto = protoFor(data);
+      proto = protoFor(proto.decoded.data);
+      // TODO: store data automaticly or not
+      return proto.decoded.data
 
-	verify(multiSignature, hash) {
-		return new MultiSignature__default["default"](this.version, this.network.multiCodec)
-			.verify(multiSignature, hash, this.publicKeyBuffer)
-	}
+      // this.put(hash, proto.decoded.data)
+    }
+    return null
+  }
 
-	/**
-	 * @param {number} account - account to return chain for
-	 * @return { internal(addressIndex), external(addressIndex) }
-	 */
-	account(index) {
-		return new HDAccount(new MultiWallet(this.networkName, this.hdnode), index);
-	}
 
-	/**
-	 * m / purpose' / coin_type' / account' / change / aadress_index
-	 *
-	 * see https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki
-	 */
-	derivePath(path) {
-		return new MultiWallet(this.networkName, this.hdnode.derivePath(path))
-	}
+  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),
+    }
+  }
 
-	derive(index) {
-		return new MultiWallet(this.networkName, this.hdnode.derive(index));
-	}
-}
-
-class MessageHandler {
-  constructor(network) {
-    this.network = network;
+  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),
+    }
   }
+
   /**
-   * 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 signature
+   * goes trough given stores and tries to find data for given hash
+   * @param {Array} stores
+   * @param {string} hash
    */
-  async hashAndSignMessage(message) {
-    const hasher = new PeernetHash(message, {name: 'peernet-message'});
-    let identity = await walletStore.get('identity');
-    identity = JSON.parse(new TextDecoder().decode(identity));
-    const wallet = new MultiWallet(this.network);
-    wallet.recover(identity.mnemonic);
-    return wallet.sign(Buffer.from(hasher.hash).slice(0, 32))
+  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
   }
 
   /**
-   * @param {String} from - peer id
-   * @param {String} to - peer id
-   * @param {String|PeernetMessage} data - data encoded message string
-   * or the messageNode itself
+   * Get content for given hash
+   *
+   * @param {String} hash - the hash of the wanted data
+   * @param {String} store - storeName to access
    */
-  async prepareMessage(from, to, data, id) {
-    if (data.encoded) data = data.encoded;
+  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
 
-    const message = {
-      from,
-      to,
-      data,
-    };
-    const signature = await this.hashAndSignMessage(message);
-    const node = new PeernetMessage({
-      ...message,
-      signature,
-    });
+    return this.requestData(hash, store?.name ? store.name : store)
+  }
 
-    return node
+  /**
+   * 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)
   }
-}
-
-const dataHandler = async message => {
-  if (!message) return
 
-  const {data, id} = message;
+  /**
+   * @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
+  }
 
-  message = protoFor(data);
-  const proto = protoFor(message.decoded.data);
-  const from = message.decoded.from;
+  /**
+   *
+   * @param {String} topic
+   * @param {String|Object|Array|Boolean|Buffer} data
+   */
+  async publish(topic, data) {
+    // globalSub.publish(topic, data)
+    if (topic instanceof Uint8Array === false) topic = new TextEncoder().encode(topic);
+    if (data instanceof Uint8Array === false) data = new TextEncoder().encode(JSON.stringify(data));
+    const id = Math.random().toString(36).slice(-12);
+    data = new PsMessage({data, topic});
+    for (const peer of this.connections) {
+      if (peer.peerId !== this.peerId) {
+        const node = await this.prepareMessage(peer.peerId, data.encoded);
+        this.sendMessage(peer, id, node.encoded);
+      }
+      // TODO: if peer subscribed
+    }
+  }
 
-  peernet._protoHandler({id, proto}, peernet.client.connections[from], from);
-};
-
-const encapsulatedError = () => {
-  return new Error('Nodes/Data should be send encapsulated by peernet-message')
-};
-
-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.leofcoin = globalThis.leofcoin || {};
-globalThis.globalSub = globalThis.globalSub || new PubSub({verbose: true});
+  createHash(data, name) {
+    return new codecFormatInterface.CodecHash(data, {name})
+  }
 
-/**
- * @access public
- * @example
- * const peernet = new Peernet();
- */
-class Peernet {
   /**
-   * @access public
-   * @param {Object} options
-   * @param {String} options.network - desired network
-   * @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'});
+   * @param {String} topic
+   * @param {Method} cb
    */
-  constructor(options = {}) {
-    this._discovered = [];
-    /**
-     * @property {String} network - current network
-     */
-    this.network = options.network || 'leofcoin';
-    const parts = this.network.split(':');
+  async subscribe(topic, cb) {
+    // TODO: if peer subscribed
+    globalSub.subscribe(topic, cb);
+  }
 
-    if (!options.storePrefix) options.storePrefix = 'lfc';
-    if (!options.port) options.port = 2000;
-    if (!options.root) {
-      if (parts[1]) options.root = `.${parts[0]}/peernet/${parts[1]}`;
-      else options.root = `.${this.network}/peernet`;
-    }
-    globalThis.peernet = this;
-    this.bw = {
-      up: 0,
-      down: 0,
-    };
-    return this._init(options)
+  async removePeer(peer) {
+    return this.client.removePeer(peer)
   }
 
-  get defaultStores() {
-    return ['account', 'wallet', 'block', 'transaction', 'chain', 'data', 'message']
+  get Buffer() {
+    return Buffer
   }
+  // async block(index) {
+  //   const _values = []
+  //   for (const peer of this.peers) {
+  //     const value = await peer.request({type: 'block', index})
+  //     console.log(value);
+  //   }
+  //
+  // }
+}
+
+module.exports = Peernet;
+
+
+/***/ }),
+
+/***/ 5698:
+/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "default": function() { return /* binding */ src; }
+});
+
+// EXTERNAL MODULE: ./node_modules/@vandeurenglenn/base32/src/base32.js
+var src_base32 = __webpack_require__(103);
+// EXTERNAL MODULE: ./node_modules/@vandeurenglenn/base58/src/base58.js
+var src_base58 = __webpack_require__(158);
+;// CONCATENATED MODULE: ./node_modules/@vandeurenglenn/is-hex/is-hex.js
+/* harmony default export */ var is_hex = (string => /^[A-F0-9]+$/i.test(string));
+
+;// CONCATENATED MODULE: ./node_modules/@leofcoin/codec-format-interface/src/basic-interface.js
+/* provided dependency */ var Buffer = __webpack_require__(8764)["Buffer"];
 
-  addProto(name, proto) {
-    if (!this.protos[name]) this.protos[name] = proto;
+
+
+
+class BasicInterface {
+  #handleDecode() {
+    if (!this.decode) throw new Error('bad implementation: needs decode func')
+    this.decode()
   }
 
-  addCodec(name, codec) {
-    if (!this.codecs[name]) this.codecs[name] = codec;
+  #handleEncode() {
+    if (!this.encode) throw new Error('bad implementation: needs encode func')
+    this.encode()
+  }
+  isHex(string) {
+    return is_hex(string)
+  }
+  isBase32(string) {
+    return base32.isBase32(string)
+  }
+  isBase58(string) {
+    return base58.isBase32(string)
+  }
+  /**
+   * @param {String} encoded
+   */
+  fromBs32(encoded) {
+    this.encoded = src_base32/* default.decode */.Z.decode(encoded)
+    return this.#handleDecode()
   }
 
-  async addStore(name, prefix, root, isPrivate = true) {
-    if (name === 'block' || name === 'transaction' || name === 'chain' ||
-        name === 'data' || name === 'message') isPrivate = false;
+  /**
+   * @param {String} encoded
+   */
+  fromBs58(encoded) {
+    this.encoded = src_base58/* default.decode */.Z.decode(encoded)
+    return this.#handleDecode()
+  }
 
-    let Storage;
-    if (this.hasDaemon) {
-      Storage = LeofcoinStorageClient;
-    } else {
-      Storage = globalThis.LeofcoinStorage?.default ? globalThis.LeofcoinStorage.default : LeofcoinStorage__default["default"];
+  async toArray() {
+    const array = []
+    for await (const value of this.encoded.values()) {
+      array.push(value)
     }
-    globalThis[`${name}Store`] = globalThis[`${name}Store`] ||
-      await new Storage(name, root);
+    return array
+  }
 
-    globalThis[`${name}Store`].private = isPrivate;
-    if (!isPrivate) this.stores.push(name);
+  fromString(string) {
+    this.encoded = new Uint8Array(string.split(','))
+    return this.#handleDecode()
   }
 
+  fromArray(array) {
+    this.encoded = new Uint8Array([...array])
+    return this.#handleDecode()
+  }
 
   /**
-   * @see MessageHandler
+   * @param {Buffer} encoded
    */
-  prepareMessage(to, data) {
-    return this._messageHandler.prepareMessage(this.id, to, data)
+  fromEncoded(encoded) {
+    this.encoded = encoded
+    return this.#handleDecode()
   }
 
   /**
-   * @access public
-   *
-   * @return {Array} peerId
+   * @param {String} encoded
    */
-  get peers() {
-    return Object.keys(this.client.connections)
+  fromHex(encoded) {
+    this.encoded = Buffer.from(encoded, 'hex')
+    return this.#handleDecode()
   }
 
-  get connections() {
-    return Object.values(this.client.connections)
+  toString(encoding = 'utf8') {
+    if (!this.encoded) this.#handleEncode()
+    return this.encoded.toString(encoding)
   }
 
-  get peerEntries() {
-    return Object.entries(this.client.connections)
+  /**
+   * @return {String} encoded
+   */
+  toHex() {
+    return this.toString('hex')
   }
 
   /**
-   * @return {String} id - peerId
+   * @return {String} encoded
    */
-  getConnection(id) {
-    return this.client.connections[id]
+  toBs32() {
+    if (!this.encoded) this.#handleEncode()
+    return src_base32/* default.encode */.Z.encode(this.encoded)
   }
 
   /**
-   * @private
-   *
-   * @param {Object} options
-   * @param {String} options.root - path to root directory
-   *
-   * @return {Promise} instance of Peernet
+   * @return {String} encoded
    */
-  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;
-
-    /**
-     * 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,
-    };
+  toBs58() {
+    if (!this.encoded) this.#handleEncode()
+    return src_base58/* default.encode */.Z.encode(this.encoded)
+  }
 
-    this.protos = globalThis.peernet.protos;
-    this.codecs = codecs;
+  /**
+   * @param {Object} data
+   */
+  create(data) {
+    const decoded = {}
+    if (this.keys?.length > 0) {
+      for (const key of this.keys) {
+        Object.defineProperties(decoded, {
+          [key]: {
+            enumerable: true,
+            configurable: true,
+            set: (val) => value = data[key],
+            get: () => data[key]
+          }
+        })
+      }
 
-    this._messageHandler = new MessageHandler(this.network);
+      this.decoded = decoded
+      this.encode()
+    }
+  }
+}
+
+// EXTERNAL MODULE: ./node_modules/varint/index.js
+var varint = __webpack_require__(4676);
+var varint_default = /*#__PURE__*/__webpack_require__.n(varint);
+;// CONCATENATED MODULE: ./node_modules/@leofcoin/codec-format-interface/src/codecs.js
+/* harmony default export */ 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('636d', 16),
+    hashAlg: 'dbl-keccak-256',
+  },
+});
+
+;// CONCATENATED MODULE: ./node_modules/@leofcoin/codec-format-interface/src/codec.js
 
-    const {daemon, environment} = await target();
-    this.hasDaemon = daemon;
 
-    
 
-    for (const store of this.defaultStores) {
-      await this.addStore(store, options.storePrefix, options.root);
-    }
 
-    try {
-      const pub = await accountStore.get('public');
-      this.id = JSON.parse(new TextDecoder().decode(pub)).walletId;
-    } catch (e) {
-      if (e.code === 'ERR_NOT_FOUND') {
-        const {identity, accounts, config} = await generateAccount(this.network);
-        walletStore.put('version', new TextEncoder().encode(1));
-        walletStore.put('accounts', new TextEncoder().encode(accounts));
-        walletStore.put('identity', new TextEncoder().encode(JSON.stringify(identity)));
-        await accountStore.put('config', new TextEncoder().encode(JSON.stringify(config)));
-        await accountStore.put('public', new TextEncoder().encode(JSON.stringify({walletId: identity.walletId})));
+class PeernetCodec extends BasicInterface {
+  get codecs() {
+    return {...globalThis.peernet.codecs, ...codecs}
+  }
+  constructor(buffer) {
+    super()
+    if (buffer) {
+      if (buffer instanceof Uint8Array) {
+        const codec = varint_default().decode(buffer);
+        const name = this.getCodecName(codec)
+        if (name) {
+          this.name = name
+          this.encoded = buffer
+          this.decode(buffer)
+        } else {
+          this.encode(buffer)
+        }
+      } else if (buffer instanceof ArrayBuffer) {
+        const encoded = new Uint8Array(buffer.byteLength)
 
-        this.id = identity.walletId;
-      } else {
-        throw e
+        for (let i = 0; i < buffer.byteLength; i++) {
+          encoded[i] = buffer[i]
+        }
+        this.encoded = encoded
+        // this.encoded = new Uint8Array(buffer, buffer.byteOffset, buffer.byteLength)
+        this.decode(buffer)
+        return
+      }
+      if (typeof buffer === 'string') {
+        if (this.codecs[buffer]) this.fromName(buffer)
+        else if (this.isHex(buffer)) this.fromHex(buffer)
+        else if (this.isBase32(buffer)) this.fromBs32(buffer)
+        else if (this.isBase58(buffer)) this.fromBs58(buffer)
+        else throw new Error(`unsupported string ${buffer}`)
       }
+      if (!isNaN(buffer)) if (this.codecs[this.getCodecName(buffer)]) this.fromCodec(buffer)
     }
-    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)
-      // })
-    });
+  fromEncoded(encoded) {
+    const codec = varint_default().decode(encoded);
+    const name = this.getCodecName(codec)
+    this.name = name
+    this.encoded = encoded
+    this.decode(encoded)
+  }
 
-    /**
-     * converts data -> message -> proto
-     * @see DataHandler
-     */
-    pubsub.subscribe('peer:data', dataHandler);
+  getCodec(name) {
+    return this.codecs[name].codec
+  }
 
-    /**
-     * @access public
-     * @type {PeernetClient}
-     */
-    this.client = new Client(this.id);
-    if (globalThis.onbeforeunload) {
-      globalThis.addEventListener('beforeunload', async () => this.client.close());
-    }
-    return this
+  getCodecName(codec) {
+    return Object.keys(this.codecs).reduce((p, c) => {
+      const item = this.codecs[c]
+      if (item.codec === codec) return c;
+      else return p;
+    }, undefined)
   }
 
-  addRequestHandler(name, method) {
-    this.requestProtos[name] = method;
+  getHashAlg(name) {
+    return this.codecs[name].hashAlg
   }
 
-  sendMessage(peer, id, data) {
-    if (peer.readyState === 'open') {
-      peer.send(data, id);
-      this.bw.up += data.length;
-    } else if (peer.readyState === 'closed') ;
+  fromCodec(codec) {
+    this.name = this.getCodecName(codec)
+    this.hashAlg = this.getHashAlg(this.name)
 
+    this.codec = this.getCodec(this.name)
+    this.codecBuffer = varint_default().encode(codec)
   }
 
-  /**
-   * @private
-   *
-   * @param {Buffer} message - peernet message
-   * @param {PeernetPeer} peer - peernet peer
-   */
-  async _protoHandler(message, peer, from) {
+  fromName(name) {
+    const codec = this.getCodec(name)
+    this.name = name
+    this.codec = codec
+    this.hashAlg = this.getHashAlg(name)
+    this.codecBuffer = varint_default().encode(codec)
+  }
 
-    const {id, proto} = message;
-    this.bw.down += proto.encoded.length;
-      if (proto.name === 'peernet-dht') {
-        let { hash, store } = proto.decoded;
-        let has;
+  decode() {
+    const codec = varint_default().decode(this.encoded);
+    this.fromCodec(codec)
+  }
 
-        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 = new DHTMessageResponse({hash, has});
-        const node = await this.prepareMessage(from, data.encoded);
+  encode() {
+    const codec = varint_default().encode(this.decoded)
+    this.encoded = codec
+    return this.encoded
+  }
+}
+
+// EXTERNAL MODULE: ./node_modules/keccak/js.js
+var js = __webpack_require__(5811);
+var js_default = /*#__PURE__*/__webpack_require__.n(js);
+;// CONCATENATED MODULE: ./node_modules/@leofcoin/codec-format-interface/src/codec-hash.js
+/* provided dependency */ var codec_hash_Buffer = __webpack_require__(8764)["Buffer"];
 
-        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 = new DataMessageResponse({hash, data});
 
-            const node = await this.prepareMessage(from, data.encoded);
-            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(from, data.encoded);
-          this.sendMessage(peer, id, node.encoded);
+
+class CodecHash extends BasicInterface {
+  constructor(buffer, options = {}) {
+    super()
+    if (options.name) this.name = options.name
+    else this.name = 'disco-hash'
+    if (options.codecs) this.codecs = options.codecs
+    if (buffer) {
+      if (buffer instanceof Uint8Array) {
+        this.discoCodec = new PeernetCodec(buffer, this.codecs)
+        const name = this.discoCodec.name
+
+        if (name) {
+          this.name = name
+          this.decode(buffer)
+        } else {
+          this.encode(buffer)
         }
-      } else if (proto.name === 'peernet-ps' && peer.peerId !== this.id) {
-        globalSub.publish(new TextDecoder().decode(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 = new DHTMessage({hash});
-    this.client.id;
-    const walk = async peer => {
-      const node = await this.prepareMessage(peer.peerId, data.encoded);
-      let result = await peer.request(node.encoded);
-      result = new Uint8Array(Object.values(result));
-      let proto = protoFor(result);
-      if (proto.name !== 'peernet-message') throw encapsulatedError()
-      const from = proto.decoded.from;
-      proto = protoFor(proto.decoded.data);
-      if (proto.name !== 'peernet-dht-response') throw dhtError(proto.name)
+      if (typeof buffer === 'string') {
+        if (this.isHex(buffer)) this.fromHex(buffer)
+        if (this.isBase32(buffer)) this.fromBs32(buffer)
+        else if (this.isBase58(buffer)) this.fromBs58(buffer)
+        else throw new Error(`unsupported string ${buffer}`)
+      } else if (typeof buffer === 'object') this.fromJSON(buffer)
+    }
+  }
 
-      // 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';
-      }
+  get prefix() {
+    const length = this.length
+    const uint8Array = new Uint8Array(length.length + this.discoCodec.codecBuffer.length)
+    uint8Array.set(length)
+    uint8Array.set(this.discoCodec.codecBuffer, length.length)
 
-      const peerInfo = {
-        family: peer.connection.remoteFamily || peer.connection.localFamily,
-        address: peer.connection.remoteAddress || peer.connection.localAddress,
-        port: peer.connection.remotePort || peer.connection.localPort,
-        id: from,
-      };
+    return uint8Array
+  }
 
-      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)
+  get length() {
+    return varint_default().encode(this.size)
   }
 
-  /**
-   * 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 buffer() {
+    return this.encoded
   }
 
-  get block() {
-    return {
-      get: async (hash) => {
-        const data = await blockStore.has(hash);
-        if (data) return await 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 hash() {
+    return this.encoded
   }
 
-  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),
-    }
+  fromJSON(json) {
+    return this.encode(codec_hash_Buffer.from(JSON.stringify(json)))
   }
 
-  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)
+  encode(buffer, name) {
+    if (!this.name && name) this.name = name;
+    if (!buffer) buffer = this.buffer;
+    this.discoCodec = new PeernetCodec(this.name, this.codecs)
+    this.discoCodec.fromName(this.name)
+    let hashAlg = this.discoCodec.hashAlg
+    if (hashAlg.includes('dbl')) {
+      hashAlg = hashAlg.replace('dbl-', '')
+      buffer = js_default()(hashAlg.replace('-', '')).update(buffer).digest()
+    }
+    this.digest = js_default()(hashAlg.replace('-', '')).update(buffer).digest()
+    this.size = this.digest.length
 
-    const id = closestPeer.id;
-    if (this.connections) {
-      let closest = this.connections.filter((peer) => {
-        if (peer.peerId === id) return peer
-      });
+    this.codec = this.discoCodec.encode();
+    this.codec = this.discoCodec.codecBuffer
+    const uint8Array = new Uint8Array(this.digest.length + this.prefix.length)
+    uint8Array.set(this.prefix)
+    uint8Array.set(this.digest, this.prefix.length)
 
-      let data = new DataMessage({hash, store: store?.name ? store?.name : store});
+    this.encoded = uint8Array
 
-      const node = await this.prepareMessage(id, data.encoded);
-      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));
-      let proto = protoFor(data);
-      proto = protoFor(proto.decoded.data);
-      // TODO: store data automaticly or not
-      return proto.decoded.data
+    return this.encoded
+  }
 
-      // this.put(hash, proto.decoded.data)
+  validate(buffer) {
+    if (codec_hash_Buffer.isBuffer(buffer)) {
+      const codec = varint_default().decode(buffer);
+      if (this.codecs[codec]) {
+        this.decode(buffer)
+      } else {
+        this.encode(buffer)
+      }
     }
-    return null
+    if (typeof buffer === 'string') {
+      if (this.isHex(buffer)) this.fromHex(buffer)
+      if (this.isBase32(buffer)) this.fromBs32(buffer)
+    }
+    if (typeof buffer === 'object') this.fromJSON(buffer)
   }
 
+  decode(buffer) {
+    this.encoded = buffer
+    const codec = varint_default().decode(buffer);
 
-  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),
+    this.discoCodec = new PeernetCodec(codec, this.codecs)
+    // TODO: validate codec
+    buffer = buffer.slice((varint_default()).decode.bytes);
+    this.size = varint_default().decode(buffer);
+    this.digest = buffer.slice((varint_default()).decode.bytes);
+    if (this.digest.length !== this.size) {
+      throw new Error(`hash length inconsistent: 0x${this.encoded.toString('hex')}`)
     }
-  }
 
-  get data() {
+    // const discoCodec = new Codec(codec, this.codecs)
+
+    this.name = this.discoCodec.name
+
+
+    this.size = this.digest.length
+
     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),
+      codec: this.codec,
+      name: this.name,
+      size: this.size,
+      length: this.length,
+      digest: this.digest,
     }
   }
+}
+
+;// CONCATENATED MODULE: ./node_modules/@leofcoin/codec-format-interface/src/codec-format-interface.js
+
 
+
+
+class FormatInterface extends BasicInterface {
   /**
-   * goes trough given stores and tries to find data for given hash
-   * @param {Array} stores
-   * @param {string} hash
+   * @param {Buffer|String|Object} buffer - data - The data needed to create the desired message
+   * @param {Object} proto - {encode, decode}
+   * @param {Object} options - {hashFormat, name}
    */
-  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
+  constructor(buffer, proto, options = {}) {
+    super()
+    this.protoEncode = proto.encode
+    this.protoDecode = proto.decode
+    this.hashFormat = options.hashFormat || 'bs32'
+    if (options.name) this.name = options.name
+    if (buffer instanceof Uint8Array) this.fromUint8Array(buffer)
+    else if (buffer instanceof ArrayBuffer) this.fromArrayBuffer(buffer)
+    else if (buffer.name === options.name) return buffer
+    else if (buffer instanceof String) {
+      if (this.isHex(buffer)) this.fromHex(buffer)
+      else if (this.isBase32(buffer)) this.fromBs32(buffer)
+      else if (this.isBase58(buffer)) this.fromBs58(buffer)
+      else throw new Error(`unsupported string ${buffer}`)
+    } else {
+      this.create(buffer)
+    }
   }
 
   /**
-   * Get content for given hash
-   *
-   * @param {String} hash - the hash of the wanted data
-   * @param {String} store - storeName to access
+   * @return {PeernetHash}
    */
-  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)
+  get peernetHash() {
+    return new CodecHash(this.decoded, {name: this.name})
   }
 
   /**
-   * put content
-   *
-   * @param {String} hash
-   * @param {Buffer} data
-   * @param {String} store - storeName to access
+   * @return {peernetHash}
    */
-  async put(hash, data, store = 'data') {
-    store = globalThis[`${store}Store`];
-    return store.put(hash, data)
+  get hash() {
+    const upper = this.hashFormat.charAt(0).toUpperCase()
+    const format = `${upper}${this.hashFormat.substring(1, this.hashFormat.length)}`
+    return this.peernetHash[`to${format}`]()
   }
 
   /**
-   * @param {String} hash
-   * @return {Boolean}
+   * @return {Object}
    */
-  async has(hash) {
-    const store = await this.whichStore([...this.stores], hash);
-    if (store) {
-      if (store.private) return false
-      else return true
-    }
-    return false
+  decode() {
+    let encoded = this.encoded;
+    const discoCodec = new PeernetCodec(this.encoded)
+    encoded = encoded.slice(discoCodec.codecBuffer.length)
+    this.name = discoCodec.name
+    this.decoded = this.protoDecode(encoded)
+    return this.decoded
   }
 
   /**
-   *
-   * @param {String} topic
-   * @param {String|Object|Array|Boolean|Buffer} data
+   * @return {Buffer}
    */
-  async publish(topic, data) {
-    // globalSub.publish(topic, data)
-    if (topic instanceof Uint8Array === false) topic = new TextEncoder().encode(topic);
-    if (data instanceof Uint8Array === false) data = new TextEncoder().encode(JSON.stringify(data));
-    const id = Math.random().toString(36).slice(-12);
-    data = new PsMessage({data, topic});
-    for (const peer of this.connections) {
-      if (peer.peerId !== this.peerId) {
-        const node = await this.prepareMessage(peer.peerId, data.encoded);
-        this.sendMessage(peer, id, node.encoded);
-      }
-      // TODO: if peer subscribed
-    }
-  }
-
-  createHash(data, name) {
-    return new PeernetHash(data, {name})
+  encode(decoded) {
+    if (!decoded) decoded = this.decoded;
+    const codec = new PeernetCodec(this.name)
+    const encoded = this.protoEncode(decoded)
+    const uint8Array = new Uint8Array(encoded.length + codec.codecBuffer.length)
+    uint8Array.set(codec.codecBuffer)
+    uint8Array.set(encoded, codec.codecBuffer.length)
+    this.encoded = uint8Array
+    return this.encoded
   }
 
-  /**
-   *
-   * @param {String} topic
-   * @param {Method} cb
-   */
-  async subscribe(topic, cb) {
-    // TODO: if peer subscribed
-    globalSub.subscribe(topic, cb);
+  hasCodec() {
+    if (!this.encoded) return false
+    const codec = new PeernetCodec(this.encoded)
+    if (codec.name) return true
   }
 
-  async removePeer(peer) {
-    return this.client.removePeer(peer)
+  fromUint8Array(buffer) {
+    this.encoded = buffer
+    if (!this.hasCodec()) this.create(
+      JSON.parse(new TextDecoder().decode(this.encoded))
+    )
+    else this.decode()
   }
 
-  get Buffer() {
-    return Buffer
+  fromArrayBuffer(buffer) {
+    this.encoded = new Uint8Array(buffer, buffer.byteOffset, buffer.byteLength)
+    if (!this.hasCodec()) this.create(
+      JSON.parse(new TextDecoder().decode(this.encoded))
+    )
+    else this.decode()
   }
-  // async block(index) {
-  //   const _values = []
-  //   for (const peer of this.peers) {
-  //     const value = await peer.request({type: 'block', index})
-  //     console.log(value);
-  //   }
-  //
-  // }
-}
+}
 
-module.exports = Peernet;
+;// CONCATENATED MODULE: ./node_modules/@leofcoin/codec-format-interface/src/index.js
+
+
+
+
+
+
+/* harmony default export */ var src = ({ codecs: codecs, Codec: PeernetCodec, CodecHash: CodecHash, FormatInterface: FormatInterface, BasicInterface: BasicInterface });
 
 
 /***/ }),
@@ -3185,7 +3211,6 @@ const base = ALPHABET => {
 /***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
-__webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _vandeurenglenn_base_x__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2353);
 
 
@@ -3197,7 +3222,7 @@ const decode = (uint8Array, hex = false) => {
   return decoder.decode(uint8Array)
 }
 
-/* harmony default export */ __webpack_exports__["default"] = ({
+/* harmony default export */ __webpack_exports__["Z"] = ({
   encode: (uint8Array, hex = false) => {
     const encoder = hex ? (0,_vandeurenglenn_base_x__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(base32Hex) : (0,_vandeurenglenn_base_x__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(base32)
     return encoder.encode(uint8Array)
@@ -3220,7 +3245,6 @@ const decode = (uint8Array, hex = false) => {
 /***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
-__webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _vandeurenglenn_base_x__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2353);
 
 
@@ -3228,7 +3252,7 @@ const base58 = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
 
 const decode = uint8Array => (0,_vandeurenglenn_base_x__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(base58).decode(uint8Array)
 
-/* harmony default export */ __webpack_exports__["default"] = ({
+/* harmony default export */ __webpack_exports__["Z"] = ({
   encode: uint8Array => (0,_vandeurenglenn_base_x__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(base58).encode(uint8Array),
   decode,
   isBase58: uint8Array => {
@@ -3256,16 +3280,6 @@ globalThis.debug = text => {
 }
 
 
-/***/ }),
-
-/***/ 6187:
-/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
-
-"use strict";
-__webpack_require__.r(__webpack_exports__);
-/* harmony default export */ __webpack_exports__["default"] = (string => /^[A-F0-9]+$/i.test(string));
-
-
 /***/ }),
 
 /***/ 8162:
@@ -16966,11 +16980,11 @@ class MultiSignature {
 	}
 
 	export() {
-		return _vandeurenglenn_base58__WEBPACK_IMPORTED_MODULE_0__["default"].encode(this.multiSignature);
+		return _vandeurenglenn_base58__WEBPACK_IMPORTED_MODULE_0__/* ["default"].encode */ .Z.encode(this.multiSignature);
 	}
 
 	import(encoded) {
-		return _vandeurenglenn_base58__WEBPACK_IMPORTED_MODULE_0__["default"].decode(this.decode(encoded));
+		return _vandeurenglenn_base58__WEBPACK_IMPORTED_MODULE_0__/* ["default"].decode */ .Z.decode(this.decode(encoded));
 	}
 
 	sign(hash, privateKey) {
@@ -17047,23 +17061,23 @@ class MultiSignature {
 	}
 
 	fromHex(hex) {
-		return _vandeurenglenn_base58__WEBPACK_IMPORTED_MODULE_0__["default"].decode(Buffer.from(hex, 'hex'))
+		return _vandeurenglenn_base58__WEBPACK_IMPORTED_MODULE_0__/* ["default"].decode */ .Z.decode(Buffer.from(hex, 'hex'))
 	}
 
 	toBs58() {
-		return _vandeurenglenn_base58__WEBPACK_IMPORTED_MODULE_0__["default"].encode(this.multiSignature)
+		return _vandeurenglenn_base58__WEBPACK_IMPORTED_MODULE_0__/* ["default"].encode */ .Z.encode(this.multiSignature)
 	}
 
 	fromBs58(multiSignature) {
-		return _vandeurenglenn_base58__WEBPACK_IMPORTED_MODULE_0__["default"].decode(multiSignature)
+		return _vandeurenglenn_base58__WEBPACK_IMPORTED_MODULE_0__/* ["default"].decode */ .Z.decode(multiSignature)
 	}
 
 	toBs32() {
-		return _vandeurenglenn_base32__WEBPACK_IMPORTED_MODULE_1__["default"].encode(this.multiSignature)
+		return _vandeurenglenn_base32__WEBPACK_IMPORTED_MODULE_1__/* ["default"].encode */ .Z.encode(this.multiSignature)
 	}
 
 	fromBs32(multiSignature) {
-		return _vandeurenglenn_base32__WEBPACK_IMPORTED_MODULE_1__["default"].decode(multiSignature)
+		return _vandeurenglenn_base32__WEBPACK_IMPORTED_MODULE_1__/* ["default"].decode */ .Z.decode(multiSignature)
 	}
 }