feat(rpc/connext): deposit & openchannel calls

This refactors the `Deposit` and `OpenChannel` methods in `SwapClient`
to make them generic and applicable to Connext. It implements this
functionality for Connext, namely retrieiving an address for sending
funds on-chain to the Connext wallet and depositing those funds into
Connext channels.

It also refactors the `CloseChannel` call similarly, however the
Connext REST client does not currently implement a `/withdraw` endpoint
for taking funds out of Connext channels. This adds dummy code to
construct a withdraw payload and make a request.

Withdrawing coins from the on-chain Connext wallet is not currently
supported by the Connext client and so the `Withdraw` rpc call remains
specific to lnd.

Closes #1472. Closes #1473.

Author: sangaman

Diff for: docs/api.md

@@ -1,32 +1,50 @@
 import { Arguments, Argv } from 'yargs';
 import { CloseChannelRequest } from '../../proto/xudrpc_pb';
 import { callback, loadXudClient } from '../command';
+import { coinsToSats } from '../utils';
 
-export const command = 'closechannel <node_identifier> <currency> [--force]';
+export const command = 'closechannel <currency> [node_identifier ] [--force]';
 
 export const describe = 'close any payment channels with a peer';
 
 export const builder = (argv: Argv) => argv
-  .positional('node_identifier', {
-    description: 'the node key or alias of the connected peer to close the channel with',
-    type: 'string',
-  })
   .positional('currency', {
     description: 'the ticker symbol for the currency',
     type: 'string',
   })
+  .option('node_identifier', {
+    description: 'the node key or alias of the connected peer to close the channel with',
+    type: 'string',
+  })
   .option('force', {
     type: 'boolean',
     description: 'whether to force close if the peer is offline',
   })
-  .example('$0 closechannel 028599d05b18c0c3f8028915a17d603416f7276c822b6b2d20e71a3502bd0f9e0b BTC', 'close BTC channels by node key')
-  .example('$0 closechannel CheeseMonkey BTC', 'close BTC channels by alias')
-  .example('$0 closechannel CheeseMonkey BTC --force', 'force close BTC channels by alias');
+  .option('destination', {
+    type: 'string',
+    description: 'the on-chain address to send funds extracted from the channel',
+  })
+  .option('amount', {
+    type: 'number',
+    description: 'for Connext only - the amount to extract from the channel',
+  })
+  .example('$0 closechannel BTC 028599d05b18c0c3f8028915a17d603416f7276c822b6b2d20e71a3502bd0f9e0b', 'close BTC channels by node key')
+  .example('$0 closechannel BTC CheeseMonkey', 'close BTC channels by alias')
+  .example('$0 closechannel BTC CheeseMonkey --force', 'force close BTC channels by alias')
+  .example('$0 closechannel ETH --amount 0.1', '[UNIMPLEMENTED] remove 0.1 ETH from a Connext channel');
 
 export const handler = async (argv: Arguments<any>) => {
   const request = new CloseChannelRequest();
-  request.setNodeIdentifier(argv.node_identifier);
+  if (argv.node_identifier) {
+    request.setNodeIdentifier(argv.node_identifier);
+  }
   request.setCurrency(argv.currency.toUpperCase());
+  if (argv.destination) {
+    request.setDestination(argv.destination);
+  }
+  if (argv.amount) {
+    request.setAmount(coinsToSats(argv.amount));
+  }
   if (argv.force) {
     request.setForce(argv.force);
   }

Diff for: lib/cli/commands/closechannel.ts

@@ -27,7 +27,8 @@ export const builder = (argv: Argv) => argv
   })
   .example('$0 openchannel BTC 0.1 028599d05b18c0c3f8028915a17d603416f7276c822b6b2d20e71a3502bd0f9e0b', 'open an 0.1 BTC channel by node key')
   .example('$0 openchannel BTC 0.1 CheeseMonkey', 'open an 0.1 BTC channel by alias')
-  .example('$0 openchannel BTC 0.1 CheeseMonkey 0.05', 'open an 0.1 BTC channel by alias and push 0.05 to remote side');
+  .example('$0 openchannel BTC 0.1 CheeseMonkey 0.05', 'open an 0.1 BTC channel by alias and push 0.05 to remote side')
+  .example('$0 openchannel ETH 0.5', 'deposit 0.5 into an ETH Connext channel without specifying a remote node');
 
 export const handler = async (argv: Arguments<any>) => {
   const request = new OpenChannelRequest();

Diff for: lib/cli/commands/openchannel.ts

@@ -2,7 +2,7 @@ import { Arguments, Argv } from 'yargs';
 import { DepositRequest } from '../../proto/xudrpc_pb';
 import { callback, loadXudClient } from '../command';
 
-export const command = 'deposit <currency>';
+export const command = 'walletdeposit <currency>';
 
 export const describe = 'gets an address to deposit funds to xud';
 
@@ -16,5 +16,5 @@ export const builder = (argv: Argv) => argv
 export const handler = async (argv: Arguments<any>) => {
   const request = new DepositRequest();
   request.setCurrency(argv.currency);
-  (await loadXudClient(argv)).deposit(request, callback(argv));
+  (await loadXudClient(argv)).walletDeposit(request, callback(argv));
 };

Diff for: lib/cli/commands/deposit.ts renamed to lib/cli/commands/walletdeposit.ts

@@ -1,8 +1,9 @@
 import { Arguments, Argv } from 'yargs';
 import { WithdrawRequest } from '../../proto/xudrpc_pb';
 import { callback, loadXudClient } from '../command';
+import { coinsToSats } from '../utils';
 
-export const command = 'withdraw [amount] [currency] [destination] [fee]';
+export const command = 'walletwithdraw [amount] [currency] [destination] [fee]';
 
 export const describe = 'withdraws on-chain funds from xud';
 
@@ -37,10 +38,10 @@ export const handler = async (argv: Arguments<any>) => {
   if (argv.all) {
     request.setAll(argv.all);
   } else {
-    request.setAmount(argv.amount);
+    request.setAmount(coinsToSats(argv.amount));
   }
   request.setDestination(argv.destination);
   request.setFee(argv.fee);
 
-  (await loadXudClient(argv)).withdraw(request, callback(argv));
+  (await loadXudClient(argv)).walletWithdraw(request, callback(argv));
 };

Diff for: lib/cli/commands/withdraw.ts renamed to lib/cli/commands/walletwithdraw.ts

@@ -13,7 +13,7 @@ import SwapClient, {
   SwapClientInfo,
   PaymentStatus,
 } from '../swaps/SwapClient';
-import { SwapDeal } from '../swaps/types';
+import { SwapDeal, CloseChannelParams, OpenChannelParams } from '../swaps/types';
 import { UnitConverter } from '../utils/UnitConverter';
 import errors, { errorCodes } from './errors';
 import {
@@ -547,28 +547,33 @@ class ConnextClient extends SwapClient {
     };
   }
 
-  /**
-   * Deposits funds to a node
-   */
-  public deposit = async (
-    { currency, units }:
-    { currency: string, units: number },
-  ) => {
+  public deposit = async () => {
+    const clientConfig = await this.getClientConfig();
+    return clientConfig.signerAddress;
+  }
+
+  public openChannel = async ({ currency, units }: OpenChannelParams) => {
+    if (!currency) {
+      throw errors.CURRENCY_MISSING;
+    }
     const assetId = this.getTokenAddress(currency);
     await this.sendRequest('/deposit', 'POST', {
       assetId,
       amount: BigInt(units).toString(),
     });
   }
 
-  public async openChannel() {}
-
-  /**
-   * Closes a payment client.
-   * @param multisigAddress the address of the client to close
-   */
-  public closeChannel = async (): Promise<void> => {
-    // not relevant for connext
+  public closeChannel = async ({ units, currency, destination }: CloseChannelParams): Promise<void> => {
+    if (!currency) {
+      throw errors.CURRENCY_MISSING;
+    }
+    const amount = units || (await this.channelBalance(currency)).balance;
+    // TODO: connext-api-client withdraw endpoint not currently implemented
+    await this.sendRequest('/withdraw', 'POST', {
+      recipient: destination,
+      amount: BigInt(amount).toString(),
+      assetId: this.tokenAddresses.get(currency),
+    });
   }
 
   /**

Diff for: lib/connextclient/ConnextClient.ts

@@ -343,30 +343,31 @@ class GrpcService {
   }
 
   /**
-   * See [[Service.deposit]]
+   * See [[Service.walletDeposit]]
    */
-  public deposit: grpc.handleUnaryCall<xudrpc.DepositRequest, xudrpc.DepositResponse> = async (call, callback) => {
+  public walletDeposit: grpc.handleUnaryCall<xudrpc.DepositRequest, xudrpc.DepositResponse> = async (call, callback) => {
     if (!this.isReady(this.service, callback)) {
       return;
     }
     try {
-      await this.service.deposit(call.request.toObject());
+      const address = await this.service.walletDeposit(call.request.toObject());
       const response = new xudrpc.DepositResponse();
+      response.setAddress(address);
       callback(null, response);
     } catch (err) {
       callback(getGrpcError(err), null);
     }
   }
 
   /**
-   * See [[Service.withdraw]]
+   * See [[Service.walletWithdraw]]
    */
-  public withdraw: grpc.handleUnaryCall<xudrpc.WithdrawRequest, xudrpc.WithdrawResponse> = async (call, callback) => {
+  public walletWithdraw: grpc.handleUnaryCall<xudrpc.WithdrawRequest, xudrpc.WithdrawResponse> = async (call, callback) => {
     if (!this.isReady(this.service, callback)) {
       return;
     }
     try {
-      await this.service.withdraw(call.request.toObject());
+      await this.service.walletWithdraw(call.request.toObject());
       const response = new xudrpc.WithdrawResponse();
       callback(null, response);
     } catch (err) {

Diff for: lib/grpc/GrpcService.ts

@@ -20,6 +20,7 @@ const getGrpcError = (err: any) => {
     case p2pErrorCodes.NODE_TOR_ADDRESS:
     case orderErrorCodes.MIN_QUANTITY_VIOLATED:
     case orderErrorCodes.QUANTITY_DOES_NOT_MATCH:
+    case swapErrorCodes.REMOTE_IDENTIFIER_MISSING:
       code = status.INVALID_ARGUMENT;
       break;
     case orderErrorCodes.PAIR_DOES_NOT_EXIST:

Diff for: lib/grpc/getGrpcError.ts

@@ -10,7 +10,7 @@ import { LightningClient, WalletUnlockerClient } from '../proto/lndrpc_grpc_pb';
 import * as lndrpc from '../proto/lndrpc_pb';
 import swapErrors from '../swaps/errors';
 import SwapClient, { ChannelBalance, ClientStatus, PaymentState, SwapClientInfo, TradingLimits } from '../swaps/SwapClient';
-import { SwapDeal } from '../swaps/types';
+import { SwapDeal, CloseChannelParams, OpenChannelParams } from '../swaps/types';
 import { base64ToHex, hexToUint8Array } from '../utils/utils';
 import errors from './errors';
 import { Chain, ChannelCount, ClientMethods, LndClientConfig, LndInfo } from './types';
@@ -519,8 +519,13 @@ class LndClient extends SwapClient {
     return this.unaryCall<lndrpc.ClosedChannelsRequest, lndrpc.ClosedChannelsResponse>('closedChannels', new lndrpc.ClosedChannelsRequest());
   }
 
+  public deposit = async () => {
+    const depositAddress = await this.newAddress();
+    return depositAddress;
+  }
+
   public withdraw = async ({ amount, destination, all = false, fee }: {
-    amount: number,
+    amount?: number,
     destination: string,
     all?: boolean,
     fee?: number,
@@ -532,7 +537,7 @@ class LndClient extends SwapClient {
     }
     if (all) {
       request.setSendAll(all);
-    } else {
+    } else if (amount) {
       request.setAmount(amount);
     }
     const withdrawResponse = await this.unaryCall<lndrpc.SendCoinsRequest, lndrpc.SendCoinsResponse>('sendCoins', request);
@@ -653,7 +658,7 @@ class LndClient extends SwapClient {
   /**
    * Gets a new address for the internal lnd wallet.
    */
-  public newAddress = async (addressType = lndrpc.AddressType.WITNESS_PUBKEY_HASH) => {
+  private newAddress = async (addressType = lndrpc.AddressType.WITNESS_PUBKEY_HASH) => {
     const request = new lndrpc.NewAddressRequest();
     request.setType(addressType);
     const newAddressResponse = await this.unaryCall<lndrpc.NewAddressRequest, lndrpc.NewAddressResponse>('newAddress', request);
@@ -739,14 +744,17 @@ class LndClient extends SwapClient {
    * Opens a channel given peerPubKey and amount.
    */
   public openChannel = async (
-    { peerIdentifier: peerPubKey, units, uris, pushUnits = 0 }:
-    { peerIdentifier: string, units: number, uris?: string[], pushUnits?: number },
+    { remoteIdentifier, units, uris, pushUnits = 0 }: OpenChannelParams,
   ): Promise<void> => {
+    if (!remoteIdentifier) {
+      // TODO: better handling for for unrecognized peers & force closing channels
+      throw new Error('peer not connected to swap client');
+    }
     if (uris) {
       await this.connectPeerAddresses(uris);
     }
 
-    await this.openChannelSync(peerPubKey, units, pushUnits);
+    await this.openChannelSync(remoteIdentifier, units, pushUnits);
   }
 
   /**
@@ -1025,13 +1033,32 @@ class LndClient extends SwapClient {
   }
 
   /**
-   * Attempts to close an open channel.
+   * Closes any payment channels with a specified node.
    */
-  public closeChannel = (fundingTxId: string, outputIndex: number, force: boolean): Promise<void> => {
+  public closeChannel = async ({ remoteIdentifier, force = false }: CloseChannelParams) => {
+    if (remoteIdentifier === undefined) {
+      throw swapErrors.REMOTE_IDENTIFIER_MISSING;
+    }
+    const channels = (await this.listChannels()).getChannelsList();
+    const closePromises: Promise<void>[] = [];
+    channels.forEach((channel) => {
+      if (channel.getRemotePubkey() === remoteIdentifier) {
+        const [fundingTxId, outputIndex] = channel.getChannelPoint().split(':');
+        const closePromise = this.closeChannelSync(fundingTxId, Number(outputIndex), force);
+        closePromises.push(closePromise);
+      }
+    });
+    await Promise.all(closePromises);
+  }
+
+  /** A synchronous helper method for the closeChannel call */
+  public closeChannelSync = (fundingTxId: string, outputIndex: number, force: boolean): Promise<void> => {
     return new Promise<void>((resolve, reject) => {
       if (!this.lightning) {
         throw(errors.UNAVAILABLE(this.currency, this.status));
       }
+
+      // TODO: set delivery_address parameter after upgrading to 0.10+ lnd API proto definition
       const request = new lndrpc.CloseChannelRequest();
       const channelPoint = new lndrpc.ChannelPoint();
       channelPoint.setFundingTxidStr(fundingTxId);