@leofcoin/peernet 0.10.6 → 0.11.0

package/dist/commonjs/client-bd0caeb7.js

@@ -0,0 +1,324 @@
+'use strict';
+
+/* 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));
+  }
+  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.onclose = message => {
+          if (exit) process.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/{codec-6367213c.js → codec-4a768e5e.js}

@@ -1,8 +1,8 @@
 'use strict';
 
 var varint = require('varint');
-var bs32 = require('bs32');
-var bs58 = require('bs58');
+var bs32 = require('@vandeurenglenn/base32');
+var bs58 = require('@vandeurenglenn/base58');
 var isHex = require('is-hex');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
@@ -12,84 +12,84 @@ var bs32__default = /*#__PURE__*/_interopDefaultLegacy(bs32);
 var bs58__default = /*#__PURE__*/_interopDefaultLegacy(bs58);
 var isHex__default = /*#__PURE__*/_interopDefaultLegacy(isHex);
 
-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 {
@@ -98,10 +98,9 @@ class PeernetCodec {
   }
   constructor(buffer) {
     if (buffer) {
-      if (Buffer.isBuffer(buffer)) {
+      if (buffer instanceof Uint8Array) {
         const codec = varint__default["default"].decode(buffer);
         const name = this.getCodecName(codec);
-
         if (name) {
           this.name = name;
           this.encoded = buffer;
@@ -109,12 +108,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__default["default"](buffer)) this.fromHex(buffer);
-        else if (bs32__default["default"].test(buffer)) this.fromBs32(buffer);
-        else this.fromBs58(buffer);
+        else if (bs32__default["default"].isBase32(buffer)) this.fromBs32(buffer);
+        else if (bs58__default["default"].isBase58(buffer)) this.fromBs58(buffer);
+        else throw new Error(`unsupported string ${buffer}`)
       }
       if (!isNaN(buffer)) if (this.codecs[this.getCodecName(buffer)]) this.fromCodec(buffer);
     }
@@ -149,7 +159,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)
   }
@@ -163,7 +174,7 @@ class PeernetCodec {
     this.hashAlg = this.getHashAlg(this.name);
 
     this.codec = this.getCodec(this.name);
-    this.codecBuffer = Buffer.from(varint__default["default"].encode(parseInt(Buffer.from(`${this.codec}`, 'hex').toString('hex'), 16)), 'hex');
+    this.codecBuffer = varint__default["default"].encode(codec);
   }
 
   fromName(name) {
@@ -171,7 +182,7 @@ class PeernetCodec {
     this.name = name;
     this.codec = codec;
     this.hashAlg = this.getHashAlg(name);
-    this.codecBuffer = Buffer.from(varint__default["default"].encode(parseInt(Buffer.from(`${codec}`, 'hex').toString('hex'), 16)), 'hex');
+    this.codecBuffer = varint__default["default"].encode(codec);
   }
 
   toBs32() {
@@ -191,11 +202,10 @@ class PeernetCodec {
   decode() {
     const codec = varint__default["default"].decode(this.encoded);
     this.fromCodec(codec);
-    this.name = this.getCodecName(codec);
   }
 
   encode() {
-    const codec = Buffer.from(varint__default["default"].encode(parseInt(Buffer.from(`${this.codec}`, 'hex').toString('hex'), 16)), 'hex');
+    const codec = varint__default["default"].encode(this.decoded);
     this.encoded = codec;
     return this.encoded
   }

package/dist/commonjs/codec-format-interface.js

@@ -1,9 +1,9 @@
 'use strict';
 
-var bs32 = require('bs32');
-var bs58 = require('bs58');
+var bs32 = require('@vandeurenglenn/base32');
+var bs58 = require('@vandeurenglenn/base58');
 var isHex = require('is-hex');
-var codec = require('./codec-6367213c.js');
+var codec = require('./codec-4a768e5e.js');
 var hash = require('./hash.js');
 require('varint');
 require('keccak');
@@ -23,25 +23,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$1 = new codec.PeernetCodec(buffer);
-      if (codec$1.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__default["default"](buffer)) this.fromHex(buffer);
-        else if (bs32__default["default"].test(buffer)) this.fromBs32(buffer);
-        else this.fromBs58(buffer);
-      } else if (typeof buffer === 'object' && !Array.isArray(buffer)) {
-        this.create(buffer);
-      }
+        else if (bs32__default["default"].isBase32(buffer)) this.fromBs32(buffer);
+        else if (bs58__default["default"].isBase58(buffer)) this.fromBs58(buffer);
+        else throw new Error(`unsupported string ${buffer}`)
+    } else {
+      this.create(buffer);
     }
   }
 
@@ -66,7 +59,7 @@ class FormatInterface {
    */
   decode() {
     let encoded = this.encoded;
-    const discoCodec = new codec.PeernetCodec(this.encoded.toString('hex'));
+    const discoCodec = new codec.PeernetCodec(this.encoded);
     encoded = encoded.slice(discoCodec.codecBuffer.length);
     this.name = discoCodec.name;
     this.decoded = this.protoDecode(encoded);
@@ -79,16 +72,40 @@ class FormatInterface {
   encode(decoded) {
     if (!decoded) decoded = this.decoded;
     const codec$1 = new codec.PeernetCodec(this.name);
-    this.encoded = Buffer.concat([codec$1.codecBuffer, this.protoEncode(decoded)]);
+    const encoded = this.protoEncode(decoded);
+    const uint8Array = new Uint8Array(encoded.length + codec$1.codecBuffer.length);
+    uint8Array.set(codec$1.codecBuffer);
+    uint8Array.set(encoded, codec$1.codecBuffer.length);
+    this.encoded = uint8Array;
     return this.encoded
   }
 
+  hasCodec() {
+    if (!this.encoded) return false
+    const codec$1 = new codec.PeernetCodec(this.encoded);
+    if (codec$1.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$1 = new codec.PeernetCodec(encoded);
-    this.name = codec$1.name;
     this.encoded = encoded;
     this.decode();
   }

package/dist/commonjs/codec.js

@@ -1,10 +1,10 @@
 'use strict';
 
 require('varint');
-require('bs32');
-require('bs58');
+require('@vandeurenglenn/base32');
+require('@vandeurenglenn/base58');
 require('is-hex');
-var codec = require('./codec-6367213c.js');
+var codec = require('./codec-4a768e5e.js');