Merge pull request #1005 from lightninglabs/bos-scores

Bos scores

Author: tanx

public/lnd-child-process.js

@@ -65,6 +65,8 @@ module.exports.startLndProcess = async function({
     '--autopilot.private',
     '--autopilot.minconfs=0',
     '--autopilot.allocation=0.95',
+    '--autopilot.heuristic=externalscore:1',
+    '--autopilot.heuristic=preferential:0',
     lndPort ? `--rpclisten=localhost:${lndPort}` : '',
     lndPeerPort ? `--listen=localhost:${lndPeerPort}` : '',
     lndRestPort ? `--restlisten=localhost:${lndRestPort}` : '',

src/action/autopilot.js

@@ -3,23 +3,31 @@
  * whether autopilot should open channels.
  */
 
+import { ATPL_DELAY } from '../config';
+import { poll, checkHttpStatus } from '../helper';
+import * as log from './log';
+
 class AtplAction {
-  constructor(store, grpc, db, notification) {
+  constructor(store, grpc, info, db, notification) {
     this._store = store;
     this._grpc = grpc;
+    this._info = info;
     this._db = db;
     this._notification = notification;
   }
 
   /**
    * Initialize autopilot from the stored settings and enable it via grpc
-   * depending on if the user has enabled it in the last session.
+   * depending on if the user has enabled it in the last session. Fetch node
+   * scores are fetched from an api to inform channel selection.
    * @return {Promise<undefined>}
    */
   async init() {
+    await this.updateNodeScores();
     if (this._store.settings.autopilot) {
       await this._setStatus(true);
     }
+    await poll(() => this.updateNodeScores(), ATPL_DELAY);
   }
 
   /**
@@ -48,6 +56,65 @@ class AtplAction {
       this._notification.display({ msg: 'Error toggling autopilot', err });
     }
   }
+
+  /**
+   * Update node scores to get better channels via autopilot.
+   * @return {Promise<undefined>}
+   */
+  async updateNodeScores() {
+    try {
+      await this._setNetwork();
+      const scores = await this._readNodeScores();
+      await this._setNodeScores(scores);
+    } catch (err) {
+      log.error('Updating autopilot scores failed', err);
+    }
+  }
+
+  async _setNetwork() {
+    await this._info.getInfo();
+    if (!this._store.network) {
+      throw new Error('Could not read network');
+    }
+  }
+
+  async _readNodeScores() {
+    const { network, settings } = this._store;
+    try {
+      settings.nodeScores[network] = await this._fetchNodeScores(network);
+      this._db.save();
+    } catch (err) {
+      log.error('Fetching node scores failed', err);
+    }
+    return settings.nodeScores[network];
+  }
+
+  async _fetchNodeScores(network) {
+    const baseUri = 'https://nodes.lightning.computer/availability/v1';
+    const uri = `${baseUri}/btc${network === 'testnet' ? 'testnet' : ''}.json`;
+    const response = checkHttpStatus(await fetch(uri));
+    return this._formatNodesScores((await response.json()).scores);
+  }
+
+  _formatNodesScores(jsonScores) {
+    return jsonScores.reduce((map, { public_key, score }) => {
+      if (typeof public_key !== 'string' || !Number.isInteger(score)) {
+        throw new Error('Invalid node score format!');
+      }
+      map[public_key] = score / 100000000.0;
+      return map;
+    }, {});
+  }
+
+  async _setNodeScores(scores) {
+    if (!scores) {
+      throw new Error('Node scores are emtpy');
+    }
+    await this._grpc.sendAutopilotCommand('setScores', {
+      heuristic: 'externalscore',
+      scores,
+    });
+  }
 }
 
 export default AtplAction;

src/action/index-mobile.js

@@ -63,7 +63,7 @@ export const auth = new AuthAction(
   LocalAuthentication,
   Alert
 );
-export const autopilot = new AtplAction(store, grpc, db, notify);
+export const autopilot = new AtplAction(store, grpc, info, db, notify);
 
 payment.listenForUrlMobile(Linking); // enable incoming url handler
 

src/action/index.js

@@ -42,7 +42,7 @@ export const channel = new ChannelAction(store, grpc, nav, notify);
 export const invoice = new InvoiceAction(store, grpc, nav, notify, Clipboard);
 export const payment = new PaymentAction(store, grpc, nav, notify, Clipboard);
 export const setting = new SettingAction(store, wallet, db, ipc);
-export const autopilot = new AtplAction(store, grpc, db, notify);
+export const autopilot = new AtplAction(store, grpc, info, db, notify);
 
 payment.listenForUrl(ipc); // enable incoming url handler
 

src/action/info.js

@@ -28,6 +28,7 @@ class InfoAction {
       this._store.pubKey = response.identityPubkey;
       this._store.syncedToChain = response.syncedToChain;
       this._store.blockHeight = response.blockHeight;
+      this._store.network = response.chains[0].network;
       if (this.startingSyncTimestamp === undefined) {
         this.startingSyncTimestamp = response.bestHeaderTimestamp || 0;
       }

src/config.js

@@ -6,6 +6,7 @@ module.exports.RETRY_DELAY = 1000;
 module.exports.LND_INIT_DELAY = 5000;
 module.exports.NOTIFICATION_DELAY = 5000;
 module.exports.RATE_DELAY = 15 * 60 * 1000;
+module.exports.ATPL_DELAY = 60 * 60 * 1000;
 module.exports.PAYMENT_TIMEOUT = 60 * 1000;
 module.exports.POLL_STORE_TIMEOUT = 100;
 

src/store.js

@@ -35,6 +35,7 @@ export class Store {
       unconfirmedBalanceSatoshis: 0,
       pendingBalanceSatoshis: 0,
       channelBalanceSatoshis: 0,
+      network: null,
       pubKey: null,
       walletAddress: null,
       displayCopied: false,
@@ -91,6 +92,7 @@ export class Store {
         exchangeRate: {},
         restoring: false,
         autopilot: true,
+        nodeScores: {},
       },
     });
   }

test/integration/action/action-integration.spec.js

@@ -167,7 +167,7 @@ describe('Action Integration Tests', function() {
     channels1 = new ChannelAction(store1, grpc1, nav1, notify1);
     invoice1 = new InvoiceAction(store1, grpc1, nav1, notify1);
     payments1 = new PaymentAction(store1, grpc1, nav1, notify1);
-    autopilot1 = new AtplAction(store1, grpc1, db1, notify1);
+    autopilot1 = new AtplAction(store1, grpc1, info1, db1, notify1);
 
     db2 = sinon.createStubInstance(AppStorage);
     nav2 = sinon.createStubInstance(NavAction);
@@ -180,7 +180,10 @@ describe('Action Integration Tests', function() {
     channels2 = new ChannelAction(store2, grpc2, nav2, notify2);
     invoice2 = new InvoiceAction(store2, grpc2, nav2, notify2);
     payments2 = new PaymentAction(store2, grpc2, nav2, notify2);
-    autopilot2 = new AtplAction(store2, grpc2, db2, notify2);
+    autopilot2 = new AtplAction(store2, grpc2, info2, db2, notify2);
+
+    sandbox.stub(autopilot1, 'updateNodeScores').resolves(true);
+    sandbox.stub(autopilot2, 'updateNodeScores').resolves(true);
   });
 
   after(async () => {
@@ -298,6 +301,7 @@ describe('Action Integration Tests', function() {
     it('should get public key node1', async () => {
       await info1.pollInfo();
       expect(store1.pubKey, 'to be ok');
+      expect(store1.network, 'to equal', 'simnet');
     });
 
     it('should wait until node1 is synced to chain', async () => {

test/unit/action/autopilot.spec.js

@@ -2,43 +2,56 @@ import { Store } from '../../../src/store';
 import GrpcAction from '../../../src/action/grpc';
 import NotificationAction from '../../../src/action/notification';
 import AppStorage from '../../../src/action/app-storage';
+import InfoAction from '../../../src/action/info';
 import AtplAction from '../../../src/action/autopilot';
 import * as logger from '../../../src/action/log';
+import nock from 'nock';
+import 'isomorphic-fetch';
 
 describe('Action Autopilot Unit Test', () => {
   let store;
   let db;
   let grpc;
   let notify;
+  let info;
   let autopilot;
   let sandbox;
 
   beforeEach(() => {
     sandbox = sinon.createSandbox({});
     sandbox.stub(logger);
     store = new Store();
+    require('../../../src/config').ATPL_DELAY = 1;
     grpc = sinon.createStubInstance(GrpcAction);
     db = sinon.createStubInstance(AppStorage);
     notify = sinon.createStubInstance(NotificationAction);
-    autopilot = new AtplAction(store, grpc, db, notify);
+    info = sinon.createStubInstance(InfoAction);
+    autopilot = new AtplAction(store, grpc, info, db, notify);
   });
 
   afterEach(() => {
     sandbox.restore();
   });
 
   describe('init()', () => {
-    it('should enable autopilot by default', async () => {
+    beforeEach(() => {
+      sandbox.stub(autopilot, 'updateNodeScores').resolves();
+      autopilot.updateNodeScores.onThirdCall().resolves(true);
+    });
+
+    it('should enable autopilot and fetch scores by default', async () => {
       await autopilot.init();
       expect(grpc.sendAutopilotCommand, 'was called with', 'modifyStatus', {
         enable: true,
       });
+      expect(autopilot.updateNodeScores, 'was called thrice');
     });
 
-    it('should not enable autopilot if disabled', async () => {
+    it('should not enable autopilot if disabled but fetch scores', async () => {
       store.settings.autopilot = false;
       await autopilot.init();
       expect(grpc.sendAutopilotCommand, 'was not called');
+      expect(autopilot.updateNodeScores, 'was called thrice');
     });
   });
 
@@ -59,4 +72,110 @@ describe('Action Autopilot Unit Test', () => {
       expect(db.save, 'was not called');
     });
   });
+
+  describe('updateNodeScores()', async () => {
+    let scoresJson;
+
+    beforeEach(() => {
+      scoresJson = {
+        last_updated: '2019-03-21T04:39:41.031Z',
+        scores: [
+          {
+            alias: 'some-alias',
+            public_key: 'some-pubkey',
+            score: 14035087,
+          },
+        ],
+      };
+      info.getInfo.resolves();
+      store.network = 'testnet';
+    });
+
+    it('should fail if network cannot be read', async () => {
+      store.network = null;
+      await autopilot.updateNodeScores();
+      expect(logger.error, 'was called once');
+      expect(grpc.sendAutopilotCommand, 'was not called');
+      expect(db.save, 'was not called');
+      expect(store.settings.nodeScores, 'to equal', {});
+    });
+
+    it('should read scores for testnet from empty cache', async () => {
+      nock('https://nodes.lightning.computer')
+        .get('/availability/v1/btctestnet.json')
+        .reply(500, 'Boom!');
+
+      await autopilot.updateNodeScores();
+      expect(grpc.sendAutopilotCommand, 'was not called');
+      expect(logger.error, 'was called twice');
+      expect(db.save, 'was not called');
+      expect(store.settings.nodeScores, 'to equal', {});
+    });
+
+    it('should handle invalid score format', async () => {
+      delete scoresJson.scores[0].public_key;
+      nock('https://nodes.lightning.computer')
+        .get('/availability/v1/btctestnet.json')
+        .reply(200, scoresJson);
+
+      await autopilot.updateNodeScores();
+      expect(logger.error, 'was called twice');
+      expect(grpc.sendAutopilotCommand, 'was not called');
+      expect(db.save, 'was not called');
+      expect(store.settings.nodeScores, 'to equal', {});
+    });
+
+    it('should read scores for testnet from cache', async () => {
+      nock('https://nodes.lightning.computer')
+        .get('/availability/v1/btctestnet.json')
+        .reply(500, 'Boom!');
+      store.settings.nodeScores = {
+        testnet: { 'some-pubkey': 0.14035087 },
+      };
+
+      await autopilot.updateNodeScores();
+      expect(grpc.sendAutopilotCommand, 'was called with', 'setScores', {
+        heuristic: 'externalscore',
+        scores: { 'some-pubkey': 0.14035087 },
+      });
+      expect(logger.error, 'was called once');
+      expect(db.save, 'was not called');
+      expect(store.settings.nodeScores, 'to equal', {
+        testnet: { 'some-pubkey': 0.14035087 },
+      });
+    });
+
+    it('should set scores for testnet', async () => {
+      nock('https://nodes.lightning.computer')
+        .get('/availability/v1/btctestnet.json')
+        .reply(200, scoresJson);
+
+      await autopilot.updateNodeScores();
+      expect(grpc.sendAutopilotCommand, 'was called with', 'setScores', {
+        heuristic: 'externalscore',
+        scores: { 'some-pubkey': 0.14035087 },
+      });
+      expect(db.save, 'was called once');
+      expect(store.settings.nodeScores, 'to equal', {
+        testnet: { 'some-pubkey': 0.14035087 },
+      });
+    });
+
+    it('should set scores for mainnet', async () => {
+      store.network = 'mainnet';
+      nock('https://nodes.lightning.computer')
+        .get('/availability/v1/btc.json')
+        .reply(200, scoresJson);
+
+      await autopilot.updateNodeScores();
+      expect(grpc.sendAutopilotCommand, 'was called with', 'setScores', {
+        heuristic: 'externalscore',
+        scores: { 'some-pubkey': 0.14035087 },
+      });
+      expect(db.save, 'was called once');
+      expect(store.settings.nodeScores, 'to equal', {
+        mainnet: { 'some-pubkey': 0.14035087 },
+      });
+    });
+  });
 });