@leofcoin/peernet 0.10.8 → 0.11.2

package/dist/messages/dht.js

@@ -1,453 +0,0 @@
-'use strict';
-
-var protons = require('protons');
-var bs32 = require('bs32');
-var bs58 = require('bs58');
-var isHex = require('is-hex');
-var varint = require('varint');
-var createKeccakHash = require('keccak');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var protons__default = /*#__PURE__*/_interopDefaultLegacy(protons);
-var bs32__default = /*#__PURE__*/_interopDefaultLegacy(bs32);
-var bs58__default = /*#__PURE__*/_interopDefaultLegacy(bs58);
-var isHex__default = /*#__PURE__*/_interopDefaultLegacy(isHex);
-var varint__default = /*#__PURE__*/_interopDefaultLegacy(varint);
-var createKeccakHash__default = /*#__PURE__*/_interopDefaultLegacy(createKeccakHash);
-
-var proto = `
-// PeernetDHTMessage
-message PeernetDHTMessage {
-  required string hash = 1;
-}
-`;
-
-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'
-  },
-};
-
-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
-  }
-}
-
-class DiscoHash {
-  constructor(buffer, options = {}) {
-    if (options.name) this.name = options.name;
-    else this.name = 'disco-hash';
-    if (options.codecs) this.codecs = options.codecs;
-    if (buffer) {
-      if (Buffer.isBuffer(buffer)) {
-        this.discoCodec = new PeernetCodec(buffer, this.codecs);
-        const name = this.discoCodec.name;
-
-        if (name) {
-          this.name = name;
-          this.decode(buffer);
-        } else {
-          this.encode(buffer);
-        }
-      }
-
-      if (typeof buffer === 'string') {
-        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);
-    }
-  }
-
-  get prefix() {
-    return Buffer.concat([this.discoCodec.codecBuffer, this.length])
-  }
-
-  get length() {
-    return Buffer.from(varint__default['default'].encode(this.size))
-  }
-
-  get buffer() {
-    return this.hash
-  }
-
-  toHex() {
-    return this.hash.toString('hex')
-  }
-
-  fromHex(hex) {
-    return this.decode(Buffer.from(hex, 'hex'))
-  }
-
-  fromJSON(json) {
-    return this.encode(Buffer.from(JSON.stringify(json)))
-  }
-
-  toBs32() {
-    return bs32__default['default'].encode(this.hash)
-  }
-
-  fromBs32(bs) {
-    return this.decode(bs32__default['default'].decode(bs))
-  }
-
-  toBs58() {
-    return bs58__default['default'].encode(this.hash)
-  }
-
-  fromBs58(bs) {
-    return this.decode(bs58__default['default'].decode(bs))
-  }
-
-  toString(encoding = 'utf8') {
-    return this.hash.toString(encoding)
-  }
-
-  encode(buffer, name) {
-    if (!this.name && name) this.name = name;
-    if (!buffer) buffer = this.buffer;
-    this.discoCodec = new PeernetCodec(this.name, this.codecs);
-    this.discoCodec.fromName(this.name);
-    let hashAlg = this.discoCodec.hashAlg;
-    if (hashAlg.includes('dbl')) {
-      hashAlg = hashAlg.replace('dbl-', '');
-      buffer = 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();
-    this.codec = this.discoCodec.codecBuffer;
-    this.hash = Buffer.concat([
-      this.prefix,
-      this.digest,
-    ]);
-
-    return this.hash
-  }
-
-  validate(buffer) {
-    if (Buffer.isBuffer(buffer)) {
-      const codec = varint__default['default'].decode(buffer);
-      if (this.codecs[codec]) {
-        this.decode(buffer);
-      } else {
-        this.encode(buffer);
-      }
-    }
-    if (typeof buffer === 'string') {
-      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 = varint__default['default'].decode(buffer);
-
-    this.discoCodec = new PeernetCodec(codec, 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);
-    if (this.digest.length !== this.size) {
-      throw new Error(`hash length inconsistent: 0x${this.hash.toString('hex')}`)
-    }
-
-    // const discoCodec = new DiscoCodec(codec, this.codecs)
-
-    this.name = this.discoCodec.name;
-
-
-    this.size = this.digest.length;
-
-    return {
-      codec: this.codec,
-      name: this.name,
-      size: this.size,
-      length: this.length,
-      digest: this.digest,
-    }
-  }
-}
-
-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.isBuffer(buffer)) {
-      const codec = new PeernetCodec(buffer);
-
-      if (codec.name) {
-        this.fromEncoded(buffer);
-      } else {
-        this.create(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);
-    }
-  }
-
-  get peernetHash() {
-    return new DiscoHash(this.decoded, {name: this.name})
-  }
-
-  get hash() {
-    const upper = this.hashFormat.charAt(0).toUpperCase();
-    const format = `${upper}${this.hashFormat.substring(1, this.hashFormat.length)}`;
-    return this.peernetHash[`to${format}`]()
-  }
-
-  decode() {
-    let encoded = this.encoded;
-    const discoCodec = new PeernetCodec(this.encoded.toString('hex'));
-    encoded = encoded.slice(discoCodec.codecBuffer.length);
-    this.name = discoCodec.name;
-    this.decoded = this.protoDecode(encoded);
-    return this.decoded
-  }
-
-  encode(decoded) {
-    if (!decoded) decoded = this.decoded;
-    const codec = new PeernetCodec(this.name);
-    this.encoded = Buffer.concat([codec.codecBuffer, this.protoEncode(decoded)]);
-    return this.encoded
-  }
-
-  fromEncoded(encoded) {
-    const codec = new PeernetCodec(encoded);
-    this.name = codec.name;
-    this.encoded = encoded;
-    this.decode();
-  }
-
-  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();
-  }
-
-  toHex() {
-    if (!this.encoded) this.encode();
-    return this.encoded.toString('hex')
-  }
-
-  toBs32() {
-    if (!this.encoded) this.encode();
-    return bs32__default['default'].encode(this.encoded)
-  }
-
-  toBs58() {
-    if (!this.encoded) this.encode();
-    return bs58__default['default'].encode(this.encoded)
-  }
-
-  create(data) {
-    this.decoded = data;
-    this.encode(data);
-  }
-}
-
-class DHTMessage extends FormatInterface {
-  get keys() {
-    return ['hash']
-  }
-
-  constructor(data) {
-    const name = 'peernet-dht';
-    super(data, protons__default['default'](proto).PeernetDHTMessage, {name});
-  }
-}
-
-module.exports = DHTMessage;