@leofcoin/peernet 0.10.6 → 0.11.0

package/dist/module/peernet.js

@@ -1,774 +1,584 @@
-import PubSub from '@vandeurenglenn/little-pubsub';
-import sha256 from 'crypto-js/sha256';
-import P2P from 'p2pt';
-import LeofcoinStorage$1 from '@leofcoin/storage';
-import { server } from 'websocket';
-import { createServer } from 'http';
-import Koa from 'koa';
+import LeofcoinStorage from '@leofcoin/storage';
 import protons from 'protons';
-import bs32 from 'bs32';
-import bs58 from 'bs58';
+import bs32 from '@vandeurenglenn/base32';
+import bs58 from '@vandeurenglenn/base58';
 import isHex from 'is-hex';
 import varint from 'varint';
 import createKeccakHash from 'keccak';
-import fetch$1 from 'node-fetch';
-import MultiWallet from '@leofcoin/multi-wallet';
-
-class PeernetPeer {
-  constructor(id, connection) {
-    this._events = {};
-    this.bw = {
-      up: 0,
-      down: 0,
-    };
-    this.id = id;
-    this.connection = connection;
-
-    this.connection.on('data', (message) => {
-      this.bw.down += message.length;
-      pubsub.publish('peernet.data', JSON.parse(message.toString()));
-    });
-  }
-
-  request(data) {
-    return new Promise((resolve, reject) => {
-      const id = Math.random().toString(36).slice(-12);
-      data = Buffer.from(JSON.stringify({id, data}));
-      const _onData = (message) => {
-        if (message.id !== id) return
-
-        resolve(message.data);
-      };
-
-      pubsub.subscribe('peernet.data', _onData);
-
-      // cleanup subscriptions
-      setTimeout(() => {
-        pubsub.unsubscribe('peernet.data', _onData);
-      }, 5000);
-
-      this.write(data);
-    });
-  }
-
-  write(data) {
-    if (!Buffer.isBuffer(data)) data = Buffer.from(data);
-
-    this.bw.up += data.length;
-    this.connection.write(data);
-  }
-
-  on(event = 'peernet.data', cb) {
-    this._events[event] = cb;
-    pubsub.subscribe(event, cb);
-    // this.connection.on(event, cb)
-  }
-
-  removeListener(event = 'data', cb) {
-    delete this._events[event];
-    pubsub.unsubscribe(event, cb);
+import fetch from 'node-fetch';
+import generateAccount from '@leofcoin/generate-account';
+import * as bs58check from 'bs58check';
+import bs58check__default from 'bs58check';
+import { generateMnemonic, mnemonicToSeed } from 'bip39';
+import * as bip32 from 'bip32';
+import { publicKeyConvert } from 'secp256k1';
+import ecc from 'tiny-secp256k1';
+import MultiSignature from 'multi-signature';
+import AES from 'crypto-js/aes.js';
+import 'crypto-js/sha512.js';
+import ENC from 'crypto-js/enc-utf8.js';
+
+/* socket-request-client version 1.6.1 */
+
+class LittlePubSub {
+  constructor(verbose = true) {
+    this.subscribers = {};
+    this.verbose = verbose;
+  }
+  subscribe(event, handler, context) {
+    if (typeof context === 'undefined') {
+      context = handler;
+    }
+    this.subscribers[event] = this.subscribers[event] || { handlers: [], value: null};
+    this.subscribers[event].handlers.push(handler.bind(context));
   }
-
-  close() {
-    for (const event of Object.keys(this._events)) {
-      pubsub.unsubscribe(event, this._events[event]);
+  unsubscribe(event, handler, context) {
+    if (typeof context === 'undefined') {
+      context = handler;
     }
-    this._events = [];
-
-    for (const event of this.connection._events.data) {
-      this.connection.removeListener('data', event);
+    if (this.subscribers[event]) {
+      const index = this.subscribers[event].handlers.indexOf(handler.bind(context));
+      this.subscribers[event].handlers.splice(index);
+      if (this.subscribers[event].handlers.length === 0) delete this.subscribers[event];
     }
-    this.connection.destroy();
   }
-}
-
-/**
- * Array of peers
- * @type {Array}
- * @property {PeernetPeer} peer Instance of Peer
- */
-globalThis.connections = new Map();
-globalThis.recentConnections = new Map();
-globalThis.pubsub = globalThis.pubsub || new PubSub({verbose: false});
-
-class PeernetClient {
-  constructor(options = {}) {
-    if (!options.id) options.id = Buffer.from('00000000000000000000000000000000');
-    if (!options.networkVersion) options.networkVersion = 'v0.1.0';
-    if (!options.networkName) options.networkName = 'peernet';
-    this.id = options.id;
-
-    this.topic = Buffer.from(sha256(`${options.networkName}-${options.networkVersion}`).toString());
-
-    const trackers = [
-      'wss://star.leofcoin.org',
-      'wss://tracker.openwebtorrent.com',
-      // 'wss://tracker.sloppyta.co:443/announce',
-    ];
-    this.p2p = new P2P(trackers, this.topic.slice(0, 20));
-    this.p2p.on('peerconnect', (peer) => {
-      peer = new PeernetPeer(peer.id, peer);
-      connections.set(peer.id, peer);
-      pubsub.publish('peer:discovered', peer);
-    });
-
-    this.p2p.on('peerclose', (peer) => {
-      // TODO: close peernetPeer
-      const peernetPeer = connections.get(peer.id);
-      if (peernetPeer) {
-        peernetPeer.close();
+  publish(event, change) {
+    if (this.subscribers[event]) {
+      if (this.verbose || this.subscribers[event].value !== change) {
+        this.subscribers[event].value = change;
+        this.subscribers[event].handlers.forEach(handler => {
+          handler(change, this.subscribers[event].value);
+        });
       }
-      connections.delete(peer.id);
-      pubsub.publish('peer:disconnected', peer);
-    });
-
-    this.p2p.start();
-
-    if (globalThis.process) {
-      process.on('SIGINT', async () => {
-        console.log('Caught interrupt signal');
-        this.close();
-        setTimeout(async () => {
-          process.exit();
-        }, 100);
-      });
-    } else {
-      globalThis.onbeforeunload = () => {
-        this.close();
-      };
     }
-    //
-    // this.sw.on('close', () => {
-    // })
-  }
-
-  close() {
-    return this.p2p.destroy()
-  }
-
-  _peers() {
-    return this.p2p.getPeers()
   }
 }
 
-var version = "0.10.5";
-
-var api$1 = {
-  version: ({send}) => send({client: '@peernet/api/http', version}),
-  ready: ({send}) => {
-    if (globalThis.states.ready) send(true);
-    else pubsub.subscribe('ready', () => send(true));
-  },
-  storage: async (params, {send, error}) => {
-    console.log(params);
-    const {name, root, key, value, method} = params;
-    try {
-      if (name && root) {
-        globalThis[name] = globalThis[name] || await new LeofcoinStorage(name, root);
-      } else {
-        return error('Expected name & root')
-      }
-      if (method === 'put') {
-        await globalThis[name].put(key, value);
-        return send('ok')
-      }
-      if (method === 'remove') {
-        await globalThis[name].remove(key, value);
-        return send('ok')
-      }
-      value = await globalThis[name].get(key);
-      return send(value)
-    } catch (e) {
-      return error(e)
-    }
-  },
-  getConfig: async (params, {send, error}) => {
-    try {
-      const config = await api.getConfig(params);
-      send(config);
-    } catch (e) {
-      error(e);
-    }
-  },
-  setMinerConfig: async (params, {send, error}) => {
-    try {
-      await api.setMinerConfig(params);
-      send('ok');
-    } catch (e) {
-      error(e);
+var clientApi = _pubsub => {
+  const subscribe = (topic, cb) => {
+    _pubsub.subscribe(topic, cb);
+  };
+  const unsubscribe = (topic, cb) => {
+    _pubsub.unsubscribe(topic, cb);
+  };
+  const publish = (topic, value) => {
+    _pubsub.publish(topic, value);
+  };
+  const _connectionState = (state) => {
+    switch (state) {
+      case 0:
+        return 'connecting'
+      case 1:
+        return 'open'
+      case 2:
+        return 'closing'
+      case 3:
+        return 'closed'
     }
-  },
-  getMinerConfig: async ({send, error}) => {
-    try {
-      const config = await api.getMinerConfig();
-      send(config);
-    } catch (e) {
-      error(e);
+  };
+  const request = (client, request) => {
+    return new Promise((resolve, reject) => {
+      const state = _connectionState(client.readyState);
+      if (state !== 'open') return reject(`coudn't send request to ${client.id}, no open connection found.`)
+      request.id = Math.random().toString(36).slice(-12);
+      const handler = result => {
+        if (result && result.error) return reject(result.error)
+        resolve({result, id: request.id, handler});
+        unsubscribe(request.id, handler);
+      };
+      subscribe(request.id, handler);
+      send(client, request);
+    });
+  };
+  const send = async (client, request) => {
+    return client.send(JSON.stringify(request))
+  };
+  const pubsub = client => {
+    return {
+      publish: (topic = 'pubsub', value) => {
+        return send(client, {url: 'pubsub', params: { topic, value }})
+      },
+      subscribe: (topic = 'pubsub', cb) => {
+        subscribe(topic, cb);
+        return send(client, {url: 'pubsub', params: { topic, subscribe: true }})
+      },
+      unsubscribe: (topic = 'pubsub', cb) => {
+        unsubscribe(topic, cb);
+        return send(client, {url: 'pubsub', params: { topic, unsubscribe: true }})
+      },
+      subscribers: _pubsub.subscribers
     }
-  },
-  wallet: async ({send}) => {
-    const wallet = await walletStore.get();
-    send(wallet);
-  },
-  addresses: async ({send, error}) => {
-    try {
-      const adresses = await api.addresses();
-      send(adresses);
-    } catch (e) {
-      error(e);
+  };
+  const server = (client) => {
+    return {
+      uptime: async () => {
+        try {
+          const { result, id, handler } = await request(client, {url: 'uptime'});
+          unsubscribe(id, handler);
+          return result
+        } catch (e) {
+          throw e
+        }
+      },
+      ping: async () => {
+        try {
+          const now = new Date().getTime();
+          const { result, id, handler } = await request(client, {url: 'ping'});
+          unsubscribe(id, handler);
+          return (Number(result) - now)
+        } catch (e) {
+          throw e
+        }
+      }
     }
-  },
-  accountNames: async (params, {send, error}) => {
-    try {
-      const adresses = await api.accountNames(params.index);
-      send(adresses);
-    } catch (e) {
-      error(e);
+  };
+  const peernet = (client) => {
+    return {
+      join: async (params) => {
+        try {
+          params.join = true;
+          const requested = { url: 'peernet', params };
+          const { result, id, handler } = await request(client, requested);
+          unsubscribe(id, handler);
+          return result
+        } catch (e) {
+          throw e
+        }
+      },
+      leave: async (params) => {
+        try {
+          params.join = false;
+          const requested = { url: 'peernet', params };
+          const { result, id, handler } = await request(client, requested);
+          unsubscribe(id, handler);
+          return result
+        } catch (e) {
+          throw e
+        }
+      }
     }
-  },
-  accounts: async ({send}) => {
-    const accounts = await accountStore.get();
-    send(accounts);
-  },
-  account: async (params, {send}) => {
-    const account = await accountStore.get(params);
-    send(account);
-  },
-  balance: async (params, {send, error}) => {
-    console.log('balance');
-    try {
-      console.log(await api.getBalanceForAddress(params.address));
-      const value = await api.getBalanceForAddress(params.address);
-      send(value);
-    } catch (e) {
-      console.log(e);
-      error(e);
+  };
+  return { send, request, pubsub, server, subscribe, unsubscribe, publish, peernet }
+};
+
+if (!globalThis.PubSub) globalThis.PubSub = LittlePubSub;
+if (!globalThis.pubsub) globalThis.pubsub = new LittlePubSub({verbose: false});
+const socketRequestClient = (url, protocols = 'echo-protocol', options = { retry: false }) => {
+  const { retry } = options;
+  const api = clientApi(pubsub);
+  let tries = 0;
+  const onerror = error => {
+    if (pubsub.subscribers['error']) {
+      pubsub.publish('error', error);
+    } else {
+      console.error(error);
     }
-  },
-  balanceAfter: async (params, {send, error}) => {
-    try {
-      const value = await api.getBalanceForAddressAfter(params.address, params.index);
-      send(value);
-    } catch (e) {
-      error(e);
+  };
+  const onmessage = message => {
+    const {value, url, status, id} = JSON.parse(message.data.toString());
+    const publisher = id ? id : url;
+    if (status === 200) {
+      pubsub.publish(publisher, value);
+    } else {
+      pubsub.publish(publisher, {error: value});
     }
-  },
-  mine: async (params, {send, error}) => {
-    api.mine(params);
-    send('ok');
-  },
-  lastBlock: async ({send, error}) => {
-    try {
-      const value = await api.lastBlock();
-      send(value);
-    } catch (e) {
-      error(e);
+  };
+  const clientConnection = client => {
+    const startTime = new Date().getTime();
+    return {
+      client,
+      request: async req => {
+        const { result, id, handler } = await api.request(client, req);
+        pubsub.unsubscribe(id, handler);
+        return result
+      },
+      send: req => api.send(client, req),
+      subscribe: api.subscribe,
+      unsubscribe: api.unsubscribe,
+      subscribers: api.subscribers,
+      publish: api.publish,
+      pubsub: api.pubsub(client),
+      uptime: () => {
+        const now = new Date().getTime();
+        return (now - startTime)
+      },
+      peernet: api.peernet(client),
+      server: api.server(client),
+      close: exit => {
+        client.onclose = message => {
+          if (exit) process.exit();
+        };
+        client.close();
+      }
     }
-  },
-};
-
-const fullLog = text => {
-  return console.log(`${new Date()}: ${text}`)
+  };
+  return new Promise((resolve, reject) => {
+    const init = () => {
+      let ws;
+      if (typeof process === 'object' && !globalThis.WebSocket) {
+        ws = require('websocket').w3cwebsocket;
+      } else {
+        ws = WebSocket;
+      }
+      const client = new ws(url, protocols);
+      client.onmessage = onmessage;
+      client.onerror = onerror;
+      client.onopen = () => {
+        tries = 0;
+        resolve(clientConnection(client));
+      };
+      client.onclose = message => {
+        tries++;
+        if (!retry) return reject(options)
+        if (tries > 5) {
+          console.log(`${protocols} Client Closed`);
+          console.error(`could not connect to - ${url}/`);
+          return resolve(clientConnection(client))
+        }
+        if (message.code === 1006) {
+          console.log('Retrying in 10 seconds');
+          setTimeout(() => {
+            return init();
+          }, retry);
+        }
+      };
+    };
+    return init();
+  });
 };
 
-const originIsAllowed = (requestOrigin, origin) => {
-  // put logic here to detect whether the specified origin is allowed.
-  if (origin && requestOrigin !== origin) return false;
-  return true;
-};
+class Peer {
+  #connection
+  #ready = false
+  #connecting = false
+  #connected = false
+  #channelReady = false
+  #destroying = false
+  #destroyed = false
+  #isNegotiating = false
+  #firstNegotiation = true
+  #iceComplete = false
+  #remoteTracks = []
+  #remoteStreams = []
+  #pendingCandidates = []
+  #senderMap = new Map()
+  #iceCompleteTimer
+  #channel
+
+  get connection() {
+    return this.#connection
+  }
+
+  get connected() {
+    return this.#connected
+  }
 
 /**
- * @module socketResponse
- *
- * @param {object} connection socket connection
- * @param {string} route the route to handle
- */
-var socketConnection = (request, protocol, origin) => {  
-	if (origin && !originIsAllowed(request.origin, origin)) {
-		// Make sure we only accept requests from an allowed origin
-		request.reject();
-    fullLog(`Connection from origin ${request.origin} rejected.`);
-		return;
-	}
-  // console.log(request);
-  const connection = request.accept(protocol, request.origin);
-  fullLog(`Connection accepted @${protocol}`);
-  return connection;
-};
-
-/**
- * @module socketResponse
- *
- * @param {object} connection socket connection
- * @param {string} url the request url
+ * @params {Object} options
+ * @params {string} options.channelName - this peerid : otherpeer id
  */
-var socketResponse = (connection, url, id, customEvent) => {
-  const send = (data = 'ok', status = 200) => connection.send(
-    JSON.stringify({url, status, value: data, id, customEvent})
-  );
-  const error = data => connection.send(JSON.stringify({url, value: data}));
-  return {
-    connection,
-    send,
-    error
-  }
-};
-
-const socketRequestServer = (options, routes = {}) => {
-  // if (!routes && !routes.port && options) routes = options;
-  // else if (!options && !routes) return console.error('no routes defined');
-
-  let {httpServer, httpsServer, port, protocol, credentials, origin, pubsub } = options;
-  if (!pubsub) pubsub = new PubSub({verbose: false});
-  if (!port) port = 6000;
-  const connections = [];
-  let connection;
-  const startTime = new Date().getTime();
-  // default routes
-  if (!routes.ping) routes.ping = (response) => response.send(new Date().getTime());
-    if (!routes.uptime) routes.uptime = (response) => {
-      const now = new Date().getTime();
-      response.send(now - startTime);
+constructor(options = {}) {
+    this._in = this._in.bind(this);
+    this.offerOptions = options.offerOptions;
+    this.initiator = options.initiator;
+    this.streams = options.streams;
+    this.socketClient = options.socketClient;
+    this.id = options.id;
+    this.to = options.to;
+    this.bw = {
+      up: 0,
+      down: 0
     };
-    if (!routes.pubsub) {
-      routes.pubsub = (params, response) => {
-        if (!response) {
-          response = params;
-          params = {};
-        }
-        
-        if (!params.topic) params.topic = 'pubsub';
-                
-        const topic = params.topic;
-        delete params.topic;
-        
-        if (params.subscribe) {
-          pubsub.subscribe(topic, message => {
-            response.connection.send(JSON.stringify({url: topic, status: 200, value: message}));
-          });
-          response.send('ok', 200);
-        } else if (params.unsubscribe) {
-          pubsub.unsubscribe(topic, message => {
-            response.connection.send(JSON.stringify({url: topic, status: 200, value: message}));
-          });
-          for (const connection of connections) {
-            if (connection !== response.connection) connection.send(JSON.stringify({url: topic, status: 200, value: params}));
-          }
-          response.send('ok', 200);
+
+    this.channelName = options.channelName || Buffer.from(Math.random().toString(36).slice(-12)).toString('hex');
+    console.log(this.channelName);
+    this.options = options;
+    this.#init();
+   }
+
+   set socketClient(value) {
+     // this.socketClient?.pubsub.unsubscribe('signal', this._in)
+     this._socketClient = value;
+     this._socketClient.pubsub.subscribe('signal', this._in);
+   }
+
+   get socketClient() {
+     return this._socketClient
+   }
+
+   send(message) {
+     this.bw.up += message.length;
+     this.channel.send(message);
+   }
+
+   request(data) {
+    return new Promise((resolve, reject) => {
+      const id = Math.random().toString(36).slice(-12);
+      data = new TextEncoder().encode(JSON.stringify({id, data}));
+      const _onData = message => {
+        message = JSON.parse(new TextDecoder().decode(message.data));
+        if (message.id === id) {
+          resolve(message.data);
+          pubsub.unsubscribe('peer:data', _onData);
         }
-        else if (params.value !== undefined)
-          // should only be send raw to stars
-          // for (const connection of connections) {
-            // if (connection !== response.connection) connection.send(JSON.stringify({
-              // url: topic, status: 200, value: params
-            // }));
-          // }
-          pubsub.publish(topic, params.value);
-          response.send('ok', 200);
       };
-      
+
+      pubsub.subscribe('peer:data', _onData);
+
+      // cleanup subscriptions
+      setTimeout(() => {
+        pubsub.unsubscribe('peer:data', _onData);
+      }, 5000);
+
+      this.send(data);
+    });
+  }
+
+   async #init() {
+     try {
+       const iceServers = [{
+        urls: 'stun:stun.l.google.com:19302' // Google's public STUN server
+       }];
+
+       this.#connection = new wrtc.RTCPeerConnection();
+       this.#connection.onicecandidate = ({ candidate }) => {
+         if (candidate) {
+           this.address = candidate.address;
+           this.port = candidate.port;
+           this.protocol = candidate.protocol;
+           this.ipFamily = this.address.includes('::') ? 'ipv6': 'ipv4';
+           this._sendMessage({candidate});
+         }
+       };
+       // if (this.initiator) this.#connection.onnegotiationneeded = () => {
+         // console.log('create offer');
+       this.#connection.ondatachannel = (message) => {
+         message.channel.onopen = () => {
+           this.#connected = true;
+           pubsub.publish('peer:connected', this);
+         };
+         message.channel.onclose = () => console.log('close');
+         message.channel.onmessage = (message) => {
+           if (message.to) {
+             if (message.to === this.id) pubsub.publish('peer:data', message);
+           } else pubsub.publish('peer:data', message);
+           this.bw.down += message.length;
+         };
+         this.channel = message.channel;
+       };
+      if (this.initiator) {
+
+        this.channel = this.#connection.createDataChannel('messageChannel');
+        this.channel.onopen = () => {
+          this.#connected = true;
+          pubsub.publish('peer:connected', this);
+          // this.channel.send('hi')
+        };
+        this.channel.onclose = () => this.close.bind(this);
+
+        this.channel.onmessage = (message) => {
+          if (message.to) {
+            if (message.to === this.id) pubsub.publish('peer:data', message);
+          } else pubsub.publish('peer:data', message);
+          this.bw.down += message.length;
+        };
+
+       const offer = await this.#connection.createOffer();
+       await this.#connection.setLocalDescription(offer);
+
+       this._sendMessage({'sdp': this.#connection.localDescription});
+      }
+       // }
+
+     } catch (e) {
+       console.log(e);
+     }
+   }
+
+   _sendMessage(message) {
+     this.socketClient.send({url: 'signal', params: {
+       to: this.to,
+       from: this.id,
+       channelName: this.options.channelName,
+       ...message
+     }});
+   }
+
+   async _in(message, data) {
+    // message = JSON.parse(message);
+    if (message.to !== this.id) return
+    // if (data.videocall) return this._startStream(true, false); // start video and audio stream
+    // if (data.call) return this._startStream(true, true); // start audio stream
+    if (message.candidate) {
+      this.remoteAddress = message.candidate.address;
+      this.remotePort = message.candidate.port;
+      this.remoteProtocol = message.candidate.protocol;
+      this.remoteIpFamily = this.remoteAddress?.includes('::') ? 'ipv6': 'ipv4';
+      return this.#connection.addIceCandidate(new wrtc.RTCIceCandidate(message.candidate));
     }
-    globalThis.peerMap = new Map();
-    if (!routes.peernet) {
-      routes.peernet = (params, response) => {
-        if (params.join) {
-          peerMap.set(params.peerId, params.address);
-          response.send([...peerMap.values()]);
-          for (const connection of connections) {
-            if (connection !== response.connection)
-              socketResponse(connection, 'peernet', 'peernet').send({discovered: params.address});
-          }
-          return
+    try {
+      if (message.sdp) {
+        if (message.sdp.type === 'offer') {
+          await this.#connection.setRemoteDescription(new wrtc.RTCSessionDescription(message.sdp));
+          const answer = await this.#connection.createAnswer();
+          await this.#connection.setLocalDescription(answer);
+          this._sendMessage({'sdp': this.#connection.localDescription});
         }
-        if (!params.join) {
-          peerMap.delete(params.peerId);
-          return response.send()
+        if (message.sdp.type === 'answer') {
+          await this.#connection.setRemoteDescription(new wrtc.RTCSessionDescription(message.sdp));
         }
-      };
+     }
+    } catch (e) {
+      console.log(e);
     }
-  // if (!protocol) protocol = 'echo-protocol';
-  if (!httpServer && !httpsServer) {
-    const { createServer } = credentials ? require('https') : require('http');
-    if (credentials) httpServer = createServer(credentials);
-    else httpServer = createServer();
-
-    httpServer.listen(port, () => {
-      console.log(`listening on ${port}`);
-    });
+ }
+
+ close() {
+   this.channel?.close();
+   this.#connection?.close();
+
+   this.socketClient.pubsub.unsubscribe('signal', this._in);
+ }
+}
+
+class Client {
+  #peerConnection
+  #connections = {}
+  #stars = {}
+
+  get connections() {
+    return { ...this.#connections }
   }
 
-	const socketServer = new server({
-  	httpServer,
-  	autoAcceptConnections: false
-	});
-
-	socketServer.on('request', request => {
-
-    connection = socketConnection(request, protocol, origin);
-    connections.push(connection);
-
-    const routeHandler = message => {
-      let data;
-      if (message.type) {
-        switch (message.type) {
-          case 'binary':
-            data = message.binaryData.toString();
-            break;
-          case 'utf8':
-            data = message.utf8Data;
-            break;
-        }
-      }
-      const { route, params, url, id, customEvent } = JSON.parse(data);
-      // ignore api when customEvent is defined
-      if (customEvent) return;
-      if (routes[url]) {
-        if (!params) return routes[url](socketResponse(connection, url, id));
-        return routes[url](params, socketResponse(connection, url, id));
-      }
-      else return socketResponse(connection, url, id).error(`nop handler found for '${message.url}'`);
-    };
+  constructor(id, identifiers = ['peernet-v0.1.0'], stars = []) {
+    this.id = id || Math.random().toString(36).slice(-12);
+    if (!Array.isArray(identifiers)) identifiers = [identifiers];
+    this.peerJoined = this.peerJoined.bind(this);
+    this.peerLeft = this.peerLeft.bind(this);
+    this.starLeft = this.starLeft.bind(this);
+    this.starJoined = this.starJoined.bind(this);
 
-    connection.on('message', routeHandler);
-	});
+    this._init(identifiers, stars);
+  }
 
-  return {
-    close: () => socketServer.shutDown(),
-    connections
-  };
-};
-
-var http = (config = {}) => {
-  if (typeof config !== 'object') config = {};
-  if (!config.protocol) config.protocol = 'peernet-v0.1.0';
-  if (!config.port) config.port = 2000;
-  if (!config.host) config.host = '127.0.0.1';
-
-  const app = new Koa();
-
-  app.use(async (ctx) => {
-    const url = ctx.url.split('/api/')[1];
-    if (url === 'version') ctx.body = {client: '@peernet/api/http', version};
-  });
-
-  const httpServer = createServer(app.callback());
-
-  config.httpServer = httpServer;
-
-  httpServer.listen(config.port, () => {
-    console.log(`listening on ${config.port}`);
-  });
-
-  return socketRequestServer(config, api$1)
-};
-
-var clientApi = _pubsub => {
-  
-  const subscribe = (topic, cb) => {
-    _pubsub.subscribe(topic, cb);
-  };
-  
-  const unsubscribe = (topic, cb) => {
-    _pubsub.unsubscribe(topic, cb);
-  };
-  
-  const publish = (topic, value) => {
-    _pubsub.publish(topic, value);
-  };
-  
-  const _connectionState = (state) => {
-    switch (state) {
-      case 0:
-        return 'connecting'
-      case 1:
-        return 'open'
-      case 2:
-        return 'closing'
-      case 3:
-        return 'closed'
+  async _init(identifiers, stars = []) {
+    if (stars.length === 0) {
+      stars.push('wss://star.leofcoin.org');
+      stars.push('ws://localhost:44444');
     }
-  };
-  /**
-   * @param {string} type
-   * @param {string} name
-   * @param {object} params
-   */
-  const request = (client, request) => {
-    return new Promise((resolve, reject) => {
-      
-      const state = _connectionState(client.readyState);
-      if (state !== 'open') return reject(`coudn't send request to ${client.id}, no open connection found.`)
-      
-      request.id = Math.random().toString(36).slice(-12);
-      const handler = result => {
-        if (result && result.error) return reject(result.error)
-        resolve({result, id: request.id, handler});
-      };
-      subscribe(request.id, handler);
-      send(client, request);
+    this.identifiers = identifiers;
+    this.starsConfig = stars;
+    // reconnectJob()
+
+    globalThis.wrtc = await import('wrtc');
+    for (const star of stars) {
+      try {
+        this.socketClient = await socketRequestClient(star, identifiers[0]);
+        const id = await this.socketClient.request({url: 'id', params: {from: this.id}});
+        this.socketClient.peerId = id;
+        this.#stars[id] = this.socketClient;
+      } catch (e) {
+        if (stars.indexOf(star) === stars.length -1 && !this.socketClient) throw new Error(`No star available to connect`);
+      }
+    }
+    const peers = await this.socketClient.peernet.join({id: this.id});
+    for (const id of peers) {
+      if (id !== this.id && !this.#connections[id]) this.#connections[id] = new Peer({channelName: `${id}:${this.id}`, socketClient: this.socketClient, id: this.id, to: id});
+    }
+    this.setupListeners();
+
+    pubsub.subscribe('peer:connected', (peer) => {
+      // peer.send(JSON.stringify({data: 'hello', from: this.id, to: peer.to}))
+      console.log({peer: peer.to});
+      console.log({id: peer.id});
+      console.log({id: this.id});
     });
-  };
-  
-  const send = async (client, request) => {
-    return client.send(JSON.stringify(request))
-  };
-
-  const pubsub = client => {
-    return {
-      publish: (topic = 'pubsub', value) => {        
-        return send(client, {url: 'pubsub', params: { topic, value }})
-      },
-      subscribe: (topic = 'pubsub', cb) => {
-        subscribe(topic, cb);
-        return send(client, {url: 'pubsub', params: { topic, subscribe: true }})
-      },
-      unsubscribe: (topic = 'pubsub', cb) => {
-        unsubscribe(topic, cb);        
-        return send(client, {url: 'pubsub', params: { topic, unsubscribe: true }})
-      },
-      subscribers: _pubsub.subscribers
+    // pubsub.subscribe('peer:data', (data) => console.log({data}))
+  }
+
+  setupListeners() {
+    this.socketClient.subscribe('peer:joined', this.peerJoined);
+    this.socketClient.subscribe('peer:left', this.peerLeft);
+    this.socketClient.subscribe('star:left', this.starLeft);
+  }
+
+  starJoined(id) {
+    if (this.#stars[id]) {
+      this.#stars[id].close();
+      delete this.#stars[id];
     }
-  };
-  
-  const server = (client) => {
-    return {
-      uptime: async () => {
-        try {
-          const { result, id, handler } = await request(client, {url: 'uptime'});        
-          unsubscribe(id, handler);
-          return result
-        } catch (e) {
-          throw e
-        }
-      },
-      ping: async () => {
-        try {
-          const now = new Date().getTime();
-          const { result, id, handler } = await request(client, {url: 'ping'});
-          unsubscribe(id, handler);
-          return (Number(result) - now)
-        } catch (e) {
-          throw e
-        }
-      }
+    console.log(`star ${id} joined`);
+  }
+
+  async starLeft(id) {
+    if (this.#stars[id]) {
+      this.#stars[id].close();
+      delete this.#stars[id];
     }
-  };
-  
-  const peernet = (client) => {
-    return {
-      join: async (params) => {
-        try {
-          params.join = true;
-          const requested = { url: 'peernet', params };
-          const { result, id, handler } = await request(client, requested);        
-          unsubscribe(id, handler);
-          return result
-        } catch (e) {
-          throw e
-        }
-      },
-      leave: async (params) => {
+    if (this.socketClient?.peerId === id) {
+
+      this.socketClient.unsubscribe('peer:joined', this.peerJoined);
+      this.socketClient.unsubscribe('peer:left', this.peerLeft);
+      this.socketClient.unsubscribe('star:left', this.starLeft);
+      this.socketClient.close();
+      this.socketClient = undefined;
+
+      for (const star of this.starsConfig) {
         try {
-          params.join = false;
-          const requested = { url: 'peernet', params };
-          const { result, id, handler } = await request(client, requested);        
-          unsubscribe(id, handler);
-          return result
+          this.socketClient = await socketRequestClient(star, this.identifiers[0]);
+          if (!this.socketClient?.client?._connection.connected) return
+          const id = await this.socketClient.request({url: 'id', params: {from: this.id}});
+          this.#stars[id] = this.socketClient;
+
+          this.socketClient.peerId = id;
+
+          const peers = await this.socketClient.peernet.join({id: this.id});
+          this.setupListeners();
+          for (const id of peers) {
+            if (id !== this.id) {
+              // close connection
+              if (this.#connections[id]) {
+                if (this.#connections[id].connected) await this.#connections[id].close();
+                delete this.#connections[id];
+              }
+              // reconnect
+              if (id !== this.id) this.#connections[id] = new Peer({channelName: `${id}:${this.id}`, socketClient: this.socketClient, id: this.id, to: id});
+            }
+
+          }
         } catch (e) {
-          throw e
+          console.log(e);
+          if (this.starsConfig.indexOf(star) === this.starsConfig.length -1 && !this.socketClient) throw new Error(`No star available to connect`);
         }
       }
     }
-  };
-  
-  return { send, request, pubsub, server, subscribe, unsubscribe, publish, peernet }
-};
-
-const socketRequestClient = (url, protocols = 'echo-protocol', options = { retry: false, pubsub: false }) => {
-  let { pubsub, retry } = options;
-  if (!pubsub) pubsub = new PubSub({verbose: false});
-  
-  const api = clientApi(pubsub);
-  
-  let tries = 0;
-
-  const onerror = error => {
-    if (pubsub.subscribers['error']) {
-      pubsub.publish('error', error);
-    } else {
-      console.error(error);
-    }
-  };
-
-  const onmessage = message => {
-    const {value, url, status, id} = JSON.parse(message.data.toString());
-    const publisher = id ? id : url;
-    if (status === 200) {
-      pubsub.publish(publisher, value);
-    } else {
-      pubsub.publish(publisher, {error: value});
+
+    console.log(`star ${id} left`);
+
+
+  }
+
+  peerLeft(id) {
+    if (this.#connections[id]) {
+      this.#connections[id].close();
+      delete this.#connections[id];
     }
+    console.log(`peer ${id} left`);
+  }
 
-  };  
-
-  const clientConnection = client => {
-    const startTime = new Date().getTime();
-    return {
-      client,
-      request: async req => {
-        const { result, id, handler } = await api.request(client, req);
-        pubsub.unsubscribe(id, handler);
-        return result
-      },
-      send: req => api.send(client, req),
-      subscribe: api.subscribe,
-      unsubscribe: api.unsubscribe,
-      subscribers: api.subscribers,
-      publish: api.publish,
-      pubsub: api.pubsub(client),
-      uptime: () => {
-        const now = new Date().getTime();
-        return (now - startTime)
-      },
-      peernet: api.peernet(client),
-      server: api.server(client),
-      close: exit => {
-        client.onclose = message => {
-          if (exit) process.exit();
-        };
-        client.close();
-      }
+  peerJoined(id, signal) {
+    if (this.#connections[id]) {
+      if (this.#connections[id].connected) this.#connections[id].close();
+      delete this.#connections[id];
     }
-  };
-  
-  return new Promise((resolve, reject) => {
-    const init = () => {
-      let ws;
-      if (typeof process === 'object') {
-        ws = require('websocket').w3cwebsocket;
-      } else {
-        ws = WebSocket;
-      }
-      const client = new ws(url, protocols);
+    // RTCPeerConnection
+    this.#connections[id] = new Peer({initiator: true, channelName: `${this.id}:${id}`, socketClient: this.socketClient, id: this.id, to: id});
+    console.log(`peer ${id} joined`);
+  }
+
 
-      client.onmessage = onmessage;
-      client.onerror = onerror;
-      client.onopen = () => {
-        tries = 0;
-        resolve(clientConnection(client));
-      };
-      client.onclose = message => {
-        tries++;
-        if (!retry) return reject(options)
-        if (tries > 5) {
-          console.log(`${protocols} Client Closed`);
-          console.error(`could not connect to - ${url}/`);
-          return resolve(clientConnection(client))
-        }
-        if (message.code === 1006) {
-          console.log('Retrying in 10 seconds');
-          setTimeout(() => {
-            return init();
-          }, retry);
-        }
-      };
-    };
-    return init();
-  });
-};
-
-class HttpClientApi$1 {
-  constructor(config = {}) {
-    if (!config.apiPath) config.apiPath = 'api';
-
-    const address = `ws://${config.host}:${config.port}`;
-
-    this.apiUrl = (url) => `${address}/${url}`;
-    return (async () => {
-      this.client = await socketRequestClient(address, config.protocol, {pubsub: config.pubsub, retry: 3000});
-      return this
-    })()
-  }
-
-  async get(url, obj) {
-    const headers = {};
-    let body = null;
-    let method = 'GET';
-    if (obj) {
-      method = 'POST';
-      headers['Content-Type'] = 'application/json';
-      body = JSON.stringify(obj);
-    }
-    let response = await this.client.request(url, {headers, body, method});
-    const type = response.headers.get('content-type').split(';')[0];
-    if (type==='application/json') response = await response.json();
-    return response
-  }
-
-  async put(url, obj) {
-    const headers = {};
-    let body = {};
-    if (obj) {
-      headers['Content-Type'] = 'application/json';
-      body = JSON.stringify(obj);
-    }
-
-    let response = await fetch(this.apiUrl(url), {method: 'PUT', headers, body});
-    const type = response.headers.get('content-type').split(';')[0];
-    if (type==='application/json') response = await response.json();
-    return response
-  }
-}
-
-class HttpClientApi extends HttpClientApi$1 {
-  constructor(config = {}) {
-    config.apiPath = 'api';
-    return (async () => {
-      await super(config);
-
-      this.properties = {
-        wallet: 'get',
-        version: 'get',
-        addresses: 'get',
-        config: 'get',
-        account: 'get',
-        accounts: 'get',
-        transaction: 'any',
-        transactions: 'get',
-        block: 'get',
-        blocks: 'get',
-      };
-      this.keys = Object.keys(this.properties);
-      return this
-    })()
-  }
-
-  async request(url, data) {
-    return await this.client.request({url, params: data})
-  }
-
-  async ready() {
-    return await this.request('ready')
-  }
-
-  async version() {
-    return await this.request('version')
-  }
-
-  async account(index) {
-    return await this.request('account', {index})
-  }
 }
 
-var httpClient = (config = {}) => {
-  if (typeof config !== 'object') config = {};
-  if (!config.protocol) config.protocol = 'peernet-v0.1.0';
-  if (!config.port) config.port = 1000;
-  if (!config.host) config.host = '127.0.0.1';
-
-  return new HttpClientApi(config)
-};
-
 class LeofcoinStorageClient {
   constructor(name, root) {
     this.name = name;
@@ -816,84 +626,84 @@ message PeernetMessage {
   optional string id = 5;
 }`;
 
-var codecs = {
-  // just a hash
-  'disco-hash': {
-    codec: '30',
-    hashAlg: 'dbl-keccak-512', // ,
-    // testnet: 'olivia'
-  },
-  'peernet-peer-response': {
-    codec: '707072',
-    hashAlg: 'keccak-256',
-  },
-  'peernet-peer': {
-    codec: '7070',
-    hashAlg: 'keccak-256',
-  },
-  'peernet-dht': {
-    codec: '706468',
-    hashAlg: 'keccak-256',
-  },
-  'peernet-dht-response': {
-    codec: '706472',
-    hashAlg: 'keccak-256',
-  },
-  // data
-  'peernet-data': {
-    codec: '706461',
-    hashAlg: 'keccak-256',
-  },
-  'peernet-data-response': {
-    codec: '70646172',
-    hashAlg: 'keccak-256',
-  },
-  // message
-  'peernet-message': {
-    codec: '706d65',
-    hashAlg: 'keccak-512',
-  },
-  // pubsub
-  'peernet-ps': {
-    codec: '707073',
-    hashAlg: 'keccak-256',
-  },
-  'peernet-response': {
-    codec: '7072',
-    hashAlg: 'keccak-256',
-  },
-  'peernet-request': {
-    codec: '707271',
-    hashAlg: 'keccak-256',
-  },
-  // normal block
-  'leofcoin-block': {
-    codec: '6c62',
-    hashAlg: 'dbl-keccak-512', // ,
-    // testnet: 'olivia'
-  },
-  'leofcoin-tx': {
-    codec: '6c74',
-    hashAlg: 'dbl-keccak-512', // ,
-    // testnet: 'olivia'
-  },
-  // itx
-  'leofcoin-itx': {
-    codec: '6c69',
-    hashAlg: 'keccak-512', // ,
-    // testnet: 'olivia'
-  },
-  // peer reputation
-  'leofcoin-pr': {
-    codec: '6c70',
-    hashAlg: 'keccak-256', // ,
-    // testnet: 'olivia'
-  },
-  // chat message
-  'chat-message': {
-    codec: '636d',
-    hashAlg: 'dbl-keccak-512',
-  },
+var codecs = {
+  // just a hash
+  'disco-hash': {
+    codec: parseInt('30', 16),
+    hashAlg: 'dbl-keccak-512', // ,
+    // 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-512',
+  },
+  // 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-512',
+  },
 };
 
 class PeernetCodec {
@@ -902,10 +712,9 @@ class PeernetCodec {
   }
   constructor(buffer) {
     if (buffer) {
-      if (Buffer.isBuffer(buffer)) {
+      if (buffer instanceof Uint8Array) {
         const codec = varint.decode(buffer);
         const name = this.getCodecName(codec);
-
         if (name) {
           this.name = name;
           this.encoded = buffer;
@@ -913,12 +722,23 @@ class PeernetCodec {
         } 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(buffer)) this.fromHex(buffer);
-        else if (bs32.test(buffer)) this.fromBs32(buffer);
-        else this.fromBs58(buffer);
+        else if (bs32.isBase32(buffer)) this.fromBs32(buffer);
+        else if (bs58.isBase58(buffer)) this.fromBs58(buffer);
+        else throw new Error(`unsupported string ${buffer}`)
       }
       if (!isNaN(buffer)) if (this.codecs[this.getCodecName(buffer)]) this.fromCodec(buffer);
     }
@@ -953,7 +773,8 @@ class PeernetCodec {
 
   getCodecName(codec) {
     return Object.keys(this.codecs).reduce((p, c) => {
-      if (parseInt(Buffer.from(`${this.getCodec(c)}`, 'hex').toString('hex'), 16) === codec) return c;
+      const item = this.codecs[c];
+      if (item.codec === codec) return c;
       else return p;
     }, undefined)
   }
@@ -967,7 +788,7 @@ class PeernetCodec {
     this.hashAlg = this.getHashAlg(this.name);
 
     this.codec = this.getCodec(this.name);
-    this.codecBuffer = Buffer.from(varint.encode(parseInt(Buffer.from(`${this.codec}`, 'hex').toString('hex'), 16)), 'hex');
+    this.codecBuffer = varint.encode(codec);
   }
 
   fromName(name) {
@@ -975,7 +796,7 @@ class PeernetCodec {
     this.name = name;
     this.codec = codec;
     this.hashAlg = this.getHashAlg(name);
-    this.codecBuffer = Buffer.from(varint.encode(parseInt(Buffer.from(`${codec}`, 'hex').toString('hex'), 16)), 'hex');
+    this.codecBuffer = varint.encode(codec);
   }
 
   toBs32() {
@@ -995,11 +816,10 @@ class PeernetCodec {
   decode() {
     const codec = varint.decode(this.encoded);
     this.fromCodec(codec);
-    this.name = this.getCodecName(codec);
   }
 
   encode() {
-    const codec = Buffer.from(varint.encode(parseInt(Buffer.from(`${this.codec}`, 'hex').toString('hex'), 16)), 'hex');
+    const codec = varint.encode(this.decoded);
     this.encoded = codec;
     return this.encoded
   }
@@ -1025,18 +845,28 @@ class PeernetHash {
 
       if (typeof buffer === 'string') {
         if (isHex(buffer)) this.fromHex(buffer);
-        if (bs32.test(buffer)) this.fromBs32(buffer);
-        else this.fromBs58(buffer);
+        if (bs32.isBase32(buffer)) this.fromBs32(buffer);
+        else if (bs58.isBase58(buffer)) this.fromBs58(buffer);
+        else throw new Error(`unsupported string ${buffer}`)
       } else if (typeof buffer === 'object') this.fromJSON(buffer);
     }
   }
 
   get prefix() {
-    return Buffer.concat([this.discoCodec.codecBuffer, this.length])
+    const length = this.length;
+    const uint8Array = new Uint8Array(length.length + this.discoCodec.codecBuffer.length);
+    for (let i = 0; i < this.discoCodec.codecBuffer.length; i++) {
+      uint8Array[i] = this.discoCodec.codecBuffer[i];
+    }
+
+    for (let i = uint8Array.length - 1; i < length.length; i++) {
+      uint8Array[i] = length[i];
+    }
+    return uint8Array
   }
 
   get length() {
-    return Buffer.from(varint.encode(this.size))
+    return varint.encode(this.size)
   }
 
   get buffer() {
@@ -1153,25 +983,18 @@ class FormatInterface {
   constructor(buffer, proto, options = {}) {
     this.protoEncode = proto.encode;
     this.protoDecode = proto.decode;
-    if (options.name) this.name = options.name;
     this.hashFormat = options.hashFormat || 'bs32';
-    if (buffer.name === options.name) {
-      return buffer
-    } else if (Buffer.isBuffer(buffer)) {
-      const codec = new PeernetCodec(buffer);
-      if (codec.name) {
-        this.fromEncoded(buffer);
-      } else {
-        this.create(buffer);
-      }
-    } else {
-      if (typeof buffer === 'string') {
+    if (options.name) this.name = options.name;
+    if (buffer instanceof Uint8Array) return this.fromUint8Array(buffer)
+    else if (buffer instanceof ArrayBuffer) return this.fromArrayBuffer(buffer)
+    else if (buffer.name === options.name) return buffer
+    else if (typeof buffer === 'string') {
         if (isHex(buffer)) this.fromHex(buffer);
-        else if (bs32.test(buffer)) this.fromBs32(buffer);
-        else this.fromBs58(buffer);
-      } else if (typeof buffer === 'object' && !Array.isArray(buffer)) {
-        this.create(buffer);
-      }
+        else if (bs32.isBase32(buffer)) this.fromBs32(buffer);
+        else if (bs58.isBase58(buffer)) this.fromBs58(buffer);
+        else throw new Error(`unsupported string ${buffer}`)
+    } else {
+      this.create(buffer);
     }
   }
 
@@ -1196,7 +1019,7 @@ class FormatInterface {
    */
   decode() {
     let encoded = this.encoded;
-    const discoCodec = new PeernetCodec(this.encoded.toString('hex'));
+    const discoCodec = new PeernetCodec(this.encoded);
     encoded = encoded.slice(discoCodec.codecBuffer.length);
     this.name = discoCodec.name;
     this.decoded = this.protoDecode(encoded);
@@ -1209,16 +1032,40 @@ class FormatInterface {
   encode(decoded) {
     if (!decoded) decoded = this.decoded;
     const codec = new PeernetCodec(this.name);
-    this.encoded = Buffer.concat([codec.codecBuffer, this.protoEncode(decoded)]);
+    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();
+  }
+
   /**
    * @param {Buffer} encoded
    */
   fromEncoded(encoded) {
-    const codec = new PeernetCodec(encoded);
-    this.name = codec.name;
     this.encoded = encoded;
     this.decode();
   }
@@ -1294,15 +1141,15 @@ class FormatInterface {
   }
 }
 
-class PeernetMessage extends FormatInterface {
-  get keys() {
-    return ['data', 'signature', 'from', 'to', 'id']
-  }
-
-  constructor(buffer) {
-    const name = 'peernet-message';
-    super(buffer, protons(proto$a).PeernetMessage, {name});
-  }
+class PeernetMessage extends FormatInterface {
+  get keys() {
+    return ['data', 'signature', 'from', 'to', 'id']
+  }
+
+  constructor(buffer) {
+    const name = 'peernet-message';
+    super(buffer, protons(proto$a).PeernetMessage, {name});
+  }
 }
 
 var proto$9 = `
@@ -1313,26 +1160,26 @@ message PeernetDHTMessage {
 }
 `;
 
-/**
- * @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 FormatInterface {
-  /**
-   *
-   */
-  get keys() {
-    return ['hash', 'store']
-  }
-
-  constructor(data) {
-    const name = 'peernet-dht';
-    super(data, protons(proto$9).PeernetDHTMessage, {name});
-  }
+/**
+ * @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 FormatInterface {
+  /**
+   *
+   */
+  get keys() {
+    return ['hash', 'store']
+  }
+
+  constructor(data) {
+    const name = 'peernet-dht';
+    super(data, protons(proto$9).PeernetDHTMessage, {name});
+  }
 }
 
 var proto$8 = `
@@ -1362,19 +1209,19 @@ message PeernetDataMessage {
 }
 `;
 
-/**
- * @extends {CodecFormat}
- */
-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(proto$7).PeernetDataMessage, {name: 'peernet-data'});
-  }
+/**
+ * @extends {CodecFormat}
+ */
+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(proto$7).PeernetDataMessage, {name: 'peernet-data'});
+  }
 }
 
 var proto$6 = `
@@ -1384,15 +1231,15 @@ message PsMessage {
   required bytes topic = 2;
 }`;
 
-class PsMessage extends FormatInterface {
-  get keys() {
-    return ['data', 'topic']
-  }
-
-  constructor(buffer) {
-    const name = 'peernet-ps';
-    super(buffer, protons(proto$6).PsMessage, {name});
-  }
+class PsMessage extends FormatInterface {
+  get keys() {
+    return ['data', 'topic']
+  }
+
+  constructor(buffer) {
+    const name = 'peernet-ps';
+    super(buffer, protons(proto$6).PsMessage, {name});
+  }
 }
 
 var proto$5 = `
@@ -1402,15 +1249,15 @@ message PeernetPeerMessage {
 }
 `;
 
-class PeerMessage extends FormatInterface {
-  get keys() {
-    return ['id']
-  }
-
-  constructor(data) {
-    const name = 'peernet-peer';
-    super(data, protons(proto$5).PeernetPeerMessage, {name});
-  }
+class PeerMessage extends FormatInterface {
+  get keys() {
+    return ['id']
+  }
+
+  constructor(data) {
+    const name = 'peernet-peer';
+    super(data, protons(proto$5).PeernetPeerMessage, {name});
+  }
 }
 
 var proto$4 = `
@@ -1420,15 +1267,15 @@ message PeernetRequestMessage {
 }
 `;
 
-class RequestMessage extends FormatInterface {
-  get keys() {
-    return ['request']
-  }
-
-  constructor(data) {
-    const name = 'peernet-request';
-    super(data, protons(proto$4).PeernetRequestMessage, {name});
-  }
+class RequestMessage extends FormatInterface {
+  get keys() {
+    return ['request']
+  }
+
+  constructor(data) {
+    const name = 'peernet-request';
+    super(data, protons(proto$4).PeernetRequestMessage, {name});
+  }
 }
 
 var proto$3 = `
@@ -1438,15 +1285,15 @@ message PeernetResponseMessage {
 }
 `;
 
-class ResponseMessage extends FormatInterface {
-  get keys() {
-    return ['response']
-  }
-
-  constructor(data) {
-    const name = 'peernet-response';
-    super(data, protons(proto$3).PeernetResponseMessage, {name});
-  }
+class ResponseMessage extends FormatInterface {
+  get keys() {
+    return ['response']
+  }
+
+  constructor(data) {
+    const name = 'peernet-response';
+    super(data, protons(proto$3).PeernetResponseMessage, {name});
+  }
 }
 
 var proto$2 = `
@@ -1456,15 +1303,15 @@ message PeernetPeerMessageResponse {
 }
 `;
 
-class PeerMessageResponse extends FormatInterface {
-  get keys() {
-    return ['id']
-  }
-
-  constructor(data) {
-    const name = 'peernet-peer-response';
-    super(data, protons(proto$2).PeernetPeerMessageResponse, {name});
-  }
+class PeerMessageResponse extends FormatInterface {
+  get keys() {
+    return ['id']
+  }
+
+  constructor(data) {
+    const name = 'peernet-peer-response';
+    super(data, protons(proto$2).PeernetPeerMessageResponse, {name});
+  }
 }
 
 var proto$1 = `
@@ -1475,15 +1322,15 @@ message PeernetDataMessageResponse {
 }
 `;
 
-class DataMessageResponse extends FormatInterface {
-  get keys() {
-    return ['hash', 'data']
-  }
-
-  constructor(data) {
-    const name = 'peernet-data-response';
-    super(data, protons(proto$1).PeernetDataMessageResponse, {name});
-  }
+class DataMessageResponse extends FormatInterface {
+  get keys() {
+    return ['hash', 'data']
+  }
+
+  constructor(data) {
+    const name = 'peernet-data-response';
+    super(data, protons(proto$1).PeernetDataMessageResponse, {name});
+  }
 }
 
 var proto = `
@@ -1494,15 +1341,15 @@ message ChatMessage {
   repeated string files = 4;
 }`;
 
-class ChatMessage extends FormatInterface {
-  get keys() {
-    return ['author', 'value', 'timestamp', 'files']
-  }
-
-  constructor(buffer) {
-    const name = 'chat-message';
-    super(buffer, protons(proto).ChatMessage, {name});
-  }
+class ChatMessage extends FormatInterface {
+  get keys() {
+    return ['author', 'value', 'timestamp', 'files']
+  }
+
+  constructor(buffer) {
+    const name = 'chat-message';
+    super(buffer, protons(proto).ChatMessage, {name});
+  }
 }
 
 const debug = (log) => {
@@ -1524,7 +1371,7 @@ const protoFor = (data) => {
  */
 const hasDaemon = async () => {
   try {
-    let response = await fetch$1('http://127.0.0.1:1000/api/version');
+    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) {
@@ -1660,7 +1507,7 @@ const getAddress = async () => {
   const {address} = lastFetched;
   const now = Math.round(new Date().getTime() / 1000);
   if (now - address.timestamp > 1200000) {
-    address.value = await fetch$1('https://icanhazip.com/');
+    address.value = await fetch('https://icanhazip.com/');
     address.value = await address.value.text();
     address.timestamp = Math.round(new Date().getTime() / 1000);
     lastFetched.address = address;
@@ -1702,7 +1549,7 @@ class DhtEarth {
   async getCoordinates(address) {
     // const {address} = parseAddress(provider)
     const request = `https://whereis.leofcoin.org/?ip=${address}`;
-    let response = await fetch$1(request);
+    let response = await fetch(request);
     response = await response.json();
     const {lat, lon} = response;
     return {latitude: lat, longitude: lon}
@@ -1760,93 +1607,441 @@ class DhtEarth {
   }
 }
 
+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
+  	}
+  }
+
+};
+
+// https://en.bitcoin.it/wiki/List_of_address_prefixes
 /**
- * @params {String} network
- * @return {object} { identity, accounts, config }
+ * Main network
+ * @return {messagePrefix, pubKeyHash, scriptHash, wif, bip32}
  */
-var generateAccount = async network => {
-    const wallet = new MultiWallet(network);
-    /**
-     * @type {string}
-     */
-    const mnemonic = await wallet.generate();
-    /**
-     * @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: {
-        miner: {
-          intensity: 1,
-          address: external.address,
-          donationAddress: undefined,
-          donationAmount: 1 //percent
-        }
-       }
-    }
-  };
+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 bitcoin = {
+	messagePrefix: '\x18Bitcoin Signed Message:\n',
+	bech32: 'bc',
+	pubKeyHash: 0x00,
+	scriptHash: 0x05,
+	wif: 0x80,
+	coin_type: 0,
+	bip32: {
+		public: 0x0488b21e, private: 0x0488ade4
+	},
+	testnet: testnets['bitcoin:testnet']
+};
+
+const litecoin = {
+	messagePrefix: '\x19Litecoin Signed Message:\n',
+	pubKeyHash: 0x30,
+	scriptHash: 0x32,
+	wif: 0xb0,
+	bip32: {
+		public: 0x019da462,
+		private: 0x019d9cfe
+	}
+};
+
+const ethereum = {
+	messagePrefix: '\x19Ethereum Signed Message:\n',
+	pubKeyHash: 0x30,
+	scriptHash: 0x32,
+	bip32: {
+		private: 0x0488ADE4, public: 0x0488B21E
+	},
+	coin_type: 60,
+	wif: 0x45,//E
+	multiCodec: 0x3c5
+};
+
+/**
+ * Our & supported networks
+ * @return {leofcoin, olivia}
+ */
+var networks = {
+	leofcoin,
+	bitcoin,
+	litecoin,
+	ethereum
+};
 
-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 PeernetHash(message, {name: 'peernet-message'});
-    const identity = await walletStore.get('identity');
+const fromNetworkString = network => {
+  const parts = network.split(':');
+  network = networks[parts[0]];
+  if (parts[1]) {
+    if (network[parts[1]]) network = network[parts[1]];
+    
+    network.coin_type = 1;
+  }
+	return network;
+};
 
-    const wallet = new MultiWallet(this.network);
-    wallet.import(identity.multiWIF);
-    return wallet.sign(hasher.hash.slice(0, 32))
-  }
+const { encode: encode$1, decode: decode$1 } = bs58check__default;
+class HDWallet {
+
+	get chainCodeBuffer() {
+		return this.ifNotLocked(() => this.hdnode.chainCode)
+	}
+
+	get chainCode() {
+		return this.ifNotLocked(() => this.chainCodeBuffer.toString('hex'))
+	}
+
+	get privateKeyBuffer() {
+		return this.ifNotLocked(() => this.hdnode.privateKey)
+	}
+
+	get privateKey() {
+		return this.ifNotLocked(() => this.privateKeyBuffer.toString('hex'))
+	}
+
+	get publicKeyBuffer() {
+		return this.ifNotLocked(() => this.hdnode.publicKey)
+	}
+
+	get publicKey() {
+		return this.ifNotLocked(() => this.publicKeyBuffer.toString('hex'))
+	}
+
+	get address() {
+		// override testnet coin_type
+		let 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 === 60 || coin_type === 640) {
+			let buffer = ecc.pointFromScalar(this.hdnode.__D, false);
+			buffer = Buffer.from(publicKeyConvert(buffer, false)).slice(1);
+			let hash = createKeccakHash('keccak256').update(buffer).digest();
+			return hash.slice(-20).toString('hex')
+		}
+		return encode$1(this.neutered.publicKeyBuffer)
+	}
+
+	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(network) {
+		network = this.validateNetwork(network);
+		const mnemonic = generateMnemonic();
+		const seed = await mnemonicToSeed(mnemonic);
+		this.defineHDNode(bip32.fromSeed(seed, network));
+		return mnemonic; // userpw
+	}
+
+	/**
+   * recover using mnemonic (recovery word list)
+   */
+	async recover(mnemonic, network) {
+		network = this.validateNetwork(network);
+		const seed = await mnemonicToSeed(mnemonic);
+		this.defineHDNode(bip32.fromSeed(seed, network));
+	}
+
+	load(base58, network) {
+		network = this.validateNetwork(network);
+		this.defineHDNode(bip32.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.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.fromPublicKey(hex, chainCode, network));
+	}
+}
 
-  /**
-   * @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) {
-    if (!Buffer.isBuffer(from)) from = new Buffer.from(from);
-    if (!Buffer.isBuffer(to)) to = new Buffer.from(to);
-    if (data.encoded) data = data.encoded;
-
-    const message = {
-      from,
-      to,
-      data,
-    };
-    const signature = await this.hashAndSignMessage(message);
-    const node = new PeernetMessage({
-      ...message,
-      signature,
-    });
+const { encode, decode } = bs58check;
+
+// 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) {
+		const networkName = network;
+		super(network, hdnode);
+		if (typeof networkName === 'string') this.networkName = networkName;
+		this.multiCodec = this.network.multiCodec;
+		this.version = 0x00;
+	}
+
+	get id() {
+		const buffer = Buffer.concat([
+			Buffer.from(varint.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.network, this.hdnode.neutered()));
+		if (neutered) this._neutered = neutered;
+		return this._neutered
+	}
+
+	fromId(id) {
+		let buffer = decode(id);
+		varint.decode(buffer);
+		buffer = buffer.slice(varint.decode.bytes);
+		this.fromPublicKey(buffer, null, this.network);
+	}
+
+	lock(key, multiWIF) {
+		if (!multiWIF) multiWIF = this.multiWIF;
+		this.encrypted = AES.encrypt(multiWIF.toString('hex'), key).toString();
+		this.locked = true;
+	}
+
+	unlock(key, encrypted) {
+		if (!encrypted) encrypted = this.encrypted;
+		this.import(AES.decrypt(encrypted, key).toString(ENC));
+		this.locked = false;
+	}
+
+	export() {
+		return this.encode();
+	}
+
+	/**
+	 * encodes the multiWIF and loads wallet from bs58
+	 *
+	 * @param {multiWIF} multiWIF - note a multiWIF is not the same as a wif
+	 */
+	import(multiWIF) {
+		const { bs58, version, multiCodec } = this.decode(multiWIF);
+		this.network = Object.values(networks).reduce((p, c) => {
+			if (c.multiCodec===multiCodec) return c
+			else if (c.testnet && c.testnet.multiCodec === multiCodec) return c.testnet
+			else return p
+		}, networks['leofcoin']);
+		this.load(bs58, this.network);
+	}
+
+	/**
+	 * @return base58Check encoded string
+	 */
+	encode() {
+		const buffer = Buffer.concat([
+			Buffer.from(varint.encode(this.version)),
+			Buffer.from(varint.encode(this.multiCodec)),
+			decode(this.save())
+		]);
+		return encode(buffer);
+	}
+
+	decode(bs58) {
+		let buffer = decode(bs58);
+		const version = varint.decode(buffer);
+		buffer = buffer.slice(varint.decode.bytes);
+		const multiCodec = varint.decode(buffer);
+		buffer = buffer.slice(varint.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(this.version, this.network.multiCodec)
+			.sign(hash, this.privateKeyBuffer);
+
+	}
+
+	verify(multiSignature, hash) {
+		return new MultiSignature(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.network, 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.network, this.hdnode.derivePath(path))
+	}
+
+	derive(index) {
+		return new MultiWallet(this.network, this.hdnode.derive(index));
+	}
+}
 
-    return node
-  }
+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 PeernetHash(message, {name: 'peernet-message'});
+    const identity = await walletStore.get('identity');
+
+    const wallet = new MultiWallet(this.network);
+    wallet.import(identity.multiWIF);
+    return wallet.sign(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 (!Buffer.isBuffer(from)) from = new Buffer.from(from);
+    if (!Buffer.isBuffer(to)) to = new Buffer.from(to);
+    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 encapsulatedError = () => {
@@ -1925,7 +2120,7 @@ class Peernet {
     if (this.hasDaemon) {
       Storage = LeofcoinStorageClient;
     } else {
-      Storage = LeofcoinStorage$1;
+      Storage = LeofcoinStorage;
     }
     globalThis[`${name}Store`] = globalThis[`${name}Store`] ||
       await new Storage(`${prefix}-${name}`, root);
@@ -2007,13 +2202,7 @@ class Peernet {
     const {daemon, environment} = await target();
     this.hasDaemon = daemon;
 
-    if (this.hasDaemon) {
-      globalThis.peernet.client = await httpClient({
-        protocol: 'peernet-v0.1.0', host: '127.0.0.1', port: options.port,
-      });
-    } else {
-      if (environment !== 'browser') http(options);
-    }
+    HTTP_IMPORT;
 
     for (const store of this.defaultStores) {
       await this.addStore(store, options.storePrefix, options.root);
@@ -2039,42 +2228,41 @@ class Peernet {
       }
     }
     this._peerHandler = new PeerDiscovery(this.id);
-    // peernet id
-    const id = Buffer.from(this.id.slice(0, 32));
-    this.peerId = id;
-
-    pubsub.subscribe('peer:discovered', async (peer) => {
-      peer.on('peernet.data', async (message) => {
-        const id = message.id;
-        message = new PeernetMessage(Buffer.from(message.data.data));
-        const proto = protoFor(message.decoded.data);
-        await this._protoHandler({id, proto}, peer);
-      });
-      await this._peerHandler.discover(peer);
-      const fulldId = this._getPeerId(peer.id);
-      if (fulldId && this._discovered.indexOf(peer.id) === -1) {
-        this._discovered.push(peer.id);
-        pubsub.publish('peer:connected', peer);
-      }
-    });
-    pubsub.subscribe('peer:disconnected', async (peer) => {
-      let index = this._discovered.indexOf(peer.id);
-      if (index !== -1) this._discovered.splice(index, 1);
-      const id = this._getPeerId(peer.id);
-      let peerIds = this.peerMap.get(id);
-
-      if (peerIds) {
-        index = peerIds.indexOf(peer.id);
-        if (index !== -1) peerIds.splice(index, 1);
-      } else {
-        peerIds = [];
-      }
-
-      if (peerIds.length === 0) this.peerMap.delete(id);
-      else this.peerMap.set(id, peerIds);
-    });
+    this.peerId = this.id;
+
+    // pubsub.subscribe('peer:discovered', async (peer) => {
+    //   peer.on('peernet.data', async (message) => {
+    //     const id = message.id;
+    //     message = new PeernetMessage(Buffer.from(message.data.data));
+    //     const proto = protoFor(message.decoded.data);
+    //     await this._protoHandler({id, proto}, peer);
+    //   });
+    //   await this._peerHandler.discover(peer);
+    //   const fulldId = this._getPeerId(peer.id);
+    //   if (fulldId && this._discovered.indexOf(peer.id) === -1) {
+    //     this._discovered.push(peer.id);
+    //     pubsub.publish('peer:connected', peer);
+    //   }
+    // });
+    // pubsub.subscribe('peer:disconnected', async (peer) => {
+    //   let index = this._discovered.indexOf(peer.id)
+    //   if (index !== -1) this._discovered.splice(index, 1)
+    //   const id = this._getPeerId(peer.id)
+    //   let peerIds = this.peerMap.get(id)
+    //
+    //   if (peerIds) {
+    //     index = peerIds.indexOf(peer.id)
+    //     if (index !== -1) peerIds.splice(index, 1)
+    //   } else {
+    //     peerIds = []
+    //   }
+    //
+    //   if (peerIds.length === 0) this.peerMap.delete(id)
+    //   else this.peerMap.set(id, peerIds)
+    // })
     pubsub.subscribe('peer:connected', async (peer) => {
-      console.log({connected: peer.id, as: this._getPeerId(peer.id) });
+      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))
@@ -2083,11 +2271,27 @@ class Peernet {
       // })
     });
 
+    pubsub.subscribe('peer:data', async message => {
+      console.log({message});
+      if (!message.data) return
+      const {id, data} = JSON.parse(new TextDecoder().decode(message.data));
+      const uint8Array = new Uint8Array(Object.keys(data).length);
+      for (var i = 0; i < Object.keys(data).length; i++) {
+        uint8Array[i] = data[i];
+      }
+      message = new PeernetMessage(uint8Array);
+      const proto = protoFor(message.decoded.data);
+
+      console.log(message.decoded);
+      const from = new TextDecoder().decode(message.decoded.from);
+      this._protoHandler({id, proto}, this.client.connections[from], from);
+    });
+
     /**
      * @access public
      * @type {PeernetClient}
      */
-    this.client = new PeernetClient({...options, id});
+    this.client = new Client(this.id);
     if (globalThis.onbeforeunload) {
       globalThis.addEventListener('beforeunload', async () => this.client.close());
     }
@@ -2112,55 +2316,56 @@ class Peernet {
    * @param {Buffer} message - peernet message
    * @param {PeernetPeer} peer - peernet peer
    */
-  async _protoHandler(message, peer) {
+  async _protoHandler(message, peer, from) {
     const {id, proto} = message;
+    console.log(message);
     this.bw.down += proto.encoded.length;
-    if (proto.name === 'peernet-peer') {
-      const from = proto.decoded.id;
-      if (!this.peerMap.has(from)) this.peerMap.set(from, [peer.id]);
-      else {
-        const connections = this.peerMap.get(from);
-        if (connections.indexOf(peer.id) === -1) {
-          connections.push(peer.id);
-          this.peerMap.set(from, connections);
-        }
-      }
-      const data = new PeerMessageResponse({id: this.id});
-      const node = await this.prepareMessage(from, data.encoded);
-
-      peer.write(Buffer.from(JSON.stringify({id, data: node.encoded})));
-      this.bw.up += node.encoded.length;
-    } else if (proto.name === 'peernet-peer-response') {
-      const from = proto.decoded.id;
-      if (!this.peerMap.has(from)) this.peerMap.set(from, [peer.id]);
-      else {
-        const connections = this.peerMap.get(from);
-        if (connections.indexOf(peer.id) === -1) {
-          connections.push(peer.id);
-          this.peerMap.set(from, connections);
-        }
-      }
-    } else {
-      let from = this._getPeerId(peer.id);
-      if (!from) {
-        const data = new PeerMessage({id: this.id});
-        const node = await this.prepareMessage(peer.id, data.encoded);
-        this.bw.up += node.encoded.length;
-        let response = await peer.request(node.encoded);
-        response = protoFor(response);
-
-        response = new PeerMessageResponse(response.decoded.data);
-
-        from = response.decoded.id;
-        if (!this.peerMap.has(from)) this.peerMap.set(from, [peer.id]);
-        else {
-          const connections = this.peerMap.get(from);
-          if (connections.indexOf(peer.id) === -1) {
-            connections.push(peer.id);
-            this.peerMap.set(from, connections);
-          }
-        }
-      }
+    // if (proto.name === 'peernet-peer') {
+    //   const from = proto.decoded.id
+    //   if (!this.peerMap.has(from)) this.peerMap.set(from, [peer.id])
+    //   else {
+    //     const connections = this.peerMap.get(from)
+    //     if (connections.indexOf(peer.id) === -1) {
+    //       connections.push(peer.id)
+    //       this.peerMap.set(from, connections)
+    //     }
+    //   }
+    //   const data = new PeerMessageResponse({id: this.id})
+    //   const node = await this.prepareMessage(from, data.encoded)
+    //
+    //   peer.send(Buffer.from(JSON.stringify({id, data: node.encoded})))
+    //   this.bw.up += node.encoded.length
+    // } else if (proto.name === 'peernet-peer-response') {
+    //   const from = proto.decoded.id
+    //   if (!this.peerMap.has(from)) this.peerMap.set(from, [peer.id])
+    //   else {
+    //     const connections = this.peerMap.get(from)
+    //     if (connections.indexOf(peer.id) === -1) {
+    //       connections.push(peer.id)
+    //       this.peerMap.set(from, connections)
+    //     }
+    //   }
+    // } else {
+    //   let from = this._getPeerId(peer.id)
+    //   if (!from) {
+    //     const data = new PeerMessage({id: this.id})
+    //     const node = await this.prepareMessage(peer.id, data.encoded)
+    //     this.bw.up += node.encoded.length
+    //     let response = await peer.request(node.encoded)
+    //     response = protoFor(response)
+    //
+    //     response = new PeerMessageResponse(response.decoded.data)
+    //
+    //     from = response.decoded.id
+    //     if (!this.peerMap.has(from)) this.peerMap.set(from, [peer.id])
+    //     else {
+    //       const connections = this.peerMap.get(from)
+    //       if (connections.indexOf(peer.id) === -1) {
+    //         connections.push(peer.id)
+    //         this.peerMap.set(from, connections)
+    //       }
+    //     }
+    //   }
       if (proto.name === 'peernet-dht') {
         let { hash, store } = proto.decoded;
         let has;
@@ -2175,7 +2380,7 @@ class Peernet {
         const data = new DHTMessageResponse({hash, has});
         const node = await this.prepareMessage(from, data.encoded);
 
-        peer.write(Buffer.from(JSON.stringify({id, data: node.encoded})));
+        peer.send(Buffer.from(JSON.stringify({id, data: node.encoded})));
         this.bw.up += node.encoded.length;
       } else if (proto.name === 'peernet-data') {
         let { hash, store } = proto.decoded;
@@ -2183,7 +2388,7 @@ class Peernet {
         if (!store) {
           store = await this.whichStore([...this.stores], hash);
         } else {
-          store = globalThis.stores[`${store}Store`];
+          store = globalThis[`${store}Store`];
         }
         if (store && !store.private) {
           data = await store.get(hash);
@@ -2192,7 +2397,7 @@ class Peernet {
             data = new DataMessageResponse({hash, data: data.decoded ? Buffer.from(JSON.stringify(data)) : Buffer.from(data)});
 
             const node = await this.prepareMessage(from, data.encoded);
-            peer.write(Buffer.from(JSON.stringify({id, data: node.encoded})));
+            peer.send(Buffer.from(JSON.stringify({id, data: node.encoded})));
             this.bw.up += node.encoded.length;
           }
         }
@@ -2208,7 +2413,7 @@ class Peernet {
         const data = new PeerMessage({id: this.id});
         const node = await this.prepareMessage(from, data.encoded);
 
-        peer.write(Buffer.from(JSON.stringify({id, data: node.encoded})));
+        peer.send(Buffer.from(JSON.stringify({id, data: node.encoded})));
         this.bw.up += node.encoded.length;
       } else if (proto.name === 'peernet-request') {
         // TODO: make dynamic
@@ -2217,14 +2422,14 @@ class Peernet {
         if (method) {
           const data = await method();
           const node = await this.prepareMessage(from, data.encoded);
-          peer.write(Buffer.from(JSON.stringify({id, data: node.encoded})));
+          peer.send(new TextEncoder().encode(JSON.stringify({id, data: node.encoded})));
           this.bw.up += node.encoded.length;
         }
       } else if (proto.name === 'peernet-ps' &&
                  this._getPeerId(peer.id) !== this.id.toString()) {
         globalSub.publish(proto.decoded.topic.toString(), proto.decoded.data.toString());
       }
-    }
+    // }
   }
 
   /**
@@ -2339,7 +2544,7 @@ class Peernet {
         if (this._getPeerId(peer.id) === id) return peer
       });
 
-      let data = new DataMessage({hash, store});
+      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);
@@ -2489,7 +2694,7 @@ class Peernet {
       if (peer.connection._connected) {
         if (peer.id.toString() !== this.peerId.toString()) {
           const node = await this.prepareMessage(peer.id, data.encoded);
-          peer.write(Buffer.from(JSON.stringify({id, data: node.encoded})));
+          peer.send(Buffer.from(JSON.stringify({id, data: node.encoded})));
         }
       } else {
         this.removePeer(peer);