channels: fetch aliases for channel peers

Author: jamaljsr

app/src/__tests__/components/loop/ChannelRow.spec.tsx

@@ -49,9 +49,9 @@ describe('ChannelRow component', () => {
     expect(getByText(channel.uptime.toString())).toBeInTheDocument();
   });
 
-  it('should display the peer pubkey', () => {
+  it('should display the peer pubkey or alias', () => {
     const { getByText } = render();
-    expect(getByText(channel.ellipsedPubkey)).toBeInTheDocument();
+    expect(getByText(channel.aliasLabel)).toBeInTheDocument();
   });
 
   it('should display the capacity', () => {

app/src/__tests__/store/channelStore.spec.ts

@@ -4,7 +4,12 @@ import { grpc } from '@improbable-eng/grpc-web';
 import { waitFor } from '@testing-library/react';
 import Big from 'big.js';
 import { BalanceMode } from 'util/constants';
-import { lndChannelEvent, lndListChannels } from 'util/tests/sampleData';
+import {
+  lndChannel,
+  lndChannelEvent,
+  lndGetNodeInfo,
+  lndListChannels,
+} from 'util/tests/sampleData';
 import { createStore, Store } from 'store';
 import Channel from 'store/models/channel';
 import ChannelStore from 'store/stores/channelStore';
@@ -120,6 +125,16 @@ describe('ChannelStore', () => {
     expect(+store.totalOutbound).toBe(outbound);
   });
 
+  it('should fetch aliases for channels', async () => {
+    await store.fetchChannels();
+    const channel = store.channels.get(lndChannel.chanId) as Channel;
+    expect(channel.alias).toBeUndefined();
+    // the alias is fetched from the API and should be updated after a few ticks
+    waitFor(() => {
+      expect(channel.alias).toBe(lndGetNodeInfo.node.alias);
+    });
+  });
+
   describe('onChannelEvent', () => {
     const {
       OPEN_CHANNEL,

app/src/api/lnd.ts

@@ -56,6 +56,16 @@ class LndApi extends BaseApi<LndEvents> {
     return res.toObject();
   }
 
+  /**
+   * call the LND `GetNodeInfo` RPC and return the response
+   */
+  async getNodeInfo(pubkey: string): Promise<LND.NodeInfo.AsObject> {
+    const req = new LND.NodeInfoRequest();
+    req.setPubKey(pubkey);
+    const res = await this._grpc.request(Lightning.GetNodeInfo, req, this._meta);
+    return res.toObject();
+  }
+
   /**
    * Connect to the LND streaming endpoints
    */

app/src/components/loop/ChannelRow.tsx

@@ -137,7 +137,7 @@ const ChannelRow: React.FC<Props> = ({ channel, style }) => {
       <Column>{channel.uptimePercent}</Column>
       <Column>
         <Tip overlay={channel.remotePubkey} placement="left">
-          <span>{channel.ellipsedPubkey}</span>
+          <span>{channel.aliasLabel}</span>
         </Tip>
       </Column>
       <Column right>

app/src/i18n/locales/en-US.json

@@ -22,7 +22,7 @@
   "cmps.loop.ChannelRowHeader.canReceive": "Can Receive",
   "cmps.loop.ChannelRowHeader.canSend": "Can Send",
   "cmps.loop.ChannelRowHeader.upTime": "Up Time %",
-  "cmps.loop.ChannelRowHeader.peer": "Peer Pubkey",
+  "cmps.loop.ChannelRowHeader.peer": "Peer/Alias",
   "cmps.loop.ChannelRowHeader.capacity": "Capacity",
   "cmps.loop.LoopActions.channelsSelected": "channels selected",
   "cmps.loop.LoopActions.loopInNote": "For multi Loop In, all channels must use the same peer.",

app/src/store/models/channel.ts

@@ -13,6 +13,7 @@ export default class Channel {
 
   @observable chanId = '';
   @observable remotePubkey = '';
+  @observable alias: string | undefined;
   @observable channelPoint = '';
   @observable capacity = Big(0);
   @observable localBalance = Big(0);
@@ -27,10 +28,10 @@ export default class Channel {
   }
 
   /**
-   * The remotePubkey shortened to ~20 chars with ellipses inside
+   * The alias or remotePubkey shortened to ~20 chars with ellipses inside
    */
-  @computed get ellipsedPubkey() {
-    return ellipseInside(this.remotePubkey);
+  @computed get aliasLabel() {
+    return this.alias || ellipseInside(this.remotePubkey);
   }
 
   /**

app/src/store/stores/channelStore.ts

@@ -93,6 +93,8 @@ export default class ChannelStore {
           .forEach(id => this.channels.delete(id));
 
         this._store.log.info('updated channelStore.channels', toJS(this.channels));
+        // fetch the aliases for each of the channels
+        this.fetchAliases();
       });
     } catch (error) {
       this._store.uiStore.handleError(error, 'Unable to fetch Channels');
@@ -102,6 +104,35 @@ export default class ChannelStore {
   /** fetch channels at most once every 2 seconds when using this func  */
   fetchChannelsThrottled = debounce(this.fetchChannels, 2000);
 
+  /**
+   * queries the LND api to fetch the aliases for all of the peers we have
+   * channels opened with
+   */
+  @action.bound
+  async fetchAliases() {
+    const pubKeys = values(this.channels)
+      .map(c => c.remotePubkey)
+      .filter((r, i, a) => a.indexOf(r) === i); // remove duplicates
+    // call getNodeInfo for each pubkey and wait for all the requests to complete
+    const nodeInfos = await Promise.all(
+      pubKeys.map(pk => this._store.api.lnd.getNodeInfo(pk)),
+    );
+
+    // create a map of pubKey to alias
+    const aliases = nodeInfos.reduce((acc, { node }) => {
+      if (node) acc[node.pubKey] = node.alias;
+      return acc;
+    }, {} as Record<string, string>);
+
+    runInAction('fetchAliasesContinuation', () => {
+      values(this.channels).forEach(c => {
+        if (aliases[c.remotePubkey]) {
+          c.alias = aliases[c.remotePubkey];
+        }
+      });
+    });
+  }
+
   /** update the channel list based on events from the API */
   @action.bound
   onChannelEvent(event: ChannelEventUpdate.AsObject) {
@@ -136,6 +167,8 @@ export default class ChannelStore {
       this.channels.set(channel.chanId, channel);
       this._store.log.info('added new open channel', toJS(channel));
       this._store.nodeStore.fetchBalancesThrottled();
+      // fetch the alias for the added channel
+      this.fetchAliases();
     }
   }
 

app/src/util/tests/sampleData.ts

@@ -36,6 +36,33 @@ export const lndGetInfo: LND.GetInfoResponse.AsObject = {
   ],
 };
 
+export const lndGetNodeInfo: Required<LND.NodeInfo.AsObject> = {
+  channelsList: [],
+  node: {
+    addressesList: [
+      {
+        addr: '172.28.0.8:9735',
+        network: 'tcp',
+      },
+    ],
+    alias: 'alice',
+    color: '#cccccc',
+    featuresMap: [
+      [0, { name: 'data-loss-protect', isRequired: true, isKnown: true }],
+      [13, { name: 'static-remote-key', isRequired: false, isKnown: true }],
+      [15, { name: 'payment-addr', isRequired: false, isKnown: true }],
+      [17, { name: 'multi-path-payments', isRequired: false, isKnown: true }],
+      [5, { name: 'upfront-shutdown-script', isRequired: false, isKnown: true }],
+      [7, { name: 'gossip-queries', isRequired: false, isKnown: true }],
+      [9, { name: 'tlv-onion', isRequired: false, isKnown: true }],
+    ],
+    lastUpdate: 1591393224,
+    pubKey: '037136742c67e24681f36542f7c8916aa6f6fdf665c1dca2a107425503cff94501',
+  },
+  numChannels: 3,
+  totalCapacity: 47000000,
+};
+
 export const lndChannelBalance: LND.ChannelBalanceResponse.AsObject = {
   balance: 9990950,
   pendingOpenBalance: 0,
@@ -95,7 +122,7 @@ export const lndListChannels: LND.ListChannelsResponse.AsObject = {
       ...c,
       chanId: `${i || ''}${c.chanId}`,
       channelPoint: `${c.channelPoint.substring(0, c.channelPoint.length - 2)}:${i}`,
-      remotePubkey: `${i}${c.remotePubkey}`,
+      remotePubkey: `${i || ''}${c.remotePubkey}`,
       localBalance: local,
       remoteBalance: cap - local,
       capacity: cap,
@@ -186,6 +213,7 @@ export const loopQuote: LOOP.QuoteResponse.AsObject = {
 // collection of sample API responses
 export const sampleApiResponses: Record<string, any> = {
   'lnrpc.Lightning.GetInfo': lndGetInfo,
+  'lnrpc.Lightning.GetNodeInfo': lndGetNodeInfo,
   'lnrpc.Lightning.ChannelBalance': lndChannelBalance,
   'lnrpc.Lightning.WalletBalance': lndWalletBalance,
   'lnrpc.Lightning.ListChannels': lndListChannels,