@leofcoin/peernet 0.11.31 → 0.12.2

package/dist/module/peernet.js

@@ -1,910 +1,6 @@
 import '@vandeurenglenn/debug';
-import pako from 'pako';
-import LeofcoinStorage from '@leofcoin/storage';
-import protons from 'protons';
-import { FormatInterface, Codec, CodecHash, codecs } from '@leofcoin/codec-format-interface';
-import MultiWallet$1 from '@leofcoin/multi-wallet';
-import * as bs58check from 'bs58check';
-import bs58check__default from 'bs58check';
-import * as bip32 from 'bip32';
-import createKeccakHash from 'keccak';
-import ecc from 'tiny-secp256k1';
-import Mnemonic from '@leofcoin/mnemonic';
-import MultiSignature from 'multi-signature';
-import varint from 'varint';
-import randombytes from 'randombytes';
-
-/* socket-request-client version 1.6.3 */
-
-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));
-  }
-  unsubscribe(event, handler, context) {
-    if (typeof context === 'undefined') {
-      context = handler;
-    }
-    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];
-    }
-  }
-  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);
-        });
-      }
-    }
-  }
-}
-
-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'
-    }
-  };
-  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
-    }
-  };
-  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
-        }
-      }
-    }
-  };
-  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
-        }
-      }
-    }
-  };
-  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);
-    }
-  };
-  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});
-    }
-  };
-  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.close();
-      }
-    }
-  };
-  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();
-  });
-};
-
-class Peer {
-  #connection
-  #connecting = false
-  #connected = false
-  #channelReady = false
-  #destroying = false
-  #destroyed = false
-  #isNegotiating = false
-  #firstNegotiation = true
-  #iceComplete = false
-  #remoteTracks = []
-  #remoteStreams = []
-  #pendingCandidates = []
-  #senderMap = new Map()
-  #messageQue = []
-  #chunksQue = {}
-  #iceCompleteTimer
-  #channel
-  #peerId
-  #chunkSize = 16 * 1024 // 16384
-  #queRunning = false
-  #MAX_BUFFERED_AMOUNT = 16 * 1024 * 1024
-
-  get connection() {
-    return this.#connection
-  }
-
-  get connected() {
-    return this.#connected
-  }
-
-  get readyState() {
-    return this.channel?.readyState
-  }
-
-/**
- * @params {Object} options
- * @params {string} options.channelName - this peerid : otherpeer id
- */
- 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
-    };
-
-    this.channelName = options.channelName;
-
-    this.#peerId = options.peerId;
-    this.options = options;
-    this.#init();
-   }
-
-   get peerId() {
-     return this.#peerId
-   }
-
-   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
-   }
-
-   splitMessage(message) {
-     const chunks = [];
-     message = pako.deflate(message);
-     const size = message.byteLength || message.length;
-     let offset = 0;
-     return new Promise((resolve, reject) => {
-       const splitMessage = () => {
-         const chunk = message.slice(offset, offset + this.#chunkSize > size ? size : offset + this.#chunkSize);
-         offset += this.#chunkSize;
-         chunks.push(chunk);
-         if (offset < size) return splitMessage()
-         else resolve({chunks, size});
-       };
-
-       splitMessage();
-     })
-   }
-
-   async #runQue() {
-     this.#queRunning = true;
-     if (this.#messageQue.length > 0 && this.channel.bufferedAmount + this.#messageQue[0]?.length < this.#MAX_BUFFERED_AMOUNT) {
-       const message = this.#messageQue.shift();
-
-       switch (this.channel?.readyState) {
-         case 'open':
-          await this.channel.send(message);
-          if (this.#messageQue.length > 0) return this.#runQue()
-          else this.#queRunning = false;
-         break;
-         case 'closed':
-         case 'closing':
-          this.#messageQue = [];
-          this.#queRunning = false;
-          debug('channel already closed, this usually means a bad implementation, try checking the readyState or check if the peer is connected before sending');
-         break;
-         case undefined:
-          this.#messageQue = [];
-          this.#queRunning = false;
-          debug(`trying to send before a channel is created`);
-         break;
-       }
-
-
-     } else {
-       return setTimeout(() => this.#runQue(), 50)
-     }
-   }
-
-   #trySend({ size, id, chunks }) {
-     let offset = 0;
-
-     for (const chunk of chunks) {
-       const start = offset;
-       const end = offset + chunk.length;
-
-       const message = new TextEncoder().encode(JSON.stringify({ size, id, chunk, start, end }));
-       this.#messageQue.push(message);
-     }
-
-     if (!this.queRunning) return this.#runQue()
-   }
-
-   async send(message, id) {
-     const { chunks, size } = await this.splitMessage(message);
-     return this.#trySend({ size, id, chunks })
-   }
-
-   request(data) {
-    return new Promise((resolve, reject) => {
-      const id = Math.random().toString(36).slice(-12);
-
-      const _onData = message => {
-        if (message.id === id) {
-          resolve(message.data);
-          pubsub.unsubscribe(`peer:data`, _onData);
-        }
-      };
-
-      pubsub.subscribe(`peer:data`, _onData);
-
-      // cleanup subscriptions
-      // setTimeout(() => {
-      //   pubsub.unsubscribe(`peer:data-request-${id}`, _onData)
-      // }, 5000);
-
-      this.send(data, id);
-    })
-  }
-
-   async #init() {
-     try {
-       const iceServers = [{
-         urls: 'stun:stun.l.google.com:19302' // Google's public STUN server
-       }, {
-         urls: "stun:openrelay.metered.ca:80",
-       }, {
-        urls: "turn:openrelay.metered.ca:443",
-        username: "openrelayproject",
-        credential: "openrelayproject",
-       }, {
-        urls: "turn:openrelay.metered.ca:443?transport=tcp",
-        username: "openrelayproject",
-        credential: "openrelayproject",
-       }];
-
-       this.#connection = new wrtc.RTCPeerConnection({iceServers});
-
-       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 = () => this.close.bind(this);
-
-         message.channel.onmessage = (message) => {
-           this._handleMessage(this.id, message);
-         };
-         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) => {
-          this._handleMessage(this.peerId, message);
-        };
-
-       const offer = await this.#connection.createOffer();
-       await this.#connection.setLocalDescription(offer);
-
-       this._sendMessage({'sdp': this.#connection.localDescription});
-     }
-     } catch (e) {
-       console.log(e);
-     }
-   }
-
-   _handleMessage(peerId, message) {
-     debug(`incoming message from ${peerId}`);
-
-     message = JSON.parse(new TextDecoder().decode(message.data));
-     // allow sharding (multiple peers share data)
-     pubsub.publish('peernet:shard', message);
-     const { id } = message;
-
-     if (!this.#chunksQue[id]) this.#chunksQue[id] = [];
-
-     if (message.size > this.#chunksQue[id].length || message.size === this.#chunksQue[id].length) {
-       for (const value of Object.values(message.chunk)) {
-         this.#chunksQue[id].push(value);
-       }
-     }
-
-     if (message.size === this.#chunksQue[id].length) {
-       let data = new Uint8Array(Object.values(this.#chunksQue[id]));
-       delete this.#chunksQue[id];
-       data = pako.inflate(data);
-       pubsub.publish('peer:data', { id, data });
-     }
-     this.bw.down += message.byteLength || message.length;
-   }
-
-   _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) {
-      debug(`incoming candidate ${this.channelName}`);
-      debug(message.candidate.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));
-    }
-    try {
-      if (message.sdp) {
-        if (message.sdp.type === 'offer') {
-          debug(`incoming offer ${this.channelName}`);
-          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 (message.sdp.type === 'answer') {
-          debug(`incoming answer ${this.channelName}`);
-          await this.#connection.setRemoteDescription(new wrtc.RTCSessionDescription(message.sdp));
-        }
-     }
-    } catch (e) {
-      console.log(e);
-    }
- }
-
- close() {
-   debug(`closing ${this.peerId}`);
-   this.#connected = false;
-   this.channel?.close();
-   this.#connection?.close();
-
-   this.socketClient.pubsub.unsubscribe('signal', this._in);
- }
-}
-
-class Client {
-  #peerConnection
-  #connections = {}
-  #stars = {}
-
-  get connections() {
-    return { ...this.#connections }
-  }
-
-  get peers() {
-    return Object.entries(this.#connections)
-  }
-
-  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);
-
-    this._init(identifiers, stars);
-  }
-
-  async _init(identifiers, stars = []) {
-    if (stars.length === 0) {
-      stars.push('wss://star.leofcoin.org');
-    }
-    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, peerId: id});
-    }
-    this.setupListeners();
-  }
-
-  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];
-    }
-    console.log(`star ${id} joined`);
-  }
-
-  async starLeft(id) {
-    if (this.#stars[id]) {
-      this.#stars[id].close();
-      delete this.#stars[id];
-    }
-    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 {
-          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, peerId: id});
-            }
-
-          }
-        } catch (e) {
-          console.log(e);
-          if (this.starsConfig.indexOf(star) === this.starsConfig.length -1 && !this.socketClient) throw new Error(`No star available to connect`);
-        }
-      }
-    }
-    debug(`star ${id} left`);
-  }
-
-  peerLeft(peer) {
-    const id = peer.peerId || peer;
-    if (this.#connections[id]) {
-      this.#connections[id].close();
-      delete this.#connections[id];
-    }
-    debug(`peer ${id} left`);
-  }
-
-  peerJoined(peer, signal) {
-    const id = peer.peerId || peer;
-    if (this.#connections[id]) {
-      if (this.#connections[id].connected) this.#connections[id].close();
-      delete this.#connections[id];
-    }
-    // RTCPeerConnection
-    this.#connections[id] = new Peer({initiator: true, channelName: `${this.id}:${id}`, socketClient: this.socketClient, id: this.id, to: id, peerId: id});
-    debug(`peer ${id} joined`);
-  }
-
-  removePeer(peer) {
-    const id = peer.peerId || peer;
-    if (this.#connections[id]) {
-      this.#connections[id].connected && this.#connections[id].close();
-      delete this.#connections[id];
-    }
-    debug(`peer ${id} removed`);
-  }
-
-
-}
-
-var proto$a = `
-// PeernetMessage
-message PeernetMessage {
-  required bytes data = 1;
-  required bytes signature = 2;
-  optional string from = 3;
-  optional string to = 4;
-  optional string id = 5;
-}`;
-
-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 = `
-// 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 FormatInterface {
-  /**
-   *
-   */
-  get keys() {
-    return ['hash', 'store']
-  }
-
-  constructor(data) {
-    const name = 'peernet-dht';
-    super(data, protons(proto$9).PeernetDHTMessage, {name});
-  }
-}
-
-var proto$8 = `
-// PeernetDHTMessageResponse
-message PeernetDHTMessageResponse {
-  required string hash = 1;
-  required bool has = 2;
-}
-`;
-
-class DHTMessageResponse extends FormatInterface {
-  get keys() {
-    return ['hash', 'has']
-  }
-
-  constructor(data) {
-    const name = 'peernet-dht-response';
-    super(data, protons(proto$8).PeernetDHTMessageResponse, {name});
-  }
-}
-
-var proto$7 = `
-// PeernetDataMessage
-message PeernetDataMessage {
-  required string hash = 1;
-  optional string store = 2;
-}
-`;
-
-/**
- * @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 = `
-// 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(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(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(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(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(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(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(proto).ChatMessage, {name});
-  }
-}
+import { Codec, CodecHash, codecs } from '@leofcoin/codec-format-interface';
+import MultiWallet from '@leofcoin/multi-wallet';
 
 const protoFor = (data) => {
   if (!Buffer.isBuffer(data)) data = Buffer.from(data);
@@ -981,12 +77,12 @@ class PeerDiscovery {
   async discover(peer) {
     let id = this._getPeerId(peer.id);
     if (id) return id
-    const data = new peernet.protos['peernet-peer']({id: this.id});
+    const data = await new peernet.protos['peernet-peer']({id: this.id});
     const node = await peernet.prepareMessage(peer.id, data.encoded);
 
     let response = await peer.request(node.encoded);
-    response = protoFor(response);
-    response = new peernet.protos['peernet-peer-response'](response.decoded.data);
+    response = await protoFor(response);
+    response = await new peernet.protos['peernet-peer-response'](response.decoded.data);
 
     id = response.decoded.id;
     if (id === this.id) return;
@@ -1017,7 +113,7 @@ class PeerDiscovery {
           peernet.peerMap.set(from, connections);
         }
       }
-      const data = new peernet.protos['peernet-peer-response']({id: this.id});
+      const data = await new peernet.protos['peernet-peer-response']({id: this.id});
       const node = await peernet.prepareMessage(from, data.encoded);
 
       peer.write(Buffer.from(JSON.stringify({id, data: node.encoded})));
@@ -1157,527 +253,6 @@ class DhtEarth {
   }
 }
 
-/**
- * @params {String} network
- * @return {object} { identity, accounts, config }
- */
-var generateAccount = async network => {
-    let wallet = new MultiWallet$1(network);
-    /**
-     * @type {string}
-     */
-    const mnemonic = await wallet.generate();
-
-    wallet = new MultiWallet$1(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: {
-      //  }
-    }
-  };
-
-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
-/**
- * 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 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 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
-};
-
-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;
-};
-
-// import { createHash } from 'crypto'
-// import { createHash as _createHash } from './hash'
-
-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 ethereumAddress() {
-		const buffer = ecc.pointFromScalar(this.hdnode.__D, false);
-		let hash = createKeccakHash('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().generate();
-		const seed = new Mnemonic().seedFromMnemonic(mnemonic, password);
-		this.defineHDNode(bip32.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().seedFromMnemonic(mnemonic, password);
-		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));
-	}
-}
-
-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(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;
-
-// 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.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
-	}
-
-	fromId(id) {
-		let buffer = decode(id);
-		varint.decode(buffer);
-		buffer = buffer.slice(varint.decode.bytes);
-		this.fromPublicKey(buffer, null, this.networkName);
-	}
-
-	async lock(multiWIF) {
-		if (!multiWIF) multiWIF = this.multiWIF;
-		this.encrypted = await encrypt(multiWIF.toString('hex'));
-		this.locked = true;
-		return this.encrypted
-	}
-
-	async unlock({key, iv, cipher}) {
-		const decrypted = await decrypt(cipher, key, iv);
-		this.import(decrypted);
-		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.networkName);
-	}
-
-	/**
-	 * @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.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;
@@ -1716,7 +291,7 @@ class MessageHandler {
       data,
     };
     const signature = await this.hashAndSignMessage(message);
-    const node = new PeernetMessage({
+    const node = await new globalThis.peernet.protos['peernet-message']({
       ...message,
       signature,
     });
@@ -1730,8 +305,8 @@ const dataHandler = async message => {
 
   const {data, id} = message;
 
-  message = protoFor(data);
-  const proto = protoFor(message.decoded.data);
+  message = await protoFor(data);
+  const proto = await protoFor(message.decoded.data);
   const from = message.decoded.from;
 
   peernet._protoHandler({id, proto}, peernet.client.connections[from], from);
@@ -1797,6 +372,14 @@ class Peernet {
     return ['account', 'wallet', 'block', 'transaction', 'chain', 'data', 'message']
   }
 
+  get protos() {
+    return globalThis.peernet.protos
+  }
+
+  get codecs() {
+    return codecs
+  }
+
   addProto(name, proto) {
     if (!this.protos[name]) this.protos[name] = proto;
   }
@@ -1806,6 +389,10 @@ class Peernet {
   }
 
   async addStore(name, prefix, root, isPrivate = true) {
+    if (!globalThis.LeofcoinStorage) {
+      const importee = await import(/* webpackChunkName: "storage" */ '@leofcoin/storage');
+      globalThis.LeofcoinStorage = importee.default;
+    }
     if (name === 'block' || name === 'transaction' || name === 'chain' ||
         name === 'data' || name === 'message') isPrivate = false;
 
@@ -1813,7 +400,7 @@ class Peernet {
     if (this.hasDaemon) {
       Storage = LeofcoinStorageClient;
     } else {
-      Storage = globalThis.LeofcoinStorage?.default ? globalThis.LeofcoinStorage.default : LeofcoinStorage;
+      Storage = LeofcoinStorage;
     }
     globalThis[`${name}Store`] = globalThis[`${name}Store`] ||
       await new Storage(name, root);
@@ -1878,6 +465,20 @@ class Peernet {
     this.storePrefix = options.storePrefix;
     this.root = options.root;
 
+    const {
+      RequestMessage,
+      ResponseMessage,
+      PeerMessage,
+      PeerMessageResponse,
+      PeernetMessage,
+      DHTMessage,
+      DHTMessageResponse,
+      DataMessage,
+      DataMessageResponse,
+      PsMessage,
+      ChatMessage
+    } = await import(/* webpackChunkName: "messages" */ './messages-421f88db.js');
+
     /**
      * proto Object containing protos
      * @type {Object}
@@ -1887,6 +488,7 @@ class Peernet {
      * @property {DataMessage} protos[peernet-data] messageNode
      * @property {DataMessageResponse} protos[peernet-data-response] messageNode
      */
+
     globalThis.peernet.protos = {
       'peernet-request': RequestMessage,
       'peernet-response': ResponseMessage,
@@ -1901,16 +503,11 @@ class Peernet {
       'chat-message': ChatMessage,
     };
 
-    this.protos = globalThis.peernet.protos;
-    this.codecs = 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);
     }
@@ -1930,6 +527,9 @@ class Peernet {
       }
     } catch (e) {
       if (e.code === 'ERR_NOT_FOUND') {
+
+        const importee = await import(/* webpackChunkName: "generate-account" */ '@leofcoin/generate-account');
+        const generateAccount = importee.default;
         const {identity, accounts, config} = await generateAccount(this.network);
         walletStore.put('version', new TextEncoder().encode(1));
         walletStore.put('accounts', new TextEncoder().encode(JSON.stringify(accounts)));
@@ -1962,11 +562,13 @@ class Peernet {
      */
     pubsub.subscribe('peer:data', dataHandler);
 
+
+    const importee = await import(/* webpackChunkName: "peernet-swarm" */ '@leofcoin/peernet-swarm');
     /**
      * @access public
      * @type {PeernetClient}
      */
-    this.client = new Client(this.id);
+    this.client = new importee.default(this.id);
     if (globalThis.onbeforeunload) {
       globalThis.addEventListener('beforeunload', async () => this.client.close());
     }
@@ -2006,7 +608,7 @@ class Peernet {
           if (store.private) has = false;
           else has = await store.has(hash);
         }
-        const data = new DHTMessageResponse({hash, has});
+        const data = await new this.protos['peernet-dht-response']({hash, has});
         const node = await this.prepareMessage(from, data.encoded);
 
         this.sendMessage(peer, id, node.encoded);
@@ -2022,7 +624,7 @@ class Peernet {
           data = await store.get(hash);
 
           if (data) {
-            data = new DataMessageResponse({hash, data});
+            data = await new this.protos['peernet-data-response']({hash, data});
 
             const node = await this.prepareMessage(from, data.encoded);
             this.sendMessage(peer, id, node.encoded);
@@ -2049,16 +651,16 @@ class Peernet {
    */
   async walk(hash) {
     if (!hash) throw new Error('hash expected, received undefined')
-    const data = new DHTMessage({hash});
+    const data = await new this.protos['peernet-dht']({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);
+      let proto = await protoFor(result);
       if (proto.name !== 'peernet-message') throw encapsulatedError()
       const from = proto.decoded.from;
-      proto = protoFor(proto.decoded.data);
+      proto = await protoFor(proto.decoded.data);
       if (proto.name !== 'peernet-dht-response') throw dhtError(proto.name)
 
       // TODO: give ip and port (just used for location)
@@ -2157,7 +759,7 @@ class Peernet {
         if (peer.peerId === id) return peer
       });
 
-      let data = new DataMessage({hash, store: store?.name ? store?.name : store});
+      let data = await new this.protos['peernet-data']({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);
@@ -2168,8 +770,8 @@ class Peernet {
         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);
+      let proto = await protoFor(data);
+      proto = await protoFor(proto.decoded.data);
       // TODO: store data automaticly or not
       return proto.decoded.data
 
@@ -2302,7 +904,7 @@ class Peernet {
     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});
+    data = await new this.protos['peernet-ps']({data, topic});
     for (const peer of this.connections) {
       if (peer.peerId !== this.peerId) {
         const node = await this.prepareMessage(peer.peerId, data.encoded);
@@ -2313,7 +915,7 @@ class Peernet {
   }
 
   createHash(data, name) {
-    return new CodecHash(data, {name})
+    return new CodeHash(data, {name})
   }
 
   /**