@leofcoin/peernet 0.10.3 → 0.10.6

package/dist/commonjs/codec-6367213c.js

@@ -0,0 +1,205 @@
+'use strict';
+
+var varint = require('varint');
+var bs32 = require('bs32');
+var bs58 = require('bs58');
+var isHex = require('is-hex');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var varint__default = /*#__PURE__*/_interopDefaultLegacy(varint);
+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',
+  },
+};
+
+class PeernetCodec {
+  get codecs() {
+    return {...globalThis.peernet.codecs, ...codecs}
+  }
+  constructor(buffer) {
+    if (buffer) {
+      if (Buffer.isBuffer(buffer)) {
+        const codec = varint__default["default"].decode(buffer);
+        const name = this.getCodecName(codec);
+
+        if (name) {
+          this.name = name;
+          this.encoded = buffer;
+          this.decode(buffer);
+        } else {
+          this.encode(buffer);
+        }
+      }
+      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);
+      }
+      if (!isNaN(buffer)) if (this.codecs[this.getCodecName(buffer)]) this.fromCodec(buffer);
+    }
+  }
+
+  fromEncoded(encoded) {
+    const codec = varint__default["default"].decode(encoded);
+    const name = this.getCodecName(codec);
+    this.name = name;
+    this.encoded = encoded;
+    this.decode(encoded);
+  }
+
+  fromHex(hex) {
+    this.encoded = Buffer.from(hex, 'hex');
+    this.decode();
+  }
+
+  fromBs32(input) {
+    this.encoded = bs32__default["default"].decode(input);
+    this.decode();
+  }
+
+  fromBs58(input) {
+    this.encoded = bs58__default["default"].decode(input);
+    this.decode();
+  }
+
+  getCodec(name) {
+    return this.codecs[name].codec
+  }
+
+  getCodecName(codec) {
+    return Object.keys(this.codecs).reduce((p, c) => {
+      if (parseInt(Buffer.from(`${this.getCodec(c)}`, 'hex').toString('hex'), 16) === codec) return c;
+      else return p;
+    }, undefined)
+  }
+
+  getHashAlg(name) {
+    return this.codecs[name].hashAlg
+  }
+
+  fromCodec(codec) {
+    this.name = this.getCodecName(codec);
+    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');
+  }
+
+  fromName(name) {
+    const codec = this.getCodec(name);
+    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');
+  }
+
+  toBs32() {
+    this.encode();
+    return bs32__default["default"].encode(this.encoded)
+  }
+
+  toBs58() {
+    this.encode();
+    return bs58__default["default"].encode(this.encoded)
+  }
+
+  toHex() {
+    return this.encoded.toString('hex')
+  }
+
+  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');
+    this.encoded = codec;
+    return this.encoded
+  }
+}
+
+exports.PeernetCodec = PeernetCodec;
+exports.codecs = codecs;

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

@@ -3,7 +3,7 @@
 var bs32 = require('bs32');
 var bs58 = require('bs58');
 var isHex = require('is-hex');
-var codec = require('./codec-73adfc0f.js');
+var codec = require('./codec-6367213c.js');
 var hash = require('./hash.js');
 require('varint');
 require('keccak');
@@ -16,7 +16,7 @@ var isHex__default = /*#__PURE__*/_interopDefaultLegacy(isHex);
 
 class FormatInterface {
   /**
-   * @param {Buffer|String|Object} buffer -
+   * @param {Buffer|String|Object} buffer - data - The data needed to create the desired message
    * @param {Object} proto - {encode, decode}
    * @param {Object} options - {hashFormat, name}
    */
@@ -25,7 +25,9 @@ class FormatInterface {
     this.protoDecode = proto.decode;
     if (options.name) this.name = options.name;
     this.hashFormat = options.hashFormat || 'bs32';
-    if (Buffer.isBuffer(buffer)) {
+    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);
@@ -34,8 +36,8 @@ class FormatInterface {
       }
     } else {
       if (typeof buffer === 'string') {
-        if (isHex__default['default'](buffer)) this.fromHex(buffer);
-        else if (bs32__default['default'].test(buffer)) this.fromBs32(buffer);
+        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);
@@ -103,7 +105,7 @@ class FormatInterface {
    * @param {String} encoded
    */
   fromBs32(encoded) {
-    this.encoded = bs32__default['default'].decode(encoded);
+    this.encoded = bs32__default["default"].decode(encoded);
     this.decode();
   }
 
@@ -111,7 +113,7 @@ class FormatInterface {
    * @param {String} encoded
    */
   fromBs58(encoded) {
-    this.encoded = bs58__default['default'].decode(encoded);
+    this.encoded = bs58__default["default"].decode(encoded);
     this.decode();
   }
 
@@ -128,7 +130,7 @@ class FormatInterface {
    */
   toBs32() {
     if (!this.encoded) this.encode();
-    return bs32__default['default'].encode(this.encoded)
+    return bs32__default["default"].encode(this.encoded)
   }
 
   /**
@@ -136,15 +138,29 @@ class FormatInterface {
    */
   toBs58() {
     if (!this.encoded) this.encode();
-    return bs58__default['default'].encode(this.encoded)
+    return bs58__default["default"].encode(this.encoded)
   }
 
   /**
    * @param {Object} data
    */
   create(data) {
-    this.decoded = data;
-    this.encode(data);
+    const decoded = {};
+    if (this.keys?.length > 0) {
+      for (const key of this.keys) {
+        Object.defineProperties(decoded, {
+          [key]: {
+            enumerable: true,
+            configurable: true,
+            set: (val) => value = data[key],
+            get: () => data[key]
+          }
+        });
+      }
+
+      this.decoded = decoded;
+      this.encode();
+    }
   }
 }
 

package/dist/commonjs/codec.js

@@ -4,7 +4,7 @@ require('varint');
 require('bs32');
 require('bs58');
 require('is-hex');
-var codec = require('./codec-73adfc0f.js');
+var codec = require('./codec-6367213c.js');
 
 
 

package/dist/commonjs/dht-response.js

@@ -5,7 +5,7 @@ require('bs32');
 var codecFormatInterface = require('./codec-format-interface.js');
 require('bs58');
 require('is-hex');
-require('./codec-73adfc0f.js');
+require('./codec-6367213c.js');
 require('varint');
 require('./hash.js');
 require('keccak');
@@ -29,7 +29,7 @@ class DHTMessageResponse extends codecFormatInterface {
 
   constructor(data) {
     const name = 'peernet-dht-response';
-    super(data, protons__default['default'](proto).PeernetDHTMessageResponse, {name});
+    super(data, protons__default["default"](proto).PeernetDHTMessageResponse, {name});
   }
 }
 

package/dist/commonjs/dht.js

@@ -5,7 +5,7 @@ var codecFormatInterface = require('./codec-format-interface.js');
 require('bs32');
 require('bs58');
 require('is-hex');
-require('./codec-73adfc0f.js');
+require('./codec-6367213c.js');
 require('varint');
 require('./hash.js');
 require('keccak');
@@ -40,7 +40,7 @@ class DHTMessage extends codecFormatInterface {
 
   constructor(data) {
     const name = 'peernet-dht';
-    super(data, protons__default['default'](proto).PeernetDHTMessage, {name});
+    super(data, protons__default["default"](proto).PeernetDHTMessage, {name});
   }
 }
 

package/dist/commonjs/hash.js

@@ -5,7 +5,7 @@ var varint = require('varint');
 var bs32 = require('bs32');
 var bs58 = require('bs58');
 var isHex = require('is-hex');
-var codec = require('./codec-73adfc0f.js');
+var codec = require('./codec-6367213c.js');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -34,8 +34,8 @@ class PeernetHash {
       }
 
       if (typeof buffer === 'string') {
-        if (isHex__default['default'](buffer)) this.fromHex(buffer);
-        if (bs32__default['default'].test(buffer)) this.fromBs32(buffer);
+        if (isHex__default["default"](buffer)) this.fromHex(buffer);
+        if (bs32__default["default"].test(buffer)) this.fromBs32(buffer);
         else this.fromBs58(buffer);
       } else if (typeof buffer === 'object') this.fromJSON(buffer);
     }
@@ -46,7 +46,7 @@ class PeernetHash {
   }
 
   get length() {
-    return Buffer.from(varint__default['default'].encode(this.size))
+    return Buffer.from(varint__default["default"].encode(this.size))
   }
 
   get buffer() {
@@ -66,19 +66,19 @@ class PeernetHash {
   }
 
   toBs32() {
-    return bs32__default['default'].encode(this.hash)
+    return bs32__default["default"].encode(this.hash)
   }
 
   fromBs32(bs) {
-    return this.decode(bs32__default['default'].decode(bs))
+    return this.decode(bs32__default["default"].decode(bs))
   }
 
   toBs58() {
-    return bs58__default['default'].encode(this.hash)
+    return bs58__default["default"].encode(this.hash)
   }
 
   fromBs58(bs) {
-    return this.decode(bs58__default['default'].decode(bs))
+    return this.decode(bs58__default["default"].decode(bs))
   }
 
   toString(encoding = 'utf8') {
@@ -93,9 +93,9 @@ class PeernetHash {
     let hashAlg = this.discoCodec.hashAlg;
     if (hashAlg.includes('dbl')) {
       hashAlg = hashAlg.replace('dbl-', '');
-      buffer = createKeccakHash__default['default'](hashAlg.replace('-', '')).update(buffer).digest();
+      buffer = createKeccakHash__default["default"](hashAlg.replace('-', '')).update(buffer).digest();
     }
-    this.digest = createKeccakHash__default['default'](hashAlg.replace('-', '')).update(buffer).digest();
+    this.digest = createKeccakHash__default["default"](hashAlg.replace('-', '')).update(buffer).digest();
     this.size = this.digest.length;
 
     this.codec = this.discoCodec.encode();
@@ -110,7 +110,7 @@ class PeernetHash {
 
   validate(buffer) {
     if (Buffer.isBuffer(buffer)) {
-      const codec = varint__default['default'].decode(buffer);
+      const codec = varint__default["default"].decode(buffer);
       if (this.codecs[codec]) {
         this.decode(buffer);
       } else {
@@ -118,21 +118,21 @@ class PeernetHash {
       }
     }
     if (typeof buffer === 'string') {
-      if (isHex__default['default'](buffer)) this.fromHex(buffer);
-      if (bs32__default['default'].test(buffer)) this.fromBs32(buffer);
+      if (isHex__default["default"](buffer)) this.fromHex(buffer);
+      if (bs32__default["default"].test(buffer)) this.fromBs32(buffer);
     }
     if (typeof buffer === 'object') this.fromJSON(buffer);
   }
 
   decode(buffer) {
     this.hash = buffer;
-    const codec$1 = varint__default['default'].decode(buffer);
+    const codec$1 = varint__default["default"].decode(buffer);
 
     this.discoCodec = new codec.PeernetCodec(codec$1, this.codecs);
     // TODO: validate codec
-    buffer = buffer.slice(varint__default['default'].decode.bytes);
-    this.size = varint__default['default'].decode(buffer);
-    this.digest = buffer.slice(varint__default['default'].decode.bytes);
+    buffer = buffer.slice(varint__default["default"].decode.bytes);
+    this.size = varint__default["default"].decode(buffer);
+    this.digest = buffer.slice(varint__default["default"].decode.bytes);
     if (this.digest.length !== this.size) {
       throw new Error(`hash length inconsistent: 0x${this.hash.toString('hex')}`)
     }

package/dist/commonjs/peernet-message.js

@@ -5,7 +5,7 @@ var codecFormatInterface = require('./codec-format-interface.js');
 require('bs32');
 require('bs58');
 require('is-hex');
-require('./codec-73adfc0f.js');
+require('./codec-6367213c.js');
 require('varint');
 require('./hash.js');
 require('keccak');
@@ -31,7 +31,7 @@ class PeernetMessage extends codecFormatInterface {
 
   constructor(buffer) {
     const name = 'peernet-message';
-    super(buffer, protons__default['default'](proto).PeernetMessage, {name});
+    super(buffer, protons__default["default"](proto).PeernetMessage, {name});
   }
 }