bolt07 1.7.4 → 1.8.2

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Versions
 
+## 1.8.2
+
+- `decodeSocket`: Decode a connection socket from hex data
+- `encodeSocket`: Encode a connection socket to hex data
+
 ## 1.7.4
 
 - `hopsFromChannels`: Derive policy hops from a list of channels

package/README.md

@@ -3,8 +3,6 @@
 Utilities for working with Lightning Network [BOLT 07](https://github.com/lightningnetwork/lightning-rfc/blob/master/07-routing-gossip.md)
 
 [![npm version](https://badge.fury.io/js/bolt07.svg)](https://badge.fury.io/js/bolt07)
-[![Coverage Status](https://coveralls.io/repos/github/alexbosworth/bolt07/badge.svg?branch=master)](https://coveralls.io/github/alexbosworth/bolt07?branch=master)
-[![Build Status](https://travis-ci.org/alexbosworth/bolt07.svg?branch=master)](https://travis-ci.org/alexbosworth/bolt07)
 
 ## Methods
 

package/addresses/decode_base32.js

@@ -0,0 +1,43 @@
+const bufferAsHex = buffer => buffer.toString('hex');
+const byte = 8;
+const max = 255;
+const read = n => 'abcdefghijklmnopqrstuvwxyz234567'.indexOf(n);
+const size = len => (len * 5 / 8) | 0;
+const word = 5;
+
+/** Decode base32 encoded value
+
+  {
+    base32: <Base32 String>
+  }
+
+  @returns
+  {
+    data: <Hex Encoded Value String>
+  }
+*/
+module.exports = ({base32}) => {
+  const b32 = base32.toLowerCase();
+  let bits = 0;
+  let index = 0;
+  const len = base32.length;
+  let value = 0;
+
+  const output = Buffer.alloc(size(len));
+
+  for (let i = 0; i < len; i++) {
+    value = (value << word) | read(b32[i]);
+
+    bits += word;
+
+    if (bits < byte) {
+      continue;
+    }
+
+    output[index++] = (value >>> (bits - byte)) & max;
+
+    bits -= byte;
+  }
+
+  return {data: bufferAsHex(output)};
+};

package/addresses/decode_socket.js

@@ -0,0 +1,64 @@
+const encodeBase32 = require('./encode_base32');
+
+const hexAsIpV4 = hex => [...Buffer.from(hex.slice(0, 8), 'hex')].join('.');
+const hexAsIpV6 = data => data.slice(0, 32).match(/.{1,4}/g).join(':');
+const hexAsTorV3 = data => encodeBase32({data: data.slice(0, 70)}).base32;
+const ip4HexLength = 12;
+const ip6HexLength = 36;
+const portFromData = data => Buffer.from(data.slice(-4), 'hex').readUInt16BE();
+const portHexLength = 4;
+const tor3HexLength = 74;
+
+/** Decode an encoded socket
+
+  {
+    [ip4]: <Hex Encoded IpV4 Socket String>
+    [ip6]: <Hex Encoded IpV6 Socket String>
+    [tor3]: <Hex Encoded TorV3 Socket String>
+  }
+
+  @returns
+  {
+    [socket]: <Connection Socket String>
+  }
+*/
+module.exports = ({ip4, ip6, tor3}) => {
+  const data = ip4 || ip6 || tor3;
+
+  if (!data) {
+    throw new Error('ExectedSocketDataToDecodeSocket');
+  }
+
+  const [, other] = [ip4, ip6, tor3].filter(n => !!n);
+
+  if (!!other) {
+    throw new Error('ExpectedOnlyOneSocketTypeToDecode');
+  }
+
+  if (data.length < portHexLength) {
+    throw new Error('ExpectedSocketDataWithPortToDecodeSocket');
+  }
+
+  // Read the port number as a UInt16 off of the end
+  const port = portFromData(data);
+
+  if (!!ip4 && ip4.length !== ip4HexLength) {
+    throw new Error('UnexpectedLengthForIpV4SocketData');
+  }
+
+  if (!!ip6 && ip6.length !== ip6HexLength) {
+    throw new Error('UnexpectedLengthForIpV6SocketData');
+  }
+
+  if (!!tor3 && tor3.length !== tor3HexLength) {
+    throw new Error('UnexpectedLengthForTorV3SocketData');
+  }
+
+  if (!!ip4) {
+    return {socket: `${hexAsIpV4(ip4)}:${port}`};
+  } else if (!!ip6) {
+    return {socket: `${hexAsIpV6(ip6)}:${port}`};
+  } else {
+    return {socket: `${hexAsTorV3(data)}.onion:${port}`};
+  }
+};

package/addresses/encode_base32.js

@@ -0,0 +1,40 @@
+const alphabet = 'abcdefghijklmnopqrstuvwxyz234567';
+const byte = 8;
+const hexAsBuffer = hex => Buffer.from(hex, 'hex');
+const lastIndex = 31;
+const word = 5;
+
+/** Encode data as base32
+
+  {
+    data: <Data To Encode as Base32 Format Hex String>
+  }
+
+  @returns
+  {
+    base32: <Base32 Encoded String>
+  }
+*/
+module.exports = ({data}) => {
+  let bits = 0;
+  const encoded = hexAsBuffer(data);
+  let base32 = '';
+  let value = 0;
+
+  for (let i = 0; i < encoded.length; i++) {
+    bits += byte;
+    value = (value << byte) | encoded[i];
+
+    while (bits >= word) {
+      base32 += alphabet[(value >>> (bits - word)) & lastIndex];
+
+      bits -= word;
+    }
+  }
+
+  if (bits > 0) {
+    base32 += alphabet[(value << (word - bits)) & lastIndex];
+  }
+
+  return {base32};
+};

package/addresses/encode_socket.js

@@ -0,0 +1,60 @@
+const decodeBase32 = require('./decode_base32');
+
+const bufferAsHex = buffer => buffer.toString('hex');
+const ipv4Match = /^((25[0-5]|(2[0-4]|1\d|[1-9]|)\d)(\.(?!$)|$)){4}$/;
+const ipv6Match = /^[a-fA-F0-9:]+$/;
+const portBuffer = () => Buffer.alloc(2);
+const torV3Data = hostname => hostname.slice(0, 56);
+const torV3Match = /[a-z2-7]{56}.onion/i;
+
+/** Hex-encode a socket
+
+  {
+    socket: <Host:Port String>
+  }
+
+  @returns
+  {
+    [ip4]: <IPv4 Socket Hex Encoded String>
+    [ip6]: <IPv6 Socket Hex Encoded String>
+    [tor3]: <Tor V3 Socket Hex Encoded String>
+  }
+*/
+module.exports = args => {
+  if (!args) {
+    throw new Error('ExpectedArgumentsToEncodeSocket');
+  }
+
+  if (!args.socket) {
+    throw new Error('ExpectedSocketToEncode');
+  }
+
+  const [port, ...host] = args.socket.split(':').reverse();
+
+  const hostname = host.reverse().join(':');
+
+  // The port will be written to a UInt16
+  const rawPort = portBuffer();
+
+  rawPort.writeUInt16BE(Number(port));
+
+  const encodedPort = bufferAsHex(rawPort);
+
+  if (ipv4Match.test(hostname)) {
+    const parts = Buffer.from(hostname.split('.').map(n => parseInt(n)));
+
+    return {ip4: `${parts.toString('hex')}${encodedPort}`};
+  }
+
+  if (ipv6Match.test(hostname)) {
+    return {ip6: `${hostname.split(':').join('')}${encodedPort}`};
+  }
+
+  if (torV3Match.test(hostname)) {
+    const {data} = decodeBase32({base32: torV3Data(hostname)});
+
+    return {tor3: `${data}${encodedPort}`};
+  }
+
+  return {};
+};

package/addresses/index.js

@@ -0,0 +1,4 @@
+const decodeSocket = require('./decode_socket');
+const encodeSocket = require('./encode_socket');
+
+module.exports = {decodeSocket, encodeSocket};

package/index.js

@@ -1,7 +1,9 @@
 const {chanFormat} = require('./ids');
 const {chanNumber} = require('./ids');
 const {decodeChanId} = require('./ids');
+const {decodeSocket} = require('./addresses');
 const {encodeChanId} = require('./ids');
+const {encodeSocket} = require('./addresses');
 const {hopsFromChannels} = require('./routing');
 const {rawChanId} = require('./ids');
 const {routeFromChannels} = require('./routing');
@@ -11,7 +13,9 @@ module.exports = {
   chanFormat,
   chanNumber,
   decodeChanId,
+  decodeSocket,
   encodeChanId,
+  encodeSocket,
   hopsFromChannels,
   rawChanId,
   routeFromChannels,

package/package.json

@@ -7,11 +7,11 @@
     "url": "https://github.com/alexbosworth/bolt07/issues"
   },
   "dependencies": {
-    "bn.js": "5.2.0"
+    "bn.js": "5.2.1"
   },
   "description": "Utilities for working with bolt07 data formats",
   "devDependencies": {
-    "@alexbosworth/tap": "15.0.10"
+    "@alexbosworth/tap": "15.0.11"
   },
   "keywords": [
     "bolt",
@@ -29,7 +29,7 @@
     "url": "https://github.com/alexbosworth/bolt07.git"
   },
   "scripts": {
-    "test": "tap test/ids/*.js test/routing/*.js"
+    "test": "tap --branches=1 --functions=1 --lines=1 --statements=1 test/addresses/*.js test/ids/*.js test/routing/*.js"
   },
-  "version": "1.7.4"
+  "version": "1.8.2"
 }

package/test/addresses/test_decode_socket.js

@@ -0,0 +1,67 @@
+const {test} = require('@alexbosworth/tap');
+
+const {decodeSocket} = require('./../../');
+
+const tests = [
+  {
+    args: {},
+    description: 'A socket is expected',
+    error: 'ExectedSocketDataToDecodeSocket',
+  },
+  {
+    args: {ip4: true, ip6: true},
+    description: 'A single socket is expected',
+    error: 'ExpectedOnlyOneSocketTypeToDecode',
+  },
+  {
+    args: {ip4: '00'},
+    description: 'A socket requires sufficient bytes',
+    error: 'ExpectedSocketDataWithPortToDecodeSocket',
+  },
+  {
+    args: {ip4: '000000'},
+    description: 'Ip4 requires sufficient bytes',
+    error: 'UnexpectedLengthForIpV4SocketData',
+  },
+  {
+    args: {ip6: '000000'},
+    description: 'Ip6 requires sufficient bytes',
+    error: 'UnexpectedLengthForIpV6SocketData',
+  },
+  {
+    args: {tor3: '000000'},
+    description: 'Tor3 requires sufficient bytes',
+    error: 'UnexpectedLengthForTorV3SocketData',
+  },
+  {
+    args: {ip4: Buffer.alloc(6).toString('hex')},
+    description: 'Decode ip version 4 socket',
+    expected: {socket: '0.0.0.0:0'},
+  },
+  {
+    args: {ip6: Buffer.alloc(18).toString('hex')},
+    description: 'Decode ip version 6 socket',
+    expected: {socket: '0000:0000:0000:0000:0000:0000:0000:0000:0'},
+  },
+  {
+    args: {tor3: Buffer.alloc(37).toString('hex')},
+    description: 'Decode tor v3 onion socket',
+    expected: {
+      socket: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.onion:0',
+    },
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, ({end, strictSame, throws}) => {
+    if (!!error) {
+      throws(() => decodeSocket(args), new Error(error), 'Got expected error');
+    } else {
+      const res = decodeSocket(args);
+
+      strictSame(res, expected, 'Got expected result');
+    }
+
+    return end();
+  });
+});

package/test/addresses/test_encode_socket.js

@@ -0,0 +1,54 @@
+const {test} = require('@alexbosworth/tap');
+
+const {encodeSocket} = require('./../../');
+
+const tests = [
+  {
+    args: undefined,
+    description: 'Arguments are required',
+    error: 'ExpectedArgumentsToEncodeSocket',
+  },
+  {
+    args: {},
+    description: 'A socket is required',
+    error: 'ExpectedSocketToEncode',
+  },
+  {
+    args: {socket: 'socket'},
+    description: 'Unknown socket type is not encoded',
+    expected: {},
+  },
+  {
+    args: {socket: '1.2.3.4:56789'},
+    description: 'Encode ip version 4 socket',
+    expected: {ip4: '01020304ddd5'},
+  },
+  {
+    args: {socket: '0000:1111:2222:3333:4444:5555:6666:12345'},
+    description: 'Encode ip version 6 socket',
+    expected: {ip6: '00001111222233334444555566663039'},
+  },
+  {
+    args: {
+      socket: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.onion:0',
+    },
+    description: 'Encode tor v3 socket',
+    expected: {
+      tor3: '00000000000000000000000000000000000000000000000000000000000000000000000000',
+    },
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, ({end, strictSame, throws}) => {
+    if (!!error) {
+      throws(() => encodeSocket(args), new Error(error), 'Got expected error');
+    } else {
+      const res = encodeSocket(args);
+
+      strictSame(res, expected, 'Got expected result');
+    }
+
+    return end();
+  });
+});

package/.travis.yml

@@ -1,15 +0,0 @@
-language: node_js
-
-node_js:
-  - 12
-  - 10
-
-os:
-  - linux
-
-cache:
-  directories:
-    - $HOME/.npm
-
-notifications:
-  email: false