@leofcoin/peernet 0.10.8 → 0.11.2

package/src/codec/codec.js

@@ -1,114 +1,124 @@
-import varint from 'varint';
-import bs32 from 'bs32';
-import bs58 from 'bs58';
-import isHex from 'is-hex';
-import codecs from './codecs'
-
-export default class PeernetCodec {
-  get codecs() {
-    return {...globalThis.peernet.codecs, ...codecs}
-  }
-  constructor(buffer) {
-    if (buffer) {
-      if (Buffer.isBuffer(buffer)) {
-        const codec = varint.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(buffer)) this.fromHex(buffer)
-        else if (bs32.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.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.decode(input)
-    this.decode()
-  }
-
-  fromBs58(input) {
-    this.encoded = bs58.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.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.encode(parseInt(Buffer.from(`${codec}`, 'hex').toString('hex'), 16)), 'hex');
-  }
-
-  toBs32() {
-    this.encode()
-    return bs32.encode(this.encoded)
-  }
-
-  toBs58() {
-    this.encode()
-    return bs58.encode(this.encoded)
-  }
-
-  toHex() {
-    return this.encoded.toString('hex')
-  }
-
-  decode() {
-    const codec = varint.decode(this.encoded);
-    this.fromCodec(codec)
-    this.name = this.getCodecName(codec)
-  }
-
-  encode() {
-    const codec = Buffer.from(varint.encode(parseInt(Buffer.from(`${this.codec}`, 'hex').toString('hex'), 16)), 'hex');
-    this.encoded = codec
-    return this.encoded
-  }
-}
+import varint from 'varint';
+import bs32 from '@vandeurenglenn/base32';
+import bs58 from '@vandeurenglenn/base58';
+import isHex from '@vandeurenglenn/is-hex';
+import codecs from './codecs'
+
+export default class PeernetCodec {
+  get codecs() {
+    return {...globalThis.peernet.codecs, ...codecs}
+  }
+  constructor(buffer) {
+    if (buffer) {
+      if (buffer instanceof Uint8Array) {
+        const codec = varint.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(buffer)) this.fromHex(buffer)
+        else if (bs32.isBase32(buffer)) this.fromBs32(buffer)
+        else if (bs58.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.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.decode(input)
+    this.decode()
+  }
+
+  fromBs58(input) {
+    this.encoded = bs58.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.encode(codec)
+  }
+
+  fromName(name) {
+    const codec = this.getCodec(name)
+    this.name = name
+    this.codec = codec
+    this.hashAlg = this.getHashAlg(name)
+    this.codecBuffer = varint.encode(codec)
+  }
+
+  toBs32() {
+    this.encode()
+    return bs32.encode(this.encoded)
+  }
+
+  toBs58() {
+    this.encode()
+    return bs58.encode(this.encoded)
+  }
+
+  toHex() {
+    return this.encoded.toString('hex')
+  }
+
+  decode() {
+    const codec = varint.decode(this.encoded);
+    this.fromCodec(codec)
+  }
+
+  encode() {
+    const codec = varint.encode(this.decoded)
+    this.encoded = codec
+    return this.encoded
+  }
+}

package/src/codec/codecs.js

@@ -1,79 +1,79 @@
-export default {
-  // 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',
-  },
-}
+export default {
+  // 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',
+  },
+}

package/src/dht/dht.js

@@ -1,121 +1,121 @@
-import fetch from 'node-fetch'
-
-/**
- * Keep history of fetched address and ptr
- * @property {Object} address
- * @property {Object} ptr
- */
-const lastFetched = {
-  address: {
-    value: undefined,
-    timestamp: 0,
-  },
-  ptr: {
-    value: undefined,
-    timestamp: 0,
-  },
-}
-
-const getAddress = async () => {
-  const {address} = lastFetched
-  const now = Math.round(new Date().getTime() / 1000);
-  if (now - address.timestamp > 1200000) {
-    address.value = await fetch('https://icanhazip.com/')
-    address.value = await address.value.text()
-    address.timestamp = Math.round(new Date().getTime() / 1000);
-    lastFetched.address = address;
-  }
-
-  return address.value
-}
-
-const degreesToRadians = (degrees) => {
-  return degrees * Math.PI / 180;
-}
-
-const distanceInKmBetweenEarthCoordinates = (lat1, lon1, lat2, lon2) => {
-  const earthRadiusKm = 6371;
-
-  const dLat = degreesToRadians(lat2-lat1);
-  const dLon = degreesToRadians(lon2-lon1);
-
-  lat1 = degreesToRadians(lat1);
-  lat2 = degreesToRadians(lat2);
-  const a = Math.sin(dLat/2) * Math.sin(dLat/2) +
-          Math.sin(dLon/2) * Math.sin(dLon/2) * Math.cos(lat1) * Math.cos(lat2);
-  const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
-  return earthRadiusKm * c;
-}
-
-export default class DhtEarth {
-  /**
-   *
-   */
-  constructor() {
-    this.providerMap = new Map();
-  }
-
-  /**
-   * @param {Object} address
-   * @return {Object} {latitude: lat, longitude: lon}
-   */
-  async getCoordinates(address) {
-    // const {address} = parseAddress(provider)
-    const request = `https://whereis.leofcoin.org/?ip=${address}`
-    let response = await fetch(request)
-    response = await response.json()
-    const {lat, lon} = response;
-    return {latitude: lat, longitude: lon}
-  }
-
-  /**
-   * @param {Object} peer
-   * @param {Object} provider
-   * @return {Object} {provider, distance}
-   */
-  async getDistance(peer, provider) {
-    const {latitude, longitude} = await this.getCoordinates(provider.address)
-    return {provider, distance: distanceInKmBetweenEarthCoordinates(peer.latitude, peer.longitude, latitude, longitude)}
-  }
-
-  /**
-   * @param {Array} providers
-   * @return {Object} closestPeer
-   */
-  async closestPeer(providers) {
-    let all = []
-    const address = await getAddress();
-    const peerLoc = await this.getCoordinates(address)
-
-    for (const provider of providers) {
-      if (provider.address === '127.0.0.1') all.push({provider, distance: 0})
-      else all.push(this.getDistance(peerLoc, provider))
-    }
-
-    all = await Promise.all(all);
-    all = all.sort((previous, current) => previous.distance - current.distance)
-    return all[0].provider;
-  }
-
-  /**
-   * @param {String} hash
-   * @return {Array} providers
-   */
-  providersFor(hash) {
-    return this.providerMap.get(hash);
-  }
-
-  /**
-   * @param {String} address
-   * @param {String} hash
-   * @return {Array} providers
-   */
-  async addProvider(address, hash) {
-    let providers = [];
-    if (this.providerMap.has(hash)) providers = this.providerMap.get(hash)
-
-    providers = new Set([...providers, address])
-    this.providerMap.set(hash, providers)
-    return providers;
-  }
-}
+import fetch from 'node-fetch'
+
+/**
+ * Keep history of fetched address and ptr
+ * @property {Object} address
+ * @property {Object} ptr
+ */
+const lastFetched = {
+  address: {
+    value: undefined,
+    timestamp: 0,
+  },
+  ptr: {
+    value: undefined,
+    timestamp: 0,
+  },
+}
+
+const getAddress = async () => {
+  const {address} = lastFetched
+  const now = Math.round(new Date().getTime() / 1000);
+  if (now - address.timestamp > 1200000) {
+    address.value = await fetch('https://icanhazip.com/')
+    address.value = await address.value.text()
+    address.timestamp = Math.round(new Date().getTime() / 1000);
+    lastFetched.address = address;
+  }
+
+  return address.value
+}
+
+const degreesToRadians = (degrees) => {
+  return degrees * Math.PI / 180;
+}
+
+const distanceInKmBetweenEarthCoordinates = (lat1, lon1, lat2, lon2) => {
+  const earthRadiusKm = 6371;
+
+  const dLat = degreesToRadians(lat2-lat1);
+  const dLon = degreesToRadians(lon2-lon1);
+
+  lat1 = degreesToRadians(lat1);
+  lat2 = degreesToRadians(lat2);
+  const a = Math.sin(dLat/2) * Math.sin(dLat/2) +
+          Math.sin(dLon/2) * Math.sin(dLon/2) * Math.cos(lat1) * Math.cos(lat2);
+  const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
+  return earthRadiusKm * c;
+}
+
+export default class DhtEarth {
+  /**
+   *
+   */
+  constructor() {
+    this.providerMap = new Map();
+  }
+
+  /**
+   * @param {Object} address
+   * @return {Object} {latitude: lat, longitude: lon}
+   */
+  async getCoordinates(address) {
+    // const {address} = parseAddress(provider)
+    const request = `https://whereis.leofcoin.org/?ip=${address}`
+    let response = await fetch(request)
+    response = await response.json()
+    const {lat, lon} = response;
+    return {latitude: lat, longitude: lon}
+  }
+
+  /**
+   * @param {Object} peer
+   * @param {Object} provider
+   * @return {Object} {provider, distance}
+   */
+  async getDistance(peer, provider) {
+    const {latitude, longitude} = await this.getCoordinates(provider.address)
+    return {provider, distance: distanceInKmBetweenEarthCoordinates(peer.latitude, peer.longitude, latitude, longitude)}
+  }
+
+  /**
+   * @param {Array} providers
+   * @return {Object} closestPeer
+   */
+  async closestPeer(providers) {
+    let all = []
+    const address = await getAddress();
+    const peerLoc = await this.getCoordinates(address)
+
+    for (const provider of providers) {
+      if (provider.address === '127.0.0.1') all.push({provider, distance: 0})
+      else all.push(this.getDistance(peerLoc, provider))
+    }
+
+    all = await Promise.all(all);
+    all = all.sort((previous, current) => previous.distance - current.distance)
+    return all[0].provider;
+  }
+
+  /**
+   * @param {String} hash
+   * @return {Array} providers
+   */
+  providersFor(hash) {
+    return this.providerMap.get(hash);
+  }
+
+  /**
+   * @param {String} address
+   * @param {String} hash
+   * @return {Array} providers
+   */
+  async addProvider(address, hash) {
+    let providers = [];
+    if (this.providerMap.has(hash)) providers = this.providerMap.get(hash)
+
+    providers = new Set([...providers, address])
+    this.providerMap.set(hash, providers)
+    return providers;
+  }
+}