@leofcoin/peernet 0.11.27 → 0.11.28

package/dist/browser/peernet.js

@@ -729,43 +729,6 @@ class Client {
 
 }
 
-class LeofcoinStorageClient {
-  constructor(name, root) {
-    this.name = name;
-    this.root = root;
-  }
-
-  async get(key) {
-    try {
-      const result = await globalThis.peernet.client.request('storage', {
-        name: this.name,
-        root: this.root,
-        key,
-      });
-      return result
-    } catch (e) {
-      console.log(e);
-      return undefined
-    }
-  }
-
-  async put(key, value) {
-    try {
-      const result = await globalThis.peernet.client.request('storage', {
-        name: this.name,
-        root: this.root,
-        key,
-        value,
-        method: 'put',
-      });
-      return result
-    } catch (e) {
-      console.log(e);
-      return undefined
-    }
-  }
-}
-
 var proto$a = `
 // PeernetMessage
 message PeernetMessage {
@@ -1999,6 +1962,8 @@ class Peernet {
     try {
       const pub = await accountStore.get('public');
       this.id = JSON.parse(new TextDecoder().decode(pub)).walletId;
+      const accounts = await walletStore.get('accounts');
+      this.accounts = JSON.parse(new TextDecoder().decode(accounts));
     } catch (e) {
       if (e.code === 'ERR_NOT_FOUND') {
         const {identity, accounts, config} = await generateAccount(this.network);

package/dist/commonjs/peernet.js

@@ -727,43 +727,6 @@ class Client {
 
 }
 
-class LeofcoinStorageClient {
-  constructor(name, root) {
-    this.name = name;
-    this.root = root;
-  }
-
-  async get(key) {
-    try {
-      const result = await globalThis.peernet.client.request('storage', {
-        name: this.name,
-        root: this.root,
-        key,
-      });
-      return result
-    } catch (e) {
-      console.log(e);
-      return undefined
-    }
-  }
-
-  async put(key, value) {
-    try {
-      const result = await globalThis.peernet.client.request('storage', {
-        name: this.name,
-        root: this.root,
-        key,
-        value,
-        method: 'put',
-      });
-      return result
-    } catch (e) {
-      console.log(e);
-      return undefined
-    }
-  }
-}
-
 var proto$5 = `
 // PeernetDataMessage
 message PeernetDataMessage {
@@ -1882,15 +1845,7 @@ class Peernet {
     const {daemon, environment} = await target();
     this.hasDaemon = daemon;
 
-    if (this.hasDaemon) {
-				const httpClient = await Promise.resolve().then(function () { return require('./client-5633ba04.js'); });
-				globalThis.peernet.client = await httpClient.default({
-					protocol: 'peernet-v0.1.0', host: '127.0.0.1', port: options.port
-				});
-			} else {
-				const http = await Promise.resolve().then(function () { return require('./http-997ec597.js'); });
-	      if (environment !== 'browser') http.default(options);
-	    }
+    
 
     for (const store of this.defaultStores) {
       await this.addStore(store, options.storePrefix, options.root);
@@ -1899,6 +1854,8 @@ class Peernet {
     try {
       const pub = await accountStore.get('public');
       this.id = JSON.parse(new TextDecoder().decode(pub)).walletId;
+      const accounts = await walletStore.get('accounts');
+      this.accounts = JSON.parse(new TextDecoder().decode(accounts));
     } catch (e) {
       if (e.code === 'ERR_NOT_FOUND') {
         const {identity, accounts, config} = await generateAccount(this.network);

package/dist/module/peernet.js

@@ -685,43 +685,6 @@ class Client {
 
 }
 
-class LeofcoinStorageClient {
-  constructor(name, root) {
-    this.name = name;
-    this.root = root;
-  }
-
-  async get(key) {
-    try {
-      const result = await globalThis.peernet.client.request('storage', {
-        name: this.name,
-        root: this.root,
-        key,
-      });
-      return result
-    } catch (e) {
-      console.log(e);
-      return undefined
-    }
-  }
-
-  async put(key, value) {
-    try {
-      const result = await globalThis.peernet.client.request('storage', {
-        name: this.name,
-        root: this.root,
-        key,
-        value,
-        method: 'put',
-      });
-      return result
-    } catch (e) {
-      console.log(e);
-      return undefined
-    }
-  }
-}
-
 var proto$a = `
 // PeernetMessage
 message PeernetMessage {
@@ -1955,6 +1918,8 @@ class Peernet {
     try {
       const pub = await accountStore.get('public');
       this.id = JSON.parse(new TextDecoder().decode(pub)).walletId;
+      const accounts = await walletStore.get('accounts');
+      this.accounts = JSON.parse(new TextDecoder().decode(accounts));
     } catch (e) {
       if (e.code === 'ERR_NOT_FOUND') {
         const {identity, accounts, config} = await generateAccount(this.network);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/peernet",
-  "version": "0.11.27",
+  "version": "0.11.28",
   "description": "",
   "main": "dist/commonjs/peernet.js",
   "module": "dist/module/peernet.js",

package/src/peernet.js

@@ -1,7 +1,6 @@
 import '@vandeurenglenn/debug'
 import Client from './../node_modules/@leofcoin/peernet-swarm/dist/es/client.js'
 import LeofcoinStorage from '@leofcoin/storage'
-import LeofcoinStorageClient from './http/client/storage.js'
 import PeernetMessage from './messages/peernet-message.js'
 import DHTMessage from './messages/dht.js'
 import DHTMessageResponse from './messages/dht-response.js'
@@ -191,6 +190,8 @@ export default class Peernet {
     try {
       const pub = await accountStore.get('public')
       this.id = JSON.parse(new TextDecoder().decode(pub)).walletId
+      const accounts = await walletStore.get('accounts')
+      this.accounts = JSON.parse(new TextDecoder().decode(accounts))
     } catch (e) {
       if (e.code === 'ERR_NOT_FOUND') {
         const wallet = {}

package/dist/commonjs/client-5633ba04.js

@@ -1,321 +0,0 @@
-'use strict';
-
-/* 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 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 client = (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)
-};
-
-exports["default"] = client;

package/dist/commonjs/http-997ec597.js

@@ -1,328 +0,0 @@
-'use strict';
-
-var websocket = require('websocket');
-var PubSub = require('@vandeurenglenn/little-pubsub');
-var http$1 = require('http');
-var Koa = require('koa');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var PubSub__default = /*#__PURE__*/_interopDefaultLegacy(PubSub);
-var Koa__default = /*#__PURE__*/_interopDefaultLegacy(Koa);
-
-var version = "0.11.25";
-
-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);
-    }
-  },
-  getMinerConfig: async ({send, error}) => {
-    try {
-      const config = await api.getMinerConfig();
-      send(config);
-    } catch (e) {
-      error(e);
-    }
-  },
-  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);
-    }
-  },
-  accountNames: async (params, {send, error}) => {
-    try {
-      const adresses = await api.accountNames(params.index);
-      send(adresses);
-    } catch (e) {
-      error(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);
-    }
-  },
-  balanceAfter: async (params, {send, error}) => {
-    try {
-      const value = await api.getBalanceForAddressAfter(params.address, params.index);
-      send(value);
-    } catch (e) {
-      error(e);
-    }
-  },
-  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 fullLog = text => {
-  return console.log(`${new Date()}: ${text}`)
-};
-
-const originIsAllowed = (requestOrigin, origin) => {
-  // put logic here to detect whether the specified origin is allowed.
-  if (origin && requestOrigin !== origin) return false;
-  return true;
-};
-
-/**
- * @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
- */
-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
-  }
-};
-
-if (!globalThis.PubSub) globalThis.PubSub = PubSub__default["default"];
-if (!globalThis.pubsub) globalThis.pubsub = new PubSub__default["default"]();
-
-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__default["default"]({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);
-    };
-    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);
-        }
-        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);
-      };
-
-    }
-    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
-        }
-        if (!params.join) {
-          peerMap.delete(params.peerId);
-          return response.send()
-        }
-      };
-    }
-  // 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}`);
-    });
-  }
-
-	const socketServer = new websocket.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), connections);
-        return routes[url](params, socketResponse(connection, url, id), connections);
-      }
-      else return socketResponse(connection, url, id).error(`no handler found for '${message.url}'`);
-    };
-
-    connection.on('message', routeHandler);
-	});
-
-  return {
-    close: () => socketServer.shutDown(),
-    connections
-  };
-};
-var server = socketRequestServer;
-
-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__default["default"]();
-
-  app.use(async (ctx) => {
-    const url = ctx.url.split('/api/')[1];
-    if (url === 'version') ctx.body = {client: '@peernet/api/http', version};
-  });
-
-  const httpServer = http$1.createServer(app.callback());
-
-  config.httpServer = httpServer;
-
-  httpServer.listen(config.port, () => {
-    console.log(`listening on ${config.port}`);
-  });
-
-  return server(config, api$1)
-};
-
-exports["default"] = http;