@leofcoin/peernet 0.10.7 → 0.11.1

package/dist/commonjs/{codec-6367213c.js → codec-8c8c652f.js}

@@ -1,9 +1,9 @@
 'use strict';
 
 var varint = require('varint');
-var bs32 = require('bs32');
-var bs58 = require('bs58');
-var isHex = require('is-hex');
+var bs32 = require('@vandeurenglenn/base32');
+var bs58 = require('@vandeurenglenn/base58');
+var isHex = require('@vandeurenglenn/is-hex');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -12,193 +12,203 @@ 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 {
-  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 PeernetCodec {
+  get codecs() {
+    return {...globalThis.peernet.codecs, ...codecs}
+  }
+  constructor(buffer) {
+    if (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;
+          this.decode(buffer);
+        } 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"].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);
+    }
+  }
+
+  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) => {
+      const item = this.codecs[c];
+      if (item.codec === 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 = varint__default["default"].encode(codec);
+  }
+
+  fromName(name) {
+    const codec = this.getCodec(name);
+    this.name = name;
+    this.codec = codec;
+    this.hashAlg = this.getHashAlg(name);
+    this.codecBuffer = varint__default["default"].encode(codec);
+  }
+
+  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);
+  }
+
+  encode() {
+    const codec = varint__default["default"].encode(this.decoded);
+    this.encoded = codec;
+    return this.encoded
+  }
 }
 
 exports.PeernetCodec = PeernetCodec;