[FEATURE] Allow payments to same lightning node where the invoice was not issued by lndhub.io

.gitignore

@@ -2,23 +2,28 @@
 
 admin.macaroon
 tls.cert
+doc/devnotes.md
 build/
 logs/
 
 # dependencies
 /node_modules
 node_modules/
+
 # misc
+.env
 .env.local
 .env.development.local
 .env.test.local
 .env.production.local
 .idea/
 
+# Docker Dev
+docker-compose.yml
+
 npm-debug.log*
 yarn-debug.log*
 yarn-error.log*
 
-# OSX# OSX
-#
+# OSX
 .DS_Store

README.md

@@ -1,3 +1,67 @@
+Satoshi Engineering - Extensions
+======
+
+### [Feature] Allow self payment
+Reading the code it seems that LndHub was never supposed to run on a node with other applications on it, which leads to the problem:
+
+If you want to pay an invoice issued by the node, but not issued "via" LndHub it will be denied. To allow this add this to your config:
+```
+allowLightningPaymentToNode: true // it defaults to false
+```
+
+### [Feature] Support Dashboard
+
+![](doc/img/support_dashboard.png)
+
+If the Support Dashboard is not turned an, all routes (api and web) are turned off. To turn it on choose a sha265 password. To Create it
+
+```javascript
+const { createHash } = require('crypto')
+const password = 'gobrrr'
+const passwordSHA256 = createHash('sha256').update(password).digest('hex')
+console.info(passwordSHA256)
+```
+
+```
+supportDashboardPasswordHash: 'e42703b94ce32a831ea363a8924dc0239ca54160a8f3fb2755bdbceb07238a8a'
+// it defaults to '' which means it's turned completly off
+```
+
+### [Feature] Account Creation Mode
+
+By default everyone could open account on our node, what we can't have as a company (KYC), so we added an account creation mode.
+
+In config you can set the mode, when it starts & can be edited by the support dashboard
+```
+accountCreationMode: 'on', // 'on', 'off', 'once' ... defaults to 'on'
+```
+
+### [Feature] Generate Safety On Chain Address
+
+In combination with Thunderhub we noticed, that an onchain address assigned to a lndhub account
+had the same addess we got from Thunderhub's "Create On Chain Address" functiontionality. Thunderhub
+somehow is caching address, which is normally ok, but in this case not :( The issue is addressed [here](https://github.com/apotdevin/thunderhub/issues/534).
+
+This feature creates an additional address from LND after an onchain address is created and assigned to the user.
+
+```
+generateSafetyOnChainAddress: true, // defaults to false
+```
+
+### [Feature] Check account balance, bc1 address
+
+To make the support dashboard even more powerfull, it is possible to show a list of accounts and
+a detailed view of the accounts.
+
+If it's turned off, no account data is published to the dashboard & and the detail route is turned off!
+
+```
+supportDashboardShowAccounts: true, // defaults to false
+```
+
+![](doc/img/account_list.png)
+![](doc/img/account_detail.png)
+
 LndHub
 ======
 

class/User.js

@@ -119,6 +119,12 @@ export class User {
     return new Promise(function (resolve, reject) {
       self._lightning.newAddress({ type: 0 }, async function (err, response) {
         if (err) return reject('LND failure when trying to generate new address');
+
+        // Due Buggy other systems, check Feature description in readme
+        if (config.generateSafetyOnChainAddress) {
+          await self.generateSafetyAddress()
+        }
+
         const addressAlreadyExists = await self.getAddress();
         if (addressAlreadyExists) {
           // one last final check, for a case of really long race condition
@@ -132,6 +138,19 @@ export class User {
     });
   }
 
+  async generateSafetyAddress() {
+    let self = this;
+
+    return new Promise(function (resolve, reject) {
+      self._lightning.newAddress({ type: 0 }, async function (err, response) {
+        if (err) return reject('LND failure when trying to generate safety address');
+
+        if (config.bitcoind) self._bitcoindrpc.request('importaddress', [response.address, response.address, false]);
+        resolve();
+      });
+    });
+  }
+
   async watchAddress(address) {
     if (!address) return;
     if (config.bitcoind) return this._bitcoindrpc.request('importaddress', [address, address, false]);

config.js

@@ -4,6 +4,11 @@ let config = {
   rateLimit: 200,
   forwardReserveFee: 0.01, // default 0.01
   intraHubFee: 0.003, // default 0.003
+  allowLightningPaymentToNode: false,
+  supportDashboardPasswordHash: '',
+  supportDashboardShowAccounts: false,
+  accountCreationMode: 'on', // 'on', 'off', 'once' ... defaults to 'on'
+  generateSafetyOnChainAddress: false,
   bitcoind: {
     rpc: 'http://login:[email protected]:8332/wallet/wallet.dat',
   },
@@ -25,4 +30,12 @@ if (process.env.CONFIG) {
   config = JSON.parse(process.env.CONFIG);
 }
 
+// Config checks
+if (!(config.supportDashboardPasswordHash)) config.supportDashboardPasswordHash = ''
+if (typeof config.supportDashboardPasswordHash !== 'string') config.supportDashboardPasswordHash = ''
+if (!(config.supportDashboardShowAccounts)) config.supportDashboardShowAccounts = false
+
+if (!(config.accountCreationMode)) config.accountCreationMode = 'on'
+if (!(config.generateSafetyOnChainAddress)) config.generateSafetyOnChainAddress = false
+
 module.exports = config;

controllers/api.js

@@ -4,6 +4,8 @@ const config = require('../config');
 let express = require('express');
 let router = express.Router();
 let logger = require('../utils/logger');
+const shared = require('../utils/shared');
+
 const MIN_BTC_BLOCK = 670000;
 if (process.env.NODE_ENV !== 'prod') {
   console.log('using config', JSON.stringify(config));
@@ -17,6 +19,8 @@ redis.monitor(function (err, monitor) {
   });
 });
 
+shared.redis = redis
+
 /****** START SET FEES FROM CONFIG AT STARTUP ******/
 /** GLOBALS */
 global.forwardFee = config.forwardReserveFee || 0.01;
@@ -149,9 +153,14 @@ router.post('/create', postLimiter, async function (req, res) {
 
   if (config.sunset) return errorSunset(res);
 
+  if (config.accountCreationMode === 'off') return errorAccountCreationOff(res)
+
   let u = new User(redis, bitcoinclient, lightning);
   await u.create();
   await u.saveMetadata({ partnerid: req.body.partnerid, accounttype: req.body.accounttype, created_at: new Date().toISOString() });
+
+  if (config.accountCreationMode === 'once') config.accountCreationMode = 'off'
+
   res.send({ login: u.getLogin(), password: u.getPassword() });
 });
 
@@ -254,49 +263,58 @@ router.post('/payinvoice', postLimiter, async function (req, res) {
         // this is internal invoice
         // now, receiver add balance
         let userid_payee = await u.getUseridByPaymentHash(info.payment_hash);
+
+        // receiver is not a lndhub account
         if (!userid_payee) {
-          await lock.releaseLock();
-          return errorGeneralServerError(res);
-        }
+          // Check if Is payment to node allowed?
+          if (!config.allowLightningPaymentToNode || false) {
+            await lock.releaseLock();
+            return errorPaymentToNodeNotAllowed(res);
+          }
 
-        if (await u.getPaymentHashPaid(info.payment_hash)) {
-          // this internal invoice was paid, no sense paying it again
-          await lock.releaseLock();
-          return errorLnd(res);
-        }
+          // Continues at // else - regular lightning network payment:
 
-        let UserPayee = new User(redis, bitcoinclient, lightning);
-        UserPayee._userid = userid_payee; // hacky, fixme
-        await UserPayee.clearBalanceCache();
-
-        // sender spent his balance:
-        await u.clearBalanceCache();
-        await u.savePaidLndInvoice({
-          timestamp: parseInt(+new Date() / 1000),
-          type: 'paid_invoice',
-          value: +info.num_satoshis + Math.floor(info.num_satoshis * internalFee),
-          fee: Math.floor(info.num_satoshis * internalFee),
-          memo: decodeURIComponent(info.description),
-          pay_req: req.body.invoice,
-        });
-
-        const invoice = new Invo(redis, bitcoinclient, lightning);
-        invoice.setInvoice(req.body.invoice);
-        await invoice.markAsPaidInDatabase();
-
-        // now, faking LND callback about invoice paid:
-        const preimage = await invoice.getPreimage();
-        if (preimage) {
-          subscribeInvoicesCallCallback({
-            state: 'SETTLED',
-            memo: info.description,
-            r_preimage: Buffer.from(preimage, 'hex'),
-            r_hash: Buffer.from(info.payment_hash, 'hex'),
-            amt_paid_sat: +info.num_satoshis,
+          // receiver is a lndhub account
+        } else {
+          if (await u.getPaymentHashPaid(info.payment_hash)) {
+            // this internal invoice was paid, no sense paying it again
+            await lock.releaseLock();
+            return errorLnd(res);
+          }
+
+          let UserPayee = new User(redis, bitcoinclient, lightning);
+          UserPayee._userid = userid_payee; // hacky, fixme
+          await UserPayee.clearBalanceCache();
+
+          // sender spent his balance:
+          await u.clearBalanceCache();
+          await u.savePaidLndInvoice({
+            timestamp: parseInt(+new Date() / 1000),
+            type: 'paid_invoice',
+            value: +info.num_satoshis + Math.floor(info.num_satoshis * internalFee),
+            fee: Math.floor(info.num_satoshis * internalFee),
+            memo: decodeURIComponent(info.description),
+            pay_req: req.body.invoice,
           });
+
+          const invoice = new Invo(redis, bitcoinclient, lightning);
+          invoice.setInvoice(req.body.invoice);
+          await invoice.markAsPaidInDatabase();
+
+          // now, faking LND callback about invoice paid:
+          const preimage = await invoice.getPreimage();
+          if (preimage) {
+            subscribeInvoicesCallCallback({
+              state: 'SETTLED',
+              memo: info.description,
+              r_preimage: Buffer.from(preimage, 'hex'),
+              r_hash: Buffer.from(info.payment_hash, 'hex'),
+              amt_paid_sat: +info.num_satoshis,
+            });
+          }
+          await lock.releaseLock();
+          return res.send(info);
         }
-        await lock.releaseLock();
-        return res.send(info);
       }
 
       // else - regular lightning network payment:
@@ -305,6 +323,9 @@ router.post('/payinvoice', postLimiter, async function (req, res) {
       call.on('data', async function (payment) {
         // payment callback
         await u.unlockFunds(req.body.invoice);
+
+        if (payment && payment.payment_error) logger.error('/payinvoice', payment);
+
         if (payment && payment.payment_route && payment.payment_route.total_amt_msat) {
           let PaymentShallow = new Paym(false, false, false);
           payment = PaymentShallow.processSendPaymentResponse(payment);
@@ -329,6 +350,7 @@ router.post('/payinvoice', postLimiter, async function (req, res) {
         payment_request: req.body.invoice,
         amt: info.num_satoshis, // amt is used only for 'tip' invoices
         fee_limit: { fixed: Math.floor(info.num_satoshis * forwardFee) + 1 },
+        allow_self_payment: (config.allowLightningPaymentToNode || false),
       };
       try {
         await u.lockFunds(req.body.invoice, info);
@@ -398,6 +420,7 @@ router.get('/balance', postLimiter, async function (req, res) {
     res.send({ BTC: { AvailableBalance: balance } });
   } catch (Error) {
     logger.log('', [req.id, 'error getting balance:', Error, 'userid:', u.getUserId()]);
+    logger.error(Error)
     return errorGeneralServerError(res);
   }
 });
@@ -618,3 +641,19 @@ function errorSunsetAddInvoice(res) {
     message: 'This LNDHub instance is scheduled to shut down. Withdraw any remaining funds',
   });
 }
+
+function errorPaymentToNodeNotAllowed(res) {
+  return res.send({
+    error: true,
+    code: 12,
+    message: 'This LNDHub instance does not allow self payments other then issued by this LNDHub',
+  });
+}
+
+function errorAccountCreationOff(res) {
+  return res.send({
+    error: true,
+    code: 22,
+    message: 'This LNDHub instance has turned off it\'s account creation.',
+  });
+}