From 7d09c44809835c8253c96d39263b076f838c0d29 Mon Sep 17 00:00:00 2001
From: emad-salah <emads14@gmail.com>
Date: Sat, 3 Jul 2021 16:53:15 +0100
Subject: [PATCH 01/32] Added presence middleware to sockets

---
 services/gunDB/sockets/index.js | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/services/gunDB/sockets/index.js b/services/gunDB/sockets/index.js
index bdab8b56..a1427703 100644
--- a/services/gunDB/sockets/index.js
+++ b/services/gunDB/sockets/index.js
@@ -10,6 +10,7 @@ const { getGun, getUser, isAuthenticated } = require('../Mediator')
 const { deepDecryptIfNeeded } = require('../rpc')
 const Subscriptions = require('./subscriptions')
 const GunEvents = require('../contact-api/events')
+const GunActions = require('../../gunDB/contact-api/actions')
 const {
   encryptedEmit,
   encryptedOn,
@@ -243,6 +244,12 @@ const startSocket = socket => {
       socket.emit(Common.Constants.ErrorCode.NOT_AUTH)
     }
 
+    if (isAuthenticated()) {
+      socket.onAny(() => {
+        GunActions.setLastSeenApp()
+      })
+    }
+
     on('subscribe:query', ({ $shock, publicKey }, response) => {
       const subscriptionId = uuidv4()
       try {

From f4db94b2546e57cc365bfe8c0560f28dcb6d5456 Mon Sep 17 00:00:00 2001
From: Erfan Besharat <erbesharat@gmail.com>
Date: Mon, 12 Jul 2021 19:33:29 +0430
Subject: [PATCH 02/32] Add volumes to Docker README

---
 README.md | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index d4206e57..0df88fbc 100644
--- a/README.md
+++ b/README.md
@@ -57,14 +57,19 @@ yarn install
 To run ShockAPI in a fully isolated environment you can use the Docker image
 provided on the Docker Hub and easily interact with API's CLI interface and flags.
 
+#### Prerequisites
+To interact with ShockAPI's Docker image you need an instance of LND running and
+also if your configs, LND related files and certificates are located on a local file system you'll need to mount **Docker Volumes** pointed to them while starting the container.
+
 Example of listing available configuration flags:
 ```
 docker run --rm shockwallet/api:latest --help
 ```
-Example of running an local instance:
+Example of running an local instance with mounted volumes:
 ```
-docker run shockwallet/api:latest -h 0.0.0.0 -c
+docker run -v /home/$USER/.lnd:/root/.lnd --network host shockwallet/api:latest
 ```
+
 <!---
 ### Docker for Raspberry Pi
 

From d4fcadfcb7e492578afe1f2bed6d3065a6971a03 Mon Sep 17 00:00:00 2001
From: Daniel Lugo <danlugo92@gmail.com>
Date: Tue, 13 Jul 2021 13:05:47 -0400
Subject: [PATCH 03/32] Deployment type env var example

---
 .env.example | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.env.example b/.env.example
index f5199e6b..710cb02f 100644
--- a/.env.example
+++ b/.env.example
@@ -16,3 +16,5 @@ LOCAL_TUNNEL_SERVER=https://tunnel.rip
 TORRENT_SEED_URL=https://webtorrent.shock.network
 # Admin token for your own seed server
 TORRENT_SEED_TOKEN=jibberish
+# "default" or "hosting"
+DEPLOYMENT_TYPE=hosting
\ No newline at end of file

From de4683605c59257301def804fd462ece7c9066d1 Mon Sep 17 00:00:00 2001
From: hatim boufnichel <boufni95@gmail.com>
Date: Wed, 14 Jul 2021 21:15:28 +0200
Subject: [PATCH 04/32] fix channels call

---
 utils/lightningServices/channelRequests.js | 34 ++++++++++------------
 1 file changed, 15 insertions(+), 19 deletions(-)

diff --git a/utils/lightningServices/channelRequests.js b/utils/lightningServices/channelRequests.js
index 4598193f..18d3ae1e 100644
--- a/utils/lightningServices/channelRequests.js
+++ b/utils/lightningServices/channelRequests.js
@@ -5,28 +5,19 @@ const { listPeers, connectPeer,getInfo } = require('./v2')
 
 const handlerBaseUrl = "https://channels.shock.network:4444"
 
-/**
- * 
- * @param {string} inviteFromAuth
- */
-module.exports = async (inviteFromAuth) => {
+module.exports = async () => {
   /**
    * @type string | undefined
    */
-  const invite = inviteFromAuth || process.env.HOSTING_INVITE
+  const invite = process.env.HOSTING_INVITE
   if(!invite) {
     return
   }
-  try{
-    await Storage.getItem('processedInvites')
-  } catch(e) {
-    await Storage.setItem('processedInvites',[])
-  }
   try {
     /**
      * @type string[]
      */
-    const invites = await Storage.getItem('processedInvites')
+    const invites = await Storage.getItem('processedInvites') || []
     if(invites.includes(invite)){
       return
     }
@@ -46,17 +37,22 @@ module.exports = async (inviteFromAuth) => {
     if(peers.findIndex(peer => peer.pub_key === pub) === -1){
       await connectPeer(pub,host)
     }
-
+    const channelReq = {
+      userPubKey:identity_pubkey,
+      invite,
+      lndTo:pub,
+    }
     //@ts-expect-error
     const res = await fetch(`${handlerBaseUrl}/channel`,{
       method:'POST',
-      body:JSON.stringify({
-        userPubKey:identity_pubkey,
-        invite,
-        lndTo:pub,
-      })
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      body:JSON.stringify(channelReq)
     })
-
+    if(res.status !== 200 ){
+      return
+    }
     invites.push(invite)
     await Storage.setItem('processedInvites',invites)
 

From 2fee9974b5518fe5dbac07c92cc542c36b3ad873 Mon Sep 17 00:00:00 2001
From: Version Update Action <actions@shock.network>
Date: Wed, 14 Jul 2021 19:31:00 +0000
Subject: [PATCH 05/32] version upgraded to 21.7.14

---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 319298df..74e68834 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "shockapi",
-  "version": "2021.07.10",
+  "version": "21.7.14",
   "description": "",
   "main": "src/server.js",
   "scripts": {

From 8b7ad32d77f361f5c53f246753688bd3e57526ec Mon Sep 17 00:00:00 2001
From: hatim boufnichel <boufni95@gmail.com>
Date: Thu, 15 Jul 2021 20:43:22 +0200
Subject: [PATCH 06/32] logs

---
 utils/lightningServices/channelRequests.js | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/utils/lightningServices/channelRequests.js b/utils/lightningServices/channelRequests.js
index 18d3ae1e..0d54c521 100644
--- a/utils/lightningServices/channelRequests.js
+++ b/utils/lightningServices/channelRequests.js
@@ -6,11 +6,13 @@ const { listPeers, connectPeer,getInfo } = require('./v2')
 const handlerBaseUrl = "https://channels.shock.network:4444"
 
 module.exports = async () => {
+  console.log("DOING CHANNEL INVITE THING: START")
   /**
    * @type string | undefined
    */
   const invite = process.env.HOSTING_INVITE
   if(!invite) {
+    console.log("DOING CHANNEL INVITE THING: NVM NO INVITE")
     return
   }
   try {
@@ -19,17 +21,17 @@ module.exports = async () => {
      */
     const invites = await Storage.getItem('processedInvites') || []
     if(invites.includes(invite)){
+      console.log("DOING CHANNEL INVITE THING: INVITE PROCESSED ALREADY")
       return
     }
-
     const me = await getInfo()
     const {identity_pubkey} = me
     //@ts-expect-error
     const connectReq = await fetch(`${handlerBaseUrl}/connect`)
     if(connectReq.status !== 200 ){
+      console.log("DOING CHANNEL INVITE THING: CONNECT FAILED")
       return
     }
-
     const connJson = await connectReq.json()
     const [uri] = connJson.uris
     const [pub,host] = uri.split("@")
@@ -51,13 +53,15 @@ module.exports = async () => {
       body:JSON.stringify(channelReq)
     })
     if(res.status !== 200 ){
+      console.log("DOING CHANNEL INVITE THING: FAILED ")
       return
     }
     invites.push(invite)
     await Storage.setItem('processedInvites',invites)
-
+    console.log("DOING CHANNEL INVITE THING: DONE!")
   } catch(e){
     logger.error("error sending invite to channels handler")
+    console.log("DOING CHANNEL INVITE THING: :(")
     console.error(e)
   }
 

From f094bd3350798854513a197568485be29941075d Mon Sep 17 00:00:00 2001
From: Version Update Action <actions@shock.network>
Date: Thu, 15 Jul 2021 18:50:02 +0000
Subject: [PATCH 07/32] version upgraded to 21.7.15

---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 74e68834..9c4d6f6c 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "shockapi",
-  "version": "21.7.14",
+  "version": "21.7.15",
   "description": "",
   "main": "src/server.js",
   "scripts": {

From e45c8e18ff16830112d2ff49e1dc08779b7f54a0 Mon Sep 17 00:00:00 2001
From: hatim boufnichel <boufni95@gmail.com>
Date: Thu, 15 Jul 2021 22:18:27 +0200
Subject: [PATCH 08/32] wait before channel req

---
 src/routes.js | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/src/routes.js b/src/routes.js
index 77696517..e515804d 100644
--- a/src/routes.js
+++ b/src/routes.js
@@ -806,7 +806,9 @@ module.exports = async (
 
         onNewChannelBackup()
 
-        channelRequest(invite)
+        setTimeout(() => {
+          channelRequest(invite)
+        }, 30 * 1000)
         res.json({
           authorization: token,
           user: {
@@ -967,7 +969,9 @@ module.exports = async (
                       await LightningServices.init()
 
                       const token = await auth.generateToken()
-                      channelRequest(invite)
+                      setTimeout(() => {
+                        channelRequest(invite)
+                      }, 30 * 1000)
                       return res.json({
                         mnemonicPhrase,
                         authorization: token,
@@ -1072,7 +1076,9 @@ module.exports = async (
 
       // Generate Access Token
       const token = await auth.generateToken()
-      channelRequest(invite)
+      setTimeout(() => {
+        channelRequest(invite)
+      }, 30 * 1000)
       res.json({
         authorization: token,
         user: {

From fd0cf24c2eafd71762f0f21ee6b8c1fb4e2d1810 Mon Sep 17 00:00:00 2001
From: Version Update Action <actions@shock.network>
Date: Thu, 15 Jul 2021 20:25:15 +0000
Subject: [PATCH 09/32] version upgraded to 2021.7.15-1

---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 9c4d6f6c..36b51589 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "shockapi",
-  "version": "21.7.15",
+  "version": "2021.7.15-1",
   "description": "",
   "main": "src/server.js",
   "scripts": {

From 27144ddadea3b064457222aa5b177cbb02417671 Mon Sep 17 00:00:00 2001
From: emad-salah <emads14@gmail.com>
Date: Sun, 18 Jul 2021 14:18:38 +0100
Subject: [PATCH 10/32] Added try/catch to async code to prevent unhandled
 rejections

---
 src/routes.js | 6162 +++++++++++++++++++++++++------------------------
 1 file changed, 3105 insertions(+), 3057 deletions(-)

diff --git a/src/routes.js b/src/routes.js
index e515804d..d0b3525c 100644
--- a/src/routes.js
+++ b/src/routes.js
@@ -49,763 +49,1034 @@ module.exports = async (
   mySocketsEvents,
   { serverPort, CA, CA_KEY, usetls }
 ) => {
-  const { timeout5 } = require('../services/gunDB/contact-api/utils')
+  try {
+    const { timeout5 } = require('../services/gunDB/contact-api/utils')
 
-  const Http = Axios.create({
-    httpsAgent: new httpsAgent.Agent({
-      ca: await FS.readFile(CA)
+    const Http = Axios.create({
+      httpsAgent: new httpsAgent.Agent({
+        ca: await FS.readFile(CA)
+      })
     })
-  })
 
-  const sanitizeLNDError = (message = '') => {
-    if (message.toLowerCase().includes('unknown')) {
-      const splittedMessage = message.split('UNKNOWN: ')
-      return splittedMessage.length > 1
-        ? splittedMessage.slice(1).join('')
-        : splittedMessage.join('')
+    const sanitizeLNDError = (message = '') => {
+      if (message.toLowerCase().includes('unknown')) {
+        const splittedMessage = message.split('UNKNOWN: ')
+        return splittedMessage.length > 1
+          ? splittedMessage.slice(1).join('')
+          : splittedMessage.join('')
+      }
+
+      return message
     }
 
-    return message
-  }
-
-  const getAvailableService = () => {
-    return lndErrorManager.getAvailableService()
-  }
-
-  const checkHealth = async () => {
-    logger.info('Getting service status...')
-    let LNDStatus = {}
-    try {
-      const serviceStatus = await getAvailableService()
-      logger.info('Received status:', serviceStatus)
-      LNDStatus = serviceStatus
-    } catch (e) {
-      LNDStatus = {
-        message: e.message,
-        success: false
-      }
+    const getAvailableService = () => {
+      return lndErrorManager.getAvailableService()
     }
 
-    try {
-      logger.info('Getting API status...')
-      const APIHealth = await Http.get(
-        `${usetls ? 'https' : 'http'}://localhost:${serverPort}/ping`
-      )
-      const APIStatus = {
-        message: APIHealth.data,
-        responseTime: APIHealth.headers['x-response-time'],
-        success: true
-      }
-      logger.info('Received API status!', APIStatus)
-      return {
-        LNDStatus,
-        APIStatus,
-        deploymentType: process.env.DEPLOYMENT_TYPE || 'default'
-      }
-    } catch (err) {
-      logger.error(err)
-      const APIStatus = {
-        message: err.response.data,
-        responseTime: err.response.headers['x-response-time'],
-        success: false
-      }
-      logger.warn('Failed to retrieve API status', APIStatus)
-      return {
-        LNDStatus,
-        APIStatus,
-        deploymentType: process.env.DEPLOYMENT_TYPE || 'default'
-      }
-    }
-  }
-
-  const handleError = async (res, err) => {
-    const health = await checkHealth()
-    if (health.LNDStatus.success) {
-      if (err) {
-        res.json({
-          errorMessage: sanitizeLNDError(err.message)
-        })
-      } else {
-        res.sendStatus(403)
-      }
-    } else {
-      res.status(500)
-      res.json({ errorMessage: 'LND is down' })
-    }
-  }
-
-  const recreateLnServices = async () => {
-    await LightningServices.init()
-
-    return true
-  }
-
-  const lastSeenMiddleware = (req, res, next) => {
-    const { authorization } = req.headers
-    const { path, method } = req
-    if (
-      !unprotectedRoutes[method][path] &&
-      authorization &&
-      GunDB.isAuthenticated()
-    ) {
-      GunActions.setLastSeenApp()
-    }
-
-    next()
-  }
-
-  const unlockWallet = password =>
-    new Promise((resolve, reject) => {
+    const checkHealth = async () => {
+      logger.info('Getting service status...')
+      let LNDStatus = {}
       try {
-        const args = {
-          wallet_password: Buffer.from(password, 'utf-8')
+        const serviceStatus = await getAvailableService()
+        logger.info('Received status:', serviceStatus)
+        LNDStatus = serviceStatus
+      } catch (e) {
+        LNDStatus = {
+          message: e.message,
+          success: false
         }
-        const { walletUnlocker } = LightningServices.services
-        walletUnlocker.unlockWallet(args, (unlockErr, unlockResponse) => {
-          if (unlockErr) {
-            reject(unlockErr)
+      }
+
+      try {
+        logger.info('Getting API status...')
+        const APIHealth = await Http.get(
+          `${usetls ? 'https' : 'http'}://localhost:${serverPort}/ping`
+        )
+        const APIStatus = {
+          message: APIHealth.data,
+          responseTime: APIHealth.headers['x-response-time'],
+          success: true
+        }
+        logger.info('Received API status!', APIStatus)
+        return {
+          LNDStatus,
+          APIStatus,
+          deploymentType: process.env.DEPLOYMENT_TYPE || 'default'
+        }
+      } catch (err) {
+        logger.error(err)
+        const APIStatus = {
+          message: err.response.data,
+          responseTime: err.response.headers['x-response-time'],
+          success: false
+        }
+        logger.warn('Failed to retrieve API status', APIStatus)
+        return {
+          LNDStatus,
+          APIStatus,
+          deploymentType: process.env.DEPLOYMENT_TYPE || 'default'
+        }
+      }
+    }
+
+    const handleError = async (res, err) => {
+      const health = await checkHealth()
+      if (health.LNDStatus.success) {
+        if (err) {
+          res.json({
+            errorMessage: sanitizeLNDError(err.message)
+          })
+        } else {
+          res.sendStatus(403)
+        }
+      } else {
+        res.status(500)
+        res.json({ errorMessage: 'LND is down' })
+      }
+    }
+
+    const recreateLnServices = async () => {
+      await LightningServices.init()
+
+      return true
+    }
+
+    const lastSeenMiddleware = (req, res, next) => {
+      const { authorization } = req.headers
+      const { path, method } = req
+      if (
+        !unprotectedRoutes[method][path] &&
+        authorization &&
+        GunDB.isAuthenticated()
+      ) {
+        GunActions.setLastSeenApp()
+      }
+
+      next()
+    }
+
+    const unlockWallet = password =>
+      new Promise((resolve, reject) => {
+        try {
+          const args = {
+            wallet_password: Buffer.from(password, 'utf-8')
+          }
+          const { walletUnlocker } = LightningServices.services
+          walletUnlocker.unlockWallet(args, (unlockErr, unlockResponse) => {
+            if (unlockErr) {
+              reject(unlockErr)
+              return
+            }
+
+            resolve(unlockResponse)
+          })
+        } catch (err) {
+          if (err.message === 'unknown service lnrpc.WalletUnlocker') {
+            resolve({
+              field: 'walletUnlocker',
+              message: 'Wallet already unlocked'
+            })
             return
           }
 
-          resolve(unlockResponse)
-        })
-      } catch (err) {
-        if (err.message === 'unknown service lnrpc.WalletUnlocker') {
-          resolve({
-            field: 'walletUnlocker',
-            message: 'Wallet already unlocked'
+          logger.error('Unlock Error:', err)
+
+          reject({
+            field: 'wallet',
+            code: err.code,
+            message: sanitizeLNDError(err.message)
           })
+        }
+      })
+
+    // Hack to check whether or not a wallet exists
+    const walletExists = async () => {
+      try {
+        const availableService = await getAvailableService()
+        if (availableService.service === 'lightning') {
+          return true
+        }
+
+        if (availableService.service === 'walletUnlocker') {
+          const randomPassword = Crypto.randomBytes(4).toString('hex')
+          try {
+            await unlockWallet(randomPassword)
+            return true
+          } catch (err) {
+            if (err.message.indexOf('invalid passphrase') > -1) {
+              return true
+            }
+            return false
+          }
+        }
+      } catch (err) {
+        logger.error('LND error:', err)
+        return false
+      }
+    }
+
+    app.use((req, res, next) => {
+      res.setHeader('x-session-id', SESSION_ID)
+      next()
+    })
+
+    app.use((req, res, next) => {
+      const legacyDeviceId = req.headers['x-shockwallet-device-id']
+      const deviceId = req.headers['encryption-device-id']
+      logger.debug('Decrypting route...')
+      try {
+        if (
+          nonEncryptedRoutes.includes(req.path) ||
+          process.env.DISABLE_SHOCK_ENCRYPTION === 'true' ||
+          (deviceId && !legacyDeviceId)
+        ) {
+          return next()
+        }
+
+        if (!legacyDeviceId) {
+          const error = {
+            field: 'deviceId',
+            message: 'Please specify a device ID'
+          }
+          logger.error('Please specify a device ID')
+          return res.status(401).json(error)
+        }
+
+        if (!Encryption.isAuthorizedDevice({ deviceId: legacyDeviceId })) {
+          const error = {
+            field: 'deviceId',
+            message: 'Please specify a device ID'
+          }
+          logger.error('Unknown Device')
+          return res.status(401).json(error)
+        }
+        if (
+          !req.body.encryptionKey &&
+          !req.body.iv &&
+          !req.headers['x-shock-encryption-token']
+        ) {
+          return next()
+        }
+        let reqData = null
+        let IV = null
+        let encryptedKey = null
+        let encryptedToken = null
+        if (req.method === 'GET' || req.method === 'DELETE') {
+          if (req.headers['x-shock-encryption-token']) {
+            encryptedToken = req.headers['x-shock-encryption-token']
+            encryptedKey = req.headers['x-shock-encryption-key']
+            IV = req.headers['x-shock-encryption-iv']
+          }
+        } else {
+          encryptedToken = req.body.token
+          encryptedKey = req.body.encryptionKey || req.body.encryptedKey
+          IV = req.body.iv
+          reqData = req.body.data || req.body.encryptedData
+        }
+        const decryptedKey = Encryption.decryptKey({
+          deviceId: legacyDeviceId,
+          message: encryptedKey
+        })
+        if (reqData) {
+          const decryptedMessage = Encryption.decryptMessage({
+            message: reqData,
+            key: decryptedKey,
+            iv: IV
+          })
+          req.body = JSON.parse(decryptedMessage)
+        }
+
+        const decryptedToken = encryptedToken
+          ? Encryption.decryptMessage({
+              message: encryptedToken,
+              key: decryptedKey,
+              iv: IV
+            })
+          : null
+
+        if (decryptedToken) {
+          req.headers.authorization = decryptedToken
+        }
+
+        return next()
+      } catch (err) {
+        logger.error(err)
+        return res.status(401).json(err)
+      }
+    })
+
+    app.use(async (req, res, next) => {
+      const legacyDeviceId = req.headers['x-shockwallet-device-id']
+      const deviceId = req.headers['encryption-device-id']
+      logger.info('Decrypting route...')
+      try {
+        if (
+          nonEncryptedRoutes.includes(req.path) ||
+          process.env.DISABLE_SHOCK_ENCRYPTION === 'true' ||
+          (legacyDeviceId && !deviceId)
+        ) {
+          logger.info(
+            'Unprotected route detected! ' +
+              req.path +
+              ' Legacy ID:' +
+              legacyDeviceId +
+              ' Device ID:' +
+              deviceId
+          )
+          return next()
+        }
+
+        if (!deviceId) {
+          const error = {
+            field: 'deviceId',
+            message: 'Please specify a device ID'
+          }
+          logger.error('Please specify a device ID')
+          return res.status(401).json(error)
+        }
+
+        if (!ECC.isAuthorizedDevice({ deviceId })) {
+          const error = {
+            field: 'deviceId',
+            message: 'Please specify a device ID'
+          }
+          logger.error('Unknown Device')
+          return res.status(401).json(error)
+        }
+
+        if (req.method === 'GET' || req.method === 'DELETE') {
+          return next()
+        }
+
+        if (!ECC.isEncryptedMessage(req.body)) {
+          logger.warn('Message not encrypted!', req.body)
+          return next()
+        }
+
+        logger.info('Decrypting ECC message...')
+
+        const decryptedMessage = await ECC.decryptMessage({
+          deviceId,
+          encryptedMessage: req.body
+        })
+
+        // eslint-disable-next-line
+        req.body = JSON.parse(decryptedMessage)
+
+        return next()
+      } catch (err) {
+        logger.error(err)
+        return res.status(401).json(err)
+      }
+    })
+
+    app.use(async (req, res, next) => {
+      logger.info(`Route: ${req.path}`)
+      if (unprotectedRoutes[req.method][req.path]) {
+        next()
+      } else {
+        try {
+          const response = await auth.validateToken(
+            req.headers.authorization.replace('Bearer ', '')
+          )
+          if (response.valid) {
+            next()
+          } else {
+            res.status(401).json({
+              field: 'authorization',
+              errorMessage: "The authorization token you've supplied is invalid"
+            })
+          }
+        } catch (err) {
+          logger.error(
+            !req.headers.authorization
+              ? 'Please add an Authorization header'
+              : err
+          )
+          res
+            .status(401)
+            .json({ field: 'authorization', errorMessage: 'Please log in' })
+        }
+      }
+    })
+
+    app.use(async (req, res, next) => {
+      try {
+        if (unprotectedRoutes[req.method][req.path]) {
+          next()
           return
         }
 
-        logger.error('Unlock Error:', err)
+        if (req.path.includes('/api/lnd')) {
+          const walletStatus = await walletExists()
+          const availableService = await getAvailableService()
+          const statusMessage = availableService.walletStatus
+          if (availableService.code === 12) {
+            return res.status(401).json({
+              field: 'lnd_locked',
+              errorMessage: availableService.message
+                ? availableService.message
+                : 'unknown'
+            })
+          }
+          if (availableService.code === 14) {
+            return res.status(401).json({
+              field: 'lnd_dead',
+              errorMessage: availableService.message
+                ? availableService.message
+                : 'unknown'
+            })
+          }
+          if (walletStatus) {
+            if (statusMessage === 'unlocked') {
+              return next()
+            }
+            return res.status(401).json({
+              field: 'wallet',
+              errorMessage: availableService.message
+                ? availableService.message
+                : 'unknown'
+            })
+          }
 
-        reject({
+          return res.status(401).json({
+            field: 'wallet',
+            errorMessage: 'Please create a wallet before using the API'
+          })
+        }
+
+        if (req.path.includes('/api/gun')) {
+          const authenticated = GunDB.isAuthenticated()
+
+          if (!authenticated) {
+            return res.status(401).json({
+              field: 'gun',
+              errorMessage: 'Please login in order to perform this action'
+            })
+          }
+        }
+        next()
+      } catch (err) {
+        logger.error(err)
+        if (err.code === 12) {
+          return res.status(401).json({
+            field: 'lnd_locked',
+            errorMessage: err.message ? err.message : 'unknown'
+          })
+        }
+        if (err.code === 14) {
+          return res.status(401).json({
+            field: 'lnd_dead',
+            errorMessage: err.message ? err.message : 'unknown'
+          })
+        }
+        res.status(500).json({
           field: 'wallet',
-          code: err.code,
-          message: sanitizeLNDError(err.message)
+          errorMessage: err.message ? err.message : err
         })
       }
     })
 
-  // Hack to check whether or not a wallet exists
-  const walletExists = async () => {
-    try {
-      const availableService = await getAvailableService()
-      if (availableService.service === 'lightning') {
-        return true
-      }
+    app.use(lastSeenMiddleware)
 
-      if (availableService.service === 'walletUnlocker') {
-        const randomPassword = Crypto.randomBytes(4).toString('hex')
-        try {
-          await unlockWallet(randomPassword)
-          return true
-        } catch (err) {
-          if (err.message.indexOf('invalid passphrase') > -1) {
-            return true
-          }
-          return false
-        }
-      }
-    } catch (err) {
-      logger.error('LND error:', err)
-      return false
-    }
-  }
+    app.use(['/ping'], responseTime())
 
-  app.use((req, res, next) => {
-    res.setHeader('x-session-id', SESSION_ID)
-    next()
-  })
-
-  app.use((req, res, next) => {
-    const legacyDeviceId = req.headers['x-shockwallet-device-id']
-    const deviceId = req.headers['encryption-device-id']
-    logger.debug('Decrypting route...')
-    try {
-      if (
-        nonEncryptedRoutes.includes(req.path) ||
-        process.env.DISABLE_SHOCK_ENCRYPTION === 'true' ||
-        (deviceId && !legacyDeviceId)
-      ) {
-        return next()
-      }
-
-      if (!legacyDeviceId) {
-        const error = {
-          field: 'deviceId',
-          message: 'Please specify a device ID'
-        }
-        logger.error('Please specify a device ID')
-        return res.status(401).json(error)
-      }
-
-      if (!Encryption.isAuthorizedDevice({ deviceId: legacyDeviceId })) {
-        const error = {
-          field: 'deviceId',
-          message: 'Please specify a device ID'
-        }
-        logger.error('Unknown Device')
-        return res.status(401).json(error)
-      }
-      if (
-        !req.body.encryptionKey &&
-        !req.body.iv &&
-        !req.headers['x-shock-encryption-token']
-      ) {
-        return next()
-      }
-      let reqData = null
-      let IV = null
-      let encryptedKey = null
-      let encryptedToken = null
-      if (req.method === 'GET' || req.method === 'DELETE') {
-        if (req.headers['x-shock-encryption-token']) {
-          encryptedToken = req.headers['x-shock-encryption-token']
-          encryptedKey = req.headers['x-shock-encryption-key']
-          IV = req.headers['x-shock-encryption-iv']
-        }
-      } else {
-        encryptedToken = req.body.token
-        encryptedKey = req.body.encryptionKey || req.body.encryptedKey
-        IV = req.body.iv
-        reqData = req.body.data || req.body.encryptedData
-      }
-      const decryptedKey = Encryption.decryptKey({
-        deviceId: legacyDeviceId,
-        message: encryptedKey
-      })
-      if (reqData) {
-        const decryptedMessage = Encryption.decryptMessage({
-          message: reqData,
-          key: decryptedKey,
-          iv: IV
-        })
-        req.body = JSON.parse(decryptedMessage)
-      }
-
-      const decryptedToken = encryptedToken
-        ? Encryption.decryptMessage({
-            message: encryptedToken,
-            key: decryptedKey,
-            iv: IV
-          })
-        : null
-
-      if (decryptedToken) {
-        req.headers.authorization = decryptedToken
-      }
-
-      return next()
-    } catch (err) {
-      logger.error(err)
-      return res.status(401).json(err)
-    }
-  })
-
-  app.use(async (req, res, next) => {
-    const legacyDeviceId = req.headers['x-shockwallet-device-id']
-    const deviceId = req.headers['encryption-device-id']
-    logger.info('Decrypting route...')
-    try {
-      if (
-        nonEncryptedRoutes.includes(req.path) ||
-        process.env.DISABLE_SHOCK_ENCRYPTION === 'true' ||
-        (legacyDeviceId && !deviceId)
-      ) {
-        logger.info(
-          'Unprotected route detected! ' +
-            req.path +
-            ' Legacy ID:' +
-            legacyDeviceId +
-            ' Device ID:' +
-            deviceId
-        )
-        return next()
-      }
-
-      if (!deviceId) {
-        const error = {
-          field: 'deviceId',
-          message: 'Please specify a device ID'
-        }
-        logger.error('Please specify a device ID')
-        return res.status(401).json(error)
-      }
-
-      if (!ECC.isAuthorizedDevice({ deviceId })) {
-        const error = {
-          field: 'deviceId',
-          message: 'Please specify a device ID'
-        }
-        logger.error('Unknown Device')
-        return res.status(401).json(error)
-      }
-
-      if (req.method === 'GET' || req.method === 'DELETE') {
-        return next()
-      }
-
-      if (!ECC.isEncryptedMessage(req.body)) {
-        logger.warn('Message not encrypted!', req.body)
-        return next()
-      }
-
-      logger.info('Decrypting ECC message...')
-
-      const decryptedMessage = await ECC.decryptMessage({
-        deviceId,
-        encryptedMessage: req.body
-      })
-
-      // eslint-disable-next-line
-      req.body = JSON.parse(decryptedMessage)
-
-      return next()
-    } catch (err) {
-      logger.error(err)
-      return res.status(401).json(err)
-    }
-  })
-
-  app.use(async (req, res, next) => {
-    logger.info(`Route: ${req.path}`)
-    if (unprotectedRoutes[req.method][req.path]) {
-      next()
-    } else {
-      try {
-        const response = await auth.validateToken(
-          req.headers.authorization.replace('Bearer ', '')
-        )
-        if (response.valid) {
-          next()
-        } else {
-          res.status(401).json({
-            field: 'authorization',
-            errorMessage: "The authorization token you've supplied is invalid"
-          })
-        }
-      } catch (err) {
-        logger.error(
-          !req.headers.authorization
-            ? 'Please add an Authorization header'
-            : err
-        )
-        res
-          .status(401)
-          .json({ field: 'authorization', errorMessage: 'Please log in' })
-      }
-    }
-  })
-
-  app.use(async (req, res, next) => {
-    try {
-      if (unprotectedRoutes[req.method][req.path]) {
-        next()
-        return
-      }
-
-      if (req.path.includes('/api/lnd')) {
-        const walletStatus = await walletExists()
-        const availableService = await getAvailableService()
-        const statusMessage = availableService.walletStatus
-        if (availableService.code === 12) {
-          return res.status(401).json({
-            field: 'lnd_locked',
-            errorMessage: availableService.message
-              ? availableService.message
-              : 'unknown'
-          })
-        }
-        if (availableService.code === 14) {
-          return res.status(401).json({
-            field: 'lnd_dead',
-            errorMessage: availableService.message
-              ? availableService.message
-              : 'unknown'
-          })
-        }
-        if (walletStatus) {
-          if (statusMessage === 'unlocked') {
-            return next()
-          }
-          return res.status(401).json({
-            field: 'wallet',
-            errorMessage: availableService.message
-              ? availableService.message
-              : 'unknown'
-          })
-        }
-
-        return res.status(401).json({
-          field: 'wallet',
-          errorMessage: 'Please create a wallet before using the API'
-        })
-      }
-
-      if (req.path.includes('/api/gun')) {
-        const authenticated = GunDB.isAuthenticated()
-
-        if (!authenticated) {
-          return res.status(401).json({
-            field: 'gun',
-            errorMessage: 'Please login in order to perform this action'
-          })
-        }
-      }
-      next()
-    } catch (err) {
-      logger.error(err)
-      if (err.code === 12) {
-        return res.status(401).json({
-          field: 'lnd_locked',
-          errorMessage: err.message ? err.message : 'unknown'
-        })
-      }
-      if (err.code === 14) {
-        return res.status(401).json({
-          field: 'lnd_dead',
-          errorMessage: err.message ? err.message : 'unknown'
-        })
-      }
-      res.status(500).json({
-        field: 'wallet',
-        errorMessage: err.message ? err.message : err
-      })
-    }
-  })
-
-  app.use(lastSeenMiddleware)
-
-  app.use(['/ping'], responseTime())
-
-  /**
-   * health check
-   */
-  app.get('/health', async (req, res) => {
-    const health = await checkHealth()
-    res.json(health)
-  })
-
-  app.get('/tunnel/status', async (req, res) => {
-    const [relayId, relayUrl] = await Promise.all([
-      Storage.getItem('relay/id'),
-      Storage.getItem('relay/url')
-    ])
-    res.json({ uri: `${relayId}@${relayUrl}` })
-  })
-
-  /**
-   * kubernetes health check
-   */
-  app.get('/healthz', async (req, res) => {
-    const health = await checkHealth()
-    logger.info('Healthz response:', health)
-    res.json(health)
-  })
-
-  app.get('/ping', (req, res) => {
-    logger.info('Ping completed!')
-    res.json({ message: 'OK' })
-  })
-
-  app.post('/api/mobile/error', (req, res) => {
-    logger.debug('Mobile error:', JSON.stringify(req.body))
-    res.json({ msg: 'OK' })
-  })
-
-  app.post('/api/security/exchangeKeys', async (req, res) => {
-    try {
-      const { publicKey, deviceId } = req.body
-
-      if (!publicKey) {
-        return res.status(400).json({
-          field: 'publicKey',
-          message: 'Please provide a valid public key'
-        })
-      }
-
-      if (
-        !deviceId ||
-        !/^[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/iu.test(
-          deviceId
-        )
-      ) {
-        return res.status(400).json({
-          field: 'deviceId',
-          message: 'Please provide a valid device ID'
-        })
-      }
-
-      const authorizedDevice = await Encryption.authorizeDevice({
-        deviceId,
-        publicKey
-      })
-      logger.info(authorizedDevice)
-      return res.json(authorizedDevice)
-    } catch (err) {
-      logger.error(err)
-      return res.status(401).json({
-        field: 'unknown',
-        message: err
-      })
-    }
-  })
-
-  app.post('/api/encryption/exchange', async (req, res) => {
-    try {
-      const { publicKey, deviceId } = req.body
-
-      if (!publicKey) {
-        return res.status(400).json({
-          field: 'publicKey',
-          message: 'Please provide a valid public key'
-        })
-      }
-
-      if (
-        !deviceId ||
-        !/^[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/iu.test(
-          deviceId
-        )
-      ) {
-        return res.status(400).json({
-          field: 'deviceId',
-          message: 'Please provide a valid device ID'
-        })
-      }
-
-      const authorizedDevice = await ECC.authorizeDevice({
-        deviceId,
-        publicKey
-      })
-      return res.json(authorizedDevice)
-    } catch (err) {
-      logger.error(err)
-      return res.status(401).json({
-        field: 'unknown',
-        message: err
-      })
-    }
-  })
-
-  app.get('/api/lnd/wallet/status', async (req, res) => {
-    try {
-      const walletStatus = await walletExists()
-      const availableService = await getAvailableService()
-
-      res.json({
-        walletExists: walletStatus,
-        walletStatus: walletStatus ? availableService.walletStatus : null
-      })
-    } catch (err) {
-      logger.error(err)
-      const sanitizedMessage = sanitizeLNDError(err.message)
-      res.status(500).json({
-        field: 'LND',
-        errorMessage: sanitizedMessage
-          ? sanitizedMessage
-          : 'An unknown error has occurred, please try restarting your LND and API servers'
-      })
-    }
-  })
-
-  const validateToken = async token => {
-    try {
-      const tokenValid = await auth.validateToken(token)
-      return tokenValid
-    } catch (err) {
-      return false
-    }
-  }
-
-  app.post('/api/lnd/auth', async (req, res) => {
-    try {
+    /**
+     * health check
+     */
+    app.get('/health', async (req, res) => {
       const health = await checkHealth()
-      const walletInitialized = await walletExists()
-      // If we're connected to lnd, unlock the wallet using the password supplied
-      // and generate an auth token if that operation was successful.
-      if (health.LNDStatus.success && walletInitialized) {
-        const { alias, password, invite } = req.body
+      res.json(health)
+    })
 
-        await recreateLnServices()
+    app.get('/tunnel/status', async (req, res) => {
+      const [relayId, relayUrl] = await Promise.all([
+        Storage.getItem('relay/id'),
+        Storage.getItem('relay/url')
+      ])
+      res.json({ uri: `${relayId}@${relayUrl}` })
+    })
 
-        if (GunDB.isAuthenticated()) {
-          GunDB.logoff()
-        }
+    /**
+     * kubernetes health check
+     */
+    app.get('/healthz', async (req, res) => {
+      const health = await checkHealth()
+      logger.info('Healthz response:', health)
+      res.json(health)
+    })
 
-        const publicKey = await GunDB.authenticate(alias, password)
+    app.get('/ping', (req, res) => {
+      logger.info('Ping completed!')
+      res.json({ message: 'OK' })
+    })
+
+    app.post('/api/mobile/error', (req, res) => {
+      logger.debug('Mobile error:', JSON.stringify(req.body))
+      res.json({ msg: 'OK' })
+    })
+
+    app.post('/api/security/exchangeKeys', async (req, res) => {
+      try {
+        const { publicKey, deviceId } = req.body
 
         if (!publicKey) {
-          res.status(401).json({
-            field: 'alias',
-            errorMessage: 'Invalid alias/password combination',
-            success: false
+          return res.status(400).json({
+            field: 'publicKey',
+            message: 'Please provide a valid public key'
           })
-          return false
         }
 
-        const trustedKeysEnabled =
-          process.env.TRUSTED_KEYS === 'true' || !process.env.TRUSTED_KEYS
-        const trustedKeys = await Storage.get('trustedPKs')
-        // Falls back to true if trusted keys is disabled in .env
-        const [isKeyTrusted = !trustedKeysEnabled] = (trustedKeys || []).filter(
-          trustedKey => trustedKey === publicKey
-        )
-        const walletUnlocked = health.LNDStatus.walletStatus === 'unlocked'
-        const { authorization = '' } = req.headers
-
-        if (!isKeyTrusted) {
-          logger.warn('Untrusted public key!')
-        }
-
-        if (!walletUnlocked) {
-          await unlockWallet(password)
-        }
-
-        if (walletUnlocked && !authorization && !isKeyTrusted) {
-          res.status(401).json({
-            field: 'alias',
-            errorMessage:
-              'Invalid alias/password combination (Untrusted Device)',
-            success: false
-          })
-          return
-        }
-
-        if (walletUnlocked && !isKeyTrusted) {
-          const validatedToken = await validateToken(
-            authorization.replace('Bearer ', '')
+        if (
+          !deviceId ||
+          !/^[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/iu.test(
+            deviceId
           )
+        ) {
+          return res.status(400).json({
+            field: 'deviceId',
+            message: 'Please provide a valid device ID'
+          })
+        }
 
-          if (!validatedToken) {
+        const authorizedDevice = await Encryption.authorizeDevice({
+          deviceId,
+          publicKey
+        })
+        logger.info(authorizedDevice)
+        return res.json(authorizedDevice)
+      } catch (err) {
+        logger.error(err)
+        return res.status(401).json({
+          field: 'unknown',
+          message: err
+        })
+      }
+    })
+
+    app.post('/api/encryption/exchange', async (req, res) => {
+      try {
+        const { publicKey, deviceId } = req.body
+
+        if (!publicKey) {
+          return res.status(400).json({
+            field: 'publicKey',
+            message: 'Please provide a valid public key'
+          })
+        }
+
+        if (
+          !deviceId ||
+          !/^[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/iu.test(
+            deviceId
+          )
+        ) {
+          return res.status(400).json({
+            field: 'deviceId',
+            message: 'Please provide a valid device ID'
+          })
+        }
+
+        const authorizedDevice = await ECC.authorizeDevice({
+          deviceId,
+          publicKey
+        })
+        return res.json(authorizedDevice)
+      } catch (err) {
+        logger.error(err)
+        return res.status(401).json({
+          field: 'unknown',
+          message: err
+        })
+      }
+    })
+
+    app.get('/api/lnd/wallet/status', async (req, res) => {
+      try {
+        const walletStatus = await walletExists()
+        const availableService = await getAvailableService()
+
+        res.json({
+          walletExists: walletStatus,
+          walletStatus: walletStatus ? availableService.walletStatus : null
+        })
+      } catch (err) {
+        logger.error(err)
+        const sanitizedMessage = sanitizeLNDError(err.message)
+        res.status(500).json({
+          field: 'LND',
+          errorMessage: sanitizedMessage
+            ? sanitizedMessage
+            : 'An unknown error has occurred, please try restarting your LND and API servers'
+        })
+      }
+    })
+
+    const validateToken = async token => {
+      try {
+        const tokenValid = await auth.validateToken(token)
+        return tokenValid
+      } catch (err) {
+        return false
+      }
+    }
+
+    app.post('/api/lnd/auth', async (req, res) => {
+      try {
+        const health = await checkHealth()
+        const walletInitialized = await walletExists()
+        // If we're connected to lnd, unlock the wallet using the password supplied
+        // and generate an auth token if that operation was successful.
+        if (health.LNDStatus.success && walletInitialized) {
+          const { alias, password, invite } = req.body
+
+          await recreateLnServices()
+
+          if (GunDB.isAuthenticated()) {
+            GunDB.logoff()
+          }
+
+          const publicKey = await GunDB.authenticate(alias, password)
+
+          if (!publicKey) {
+            res.status(401).json({
+              field: 'alias',
+              errorMessage: 'Invalid alias/password combination',
+              success: false
+            })
+            return false
+          }
+
+          const trustedKeysEnabled =
+            process.env.TRUSTED_KEYS === 'true' || !process.env.TRUSTED_KEYS
+          const trustedKeys = await Storage.get('trustedPKs')
+          // Falls back to true if trusted keys is disabled in .env
+          const [isKeyTrusted = !trustedKeysEnabled] = (
+            trustedKeys || []
+          ).filter(trustedKey => trustedKey === publicKey)
+          const walletUnlocked = health.LNDStatus.walletStatus === 'unlocked'
+          const { authorization = '' } = req.headers
+
+          if (!isKeyTrusted) {
+            logger.warn('Untrusted public key!')
+          }
+
+          if (!walletUnlocked) {
+            await unlockWallet(password)
+          }
+
+          if (walletUnlocked && !authorization && !isKeyTrusted) {
             res.status(401).json({
               field: 'alias',
               errorMessage:
-                'Invalid alias/password combination (Untrusted Auth Token)',
+                'Invalid alias/password combination (Untrusted Device)',
               success: false
             })
             return
           }
-        }
 
-        if (!isKeyTrusted) {
-          await Storage.set('trustedPKs', [...(trustedKeys || []), publicKey])
-        }
+          if (walletUnlocked && !isKeyTrusted) {
+            const validatedToken = await validateToken(
+              authorization.replace('Bearer ', '')
+            )
 
-        const { lightning } = LightningServices.services
-
-        // Generate auth token and send it as a JSON response
-        const token = await auth.generateToken()
-
-        // wait for wallet to warm up
-        await Common.Utils.makePromise((res, rej) => {
-          let tries = 0
-          let intervalID = null
-
-          intervalID = setInterval(() => {
-            if (tries === 7) {
-              rej(new Error(`Wallet did not warm up in under 7 seconds.`))
-
-              clearInterval(intervalID)
+            if (!validatedToken) {
+              res.status(401).json({
+                field: 'alias',
+                errorMessage:
+                  'Invalid alias/password combination (Untrusted Auth Token)',
+                success: false
+              })
               return
             }
+          }
 
-            tries++
+          if (!isKeyTrusted) {
+            await Storage.set('trustedPKs', [...(trustedKeys || []), publicKey])
+          }
+
+          const { lightning } = LightningServices.services
+
+          // Generate auth token and send it as a JSON response
+          const token = await auth.generateToken()
+
+          // wait for wallet to warm up
+          await Common.Utils.makePromise((res, rej) => {
+            let tries = 0
+            let intervalID = null
+
+            intervalID = setInterval(() => {
+              if (tries === 7) {
+                rej(new Error(`Wallet did not warm up in under 7 seconds.`))
 
-            lightning.listInvoices({}, err => {
-              if (!err) {
                 clearInterval(intervalID)
-                res()
+                return
+              }
+
+              tries++
+
+              lightning.listInvoices({}, err => {
+                if (!err) {
+                  clearInterval(intervalID)
+                  res()
+                }
+              })
+            }, 1000)
+          })
+
+          //get the latest channel backups before subscribing
+          const user = require('../services/gunDB/Mediator').getUser()
+          const SEA = require('../services/gunDB/Mediator').mySEA
+
+          await Common.Utils.makePromise((res, rej) => {
+            lightning.exportAllChannelBackups({}, (err, channelBackups) => {
+              if (err) {
+                return rej(new Error(err.details))
+              }
+
+              res(
+                GunActions.saveChannelsBackup(
+                  JSON.stringify(channelBackups),
+                  user,
+                  SEA
+                )
+              )
+            })
+          })
+
+          // Send an event to update lightning's status
+          mySocketsEvents.emit('updateLightning')
+
+          //register to listen for channel backups
+          const onNewChannelBackup = () => {
+            logger.warn('Subscribing to channel backup ...')
+            const stream = lightning.SubscribeChannelBackups({})
+            stream.on('data', data => {
+              logger.info(' New channel backup data')
+              GunActions.saveChannelsBackup(JSON.stringify(data), user, SEA)
+            })
+            stream.on('end', () => {
+              logger.info('Channel backup stream ended, starting a new one...')
+              // Prevents call stack overflow exceptions
+              //process.nextTick(onNewChannelBackup)
+            })
+            stream.on('error', err => {
+              logger.error('Channel backup stream error:', err)
+            })
+            stream.on('status', status => {
+              logger.error('Channel backup stream status:', status)
+              switch (status.code) {
+                case 0: {
+                  logger.info('Channel backup stream ok')
+                  break
+                }
+                case 2: {
+                  //Happens to fire when the grpc client lose access to macaroon file
+                  logger.warn('Channel backup got UNKNOWN error status')
+                  break
+                }
+                case 12: {
+                  logger.warn(
+                    'Channel backup LND locked, new registration in 60 seconds'
+                  )
+                  process.nextTick(() =>
+                    setTimeout(() => onNewChannelBackup(), 60000)
+                  )
+                  break
+                }
+                case 13: {
+                  //https://grpc.github.io/grpc/core/md_doc_statuscodes.html
+                  logger.error('Channel backup INTERNAL LND error')
+                  break
+                }
+                case 14: {
+                  logger.error(
+                    'Channel backup LND disconnected, sockets reconnecting in 30 seconds...'
+                  )
+                  process.nextTick(() =>
+                    setTimeout(() => onNewChannelBackup(), 30000)
+                  )
+                  break
+                }
+                default: {
+                  logger.error('[event:transaction:new] UNKNOWN LND error')
+                }
               }
             })
-          }, 1000)
-        })
+          }
 
-        //get the latest channel backups before subscribing
-        const user = require('../services/gunDB/Mediator').getUser()
-        const SEA = require('../services/gunDB/Mediator').mySEA
+          onNewChannelBackup()
 
-        await Common.Utils.makePromise((res, rej) => {
-          lightning.exportAllChannelBackups({}, (err, channelBackups) => {
-            if (err) {
-              return rej(new Error(err.details))
+          setTimeout(() => {
+            channelRequest(invite)
+          }, 30 * 1000)
+          res.json({
+            authorization: token,
+            user: {
+              alias,
+              publicKey
             }
-
-            res(
-              GunActions.saveChannelsBackup(
-                JSON.stringify(channelBackups),
-                user,
-                SEA
-              )
-            )
           })
+
+          return true
+        }
+
+        if (!walletInitialized) {
+          res.status(500).json({
+            field: 'wallet',
+            errorMessage: 'Please create a wallet before authenticating',
+            success: false
+          })
+          return false
+        }
+
+        res.status(500)
+        res.json({
+          field: 'health',
+          errorMessage: sanitizeLNDError(health.LNDStatus.message),
+          success: false
         })
+        return false
+      } catch (err) {
+        logger.error('Unlock Error:', err)
+        res.status(400)
+        res.json({
+          field: 'user',
+          errorMessage: err.message ? sanitizeLNDError(err.message) : err,
+          success: false
+        })
+        return err
+      }
+    })
 
-        // Send an event to update lightning's status
-        mySocketsEvents.emit('updateLightning')
-
-        //register to listen for channel backups
-        const onNewChannelBackup = () => {
-          logger.warn('Subscribing to channel backup ...')
-          const stream = lightning.SubscribeChannelBackups({})
-          stream.on('data', data => {
-            logger.info(' New channel backup data')
-            GunActions.saveChannelsBackup(JSON.stringify(data), user, SEA)
-          })
-          stream.on('end', () => {
-            logger.info('Channel backup stream ended, starting a new one...')
-            // Prevents call stack overflow exceptions
-            //process.nextTick(onNewChannelBackup)
-          })
-          stream.on('error', err => {
-            logger.error('Channel backup stream error:', err)
-          })
-          stream.on('status', status => {
-            logger.error('Channel backup stream status:', status)
-            switch (status.code) {
-              case 0: {
-                logger.info('Channel backup stream ok')
-                break
-              }
-              case 2: {
-                //Happens to fire when the grpc client lose access to macaroon file
-                logger.warn('Channel backup got UNKNOWN error status')
-                break
-              }
-              case 12: {
-                logger.warn(
-                  'Channel backup LND locked, new registration in 60 seconds'
-                )
-                process.nextTick(() =>
-                  setTimeout(() => onNewChannelBackup(), 60000)
-                )
-                break
-              }
-              case 13: {
-                //https://grpc.github.io/grpc/core/md_doc_statuscodes.html
-                logger.error('Channel backup INTERNAL LND error')
-                break
-              }
-              case 14: {
-                logger.error(
-                  'Channel backup LND disconnected, sockets reconnecting in 30 seconds...'
-                )
-                process.nextTick(() =>
-                  setTimeout(() => onNewChannelBackup(), 30000)
-                )
-                break
-              }
-              default: {
-                logger.error('[event:transaction:new] UNKNOWN LND error')
-              }
-            }
+    app.post('/api/lnd/wallet', async (req, res) => {
+      try {
+        const { walletUnlocker } = LightningServices.services
+        const { password, alias, invite } = req.body
+        const healthResponse = await checkHealth()
+        if (!alias) {
+          return res.status(400).json({
+            field: 'alias',
+            errorMessage: 'Please specify an alias for your new wallet'
           })
         }
 
-        onNewChannelBackup()
+        if (!password) {
+          return res.status(400).json({
+            field: 'password',
+            errorMessage: 'Please specify a password for your new wallet'
+          })
+        }
 
+        if (password.length < 8) {
+          return res.status(400).json({
+            field: 'password',
+            errorMessage:
+              "Please specify a password that's longer than 8 characters"
+          })
+        }
+
+        if (healthResponse.LNDStatus.service !== 'walletUnlocker') {
+          return res.status(400).json({
+            field: 'wallet',
+            errorMessage: 'Wallet is already unlocked'
+          })
+        }
+
+        walletUnlocker.genSeed({}, async (genSeedErr, genSeedResponse) => {
+          try {
+            if (genSeedErr) {
+              logger.debug('GenSeed Error:', genSeedErr)
+
+              const healthResponse = await checkHealth()
+              if (healthResponse.LNDStatus.success) {
+                const message = genSeedErr.details
+                return res.status(400).json({
+                  field: 'GenSeed',
+                  errorMessage: message,
+                  success: false
+                })
+              }
+
+              return res.status(500).json({
+                field: 'health',
+                errorMessage: 'LND is down',
+                success: false
+              })
+            }
+
+            logger.debug('GenSeed:', genSeedResponse)
+            const mnemonicPhrase = genSeedResponse.cipher_seed_mnemonic
+            const walletArgs = {
+              wallet_password: Buffer.from(password, 'utf8'),
+              cipher_seed_mnemonic: mnemonicPhrase
+            }
+
+            // Register user before creating wallet
+            const publicKey = await GunDB.register(alias, password)
+
+            await GunActions.saveSeedBackup(
+              mnemonicPhrase,
+              GunDB.getUser(),
+              GunDB.mySEA
+            )
+
+            const trustedKeys = await Storage.get('trustedPKs')
+            await Storage.setItem('trustedPKs', [
+              ...(trustedKeys || []),
+              publicKey
+            ])
+
+            walletUnlocker.initWallet(
+              walletArgs,
+              async (initWalletErr, initWalletResponse) => {
+                try {
+                  if (initWalletErr) {
+                    logger.error('initWallet Error:', initWalletErr.message)
+                    const healthResponse = await checkHealth()
+                    if (healthResponse.LNDStatus.success) {
+                      const errorMessage = initWalletErr.details
+
+                      return res.status(400).json({
+                        field: 'initWallet',
+                        errorMessage,
+                        success: false
+                      })
+                    }
+                    return res.status(500).json({
+                      field: 'health',
+                      errorMessage: 'LND is down',
+                      success: false
+                    })
+                  }
+                  logger.info('initWallet:', initWalletResponse)
+
+                  const waitUntilFileExists = seconds => {
+                    logger.info(
+                      `Waiting for admin.macaroon to be created. Seconds passed: ${seconds} Path: ${LightningServices.servicesConfig.macaroonPath}`
+                    )
+                    setTimeout(async () => {
+                      try {
+                        const macaroonExists = await FS.access(
+                          LightningServices.servicesConfig.macaroonPath
+                        )
+
+                        if (!macaroonExists) {
+                          return waitUntilFileExists(seconds + 1)
+                        }
+
+                        logger.info('admin.macaroon file created')
+
+                        await LightningServices.init()
+
+                        const token = await auth.generateToken()
+                        setTimeout(() => {
+                          channelRequest(invite)
+                        }, 30 * 1000)
+                        return res.json({
+                          mnemonicPhrase,
+                          authorization: token,
+                          user: {
+                            alias,
+                            publicKey
+                          }
+                        })
+                      } catch (err) {
+                        logger.error(err)
+                        res.status(400).json({
+                          field: 'unknown',
+                          errorMessage: sanitizeLNDError(err.message)
+                        })
+                      }
+                    }, 1000)
+                  }
+
+                  waitUntilFileExists(1)
+                } catch (err) {
+                  logger.error(err)
+                  return res.status(500).json({
+                    field: 'unknown',
+                    errorMessage: err
+                  })
+                }
+              }
+            )
+          } catch (err) {
+            logger.error(err)
+            return res.status(500).json({
+              field: 'unknown',
+              errorMessage: err.message || err
+            })
+          }
+        })
+      } catch (err) {
+        logger.error(err)
+        return res.status(500).json({
+          field: 'unknown',
+          errorMessage: err
+        })
+      }
+    })
+
+    app.post('/api/lnd/wallet/existing', async (req, res) => {
+      try {
+        const { password, alias, invite } = req.body
+        const healthResponse = await checkHealth()
+        const exists = await walletExists()
+        if (!exists) {
+          return res.status(500).json({
+            field: 'wallet',
+            errorMessage: 'LND wallet does not exist, please create a new one'
+          })
+        }
+
+        if (!alias) {
+          return res.status(400).json({
+            field: 'alias',
+            errorMessage: 'Please specify an alias for your wallet'
+          })
+        }
+
+        if (!password) {
+          return res.status(400).json({
+            field: 'password',
+            errorMessage: 'Please specify a password for your wallet alias'
+          })
+        }
+
+        if (password.length < 8) {
+          return res.status(400).json({
+            field: 'password',
+            errorMessage:
+              "Please specify a password that's longer than 8 characters"
+          })
+        }
+
+        if (healthResponse.LNDStatus.service !== 'walletUnlocker') {
+          return res.status(400).json({
+            field: 'wallet',
+            errorMessage:
+              'Wallet is already unlocked. Please restart your LND instance and try again.'
+          })
+        }
+
+        try {
+          await unlockWallet(password)
+        } catch (err) {
+          return res.status(401).json({
+            field: 'wallet',
+            errorMessage: 'Invalid LND wallet password'
+          })
+        }
+
+        // Register user after verifying wallet password
+        const publicKey = await GunDB.register(alias, password)
+
+        const trustedKeys = await Storage.get('trustedPKs')
+        await Storage.setItem('trustedPKs', [...(trustedKeys || []), publicKey])
+
+        // Generate Access Token
+        const token = await auth.generateToken()
         setTimeout(() => {
           channelRequest(invite)
         }, 30 * 1000)
@@ -816,324 +1087,87 @@ module.exports = async (
             publicKey
           }
         })
-
-        return true
-      }
-
-      if (!walletInitialized) {
-        res.status(500).json({
-          field: 'wallet',
-          errorMessage: 'Please create a wallet before authenticating',
-          success: false
-        })
-        return false
-      }
-
-      res.status(500)
-      res.json({
-        field: 'health',
-        errorMessage: sanitizeLNDError(health.LNDStatus.message),
-        success: false
-      })
-      return false
-    } catch (err) {
-      logger.error('Unlock Error:', err)
-      res.status(400)
-      res.json({
-        field: 'user',
-        errorMessage: err.message ? sanitizeLNDError(err.message) : err,
-        success: false
-      })
-      return err
-    }
-  })
-
-  app.post('/api/lnd/wallet', async (req, res) => {
-    try {
-      const { walletUnlocker } = LightningServices.services
-      const { password, alias, invite } = req.body
-      const healthResponse = await checkHealth()
-      if (!alias) {
-        return res.status(400).json({
-          field: 'alias',
-          errorMessage: 'Please specify an alias for your new wallet'
-        })
-      }
-
-      if (!password) {
-        return res.status(400).json({
-          field: 'password',
-          errorMessage: 'Please specify a password for your new wallet'
-        })
-      }
-
-      if (password.length < 8) {
-        return res.status(400).json({
-          field: 'password',
-          errorMessage:
-            "Please specify a password that's longer than 8 characters"
-        })
-      }
-
-      if (healthResponse.LNDStatus.service !== 'walletUnlocker') {
-        return res.status(400).json({
-          field: 'wallet',
-          errorMessage: 'Wallet is already unlocked'
-        })
-      }
-
-      walletUnlocker.genSeed({}, async (genSeedErr, genSeedResponse) => {
-        try {
-          if (genSeedErr) {
-            logger.debug('GenSeed Error:', genSeedErr)
-
-            const healthResponse = await checkHealth()
-            if (healthResponse.LNDStatus.success) {
-              const message = genSeedErr.details
-              return res.status(400).json({
-                field: 'GenSeed',
-                errorMessage: message,
-                success: false
-              })
-            }
-
-            return res.status(500).json({
-              field: 'health',
-              errorMessage: 'LND is down',
-              success: false
-            })
-          }
-
-          logger.debug('GenSeed:', genSeedResponse)
-          const mnemonicPhrase = genSeedResponse.cipher_seed_mnemonic
-          const walletArgs = {
-            wallet_password: Buffer.from(password, 'utf8'),
-            cipher_seed_mnemonic: mnemonicPhrase
-          }
-
-          // Register user before creating wallet
-          const publicKey = await GunDB.register(alias, password)
-
-          await GunActions.saveSeedBackup(
-            mnemonicPhrase,
-            GunDB.getUser(),
-            GunDB.mySEA
-          )
-
-          const trustedKeys = await Storage.get('trustedPKs')
-          await Storage.setItem('trustedPKs', [
-            ...(trustedKeys || []),
-            publicKey
-          ])
-
-          walletUnlocker.initWallet(
-            walletArgs,
-            async (initWalletErr, initWalletResponse) => {
-              try {
-                if (initWalletErr) {
-                  logger.error('initWallet Error:', initWalletErr.message)
-                  const healthResponse = await checkHealth()
-                  if (healthResponse.LNDStatus.success) {
-                    const errorMessage = initWalletErr.details
-
-                    return res.status(400).json({
-                      field: 'initWallet',
-                      errorMessage,
-                      success: false
-                    })
-                  }
-                  return res.status(500).json({
-                    field: 'health',
-                    errorMessage: 'LND is down',
-                    success: false
-                  })
-                }
-                logger.info('initWallet:', initWalletResponse)
-
-                const waitUntilFileExists = seconds => {
-                  logger.info(
-                    `Waiting for admin.macaroon to be created. Seconds passed: ${seconds} Path: ${LightningServices.servicesConfig.macaroonPath}`
-                  )
-                  setTimeout(async () => {
-                    try {
-                      const macaroonExists = await FS.access(
-                        LightningServices.servicesConfig.macaroonPath
-                      )
-
-                      if (!macaroonExists) {
-                        return waitUntilFileExists(seconds + 1)
-                      }
-
-                      logger.info('admin.macaroon file created')
-
-                      await LightningServices.init()
-
-                      const token = await auth.generateToken()
-                      setTimeout(() => {
-                        channelRequest(invite)
-                      }, 30 * 1000)
-                      return res.json({
-                        mnemonicPhrase,
-                        authorization: token,
-                        user: {
-                          alias,
-                          publicKey
-                        }
-                      })
-                    } catch (err) {
-                      logger.error(err)
-                      res.status(400).json({
-                        field: 'unknown',
-                        errorMessage: sanitizeLNDError(err.message)
-                      })
-                    }
-                  }, 1000)
-                }
-
-                waitUntilFileExists(1)
-              } catch (err) {
-                logger.error(err)
-                return res.status(500).json({
-                  field: 'unknown',
-                  errorMessage: err
-                })
-              }
-            }
-          )
-        } catch (err) {
-          logger.error(err)
-          return res.status(500).json({
-            field: 'unknown',
-            errorMessage: err.message || err
-          })
-        }
-      })
-    } catch (err) {
-      logger.error(err)
-      return res.status(500).json({
-        field: 'unknown',
-        errorMessage: err
-      })
-    }
-  })
-
-  app.post('/api/lnd/wallet/existing', async (req, res) => {
-    try {
-      const { password, alias, invite } = req.body
-      const healthResponse = await checkHealth()
-      const exists = await walletExists()
-      if (!exists) {
-        return res.status(500).json({
-          field: 'wallet',
-          errorMessage: 'LND wallet does not exist, please create a new one'
-        })
-      }
-
-      if (!alias) {
-        return res.status(400).json({
-          field: 'alias',
-          errorMessage: 'Please specify an alias for your wallet'
-        })
-      }
-
-      if (!password) {
-        return res.status(400).json({
-          field: 'password',
-          errorMessage: 'Please specify a password for your wallet alias'
-        })
-      }
-
-      if (password.length < 8) {
-        return res.status(400).json({
-          field: 'password',
-          errorMessage:
-            "Please specify a password that's longer than 8 characters"
-        })
-      }
-
-      if (healthResponse.LNDStatus.service !== 'walletUnlocker') {
-        return res.status(400).json({
-          field: 'wallet',
-          errorMessage:
-            'Wallet is already unlocked. Please restart your LND instance and try again.'
-        })
-      }
-
-      try {
-        await unlockWallet(password)
       } catch (err) {
-        return res.status(401).json({
-          field: 'wallet',
-          errorMessage: 'Invalid LND wallet password'
+        return res.status(500).json({
+          errorMessage: err.message
         })
       }
-
-      // Register user after verifying wallet password
-      const publicKey = await GunDB.register(alias, password)
-
-      const trustedKeys = await Storage.get('trustedPKs')
-      await Storage.setItem('trustedPKs', [...(trustedKeys || []), publicKey])
-
-      // Generate Access Token
-      const token = await auth.generateToken()
-      setTimeout(() => {
-        channelRequest(invite)
-      }, 30 * 1000)
-      res.json({
-        authorization: token,
-        user: {
-          alias,
-          publicKey
-        }
-      })
-    } catch (err) {
-      return res.status(500).json({
-        errorMessage: err.message
-      })
-    }
-  })
-
-  // get lnd info
-  app.get('/api/lnd/getinfo', (req, res) => {
-    const { lightning } = LightningServices.services
-
-    lightning.getInfo({}, async (err, response) => {
-      if (err) {
-        logger.error('GetInfo Error:', err)
-        const health = await checkHealth()
-        if (health.LNDStatus.success) {
-          res.status(400).json({
-            field: 'getInfo',
-            errorMessage: sanitizeLNDError(err.message)
-          })
-        } else {
-          res.status(500)
-          res.json({ errorMessage: 'LND is down' })
-        }
-      }
-      logger.info('GetInfo:', response)
-      if (!response.uris || response.uris.length === 0) {
-        if (config.lndAddress) {
-          response.uris = [response.identity_pubkey + '@' + config.lndAddress]
-        }
-      }
-      res.json(response)
     })
-  })
 
-  // get lnd node info
-  app.post('/api/lnd/getnodeinfo', (req, res) => {
-    const { lightning } = LightningServices.services
+    // get lnd info
+    app.get('/api/lnd/getinfo', (req, res) => {
+      const { lightning } = LightningServices.services
 
-    lightning.getNodeInfo(
-      { pub_key: req.body.pubkey },
-      async (err, response) => {
+      lightning.getInfo({}, async (err, response) => {
         if (err) {
-          logger.debug('GetNodeInfo Error:', err)
+          logger.error('GetInfo Error:', err)
           const health = await checkHealth()
           if (health.LNDStatus.success) {
-            res.status(400)
-            res.json({
+            res.status(400).json({
+              field: 'getInfo',
+              errorMessage: sanitizeLNDError(err.message)
+            })
+          } else {
+            res.status(500)
+            res.json({ errorMessage: 'LND is down' })
+          }
+        }
+        logger.info('GetInfo:', response)
+        if (!response.uris || response.uris.length === 0) {
+          if (config.lndAddress) {
+            response.uris = [response.identity_pubkey + '@' + config.lndAddress]
+          }
+        }
+        res.json(response)
+      })
+    })
+
+    // get lnd node info
+    app.post('/api/lnd/getnodeinfo', (req, res) => {
+      const { lightning } = LightningServices.services
+
+      lightning.getNodeInfo(
+        { pub_key: req.body.pubkey },
+        async (err, response) => {
+          if (err) {
+            logger.debug('GetNodeInfo Error:', err)
+            const health = await checkHealth()
+            if (health.LNDStatus.success) {
+              res.status(400)
+              res.json({
+                field: 'getNodeInfo',
+                errorMessage: sanitizeLNDError(err.message)
+              })
+            } else {
+              res.status(500)
+              res.json({ errorMessage: 'LND is down' })
+            }
+          }
+          logger.debug('GetNodeInfo:', response)
+          res.json(response)
+        }
+      )
+    })
+    // get lnd chan info
+    app.post('/api/lnd/getchaninfo', async (req, res) => {
+      try {
+        return res.json(await LV2.getChanInfo(req.body.chan_id))
+      } catch (e) {
+        console.log(e)
+        return res.status(500).json({
+          errorMessage: e.message
+        })
+      }
+    })
+
+    app.get('/api/lnd/getnetworkinfo', (req, res) => {
+      const { lightning } = LightningServices.services
+      lightning.getNetworkInfo({}, async (err, response) => {
+        if (err) {
+          logger.debug('GetNetworkInfo Error:', err)
+          const health = await checkHealth()
+          if (health.LNDStatus.success) {
+            res.status(400).json({
               field: 'getNodeInfo',
               errorMessage: sanitizeLNDError(err.message)
             })
@@ -1142,431 +1176,386 @@ module.exports = async (
             res.json({ errorMessage: 'LND is down' })
           }
         }
-        logger.debug('GetNodeInfo:', response)
+        logger.debug('GetNetworkInfo:', response)
         res.json(response)
-      }
-    )
-  })
-  // get lnd chan info
-  app.post('/api/lnd/getchaninfo', async (req, res) => {
-    try {
-      return res.json(await LV2.getChanInfo(req.body.chan_id))
-    } catch (e) {
-      console.log(e)
-      return res.status(500).json({
-        errorMessage: e.message
       })
-    }
-  })
+    })
 
-  app.get('/api/lnd/getnetworkinfo', (req, res) => {
-    const { lightning } = LightningServices.services
-    lightning.getNetworkInfo({}, async (err, response) => {
-      if (err) {
-        logger.debug('GetNetworkInfo Error:', err)
-        const health = await checkHealth()
-        if (health.LNDStatus.success) {
-          res.status(400).json({
-            field: 'getNodeInfo',
+    // get lnd node active channels list
+    app.get('/api/lnd/listpeers', async (req, res) => {
+      try {
+        return res.json({
+          peers: await LV2.listPeers(req.body.latestError)
+        })
+      } catch (e) {
+        console.log(e)
+        return res.status(500).json({
+          errorMessage: e.message
+        })
+      }
+    })
+
+    // newaddress
+    app.post('/api/lnd/newaddress', async (req, res) => {
+      try {
+        return res.json({
+          address: await LV2.newAddress(req.body.type)
+        })
+      } catch (e) {
+        return res.status(500).json({
+          errorMessage: e.message
+        })
+      }
+    })
+
+    // connect peer to lnd node
+    app.post('/api/lnd/connectpeer', (req, res) => {
+      const { lightning } = LightningServices.services
+      const connectRequest = {
+        addr: { pubkey: req.body.pubkey, host: req.body.host },
+        perm: true
+      }
+      logger.debug('ConnectPeer Request:', connectRequest)
+      lightning.connectPeer(connectRequest, (err, response) => {
+        if (err) {
+          logger.debug('ConnectPeer Error:', err)
+          res.status(500).json({
+            field: 'connectPeer',
             errorMessage: sanitizeLNDError(err.message)
           })
         } else {
-          res.status(500)
-          res.json({ errorMessage: 'LND is down' })
+          logger.debug('ConnectPeer:', response)
+          res.json(response)
         }
-      }
-      logger.debug('GetNetworkInfo:', response)
-      res.json(response)
+      })
     })
-  })
 
-  // get lnd node active channels list
-  app.get('/api/lnd/listpeers', async (req, res) => {
-    try {
-      return res.json({
-        peers: await LV2.listPeers(req.body.latestError)
+    // disconnect peer from lnd node
+    app.post('/api/lnd/disconnectpeer', (req, res) => {
+      const { lightning } = LightningServices.services
+      const disconnectRequest = { pub_key: req.body.pubkey }
+      logger.debug('DisconnectPeer Request:', disconnectRequest)
+      lightning.disconnectPeer(disconnectRequest, (err, response) => {
+        if (err) {
+          logger.debug('DisconnectPeer Error:', err)
+          res.status(400).json({
+            field: 'disconnectPeer',
+            errorMessage: sanitizeLNDError(err.message)
+          })
+        } else {
+          logger.debug('DisconnectPeer:', response)
+          res.json(response)
+        }
       })
-    } catch (e) {
-      console.log(e)
-      return res.status(500).json({
-        errorMessage: e.message
-      })
-    }
-  })
+    })
 
-  // newaddress
-  app.post('/api/lnd/newaddress', async (req, res) => {
-    try {
-      return res.json({
-        address: await LV2.newAddress(req.body.type)
-      })
-    } catch (e) {
-      return res.status(500).json({
-        errorMessage: e.message
-      })
-    }
-  })
-
-  // connect peer to lnd node
-  app.post('/api/lnd/connectpeer', (req, res) => {
-    const { lightning } = LightningServices.services
-    const connectRequest = {
-      addr: { pubkey: req.body.pubkey, host: req.body.host },
-      perm: true
-    }
-    logger.debug('ConnectPeer Request:', connectRequest)
-    lightning.connectPeer(connectRequest, (err, response) => {
-      if (err) {
-        logger.debug('ConnectPeer Error:', err)
-        res.status(500).json({
-          field: 'connectPeer',
-          errorMessage: sanitizeLNDError(err.message)
+    // get lnd node opened channels list
+    app.get('/api/lnd/listchannels', async (_, res) => {
+      try {
+        return res.json({
+          channels: await LV2.listChannels({ active_only: false })
         })
-      } else {
-        logger.debug('ConnectPeer:', response)
-        res.json(response)
-      }
-    })
-  })
-
-  // disconnect peer from lnd node
-  app.post('/api/lnd/disconnectpeer', (req, res) => {
-    const { lightning } = LightningServices.services
-    const disconnectRequest = { pub_key: req.body.pubkey }
-    logger.debug('DisconnectPeer Request:', disconnectRequest)
-    lightning.disconnectPeer(disconnectRequest, (err, response) => {
-      if (err) {
-        logger.debug('DisconnectPeer Error:', err)
-        res.status(400).json({
-          field: 'disconnectPeer',
-          errorMessage: sanitizeLNDError(err.message)
+      } catch (e) {
+        console.log(e)
+        return res.status(500).json({
+          errorMessage: e.message
         })
-      } else {
-        logger.debug('DisconnectPeer:', response)
-        res.json(response)
       }
     })
-  })
 
-  // get lnd node opened channels list
-  app.get('/api/lnd/listchannels', async (_, res) => {
-    try {
-      return res.json({
-        channels: await LV2.listChannels({ active_only: false })
-      })
-    } catch (e) {
-      console.log(e)
-      return res.status(500).json({
-        errorMessage: e.message
-      })
-    }
-  })
-
-  app.get('/api/lnd/pendingchannels', async (req, res) => {
-    try {
-      return res.json(await LV2.pendingChannels())
-    } catch (e) {
-      console.log(e)
-      return res.status(500).json({
-        errorMessage: e.message
-      })
-    }
-  })
-
-  app.get('/api/lnd/unifiedTrx', (req, res) => {
-    const { lightning } = LightningServices.services
-    const { itemsPerPage, page, reversed = true } = req.query
-    const offset = (page - 1) * itemsPerPage
-    lightning.listPayments({}, (err, { payments = [] } = {}) => {
-      if (err) {
-        return handleError(res, err)
+    app.get('/api/lnd/pendingchannels', async (req, res) => {
+      try {
+        return res.json(await LV2.pendingChannels())
+      } catch (e) {
+        console.log(e)
+        return res.status(500).json({
+          errorMessage: e.message
+        })
       }
+    })
 
-      lightning.listInvoices(
-        { reversed, index_offset: offset, num_max_invoices: itemsPerPage },
-        (err, { invoices, last_index_offset }) => {
-          if (err) {
-            return handleError(res, err)
-          }
+    app.get('/api/lnd/unifiedTrx', (req, res) => {
+      const { lightning } = LightningServices.services
+      const { itemsPerPage, page, reversed = true } = req.query
+      const offset = (page - 1) * itemsPerPage
+      lightning.listPayments({}, (err, { payments = [] } = {}) => {
+        if (err) {
+          return handleError(res, err)
+        }
 
-          lightning.getTransactions({}, (err, { transactions = [] } = {}) => {
+        lightning.listInvoices(
+          { reversed, index_offset: offset, num_max_invoices: itemsPerPage },
+          (err, { invoices, last_index_offset }) => {
             if (err) {
               return handleError(res, err)
             }
 
-            res.json({
-              transactions: getListPage({
-                entries: transactions.reverse(),
-                itemsPerPage,
-                page
-              }),
-              payments: getListPage({
-                entries: payments.reverse(),
-                itemsPerPage,
-                page
-              }),
-              invoices: {
-                content: invoices.filter(invoice => invoice.settled),
-                page,
-                totalPages: Math.ceil(last_index_offset / itemsPerPage),
-                totalItems: last_index_offset
+            lightning.getTransactions({}, (err, { transactions = [] } = {}) => {
+              if (err) {
+                return handleError(res, err)
               }
+
+              res.json({
+                transactions: getListPage({
+                  entries: transactions.reverse(),
+                  itemsPerPage,
+                  page
+                }),
+                payments: getListPage({
+                  entries: payments.reverse(),
+                  itemsPerPage,
+                  page
+                }),
+                invoices: {
+                  content: invoices.filter(invoice => invoice.settled),
+                  page,
+                  totalPages: Math.ceil(last_index_offset / itemsPerPage),
+                  totalItems: last_index_offset
+                }
+              })
             })
+          }
+        )
+      })
+    })
+
+    app.post('/api/lnd/unifiedTrx', async (req, res) => {
+      try {
+        const { type, amt, to, memo, feeLimit, ackInfo } = req.body
+        if (
+          type !== 'spontaneousPayment' &&
+          type !== 'tip' &&
+          type !== 'torrentSeed' &&
+          type !== 'contentReveal' &&
+          type !== 'service' &&
+          type !== 'product' &&
+          type !== 'other'
+        ) {
+          return res.status(415).json({
+            field: 'type',
+            errorMessage: `Only 'spontaneousPayment'| 'tip' | 'torrentSeed' | 'contentReveal' | 'service' | 'product' |'other' payments supported via this endpoint for now.`
           })
         }
+
+        const amount = Number(amt)
+
+        if (!isARealUsableNumber(amount)) {
+          return res.status(400).json({
+            field: 'amt',
+            errorMessage: 'Not an usable number'
+          })
+        }
+
+        if (amount < 1) {
+          return res.status(400).json({
+            field: 'amt',
+            errorMessage: 'Must be 1 or greater.'
+          })
+        }
+
+        if (!isARealUsableNumber(feeLimit)) {
+          return res.status(400).json({
+            field: 'feeLimit',
+            errorMessage: 'Not an usable number'
+          })
+        }
+
+        if (feeLimit < 1) {
+          return res.status(400).json({
+            field: 'feeLimit',
+            errorMessage: 'Must be 1 or greater.'
+          })
+        }
+
+        if (type === 'tip' && typeof ackInfo !== 'string') {
+          return res.status(400).json({
+            field: 'ackInfo',
+            errorMessage: `Send ackInfo`
+          })
+        }
+
+        return res.status(200).json(
+          await GunActions.sendSpontaneousPayment(to, amt, memo, feeLimit, {
+            type,
+            ackInfo
+          })
+        )
+      } catch (e) {
+        return res.status(500).json({
+          errorMessage: e.message
+        })
+      }
+    })
+
+    // get lnd node payments list
+    app.get('/api/lnd/listpayments', (req, res) => {
+      const { lightning } = LightningServices.services
+      const { itemsPerPage, page, paginate = true } = req.query
+      lightning.listPayments(
+        {
+          include_incomplete: !!req.include_incomplete
+        },
+        (err, { payments = [] } = {}) => {
+          if (err) {
+            logger.debug('ListPayments Error:', err)
+            handleError(res, err)
+          } else {
+            logger.debug('ListPayments:', payments)
+            if (paginate) {
+              res.json(getListPage({ entries: payments, itemsPerPage, page }))
+            } else {
+              res.json({ payments })
+            }
+          }
+        }
       )
     })
-  })
 
-  app.post('/api/lnd/unifiedTrx', async (req, res) => {
-    try {
-      const { type, amt, to, memo, feeLimit, ackInfo } = req.body
-      if (
-        type !== 'spontaneousPayment' &&
-        type !== 'tip' &&
-        type !== 'torrentSeed' &&
-        type !== 'contentReveal' &&
-        type !== 'service' &&
-        type !== 'product' &&
-        type !== 'other'
-      ) {
-        return res.status(415).json({
-          field: 'type',
-          errorMessage: `Only 'spontaneousPayment'| 'tip' | 'torrentSeed' | 'contentReveal' | 'service' | 'product' |'other' payments supported via this endpoint for now.`
-        })
-      }
-
-      const amount = Number(amt)
-
-      if (!isARealUsableNumber(amount)) {
-        return res.status(400).json({
-          field: 'amt',
-          errorMessage: 'Not an usable number'
-        })
-      }
-
-      if (amount < 1) {
-        return res.status(400).json({
-          field: 'amt',
-          errorMessage: 'Must be 1 or greater.'
-        })
-      }
-
-      if (!isARealUsableNumber(feeLimit)) {
-        return res.status(400).json({
-          field: 'feeLimit',
-          errorMessage: 'Not an usable number'
-        })
-      }
-
-      if (feeLimit < 1) {
-        return res.status(400).json({
-          field: 'feeLimit',
-          errorMessage: 'Must be 1 or greater.'
-        })
-      }
-
-      if (type === 'tip' && typeof ackInfo !== 'string') {
-        return res.status(400).json({
-          field: 'ackInfo',
-          errorMessage: `Send ackInfo`
-        })
-      }
-
-      return res.status(200).json(
-        await GunActions.sendSpontaneousPayment(to, amt, memo, feeLimit, {
-          type,
-          ackInfo
-        })
-      )
-    } catch (e) {
-      return res.status(500).json({
-        errorMessage: e.message
-      })
-    }
-  })
-
-  // get lnd node payments list
-  app.get('/api/lnd/listpayments', (req, res) => {
-    const { lightning } = LightningServices.services
-    const { itemsPerPage, page, paginate = true } = req.query
-    lightning.listPayments(
-      {
-        include_incomplete: !!req.include_incomplete
-      },
-      (err, { payments = [] } = {}) => {
-        if (err) {
-          logger.debug('ListPayments Error:', err)
-          handleError(res, err)
-        } else {
-          logger.debug('ListPayments:', payments)
-          if (paginate) {
-            res.json(getListPage({ entries: payments, itemsPerPage, page }))
-          } else {
-            res.json({ payments })
-          }
-        }
-      }
-    )
-  })
-
-  app.get('/api/lnd/payments', async (req, res) => {
-    const {
-      include_incomplete,
-      index_offset,
-      max_payments,
-      reversed
-    } = /** @type {Common.APISchema.ListPaymentsRequest} */ (evolve(
-      {
-        include_incomplete: x => x === 'true',
-        index_offset: x => Number(x),
-        max_payments: x => Number(x),
-        reversed: x => x === 'true'
-      },
-      req.query
-    ))
-
-    if (typeof include_incomplete !== 'boolean') {
-      return res.status(400).json({
-        field: 'include_incomplete',
-        errorMessage: 'include_incomplete not a boolean'
-      })
-    }
-
-    if (!isARealUsableNumber(index_offset)) {
-      return res.status(400).json({
-        field: 'index_offset',
-        errorMessage: 'index_offset not a number'
-      })
-    }
-
-    if (!isARealUsableNumber(max_payments)) {
-      return res.status(400).json({
-        field: 'max_payments',
-        errorMessage: 'max_payments not a number'
-      })
-    }
-
-    if (typeof reversed !== 'boolean') {
-      return res.status(400).json({
-        field: 'reversed',
-        errorMessage: 'reversed not a boolean'
-      })
-    }
-
-    return res.status(200).json(
-      await LV2.listPayments({
+    app.get('/api/lnd/payments', async (req, res) => {
+      const {
         include_incomplete,
         index_offset,
         max_payments,
         reversed
-      })
-    )
-  })
+      } = /** @type {Common.APISchema.ListPaymentsRequest} */ (evolve(
+        {
+          include_incomplete: x => x === 'true',
+          index_offset: x => Number(x),
+          max_payments: x => Number(x),
+          reversed: x => x === 'true'
+        },
+        req.query
+      ))
 
-  // get lnd node invoices list
-  app.get('/api/lnd/listinvoices', (req, res) => {
-    const { lightning } = LightningServices.services
-    const { page, itemsPerPage, reversed = true } = req.query
-    const offset = (page - 1) * itemsPerPage
-    // const limit = page * itemsPerPage;
-    lightning.listInvoices(
-      { reversed, index_offset: offset, num_max_invoices: itemsPerPage },
-      async (err, { invoices, last_index_offset } = {}) => {
+      if (typeof include_incomplete !== 'boolean') {
+        return res.status(400).json({
+          field: 'include_incomplete',
+          errorMessage: 'include_incomplete not a boolean'
+        })
+      }
+
+      if (!isARealUsableNumber(index_offset)) {
+        return res.status(400).json({
+          field: 'index_offset',
+          errorMessage: 'index_offset not a number'
+        })
+      }
+
+      if (!isARealUsableNumber(max_payments)) {
+        return res.status(400).json({
+          field: 'max_payments',
+          errorMessage: 'max_payments not a number'
+        })
+      }
+
+      if (typeof reversed !== 'boolean') {
+        return res.status(400).json({
+          field: 'reversed',
+          errorMessage: 'reversed not a boolean'
+        })
+      }
+
+      return res.status(200).json(
+        await LV2.listPayments({
+          include_incomplete,
+          index_offset,
+          max_payments,
+          reversed
+        })
+      )
+    })
+
+    // get lnd node invoices list
+    app.get('/api/lnd/listinvoices', (req, res) => {
+      const { lightning } = LightningServices.services
+      const { page, itemsPerPage, reversed = true } = req.query
+      const offset = (page - 1) * itemsPerPage
+      // const limit = page * itemsPerPage;
+      lightning.listInvoices(
+        { reversed, index_offset: offset, num_max_invoices: itemsPerPage },
+        async (err, { invoices, last_index_offset } = {}) => {
+          if (err) {
+            logger.debug('ListInvoices Error:', err)
+            const health = await checkHealth()
+            if (health.LNDStatus.success) {
+              res.status(400).json({
+                errorMessage: sanitizeLNDError(err.message),
+                success: false
+              })
+            } else {
+              res.status(500)
+              res.json({
+                errorMessage: health.LNDStatus.message,
+                success: false
+              })
+            }
+          } else {
+            // logger.debug("ListInvoices:", response);
+            res.json({
+              content: invoices,
+              page,
+              totalPages: Math.ceil(last_index_offset / itemsPerPage),
+              success: true
+            })
+          }
+        }
+      )
+    })
+
+    // get lnd node forwarding history
+    app.get('/api/lnd/forwardinghistory', (req, res) => {
+      const { lightning } = LightningServices.services
+      lightning.forwardingHistory({}, async (err, response) => {
         if (err) {
-          logger.debug('ListInvoices Error:', err)
+          logger.debug('ForwardingHistory Error:', err)
           const health = await checkHealth()
           if (health.LNDStatus.success) {
             res.status(400).json({
-              errorMessage: sanitizeLNDError(err.message),
-              success: false
+              field: 'forwardingHistory',
+              errorMessage: sanitizeLNDError(err.message)
             })
           } else {
             res.status(500)
-            res.json({ errorMessage: health.LNDStatus.message, success: false })
+            res.json({ errorMessage: 'LND is down' })
           }
-        } else {
-          // logger.debug("ListInvoices:", response);
-          res.json({
-            content: invoices,
-            page,
-            totalPages: Math.ceil(last_index_offset / itemsPerPage),
-            success: true
-          })
         }
-      }
-    )
-  })
-
-  // get lnd node forwarding history
-  app.get('/api/lnd/forwardinghistory', (req, res) => {
-    const { lightning } = LightningServices.services
-    lightning.forwardingHistory({}, async (err, response) => {
-      if (err) {
-        logger.debug('ForwardingHistory Error:', err)
-        const health = await checkHealth()
-        if (health.LNDStatus.success) {
-          res.status(400).json({
-            field: 'forwardingHistory',
-            errorMessage: sanitizeLNDError(err.message)
-          })
-        } else {
-          res.status(500)
-          res.json({ errorMessage: 'LND is down' })
-        }
-      }
-      logger.debug('ForwardingHistory:', response)
-      res.json(response)
+        logger.debug('ForwardingHistory:', response)
+        res.json(response)
+      })
     })
-  })
 
-  // get the lnd node wallet balance
-  app.get('/api/lnd/walletbalance', (req, res) => {
-    const { lightning } = LightningServices.services
-    lightning.walletBalance({}, async (err, response) => {
-      if (err) {
-        logger.debug('WalletBalance Error:', err)
-        const health = await checkHealth()
-        if (health.LNDStatus.success) {
-          res.status(400).json({
-            field: 'walletBalance',
-            errorMessage: sanitizeLNDError(err.message)
-          })
-        } else {
-          res.status(500)
-          res.json({ errorMessage: 'LND is down' })
-        }
-      }
-      logger.debug('WalletBalance:', response)
-      res.json(response)
-    })
-  })
-
-  // get the lnd node wallet balance and channel balance
-  app.get('/api/lnd/balance', async (req, res) => {
-    const { lightning } = LightningServices.services
-    const health = await checkHealth()
-    lightning.walletBalance({}, (err, walletBalance) => {
-      if (err) {
-        logger.debug('WalletBalance Error:', err)
-        if (health.LNDStatus.success) {
-          res.status(400).json({
-            field: 'walletBalance',
-            errorMessage: sanitizeLNDError(err.message)
-          })
-        } else {
-          res.status(500)
-          res.json(health.LNDStatus)
-        }
-        return err
-      }
-
-      lightning.channelBalance({}, (err, channelBalance) => {
+    // get the lnd node wallet balance
+    app.get('/api/lnd/walletbalance', (req, res) => {
+      const { lightning } = LightningServices.services
+      lightning.walletBalance({}, async (err, response) => {
         if (err) {
-          logger.debug('ChannelBalance Error:', err)
+          logger.debug('WalletBalance Error:', err)
+          const health = await checkHealth()
           if (health.LNDStatus.success) {
             res.status(400).json({
-              field: 'channelBalance',
+              field: 'walletBalance',
+              errorMessage: sanitizeLNDError(err.message)
+            })
+          } else {
+            res.status(500)
+            res.json({ errorMessage: 'LND is down' })
+          }
+        }
+        logger.debug('WalletBalance:', response)
+        res.json(response)
+      })
+    })
+
+    // get the lnd node wallet balance and channel balance
+    app.get('/api/lnd/balance', async (req, res) => {
+      const { lightning } = LightningServices.services
+      const health = await checkHealth()
+      lightning.walletBalance({}, (err, walletBalance) => {
+        if (err) {
+          logger.debug('WalletBalance Error:', err)
+          if (health.LNDStatus.success) {
+            res.status(400).json({
+              field: 'walletBalance',
               errorMessage: sanitizeLNDError(err.message)
             })
           } else {
@@ -1576,395 +1565,397 @@ module.exports = async (
           return err
         }
 
-        logger.debug('ChannelBalance:', channelBalance)
-        res.json({
-          ...walletBalance,
-          channel_balance: channelBalance.balance,
-          pending_channel_balance: channelBalance.pending_open_balance
+        lightning.channelBalance({}, (err, channelBalance) => {
+          if (err) {
+            logger.debug('ChannelBalance Error:', err)
+            if (health.LNDStatus.success) {
+              res.status(400).json({
+                field: 'channelBalance',
+                errorMessage: sanitizeLNDError(err.message)
+              })
+            } else {
+              res.status(500)
+              res.json(health.LNDStatus)
+            }
+            return err
+          }
+
+          logger.debug('ChannelBalance:', channelBalance)
+          res.json({
+            ...walletBalance,
+            channel_balance: channelBalance.balance,
+            pending_channel_balance: channelBalance.pending_open_balance
+          })
         })
       })
     })
-  })
 
-  app.post('/api/lnd/decodePayReq', (req, res) => {
-    const { lightning } = LightningServices.services
-    const { payReq } = req.body
-    lightning.decodePayReq({ pay_req: payReq }, async (err, paymentRequest) => {
-      if (err) {
-        logger.debug('DecodePayReq Error:', err)
-        const health = await checkHealth()
-        if (health.LNDStatus.success) {
-          res.status(500).json({
-            errorMessage: sanitizeLNDError(err.message)
-          })
-        } else {
-          res.status(500).json({ errorMessage: 'LND is down' })
+    app.post('/api/lnd/decodePayReq', (req, res) => {
+      const { lightning } = LightningServices.services
+      const { payReq } = req.body
+      lightning.decodePayReq(
+        { pay_req: payReq },
+        async (err, paymentRequest) => {
+          if (err) {
+            logger.debug('DecodePayReq Error:', err)
+            const health = await checkHealth()
+            if (health.LNDStatus.success) {
+              res.status(500).json({
+                errorMessage: sanitizeLNDError(err.message)
+              })
+            } else {
+              res.status(500).json({ errorMessage: 'LND is down' })
+            }
+          } else {
+            logger.info('DecodePayReq:', paymentRequest)
+            res.json({
+              decodedRequest: paymentRequest
+            })
+          }
         }
-      } else {
-        logger.info('DecodePayReq:', paymentRequest)
-        res.json({
-          decodedRequest: paymentRequest
-        })
-      }
+      )
     })
-  })
 
-  app.get('/api/lnd/channelbalance', (req, res) => {
-    const { lightning } = LightningServices.services
-    lightning.channelBalance({}, async (err, response) => {
-      if (err) {
-        logger.debug('ChannelBalance Error:', err)
-        const health = await checkHealth()
-        if (health.LNDStatus.success) {
-          res.status(400).json({
-            field: 'channelBalance',
-            errorMessage: sanitizeLNDError(err.message)
-          })
-        } else {
-          res.status(500)
-          res.json({ errorMessage: 'LND is down' })
+    app.get('/api/lnd/channelbalance', (req, res) => {
+      const { lightning } = LightningServices.services
+      lightning.channelBalance({}, async (err, response) => {
+        if (err) {
+          logger.debug('ChannelBalance Error:', err)
+          const health = await checkHealth()
+          if (health.LNDStatus.success) {
+            res.status(400).json({
+              field: 'channelBalance',
+              errorMessage: sanitizeLNDError(err.message)
+            })
+          } else {
+            res.status(500)
+            res.json({ errorMessage: 'LND is down' })
+          }
         }
-      }
-      logger.debug('ChannelBalance:', response)
-      res.json(response)
-    })
-  })
-
-  // openchannel
-  app.post('/api/lnd/openchannel', (req, res) => {
-    const { lightning } = LightningServices.services
-
-    const { pubkey, channelCapacity, channelPushAmount, satPerByte } = req.body
-
-    const openChannelRequest = {
-      node_pubkey: Buffer.from(pubkey, 'hex'),
-      local_funding_amount: channelCapacity,
-      push_sat: channelPushAmount === '' ? '0' : channelPushAmount,
-      sat_per_byte: satPerByte
-    }
-    logger.info('OpenChannelRequest', openChannelRequest)
-    let finalEvent = null //Object to send to the socket, depends on final event from the stream
-    const openedChannel = lightning.openChannel(openChannelRequest)
-    openedChannel.on('data', response => {
-      logger.debug('OpenChannelRequest:', response)
-      if (res.headersSent) {
-        //if res was already sent
-        if (response.update === 'chan_open') {
-          finalEvent = { status: 'chan_open' }
-        }
-      } else {
+        logger.debug('ChannelBalance:', response)
         res.json(response)
-      }
+      })
     })
-    openedChannel.on('error', async err => {
-      logger.info('OpenChannelRequest Error:', err)
-      if (res.headersSent) {
-        finalEvent = { error: err.details } //send error on socket if http has already finished
-      } else {
-        const health = await checkHealth()
-        if (health.LNDStatus.success) {
-          res.status(500).json({
-            field: 'openChannelRequest',
-            errorMessage: sanitizeLNDError(err.details)
-          })
-        } else if (!res.headersSent) {
-          res.status(500)
-          res.json({ errorMessage: 'LND is down' })
-        }
-      }
-    })
-    openedChannel.on('end', () => {
-      if (finalEvent !== null) {
-        //send the last event got from the stream
-        //TO DO send finalEvent on socket
-      }
-    })
-  })
 
-  // closechannel
-  app.post('/api/lnd/closechannel', (req, res) => {
-    const { lightning } = LightningServices.services
-    const { channelPoint, outputIndex, force, satPerByte } = req.body
-    const closeChannelRequest = {
-      channel_point: {
-        funding_txid_bytes: Buffer.from(channelPoint, 'hex'),
-        funding_txid_str: channelPoint,
-        output_index: outputIndex,
+    // openchannel
+    app.post('/api/lnd/openchannel', (req, res) => {
+      const { lightning } = LightningServices.services
+
+      const {
+        pubkey,
+        channelCapacity,
+        channelPushAmount,
+        satPerByte
+      } = req.body
+
+      const openChannelRequest = {
+        node_pubkey: Buffer.from(pubkey, 'hex'),
+        local_funding_amount: channelCapacity,
+        push_sat: channelPushAmount === '' ? '0' : channelPushAmount,
         sat_per_byte: satPerByte
-      },
-      force
-    }
-    logger.info('CloseChannelRequest', closeChannelRequest)
-    const closedChannel = lightning.closeChannel(closeChannelRequest)
-
-    closedChannel.on('data', response => {
-      if (!res.headersSent) {
-        logger.info('CloseChannelRequest:', response)
-        res.json(response)
       }
-    })
-
-    closedChannel.on('error', async err => {
-      logger.error('CloseChannelRequest Error:', err)
-      const health = await checkHealth()
-      if (!res.headersSent) {
-        if (health.LNDStatus.success) {
-          logger.debug('CloseChannelRequest Error:', err)
-          res.status(400).json({
-            field: 'closeChannel',
-            errorMessage: sanitizeLNDError(err.message)
-          })
+      logger.info('OpenChannelRequest', openChannelRequest)
+      let finalEvent = null //Object to send to the socket, depends on final event from the stream
+      const openedChannel = lightning.openChannel(openChannelRequest)
+      openedChannel.on('data', response => {
+        logger.debug('OpenChannelRequest:', response)
+        if (res.headersSent) {
+          //if res was already sent
+          if (response.update === 'chan_open') {
+            finalEvent = { status: 'chan_open' }
+          }
         } else {
-          res.status(500)
-          res.json({ errorMessage: 'LND is down' })
+          res.json(response)
         }
-      }
-    })
-  })
-
-  // sendpayment
-  app.post('/api/lnd/sendpayment', async (req, res) => {
-    // this is the recommended value from lightning labs
-    const { keysend, maxParts = 3, timeoutSeconds = 5, feeLimit } = req.body
-
-    if (!feeLimit) {
-      return res.status(400).json({
-        errorMessage: 'please provide a "feeLimit" to the send payment request'
       })
-    }
-
-    try {
-      if (keysend) {
-        const { dest, amt, finalCltvDelta = 40 } = req.body
-        if (!dest || !amt) {
-          return res.status(400).json({
-            errorMessage: 'please provide "dest" and "amt" for keysend payments'
-          })
+      openedChannel.on('error', async err => {
+        logger.info('OpenChannelRequest Error:', err)
+        if (res.headersSent) {
+          finalEvent = { error: err.details } //send error on socket if http has already finished
+        } else {
+          const health = await checkHealth()
+          if (health.LNDStatus.success) {
+            res.status(500).json({
+              field: 'openChannelRequest',
+              errorMessage: sanitizeLNDError(err.details)
+            })
+          } else if (!res.headersSent) {
+            res.status(500)
+            res.json({ errorMessage: 'LND is down' })
+          }
         }
+      })
+      openedChannel.on('end', () => {
+        if (finalEvent !== null) {
+          //send the last event got from the stream
+          //TO DO send finalEvent on socket
+        }
+      })
+    })
 
-        const payment = await LV2.sendPaymentV2Keysend({
-          amt,
-          dest,
+    // closechannel
+    app.post('/api/lnd/closechannel', (req, res) => {
+      const { lightning } = LightningServices.services
+      const { channelPoint, outputIndex, force, satPerByte } = req.body
+      const closeChannelRequest = {
+        channel_point: {
+          funding_txid_bytes: Buffer.from(channelPoint, 'hex'),
+          funding_txid_str: channelPoint,
+          output_index: outputIndex,
+          sat_per_byte: satPerByte
+        },
+        force
+      }
+      logger.info('CloseChannelRequest', closeChannelRequest)
+      const closedChannel = lightning.closeChannel(closeChannelRequest)
+
+      closedChannel.on('data', response => {
+        if (!res.headersSent) {
+          logger.info('CloseChannelRequest:', response)
+          res.json(response)
+        }
+      })
+
+      closedChannel.on('error', async err => {
+        logger.error('CloseChannelRequest Error:', err)
+        const health = await checkHealth()
+        if (!res.headersSent) {
+          if (health.LNDStatus.success) {
+            logger.debug('CloseChannelRequest Error:', err)
+            res.status(400).json({
+              field: 'closeChannel',
+              errorMessage: sanitizeLNDError(err.message)
+            })
+          } else {
+            res.status(500)
+            res.json({ errorMessage: 'LND is down' })
+          }
+        }
+      })
+    })
+
+    // sendpayment
+    app.post('/api/lnd/sendpayment', async (req, res) => {
+      // this is the recommended value from lightning labs
+      const { keysend, maxParts = 3, timeoutSeconds = 5, feeLimit } = req.body
+
+      if (!feeLimit) {
+        return res.status(400).json({
+          errorMessage:
+            'please provide a "feeLimit" to the send payment request'
+        })
+      }
+
+      try {
+        if (keysend) {
+          const { dest, amt, finalCltvDelta = 40 } = req.body
+          if (!dest || !amt) {
+            return res.status(400).json({
+              errorMessage:
+                'please provide "dest" and "amt" for keysend payments'
+            })
+          }
+
+          const payment = await LV2.sendPaymentV2Keysend({
+            amt,
+            dest,
+            feeLimit,
+            finalCltvDelta,
+            maxParts,
+            timeoutSeconds
+          })
+
+          return res.status(200).json(payment)
+        }
+        const { payreq } = req.body
+
+        const payment = await LV2.sendPaymentV2Invoice({
           feeLimit,
-          finalCltvDelta,
-          maxParts,
+          payment_request: payreq,
+          amt: req.body.amt,
+          max_parts: maxParts,
           timeoutSeconds
         })
 
         return res.status(200).json(payment)
-      }
-      const { payreq } = req.body
+      } catch (e) {
+        let msg = 'Unknown Error'
 
-      const payment = await LV2.sendPaymentV2Invoice({
-        feeLimit,
-        payment_request: payreq,
-        amt: req.body.amt,
-        max_parts: maxParts,
-        timeoutSeconds
+        if (e.message) msg = e.message
+
+        logger.error(e)
+        return res.status(500).json({ errorMessage: msg })
+      }
+    })
+
+    app.post('/api/lnd/trackpayment', (req, res) => {
+      const { router } = LightningServices.services
+      const { paymentHash, inflightUpdates = true } = req.body
+
+      logger.info('Tracking payment payment', { paymentHash, inflightUpdates })
+      const trackedPayment = router.trackPaymentV2({
+        payment_hash: paymentHash,
+        no_inflight_updates: !inflightUpdates
       })
 
-      return res.status(200).json(payment)
-    } catch (e) {
-      let msg = 'Unknown Error'
-
-      if (e.message) msg = e.message
-
-      logger.error(e)
-      return res.status(500).json({ errorMessage: msg })
-    }
-  })
-
-  app.post('/api/lnd/trackpayment', (req, res) => {
-    const { router } = LightningServices.services
-    const { paymentHash, inflightUpdates = true } = req.body
-
-    logger.info('Tracking payment payment', { paymentHash, inflightUpdates })
-    const trackedPayment = router.trackPaymentV2({
-      payment_hash: paymentHash,
-      no_inflight_updates: !inflightUpdates
-    })
-
-    // only emits one event
-    trackedPayment.on('data', response => {
-      if (response.payment_error) {
-        logger.error('TrackPayment Info:', response)
-        return res.status(500).json({
-          errorMessage: response.payment_error
-        })
-      }
-
-      logger.info('TrackPayment Data:', response)
-      return res.json(response)
-    })
-
-    trackedPayment.on('status', status => {
-      logger.info('TrackPayment Status:', status)
-    })
-
-    trackedPayment.on('error', async err => {
-      logger.error('TrackPayment Error:', err)
-      const health = await checkHealth()
-      if (health.LNDStatus.success) {
-        res.status(500).json({
-          errorMessage: sanitizeLNDError(err.message)
-        })
-      } else {
-        res.status(500)
-        res.json({ errorMessage: 'LND is down' })
-      }
-    })
-  })
-
-  app.post('/api/lnd/sendtoroute', (req, res) => {
-    const { router } = LightningServices.services
-    const { paymentHash, route } = req.body
-
-    router.sendToRoute({ payment_hash: paymentHash, route }, (err, data) => {
-      if (err) {
-        logger.error('SendToRoute Error:', err)
-        return res.status(400).json(err)
-      }
-
-      return res.json(data)
-    })
-  })
-
-  app.post('/api/lnd/estimateroutefee', (req, res) => {
-    const { router } = LightningServices.services
-    const { dest, amount } = req.body
-
-    router.estimateRouteFee({ dest, amt_sat: amount }, (err, data) => {
-      if (err) {
-        logger.error('EstimateRouteFee Error:', err)
-        return res.status(400).json(err)
-      }
-
-      return res.json(data)
-    })
-  })
-
-  // addinvoice
-  app.post('/api/lnd/addinvoice', async (req, res) => {
-    const { expiry, value, memo } = req.body
-    const addInvoiceRes = await LV2.addInvoice(value, memo, true, expiry)
-
-    if (value) {
-      const channelsList = await LV2.listChannels({ active_only: true })
-      let remoteBalance = Big(0)
-      channelsList.forEach(element => {
-        const remB = Big(element.remote_balance)
-        if (remB.gt(remoteBalance)) {
-          remoteBalance = remB
+      // only emits one event
+      trackedPayment.on('data', response => {
+        if (response.payment_error) {
+          logger.error('TrackPayment Info:', response)
+          return res.status(500).json({
+            errorMessage: response.payment_error
+          })
         }
+
+        logger.info('TrackPayment Data:', response)
+        return res.json(response)
       })
 
-      addInvoiceRes.liquidityCheck = remoteBalance > value
-      //newInvoice.remoteBalance = remoteBalance
-    }
-
-    try {
-      return res.json(addInvoiceRes)
-    } catch (e) {
-      console.log(e)
-      return res.status(500).json({
-        errorMessage: e.message
+      trackedPayment.on('status', status => {
+        logger.info('TrackPayment Status:', status)
       })
-    }
-  })
 
-  // signmessage
-  app.post('/api/lnd/signmessage', (req, res) => {
-    const { lightning } = LightningServices.services
-    lightning.signMessage(
-      { msg: Buffer.from(req.body.msg, 'utf8') },
-      async (err, response) => {
-        if (err) {
-          logger.debug('SignMessage Error:', err)
-          const health = await checkHealth()
-          if (health.LNDStatus.success) {
-            res.status(400).json({
-              field: 'signMessage',
-              errorMessage: sanitizeLNDError(err.message)
-            })
-          } else {
-            res.status(500)
-            res.json({ errorMessage: 'LND is down' })
-          }
-        }
-        logger.debug('SignMessage:', response)
-        res.json(response)
-      }
-    )
-  })
-
-  // verifymessage
-  app.post('/api/lnd/verifymessage', (req, res) => {
-    const { lightning } = LightningServices.services
-    lightning.verifyMessage(
-      { msg: Buffer.from(req.body.msg, 'utf8'), signature: req.body.signature },
-      async (err, response) => {
-        if (err) {
-          logger.debug('VerifyMessage Error:', err)
-          const health = await checkHealth()
-          if (health.LNDStatus.success) {
-            res.status(400).json({
-              field: 'verifyMessage',
-              errorMessage: sanitizeLNDError(err.message)
-            })
-          } else {
-            res.status(500)
-            res.json({ errorMessage: 'LND is down' })
-          }
-        }
-        logger.debug('VerifyMessage:', response)
-        res.json(response)
-      }
-    )
-  })
-
-  // sendcoins
-  app.post('/api/lnd/sendcoins', (req, res) => {
-    const { lightning } = LightningServices.services
-    const sendCoinsRequest = {
-      addr: req.body.addr,
-      amount: req.body.amount,
-      sat_per_byte: req.body.satPerByte,
-      send_all: req.body.send_all === true
-    }
-    logger.debug('SendCoins', sendCoinsRequest)
-    lightning.sendCoins(sendCoinsRequest, async (err, response) => {
-      if (err) {
-        logger.debug('SendCoins Error:', err)
+      trackedPayment.on('error', async err => {
+        logger.error('TrackPayment Error:', err)
         const health = await checkHealth()
         if (health.LNDStatus.success) {
-          res.status(400).json({
-            field: 'sendCoins',
+          res.status(500).json({
             errorMessage: sanitizeLNDError(err.message)
           })
         } else {
           res.status(500)
           res.json({ errorMessage: 'LND is down' })
         }
-      }
-      logger.debug('SendCoins:', response)
-      res.json(response)
+      })
     })
-  })
 
-  // queryroute
-  app.post('/api/lnd/queryroute', (req, res) => {
-    const { lightning } = LightningServices.services
-    const numRoutes =
-      config.maxNumRoutesToQuery || DEFAULT_MAX_NUM_ROUTES_TO_QUERY
-    lightning.queryRoutes(
-      { pub_key: req.body.pubkey, amt: req.body.amt, num_routes: numRoutes },
-      async (err, response) => {
+    app.post('/api/lnd/sendtoroute', (req, res) => {
+      const { router } = LightningServices.services
+      const { paymentHash, route } = req.body
+
+      router.sendToRoute({ payment_hash: paymentHash, route }, (err, data) => {
         if (err) {
-          logger.debug('QueryRoute Error:', err)
+          logger.error('SendToRoute Error:', err)
+          return res.status(400).json(err)
+        }
+
+        return res.json(data)
+      })
+    })
+
+    app.post('/api/lnd/estimateroutefee', (req, res) => {
+      const { router } = LightningServices.services
+      const { dest, amount } = req.body
+
+      router.estimateRouteFee({ dest, amt_sat: amount }, (err, data) => {
+        if (err) {
+          logger.error('EstimateRouteFee Error:', err)
+          return res.status(400).json(err)
+        }
+
+        return res.json(data)
+      })
+    })
+
+    // addinvoice
+    app.post('/api/lnd/addinvoice', async (req, res) => {
+      const { expiry, value, memo } = req.body
+      const addInvoiceRes = await LV2.addInvoice(value, memo, true, expiry)
+
+      if (value) {
+        const channelsList = await LV2.listChannels({ active_only: true })
+        let remoteBalance = Big(0)
+        channelsList.forEach(element => {
+          const remB = Big(element.remote_balance)
+          if (remB.gt(remoteBalance)) {
+            remoteBalance = remB
+          }
+        })
+
+        addInvoiceRes.liquidityCheck = remoteBalance > value
+        //newInvoice.remoteBalance = remoteBalance
+      }
+
+      try {
+        return res.json(addInvoiceRes)
+      } catch (e) {
+        console.log(e)
+        return res.status(500).json({
+          errorMessage: e.message
+        })
+      }
+    })
+
+    // signmessage
+    app.post('/api/lnd/signmessage', (req, res) => {
+      const { lightning } = LightningServices.services
+      lightning.signMessage(
+        { msg: Buffer.from(req.body.msg, 'utf8') },
+        async (err, response) => {
+          if (err) {
+            logger.debug('SignMessage Error:', err)
+            const health = await checkHealth()
+            if (health.LNDStatus.success) {
+              res.status(400).json({
+                field: 'signMessage',
+                errorMessage: sanitizeLNDError(err.message)
+              })
+            } else {
+              res.status(500)
+              res.json({ errorMessage: 'LND is down' })
+            }
+          }
+          logger.debug('SignMessage:', response)
+          res.json(response)
+        }
+      )
+    })
+
+    // verifymessage
+    app.post('/api/lnd/verifymessage', (req, res) => {
+      const { lightning } = LightningServices.services
+      lightning.verifyMessage(
+        {
+          msg: Buffer.from(req.body.msg, 'utf8'),
+          signature: req.body.signature
+        },
+        async (err, response) => {
+          if (err) {
+            logger.debug('VerifyMessage Error:', err)
+            const health = await checkHealth()
+            if (health.LNDStatus.success) {
+              res.status(400).json({
+                field: 'verifyMessage',
+                errorMessage: sanitizeLNDError(err.message)
+              })
+            } else {
+              res.status(500)
+              res.json({ errorMessage: 'LND is down' })
+            }
+          }
+          logger.debug('VerifyMessage:', response)
+          res.json(response)
+        }
+      )
+    })
+
+    // sendcoins
+    app.post('/api/lnd/sendcoins', (req, res) => {
+      const { lightning } = LightningServices.services
+      const sendCoinsRequest = {
+        addr: req.body.addr,
+        amount: req.body.amount,
+        sat_per_byte: req.body.satPerByte,
+        send_all: req.body.send_all === true
+      }
+      logger.debug('SendCoins', sendCoinsRequest)
+      lightning.sendCoins(sendCoinsRequest, async (err, response) => {
+        if (err) {
+          logger.debug('SendCoins Error:', err)
           const health = await checkHealth()
           if (health.LNDStatus.success) {
             res.status(400).json({
-              field: 'queryRoute',
+              field: 'sendCoins',
               errorMessage: sanitizeLNDError(err.message)
             })
           } else {
@@ -1972,1437 +1963,1494 @@ module.exports = async (
             res.json({ errorMessage: 'LND is down' })
           }
         }
-        logger.debug('QueryRoute:', response)
+        logger.debug('SendCoins:', response)
         res.json(response)
-      }
-    )
-  })
-
-  app.post('/api/lnd/estimatefee', (req, res) => {
-    const { lightning } = LightningServices.services
-    const { amount, confirmationBlocks } = req.body
-    lightning.estimateFee(
-      {
-        AddrToAmount: {
-          tb1qnpq3vj8p6jymah6nnh6wz3p333tt360mq32dtt: amount
-        },
-        target_conf: confirmationBlocks
-      },
-      async (err, fee) => {
-        if (err) {
-          const health = await checkHealth()
-          if (health.LNDStatus.success) {
-            res.status(400).json({
-              error: err.message
-            })
-          } else {
-            res.status(500)
-            res.json({ errorMessage: 'LND is down' })
-          }
-        } else {
-          logger.debug('EstimateFee:', fee)
-          res.json(fee)
-        }
-      }
-    )
-  })
-
-  const listunspent = async (req, res) => {
-    try {
-      return res.status(200).json({
-        utxos: await LV2.listUnspent(
-          req.body.minConfirmations,
-          req.body.maxConfirmations
-        )
       })
-    } catch (e) {
-      return res.status(500).json({
-        errorMessage: e.message
-      })
-    }
-  }
-
-  app.get('/api/lnd/listunspent', listunspent)
-
-  // TODO: should be GET
-  app.post('/api/lnd/listunspent', listunspent)
-
-  app.get('/api/lnd/transactions', (req, res) => {
-    const { lightning } = LightningServices.services
-    const { page, paginate = true, itemsPerPage } = req.query
-    lightning.getTransactions({}, (err, { transactions = [] } = {}) => {
-      if (err) {
-        return handleError(res, err)
-      }
-      logger.debug('Transactions:', transactions)
-      if (paginate) {
-        res.json(getListPage({ entries: transactions, itemsPerPage, page }))
-      } else {
-        res.json({ transactions })
-      }
     })
-  })
 
-  app.post('/api/lnd/sendmany', (req, res) => {
-    const { lightning } = LightningServices.services
-    const { addresses, satPerByte } = req.body
-    lightning.sendMany(
-      { AddrToAmount: addresses, sat_per_byte: satPerByte },
-      (err, transactions) => {
+    // queryroute
+    app.post('/api/lnd/queryroute', (req, res) => {
+      const { lightning } = LightningServices.services
+      const numRoutes =
+        config.maxNumRoutesToQuery || DEFAULT_MAX_NUM_ROUTES_TO_QUERY
+      lightning.queryRoutes(
+        { pub_key: req.body.pubkey, amt: req.body.amt, num_routes: numRoutes },
+        async (err, response) => {
+          if (err) {
+            logger.debug('QueryRoute Error:', err)
+            const health = await checkHealth()
+            if (health.LNDStatus.success) {
+              res.status(400).json({
+                field: 'queryRoute',
+                errorMessage: sanitizeLNDError(err.message)
+              })
+            } else {
+              res.status(500)
+              res.json({ errorMessage: 'LND is down' })
+            }
+          }
+          logger.debug('QueryRoute:', response)
+          res.json(response)
+        }
+      )
+    })
+
+    app.post('/api/lnd/estimatefee', (req, res) => {
+      const { lightning } = LightningServices.services
+      const { amount, confirmationBlocks } = req.body
+      lightning.estimateFee(
+        {
+          AddrToAmount: {
+            tb1qnpq3vj8p6jymah6nnh6wz3p333tt360mq32dtt: amount
+          },
+          target_conf: confirmationBlocks
+        },
+        async (err, fee) => {
+          if (err) {
+            const health = await checkHealth()
+            if (health.LNDStatus.success) {
+              res.status(400).json({
+                error: err.message
+              })
+            } else {
+              res.status(500)
+              res.json({ errorMessage: 'LND is down' })
+            }
+          } else {
+            logger.debug('EstimateFee:', fee)
+            res.json(fee)
+          }
+        }
+      )
+    })
+
+    const listunspent = async (req, res) => {
+      try {
+        return res.status(200).json({
+          utxos: await LV2.listUnspent(
+            req.body.minConfirmations,
+            req.body.maxConfirmations
+          )
+        })
+      } catch (e) {
+        return res.status(500).json({
+          errorMessage: e.message
+        })
+      }
+    }
+
+    app.get('/api/lnd/listunspent', listunspent)
+
+    // TODO: should be GET
+    app.post('/api/lnd/listunspent', listunspent)
+
+    app.get('/api/lnd/transactions', (req, res) => {
+      const { lightning } = LightningServices.services
+      const { page, paginate = true, itemsPerPage } = req.query
+      lightning.getTransactions({}, (err, { transactions = [] } = {}) => {
         if (err) {
           return handleError(res, err)
         }
         logger.debug('Transactions:', transactions)
-        res.json(transactions)
-      }
-    )
-  })
-
-  app.get('/api/lnd/closedchannels', (req, res) => {
-    const { lightning } = LightningServices.services
-    const { closeTypeFilters = [] } = req.query
-    const lndFilters = closeTypeFilters.reduce(
-      (filters, filter) => ({ ...filters, [filter]: true }),
-      {}
-    )
-    lightning.closedChannels(lndFilters, (err, channels) => {
-      if (err) {
-        return handleError(res, err)
-      }
-      logger.debug('Channels:', channels)
-      res.json(channels)
+        if (paginate) {
+          res.json(getListPage({ entries: transactions, itemsPerPage, page }))
+        } else {
+          res.json({ transactions })
+        }
+      })
     })
-  })
 
-  app.post('/api/lnd/exportchanbackup', (req, res) => {
-    const { lightning } = LightningServices.services
-    const { channelPoint } = req.body
-    lightning.exportChannelBackup(
-      { chan_point: { funding_txid_str: channelPoint } },
-      (err, backup) => {
+    app.post('/api/lnd/sendmany', (req, res) => {
+      const { lightning } = LightningServices.services
+      const { addresses, satPerByte } = req.body
+      lightning.sendMany(
+        { AddrToAmount: addresses, sat_per_byte: satPerByte },
+        (err, transactions) => {
+          if (err) {
+            return handleError(res, err)
+          }
+          logger.debug('Transactions:', transactions)
+          res.json(transactions)
+        }
+      )
+    })
+
+    app.get('/api/lnd/closedchannels', (req, res) => {
+      const { lightning } = LightningServices.services
+      const { closeTypeFilters = [] } = req.query
+      const lndFilters = closeTypeFilters.reduce(
+        (filters, filter) => ({ ...filters, [filter]: true }),
+        {}
+      )
+      lightning.closedChannels(lndFilters, (err, channels) => {
         if (err) {
           return handleError(res, err)
         }
-        logger.debug('ExportChannelBackup:', backup)
-        res.json(backup)
-      }
-    )
-  })
-
-  app.post('/api/lnd/exportallchanbackups', (req, res) => {
-    const { lightning } = LightningServices.services
-    lightning.exportAllChannelBackups({}, (err, channelBackups) => {
-      if (err) {
-        return handleError(res, err)
-      }
-      logger.debug('ExportAllChannelBackups:', channelBackups)
-      res.json(channelBackups)
+        logger.debug('Channels:', channels)
+        res.json(channels)
+      })
     })
-  })
 
-  const GunEvent = Common.Constants.Event
-
-  app.get('/api/gun/lndchanbackups', async (req, res) => {
-    try {
-      const user = require('../services/gunDB/Mediator').getUser()
-
-      const SEA = require('../services/gunDB/Mediator').mySEA
-      const mySecret = require('../services/gunDB/Mediator').getMySecret()
-      const encBackup = await timeout5(user.get(Key.CHANNELS_BACKUP).then())
-      const backup = await SEA.decrypt(encBackup, mySecret)
-      logger.info(backup)
-      res.json({ data: backup })
-    } catch (err) {
-      res.json({ ok: 'err' })
-    }
-  })
-  app.get('/api/gun/feedpoc', async (req, res) => {
-    try {
-      logger.warn('FEED POC')
-      const user = require('../services/gunDB/Mediator').getUser()
-      const feedObj = await timeout5(user.get('FEED_POC').then())
-      logger.warn(feedObj)
-
-      res.json({ data: feedObj })
-    } catch (err) {
-      //res.json({ok:"err"})
-    }
-  })
-
-  const Events = require('../services/gunDB/contact-api/events')
-
-  app.get(`/api/gun/${GunEvent.ON_CHATS}`, (_, res) => {
-    try {
-      const data = Events.getChats()
-      const noAvatar = data.map(mex => {
-        return { ...mex, recipientAvatar: null }
-      })
-      res.json({
-        data: noAvatar
-      })
-    } catch (err) {
-      logger.info('Error in Chats poll:')
-      logger.error(err)
-      res
-        .status(err.message === Common.Constants.ErrorCode.NOT_AUTH ? 401 : 500)
-        .json({
-          errorMessage: typeof err === 'string' ? err : err.message
-        })
-    }
-  })
-
-  app.get(`/api/gun/${GunEvent.ON_DISPLAY_NAME}`, async (_, res) => {
-    try {
-      const user = require('../services/gunDB/Mediator').getUser()
-      const data = await timeout5(
-        user
-          .get(Key.PROFILE)
-          .get(Key.DISPLAY_NAME)
-          .then()
+    app.post('/api/lnd/exportchanbackup', (req, res) => {
+      const { lightning } = LightningServices.services
+      const { channelPoint } = req.body
+      lightning.exportChannelBackup(
+        { chan_point: { funding_txid_str: channelPoint } },
+        (err, backup) => {
+          if (err) {
+            return handleError(res, err)
+          }
+          logger.debug('ExportChannelBackup:', backup)
+          res.json(backup)
+        }
       )
-      res.json({
-        data
-      })
-    } catch (err) {
-      logger.info('Error in Display Name poll:')
-      logger.error(err)
-      res
-        .status(err.message === Common.Constants.ErrorCode.NOT_AUTH ? 401 : 500)
-        .json({
-          errorMessage: typeof err === 'string' ? err : err.message
-        })
-    }
-  })
+    })
 
-  app.get(`/api/gun/${GunEvent.ON_HANDSHAKE_ADDRESS}`, async (_, res) => {
-    try {
-      const user = require('../services/gunDB/Mediator').getUser()
-      const data = await timeout5(
-        user.get(Key.CURRENT_HANDSHAKE_ADDRESS).then()
-      )
-      res.json({
-        data
+    app.post('/api/lnd/exportallchanbackups', (req, res) => {
+      const { lightning } = LightningServices.services
+      lightning.exportAllChannelBackups({}, (err, channelBackups) => {
+        if (err) {
+          return handleError(res, err)
+        }
+        logger.debug('ExportAllChannelBackups:', channelBackups)
+        res.json(channelBackups)
       })
-    } catch (err) {
-      logger.info('Error in Handshake Address poll:')
-      logger.error(err)
-      res
-        .status(err.message === Common.Constants.ErrorCode.NOT_AUTH ? 401 : 500)
-        .json({
-          errorMessage: typeof err === 'string' ? err : err.message
-        })
-    }
-  })
+    })
 
-  app.get(`/api/gun/${GunEvent.ON_BIO}`, async (_, res) => {
-    try {
-      const user = require('../services/gunDB/Mediator').getUser()
-      const data = await timeout5(user.get(Key.BIO).then())
-      logger.debug(data)
-      res.json({
-        data
-      })
-    } catch (err) {
-      logger.info('Error in BIO poll:')
-      logger.error(err)
-      res
-        .status(err.message === Common.Constants.ErrorCode.NOT_AUTH ? 401 : 500)
-        .json({
-          errorMessage: typeof err === 'string' ? err : err.message
-        })
-    }
-  })
-  ////////////////////////////////////////////////////////////////////////////////
+    const GunEvent = Common.Constants.Event
 
-  app.post(`/api/gun/sendpayment`, async (req, res) => {
-    const {
-      recipientPub,
-      amount,
-      memo,
-      maxParts,
-      timeoutSeconds,
-      feeLimit,
-      sessionUuid
-    } = req.body
-    logger.info('handling spont pay')
-    if (!feeLimit) {
-      logger.error(
-        'please provide a "feeLimit" to the send spont payment request'
-      )
-      return res.status(500).json({
-        errorMessage:
-          'please provide a "feeLimit" to the send spont payment request'
-      })
-    }
-    if (!recipientPub || !amount) {
-      logger.info(
-        'please provide a "recipientPub" and "amount" to the send spont payment request'
-      )
-      return res.status(500).json({
-        errorMessage:
-          'please provide a "recipientPub" and "amount" to the send spont payment request'
-      })
-    }
-    try {
-      const preimage = await GunActions.sendPayment(
+    app.get('/api/gun/lndchanbackups', async (req, res) => {
+      try {
+        const user = require('../services/gunDB/Mediator').getUser()
+
+        const SEA = require('../services/gunDB/Mediator').mySEA
+        const mySecret = require('../services/gunDB/Mediator').getMySecret()
+        const encBackup = await timeout5(user.get(Key.CHANNELS_BACKUP).then())
+        const backup = await SEA.decrypt(encBackup, mySecret)
+        logger.info(backup)
+        res.json({ data: backup })
+      } catch (err) {
+        res.json({ ok: 'err' })
+      }
+    })
+    app.get('/api/gun/feedpoc', async (req, res) => {
+      try {
+        logger.warn('FEED POC')
+        const user = require('../services/gunDB/Mediator').getUser()
+        const feedObj = await timeout5(user.get('FEED_POC').then())
+        logger.warn(feedObj)
+
+        res.json({ data: feedObj })
+      } catch (err) {
+        //res.json({ok:"err"})
+      }
+    })
+
+    const Events = require('../services/gunDB/contact-api/events')
+
+    app.get(`/api/gun/${GunEvent.ON_CHATS}`, (_, res) => {
+      try {
+        const data = Events.getChats()
+        const noAvatar = data.map(mex => {
+          return { ...mex, recipientAvatar: null }
+        })
+        res.json({
+          data: noAvatar
+        })
+      } catch (err) {
+        logger.info('Error in Chats poll:')
+        logger.error(err)
+        res
+          .status(
+            err.message === Common.Constants.ErrorCode.NOT_AUTH ? 401 : 500
+          )
+          .json({
+            errorMessage: typeof err === 'string' ? err : err.message
+          })
+      }
+    })
+
+    app.get(`/api/gun/${GunEvent.ON_DISPLAY_NAME}`, async (_, res) => {
+      try {
+        const user = require('../services/gunDB/Mediator').getUser()
+        const data = await timeout5(
+          user
+            .get(Key.PROFILE)
+            .get(Key.DISPLAY_NAME)
+            .then()
+        )
+        res.json({
+          data
+        })
+      } catch (err) {
+        logger.info('Error in Display Name poll:')
+        logger.error(err)
+        res
+          .status(
+            err.message === Common.Constants.ErrorCode.NOT_AUTH ? 401 : 500
+          )
+          .json({
+            errorMessage: typeof err === 'string' ? err : err.message
+          })
+      }
+    })
+
+    app.get(`/api/gun/${GunEvent.ON_HANDSHAKE_ADDRESS}`, async (_, res) => {
+      try {
+        const user = require('../services/gunDB/Mediator').getUser()
+        const data = await timeout5(
+          user.get(Key.CURRENT_HANDSHAKE_ADDRESS).then()
+        )
+        res.json({
+          data
+        })
+      } catch (err) {
+        logger.info('Error in Handshake Address poll:')
+        logger.error(err)
+        res
+          .status(
+            err.message === Common.Constants.ErrorCode.NOT_AUTH ? 401 : 500
+          )
+          .json({
+            errorMessage: typeof err === 'string' ? err : err.message
+          })
+      }
+    })
+
+    app.get(`/api/gun/${GunEvent.ON_BIO}`, async (_, res) => {
+      try {
+        const user = require('../services/gunDB/Mediator').getUser()
+        const data = await timeout5(user.get(Key.BIO).then())
+        logger.debug(data)
+        res.json({
+          data
+        })
+      } catch (err) {
+        logger.info('Error in BIO poll:')
+        logger.error(err)
+        res
+          .status(
+            err.message === Common.Constants.ErrorCode.NOT_AUTH ? 401 : 500
+          )
+          .json({
+            errorMessage: typeof err === 'string' ? err : err.message
+          })
+      }
+    })
+    ////////////////////////////////////////////////////////////////////////////////
+
+    app.post(`/api/gun/sendpayment`, async (req, res) => {
+      const {
         recipientPub,
         amount,
         memo,
-        feeLimit,
         maxParts,
-        timeoutSeconds
-      )
-      res.json({ preimage, sessionUuid })
-    } catch (err) {
-      logger.info('spont pay err:', err)
-      return res.status(500).json({
-        errorMessage: err.message
-      })
-    }
-  })
-
-  app.get(`/api/gun/wall/:publicKey?`, async (req, res) => {
-    try {
-      const { page } = req.query
-      const { publicKey } = req.params
-
-      const pageNum = Number(page)
-
-      if (!isARealUsableNumber(pageNum)) {
-        return res.status(400).json({
-          field: 'page',
-          errorMessage: 'Not a number'
+        timeoutSeconds,
+        feeLimit,
+        sessionUuid
+      } = req.body
+      logger.info('handling spont pay')
+      if (!feeLimit) {
+        logger.error(
+          'please provide a "feeLimit" to the send spont payment request'
+        )
+        return res.status(500).json({
+          errorMessage:
+            'please provide a "feeLimit" to the send spont payment request'
         })
       }
-
-      if (pageNum === 0) {
-        return res.status(400).json({
-          field: 'page',
-          errorMessage: 'Page must be a non-zero integer'
+      if (!recipientPub || !amount) {
+        logger.info(
+          'please provide a "recipientPub" and "amount" to the send spont payment request'
+        )
+        return res.status(500).json({
+          errorMessage:
+            'please provide a "recipientPub" and "amount" to the send spont payment request'
         })
       }
-
-      const totalPages = await GunGetters.getWallTotalPages(publicKey)
-      const fetchedPage = await GunGetters.getWallPage(pageNum, publicKey)
-
-      return res.status(200).json({
-        ...fetchedPage,
-        totalPages
-      })
-    } catch (err) {
-      return res.status(500).json({
-        errorMessage: err.message
-      })
-    }
-  })
-
-  app.post(`/api/gun/wall/`, async (req, res) => {
-    try {
-      const { tags, title, contentItems, enableTipsOverlay } = req.body
-      const SEA = require('../services/gunDB/Mediator').mySEA
-      const postRes = await GunActions.createPostNew(
-        tags,
-        title,
-        contentItems,
-        SEA
-      )
-      if (enableTipsOverlay) {
-        const [postID] = postRes
-        const accessId = TipsForwarder.enablePostNotifications(postID)
-        return res.status(200).json([...postRes, accessId])
+      try {
+        const preimage = await GunActions.sendPayment(
+          recipientPub,
+          amount,
+          memo,
+          feeLimit,
+          maxParts,
+          timeoutSeconds
+        )
+        res.json({ preimage, sessionUuid })
+      } catch (err) {
+        logger.info('spont pay err:', err)
+        return res.status(500).json({
+          errorMessage: err.message
+        })
       }
-      return res.status(200).json(postRes)
-    } catch (e) {
-      console.log(e)
-      return res.status(500).json({
-        errorMessage:
-          (typeof e === 'string' ? e : e.message) || 'Unknown error.'
-      })
-    }
-  })
+    })
 
-  app.delete(`/api/gun/wall/:postInfo`, async (req, res) => {
-    try {
-      const { postInfo } = req.params
-      const parts = postInfo.split('&')
-      const [page, postId] = parts
-      if (!page || !postId) {
-        throw new Error(`please provide a "postId" and a "page"`)
-      }
-      await GunActions.deletePost(postId, page)
-      return res.status(200).json({
-        ok: 'true'
-      })
-    } catch (e) {
-      return res.status(500).json({
-        errorMessage:
-          (typeof e === 'string' ? e : e.message) || 'Unknown error.'
-      })
-    }
-  })
+    app.get(`/api/gun/wall/:publicKey?`, async (req, res) => {
+      try {
+        const { page } = req.query
+        const { publicKey } = req.params
 
-  app.post(`/api/gun/userInfo`, async (req, res) => {
-    try {
-      const { pubs } = req.body
-      const reqs = pubs.map(
-        e =>
-          new Promise((res, rej) => {
-            GunGetters.getUserInfo(e)
-              .then(r => res(r))
-              .catch(e => rej(e))
-          })
-      )
-      const infos = await Promise.all(reqs)
-      return res.status(200).json({
-        pubInfos: infos
-      })
-    } catch (err) {
-      return res.status(500).json({
-        errorMessage: err.message
-      })
-    }
-  })
-  /////////////////////////////////
-  /**
-   * @template P
-   * @typedef {import('express-serve-static-core').RequestHandler<P>} RequestHandler
-   */
+        const pageNum = Number(page)
 
-  const ap = /** @type {Application} */ (app)
-
-  /**
-   * @typedef {object} FollowsRouteParams
-   * @prop {(string|undefined)=} publicKey
-   */
-
-  /**
-   * @type {RequestHandler<FollowsRouteParams>}
-   */
-  const apiGunFollowsGet = async (_, res) => {
-    try {
-      const currFollows = await GunGetters.Follows.currentFollows()
-
-      return res.status(200).json(currFollows)
-    } catch (err) {
-      return res.status(500).json({
-        errorMessage: err.message || 'Unknown ERR at GET /api/follows'
-      })
-    }
-  }
-
-  /**
-   * @type {RequestHandler<FollowsRouteParams>}
-   */
-  const apiGunFollowsPut = async (req, res) => {
-    try {
-      const { publicKey } = req.params
-      if (!publicKey) {
-        throw new Error(`Missing publicKey route param.`)
-      }
-
-      await GunActions.follow(req.params.publicKey, false)
-
-      // 201 would be extraneous here. Implement it inside app.put
-      return res.status(200).json({
-        ok: true
-      })
-    } catch (err) {
-      return res.status(500).json({
-        errorMessage: err.message || 'Unknown error inside /api/gun/follows/'
-      })
-    }
-  }
-
-  /**
-   * @type {RequestHandler<FollowsRouteParams>}
-   */
-  const apiGunFollowsDelete = async (req, res) => {
-    try {
-      const { publicKey } = req.params
-      if (!publicKey) {
-        throw new Error(`Missing publicKey route param.`)
-      }
-
-      await GunActions.unfollow(req.params.publicKey)
-
-      return res.status(200).json({
-        ok: true
-      })
-    } catch (err) {
-      return res.status(500).json({
-        errorMessage: err.message || 'Unknown error inside /api/gun/follows/'
-      })
-    }
-  }
-
-  ap.get('/api/gun/initwall', async (req, res) => {
-    try {
-      await GunActions.initWall()
-      res.json({ ok: true })
-    } catch (err) {
-      logger.error(err)
-      return res.status(500).json({
-        errorMessage: err.message
-      })
-    }
-  })
-  ap.get('/api/gun/follows/', apiGunFollowsGet)
-  ap.get('/api/gun/follows/:publicKey', apiGunFollowsGet)
-  ap.put(`/api/gun/follows/:publicKey`, apiGunFollowsPut)
-  ap.delete(`/api/gun/follows/:publicKey`, apiGunFollowsDelete)
-
-  /**
-   * @type {RequestHandler<{}>}
-   */
-  const apiGunFeedGet = async (req, res) => {
-    try {
-      const MAX_PAGES_TO_FETCH_FOR_TRY_UNTIL = 4
-
-      const { page: pageStr } = req.query
-
-      /**
-       * Similar to a "before" query param in cursor based pagination. We call
-       * it "try" because it is likely that this item lies beyond
-       * MAX_PAGES_TO_FETCH_FOR_TRY_UNTIL in which case we gracefully just send
-       * 2 pages and 205 response.
-       */
-      // eslint-disable-next-line prefer-destructuring
-      const before = req.query.before
-
-      if (pageStr) {
-        const page = Number(pageStr)
-
-        if (!isARealUsableNumber(page)) {
+        if (!isARealUsableNumber(pageNum)) {
           return res.status(400).json({
             field: 'page',
-            errorMessage: 'page must be a number'
+            errorMessage: 'Not a number'
           })
         }
 
-        if (page < 1) {
+        if (pageNum === 0) {
           return res.status(400).json({
-            field: page,
-            errorMessage: 'page must be a positive number'
+            field: 'page',
+            errorMessage: 'Page must be a non-zero integer'
           })
         }
 
+        const totalPages = await GunGetters.getWallTotalPages(publicKey)
+        const fetchedPage = await GunGetters.getWallPage(pageNum, publicKey)
+
+        return res.status(200).json({
+          ...fetchedPage,
+          totalPages
+        })
+      } catch (err) {
+        return res.status(500).json({
+          errorMessage: err.message
+        })
+      }
+    })
+
+    app.post(`/api/gun/wall/`, async (req, res) => {
+      try {
+        const { tags, title, contentItems, enableTipsOverlay } = req.body
+        const SEA = require('../services/gunDB/Mediator').mySEA
+        const postRes = await GunActions.createPostNew(
+          tags,
+          title,
+          contentItems,
+          SEA
+        )
+        if (enableTipsOverlay) {
+          const [postID] = postRes
+          const accessId = TipsForwarder.enablePostNotifications(postID)
+          return res.status(200).json([...postRes, accessId])
+        }
+        return res.status(200).json(postRes)
+      } catch (e) {
+        console.log(e)
+        return res.status(500).json({
+          errorMessage:
+            (typeof e === 'string' ? e : e.message) || 'Unknown error.'
+        })
+      }
+    })
+
+    app.delete(`/api/gun/wall/:postInfo`, async (req, res) => {
+      try {
+        const { postInfo } = req.params
+        const parts = postInfo.split('&')
+        const [page, postId] = parts
+        if (!page || !postId) {
+          throw new Error(`please provide a "postId" and a "page"`)
+        }
+        await GunActions.deletePost(postId, page)
+        return res.status(200).json({
+          ok: 'true'
+        })
+      } catch (e) {
+        return res.status(500).json({
+          errorMessage:
+            (typeof e === 'string' ? e : e.message) || 'Unknown error.'
+        })
+      }
+    })
+
+    app.post(`/api/gun/userInfo`, async (req, res) => {
+      try {
+        const { pubs } = req.body
+        const reqs = pubs.map(
+          e =>
+            new Promise((res, rej) => {
+              GunGetters.getUserInfo(e)
+                .then(r => res(r))
+                .catch(e => rej(e))
+            })
+        )
+        const infos = await Promise.all(reqs)
+        return res.status(200).json({
+          pubInfos: infos
+        })
+      } catch (err) {
+        return res.status(500).json({
+          errorMessage: err.message
+        })
+      }
+    })
+    /////////////////////////////////
+    /**
+     * @template P
+     * @typedef {import('express-serve-static-core').RequestHandler<P>} RequestHandler
+     */
+
+    const ap = /** @type {Application} */ (app)
+
+    /**
+     * @typedef {object} FollowsRouteParams
+     * @prop {(string|undefined)=} publicKey
+     */
+
+    /**
+     * @type {RequestHandler<FollowsRouteParams>}
+     */
+    const apiGunFollowsGet = async (_, res) => {
+      try {
+        const currFollows = await GunGetters.Follows.currentFollows()
+
+        return res.status(200).json(currFollows)
+      } catch (err) {
+        return res.status(500).json({
+          errorMessage: err.message || 'Unknown ERR at GET /api/follows'
+        })
+      }
+    }
+
+    /**
+     * @type {RequestHandler<FollowsRouteParams>}
+     */
+    const apiGunFollowsPut = async (req, res) => {
+      try {
+        const { publicKey } = req.params
+        if (!publicKey) {
+          throw new Error(`Missing publicKey route param.`)
+        }
+
+        await GunActions.follow(req.params.publicKey, false)
+
+        // 201 would be extraneous here. Implement it inside app.put
+        return res.status(200).json({
+          ok: true
+        })
+      } catch (err) {
+        return res.status(500).json({
+          errorMessage: err.message || 'Unknown error inside /api/gun/follows/'
+        })
+      }
+    }
+
+    /**
+     * @type {RequestHandler<FollowsRouteParams>}
+     */
+    const apiGunFollowsDelete = async (req, res) => {
+      try {
+        const { publicKey } = req.params
+        if (!publicKey) {
+          throw new Error(`Missing publicKey route param.`)
+        }
+
+        await GunActions.unfollow(req.params.publicKey)
+
+        return res.status(200).json({
+          ok: true
+        })
+      } catch (err) {
+        return res.status(500).json({
+          errorMessage: err.message || 'Unknown error inside /api/gun/follows/'
+        })
+      }
+    }
+
+    ap.get('/api/gun/initwall', async (req, res) => {
+      try {
+        await GunActions.initWall()
+        res.json({ ok: true })
+      } catch (err) {
+        logger.error(err)
+        return res.status(500).json({
+          errorMessage: err.message
+        })
+      }
+    })
+    ap.get('/api/gun/follows/', apiGunFollowsGet)
+    ap.get('/api/gun/follows/:publicKey', apiGunFollowsGet)
+    ap.put(`/api/gun/follows/:publicKey`, apiGunFollowsPut)
+    ap.delete(`/api/gun/follows/:publicKey`, apiGunFollowsDelete)
+
+    /**
+     * @type {RequestHandler<{}>}
+     */
+    const apiGunFeedGet = async (req, res) => {
+      try {
+        const MAX_PAGES_TO_FETCH_FOR_TRY_UNTIL = 4
+
+        const { page: pageStr } = req.query
+
+        /**
+         * Similar to a "before" query param in cursor based pagination. We call
+         * it "try" because it is likely that this item lies beyond
+         * MAX_PAGES_TO_FETCH_FOR_TRY_UNTIL in which case we gracefully just send
+         * 2 pages and 205 response.
+         */
+        // eslint-disable-next-line prefer-destructuring
+        const before = req.query.before
+
+        if (pageStr) {
+          const page = Number(pageStr)
+
+          if (!isARealUsableNumber(page)) {
+            return res.status(400).json({
+              field: 'page',
+              errorMessage: 'page must be a number'
+            })
+          }
+
+          if (page < 1) {
+            return res.status(400).json({
+              field: page,
+              errorMessage: 'page must be a positive number'
+            })
+          }
+
+          return res.status(200).json({
+            posts: await GunGetters.getFeedPage(page),
+            page
+          })
+        }
+
+        if (before) {
+          const pages = range(1, MAX_PAGES_TO_FETCH_FOR_TRY_UNTIL)
+          const promises = pages.map(p => GunGetters.getFeedPage(p))
+
+          let results = await Promise.all(promises)
+
+          const idxIfFound = results.findIndex(pp =>
+            pp.some(p => p.id === before)
+          )
+
+          if (idxIfFound > -1) {
+            results = results.slice(0, idxIfFound + 1)
+
+            const posts = flatten(results)
+
+            return res.status(200).json({
+              posts,
+              page: idxIfFound
+            })
+          }
+
+          // we couldn't find the posts leading up to the requested post
+          // (try_until) Let's just return the ones we found with together with a
+          // 205 code (client should refresh UI)
+
+          return res.status(205).json({
+            posts: results[0] || [],
+            page: 1
+          })
+        }
+
+        return res.status(400).json({
+          errorMessage: `Must provide at least a page or a try_until query param.`
+        })
+      } catch (err) {
+        return res.status(500).json({
+          errorMessage: err.message || 'Unknown error inside /api/gun/follows/'
+        })
+      }
+    }
+
+    ap.get(`/api/gun/feed`, apiGunFeedGet)
+
+    /**
+     * @type {RequestHandler<{}>}
+     */
+    const apiGunMeGet = async (_, res) => {
+      try {
+        return res.status(200).json(await GunGetters.getMyUser())
+      } catch (err) {
+        logger.error(err)
+        return res.status(500).json({
+          errorMessage: err.message
+        })
+      }
+    }
+
+    /**
+     * @type {RequestHandler<{}>}
+     */
+    const apiGunMePut = async (req, res) => {
+      /**
+       * @typedef {Omit<Common.Schema.User, 'publicKey'>} UserWithoutPK
+       * @typedef {{ handshakeAddress: boolean }} HasHandshakeAddress
+       * @typedef {UserWithoutPK & HasHandshakeAddress} MePutBody
+       */
+      try {
+        const {
+          avatar,
+          bio,
+          displayName,
+          handshakeAddress
+        } = /** @type {Partial<MePutBody>} */ (req.body)
+
+        if (avatar) {
+          await GunActions.setAvatar(
+            avatar,
+            require('../services/gunDB/Mediator').getUser()
+          )
+        }
+
+        if (bio) {
+          await GunActions.setBio(
+            bio,
+            require('../services/gunDB/Mediator').getUser()
+          )
+        }
+
+        if (displayName) {
+          await GunActions.setDisplayName(
+            displayName,
+            require('../services/gunDB/Mediator').getUser()
+          )
+        }
+
+        if (handshakeAddress) {
+          await GunActions.generateHandshakeAddress()
+        }
+
         return res.status(200).json({
-          posts: await GunGetters.getFeedPage(page),
-          page
+          ok: true
+        })
+      } catch (err) {
+        logger.error(err)
+        return res.status(500).json({
+          errorMessage: err.message
         })
       }
-
-      if (before) {
-        const pages = range(1, MAX_PAGES_TO_FETCH_FOR_TRY_UNTIL)
-        const promises = pages.map(p => GunGetters.getFeedPage(p))
-
-        let results = await Promise.all(promises)
-
-        const idxIfFound = results.findIndex(pp =>
-          pp.some(p => p.id === before)
-        )
-
-        if (idxIfFound > -1) {
-          results = results.slice(0, idxIfFound + 1)
-
-          const posts = flatten(results)
-
-          return res.status(200).json({
-            posts,
-            page: idxIfFound
-          })
-        }
-
-        // we couldn't find the posts leading up to the requested post
-        // (try_until) Let's just return the ones we found with together with a
-        // 205 code (client should refresh UI)
-
-        return res.status(205).json({
-          posts: results[0] || [],
-          page: 1
-        })
-      }
-
-      return res.status(400).json({
-        errorMessage: `Must provide at least a page or a try_until query param.`
-      })
-    } catch (err) {
-      return res.status(500).json({
-        errorMessage: err.message || 'Unknown error inside /api/gun/follows/'
-      })
     }
-  }
 
-  ap.get(`/api/gun/feed`, apiGunFeedGet)
+    ap.get(`/api/gun/me`, apiGunMeGet)
+    ap.put(`/api/gun/me`, apiGunMePut)
 
-  /**
-   * @type {RequestHandler<{}>}
-   */
-  const apiGunMeGet = async (_, res) => {
-    try {
-      return res.status(200).json(await GunGetters.getMyUser())
-    } catch (err) {
-      logger.error(err)
-      return res.status(500).json({
-        errorMessage: err.message
-      })
-    }
-  }
-
-  /**
-   * @type {RequestHandler<{}>}
-   */
-  const apiGunMePut = async (req, res) => {
     /**
-     * @typedef {Omit<Common.Schema.User, 'publicKey'>} UserWithoutPK
-     * @typedef {{ handshakeAddress: boolean }} HasHandshakeAddress
-     * @typedef {UserWithoutPK & HasHandshakeAddress} MePutBody
+     * @typedef {object} ChatsRouteParams
+     * @prop {(string|undefined)=} publicKey
      */
-    try {
+
+    /**
+     * @type {RequestHandler<ChatsRouteParams>}
+     */
+    const apiGunChatsPost = async (req, res) => {
+      const { publicKey } = req.params
+      const { body } = req.body
+
+      if (!publicKey) {
+        return res.status(400).json({
+          errorMessage: `Must specify a publicKey route param for POSTing a message`
+        })
+      }
+
+      try {
+        const user = GunDB.getUser()
+        const SEA = GunDB.mySEA
+
+        return res
+          .status(200)
+          .json(await GunActions.sendMessageNew(publicKey, body, user, SEA))
+      } catch (err) {
+        logger.error(err)
+        return res.status(500).json({
+          errorMessage: err.message
+        })
+      }
+    }
+
+    /**
+     * @type {RequestHandler<ChatsRouteParams>}
+     */
+    const apiGunChatsDelete = async (req, res) => {
+      const { publicKey } = req.params
+
+      if (!publicKey) {
+        return res.status(400).json({
+          errorMessage: `Must specify a publicKey route param for DELETING a chat`
+        })
+      }
+
+      try {
+        await GunActions.disconnect(publicKey)
+
+        return res.status(200).json({
+          ok: true
+        })
+      } catch (err) {
+        logger.error(err)
+        return res.status(500).json({
+          errorMessage: err.message
+        })
+      }
+    }
+
+    ap.post(`/api/gun/chats/:publicKey?`, apiGunChatsPost)
+    ap.delete(`/api/gun/chats/:publicKey?`, apiGunChatsDelete)
+
+    /**
+     * @typedef {object} RequestsRouteParams
+     * @prop {(string|undefined)=} requestID
+     */
+
+    /**
+     * @type {RequestHandler<{}>}
+     */
+    const apiGunRequestsReceivedGet = (_, res) => {
+      try {
+        const data = Events.getCurrentReceivedReqs()
+        const noAvatar = data.map(req => {
+          return { ...req, recipientAvatar: null }
+        })
+        res.json({
+          data: noAvatar
+        })
+      } catch (err) {
+        logger.error(err)
+        return res.status(500).json({
+          errorMessage: err.message
+        })
+      }
+    }
+
+    /**
+     * @type {RequestHandler<{}>}
+     */
+    const apiGunRequestsSentGet = (_, res) => {
+      try {
+        const data = Events.getCurrentSentReqs()
+        const noAvatar = data.map(req => {
+          return { ...req, recipientAvatar: null }
+        })
+        res.json({
+          data: noAvatar
+        })
+      } catch (err) {
+        logger.error(err)
+        return res.status(500).json({
+          errorMessage: err.message
+        })
+      }
+    }
+
+    /**
+     * @typedef {object} RequestsRoutePOSTBody
+     * @prop {string=} initialMsg
+     * @prop {string} publicKey
+     */
+
+    /**
+     * @type {RequestHandler<{}>}
+     */
+    const apiGunRequestsPost = async (req, res) => {
       const {
-        avatar,
-        bio,
-        displayName,
-        handshakeAddress
-      } = /** @type {Partial<MePutBody>} */ (req.body)
+        initialMsg,
+        publicKey
+      } = /** @type {RequestsRoutePOSTBody} */ (req.body)
 
-      if (avatar) {
-        await GunActions.setAvatar(
-          avatar,
-          require('../services/gunDB/Mediator').getUser()
-        )
+      if (!publicKey) {
+        return res.status(400).json({
+          errorMessage: `Must specify a publicKey route param for POSTing a message`
+        })
       }
 
-      if (bio) {
-        await GunActions.setBio(
-          bio,
-          require('../services/gunDB/Mediator').getUser()
-        )
-      }
+      try {
+        const gun = require('../services/gunDB/Mediator').getGun()
+        const user = require('../services/gunDB/Mediator').getUser()
+        const SEA = require('../services/gunDB/Mediator').mySEA
 
-      if (displayName) {
-        await GunActions.setDisplayName(
-          displayName,
-          require('../services/gunDB/Mediator').getUser()
-        )
-      }
-
-      if (handshakeAddress) {
-        await GunActions.generateHandshakeAddress()
-      }
-
-      return res.status(200).json({
-        ok: true
-      })
-    } catch (err) {
-      logger.error(err)
-      return res.status(500).json({
-        errorMessage: err.message
-      })
-    }
-  }
-
-  ap.get(`/api/gun/me`, apiGunMeGet)
-  ap.put(`/api/gun/me`, apiGunMePut)
-
-  /**
-   * @typedef {object} ChatsRouteParams
-   * @prop {(string|undefined)=} publicKey
-   */
-
-  /**
-   * @type {RequestHandler<ChatsRouteParams>}
-   */
-  const apiGunChatsPost = async (req, res) => {
-    const { publicKey } = req.params
-    const { body } = req.body
-
-    if (!publicKey) {
-      return res.status(400).json({
-        errorMessage: `Must specify a publicKey route param for POSTing a message`
-      })
-    }
-
-    try {
-      const user = GunDB.getUser()
-      const SEA = GunDB.mySEA
-
-      return res
-        .status(200)
-        .json(await GunActions.sendMessageNew(publicKey, body, user, SEA))
-    } catch (err) {
-      logger.error(err)
-      return res.status(500).json({
-        errorMessage: err.message
-      })
-    }
-  }
-
-  /**
-   * @type {RequestHandler<ChatsRouteParams>}
-   */
-  const apiGunChatsDelete = async (req, res) => {
-    const { publicKey } = req.params
-
-    if (!publicKey) {
-      return res.status(400).json({
-        errorMessage: `Must specify a publicKey route param for DELETING a chat`
-      })
-    }
-
-    try {
-      await GunActions.disconnect(publicKey)
-
-      return res.status(200).json({
-        ok: true
-      })
-    } catch (err) {
-      logger.error(err)
-      return res.status(500).json({
-        errorMessage: err.message
-      })
-    }
-  }
-
-  ap.post(`/api/gun/chats/:publicKey?`, apiGunChatsPost)
-  ap.delete(`/api/gun/chats/:publicKey?`, apiGunChatsDelete)
-
-  /**
-   * @typedef {object} RequestsRouteParams
-   * @prop {(string|undefined)=} requestID
-   */
-
-  /**
-   * @type {RequestHandler<{}>}
-   */
-  const apiGunRequestsReceivedGet = (_, res) => {
-    try {
-      const data = Events.getCurrentReceivedReqs()
-      const noAvatar = data.map(req => {
-        return { ...req, recipientAvatar: null }
-      })
-      res.json({
-        data: noAvatar
-      })
-    } catch (err) {
-      logger.error(err)
-      return res.status(500).json({
-        errorMessage: err.message
-      })
-    }
-  }
-
-  /**
-   * @type {RequestHandler<{}>}
-   */
-  const apiGunRequestsSentGet = (_, res) => {
-    try {
-      const data = Events.getCurrentSentReqs()
-      const noAvatar = data.map(req => {
-        return { ...req, recipientAvatar: null }
-      })
-      res.json({
-        data: noAvatar
-      })
-    } catch (err) {
-      logger.error(err)
-      return res.status(500).json({
-        errorMessage: err.message
-      })
-    }
-  }
-
-  /**
-   * @typedef {object} RequestsRoutePOSTBody
-   * @prop {string=} initialMsg
-   * @prop {string} publicKey
-   */
-
-  /**
-   * @type {RequestHandler<{}>}
-   */
-  const apiGunRequestsPost = async (req, res) => {
-    const {
-      initialMsg,
-      publicKey
-    } = /** @type {RequestsRoutePOSTBody} */ (req.body)
-
-    if (!publicKey) {
-      return res.status(400).json({
-        errorMessage: `Must specify a publicKey route param for POSTing a message`
-      })
-    }
-
-    try {
-      const gun = require('../services/gunDB/Mediator').getGun()
-      const user = require('../services/gunDB/Mediator').getUser()
-      const SEA = require('../services/gunDB/Mediator').mySEA
-
-      if (initialMsg) {
-        await GunActions.sendHRWithInitialMsg(
-          initialMsg,
-          publicKey,
-          gun,
-          user,
-          SEA
-        )
-      } else {
-        await GunActions.sendHandshakeRequest(publicKey, gun, user, SEA)
-      }
-
-      return res.status(200).json({
-        ok: true
-      })
-    } catch (err) {
-      logger.error(err)
-      return res.status(500).json({
-        errorMessage: err.message
-      })
-    }
-  }
-
-  /**
-   * @typedef {object} RequestsRoutePUTBody
-   * @prop {boolean=} accept
-   */
-
-  /**
-   * @type {RequestHandler<RequestsRouteParams>}
-   */
-  const apiGunRequestsPut = async (req, res) => {
-    const { requestID } = req.params
-    const { accept } = /** @type {RequestsRoutePUTBody} */ (req.body)
-
-    if (!requestID) {
-      return res.status(400).json({
-        errorMessage: `Must specify a requestID route param for accepting a request`
-      })
-    }
-
-    if (!accept) {
-      return res.status(200).json({
-        ok: true
-      })
-    }
-
-    try {
-      const gun = require('../services/gunDB/Mediator').getGun()
-      const user = require('../services/gunDB/Mediator').getUser()
-      const SEA = require('../services/gunDB/Mediator').mySEA
-
-      await GunActions.acceptRequest(requestID, gun, user, SEA)
-
-      return res.status(200).json({
-        ok: true
-      })
-    } catch (err) {
-      logger.error(err)
-      return res.status(500).json({
-        errorMessage: err.message
-      })
-    }
-  }
-
-  ap.get(`/api/gun/${GunEvent.ON_RECEIVED_REQUESTS}`, apiGunRequestsReceivedGet)
-  ap.get(`/api/gun/${GunEvent.ON_SENT_REQUESTS}`, apiGunRequestsSentGet)
-  ap.get(`/api/gun/requests/received`, apiGunRequestsReceivedGet)
-  ap.get(`/api/gun/requests/sent`, apiGunRequestsSentGet)
-  ap.post('/api/gun/requests/', apiGunRequestsPost)
-  ap.put(`/api/gun/requests/:requestID?`, apiGunRequestsPut)
-
-  ap.get(`/api/gun/dev/userToIncoming`, async (_, res) => {
-    try {
-      const { tryAndWait } = require('../services/gunDB/contact-api/utils')
-
-      const data = await tryAndWait(
-        (_, u) =>
-          new Promise(res => {
-            u.get(GunKey.USER_TO_INCOMING).load(data => {
-              res(data)
-            })
-          }),
-        v => {
-          if (typeof v !== 'object') {
-            return true
-          }
-
-          if (v === null) {
-            return true
-          }
-
-          // load sometimes returns an empty set on the first try
-          return size(v) === 0
+        if (initialMsg) {
+          await GunActions.sendHRWithInitialMsg(
+            initialMsg,
+            publicKey,
+            gun,
+            user,
+            SEA
+          )
+        } else {
+          await GunActions.sendHandshakeRequest(publicKey, gun, user, SEA)
         }
-      )
 
-      return res.status(200).json({
-        data
-      })
-    } catch (err) {
-      return res.status(500).json({
-        errorMessage: err.message
-      })
+        return res.status(200).json({
+          ok: true
+        })
+      } catch (err) {
+        logger.error(err)
+        return res.status(500).json({
+          errorMessage: err.message
+        })
+      }
     }
-  })
 
-  ap.get(`/api/gun/dev/recipientToOutgoing`, async (_, res) => {
-    try {
-      const { tryAndWait } = require('../services/gunDB/contact-api/utils')
+    /**
+     * @typedef {object} RequestsRoutePUTBody
+     * @prop {boolean=} accept
+     */
 
-      const data = await tryAndWait(
-        (_, u) =>
-          new Promise(res => {
-            u.get(GunKey.RECIPIENT_TO_OUTGOING).load(data => {
-              res(data)
-            })
-          }),
-        v => {
-          if (typeof v !== 'object') {
-            return true
-          }
+    /**
+     * @type {RequestHandler<RequestsRouteParams>}
+     */
+    const apiGunRequestsPut = async (req, res) => {
+      const { requestID } = req.params
+      const { accept } = /** @type {RequestsRoutePUTBody} */ (req.body)
 
-          if (v === null) {
-            return true
-          }
+      if (!requestID) {
+        return res.status(400).json({
+          errorMessage: `Must specify a requestID route param for accepting a request`
+        })
+      }
 
-          // load sometimes returns an empty set on the first try
-          return size(v) === 0
-        }
-      )
+      if (!accept) {
+        return res.status(200).json({
+          ok: true
+        })
+      }
 
-      return res.status(200).json({
-        data
-      })
-    } catch (err) {
-      return res.status(500).json({
-        errorMessage: err.message
-      })
+      try {
+        const gun = require('../services/gunDB/Mediator').getGun()
+        const user = require('../services/gunDB/Mediator').getUser()
+        const SEA = require('../services/gunDB/Mediator').mySEA
+
+        await GunActions.acceptRequest(requestID, gun, user, SEA)
+
+        return res.status(200).json({
+          ok: true
+        })
+      } catch (err) {
+        logger.error(err)
+        return res.status(500).json({
+          errorMessage: err.message
+        })
+      }
     }
-  })
 
-  ap.get(`/api/gun/dev/outgoings`, async (_, res) => {
-    try {
-      const { tryAndWait } = require('../services/gunDB/contact-api/utils')
+    ap.get(
+      `/api/gun/${GunEvent.ON_RECEIVED_REQUESTS}`,
+      apiGunRequestsReceivedGet
+    )
+    ap.get(`/api/gun/${GunEvent.ON_SENT_REQUESTS}`, apiGunRequestsSentGet)
+    ap.get(`/api/gun/requests/received`, apiGunRequestsReceivedGet)
+    ap.get(`/api/gun/requests/sent`, apiGunRequestsSentGet)
+    ap.post('/api/gun/requests/', apiGunRequestsPost)
+    ap.put(`/api/gun/requests/:requestID?`, apiGunRequestsPut)
 
-      const data = await tryAndWait(
-        (_, u) =>
-          new Promise(res => {
-            u.get(GunKey.OUTGOINGS).load(data => {
-              res(data)
-            })
-          }),
-        v => {
-          if (typeof v !== 'object') {
-            return true
-          }
+    ap.get(`/api/gun/dev/userToIncoming`, async (_, res) => {
+      try {
+        const { tryAndWait } = require('../services/gunDB/contact-api/utils')
 
-          if (v === null) {
-            return true
-          }
-
-          // load sometimes returns an empty set on the first try
-          return size(v) === 0
-        }
-      )
-
-      return res.status(200).json({
-        data
-      })
-    } catch (err) {
-      return res.status(500).json({
-        errorMessage: err.message
-      })
-    }
-  })
-
-  ap.get(`/api/gun/dev/currentHandshakeAddress`, async (_, res) => {
-    try {
-      const { tryAndWait } = require('../services/gunDB/contact-api/utils')
-
-      const data = await tryAndWait((_, u) =>
-        u.get(GunKey.CURRENT_HANDSHAKE_ADDRESS).then()
-      )
-
-      return res.status(200).json({
-        data
-      })
-    } catch (err) {
-      return res.status(500).json({
-        errorMessage: err.message
-      })
-    }
-  })
-
-  ap.get(`/api/gun/dev/handshakeNodes/:handshakeAddress`, async (req, res) => {
-    try {
-      const { tryAndWait } = require('../services/gunDB/contact-api/utils')
-
-      const data = await tryAndWait(
-        g =>
-          new Promise(res => {
-            g.get(GunKey.HANDSHAKE_NODES)
-              .get(req.params.handshakeAddress)
-              .load(data => {
+        const data = await tryAndWait(
+          (_, u) =>
+            new Promise(res => {
+              u.get(GunKey.USER_TO_INCOMING).load(data => {
                 res(data)
               })
-          }),
-        v => {
-          if (typeof v !== 'object') {
-            return true
+            }),
+          v => {
+            if (typeof v !== 'object') {
+              return true
+            }
+
+            if (v === null) {
+              return true
+            }
+
+            // load sometimes returns an empty set on the first try
+            return size(v) === 0
           }
+        )
 
-          if (v === null) {
-            return true
-          }
-
-          // load sometimes returns an empty set on the first try
-          return size(v) === 0
-        }
-      )
-
-      return res.status(200).json({
-        data
-      })
-    } catch (err) {
-      return res.status(500).json({
-        errorMessage: err.message
-      })
-    }
-  })
-
-  ap.get(`/api/gun/dev/user/:publicKey`, async (req, res) => {
-    try {
-      const { tryAndWait } = require('../services/gunDB/contact-api/utils')
-
-      const data = await tryAndWait(
-        g =>
-          new Promise(res => {
-            g.user(req.params.publicKey).load(data => {
-              res(data)
-            })
-          }),
-        v => {
-          if (typeof v !== 'object') {
-            return true
-          }
-
-          if (v === null) {
-            return true
-          }
-
-          // load sometimes returns an empty set on the first try
-          return size(v) === 0
-        }
-      )
-
-      return res.status(200).json({
-        data
-      })
-    } catch (err) {
-      return res.status(500).json({
-        errorMessage: err.message
-      })
-    }
-  })
-
-  ap.get(`/api/gun/dev/storedReqs`, async (req, res) => {
-    try {
-      const { tryAndWait } = require('../services/gunDB/contact-api/utils')
-
-      const data = await tryAndWait(
-        (_, u) => new Promise(res => u.get(Key.STORED_REQS).load(res)),
-        v => {
-          if (typeof v !== 'object') {
-            return true
-          }
-
-          if (v === null) {
-            return true
-          }
-
-          // load sometimes returns an empty set on the first try
-          return size(v) === 0
-        }
-      )
-
-      return res.status(200).json({
-        data
-      })
-    } catch (err) {
-      return res.status(500).json({
-        errorMessage: err.message
-      })
-    }
-  })
-
-  ap.get(`/api/gun/dev/userToLastReqSent`, async (req, res) => {
-    try {
-      const { tryAndWait } = require('../services/gunDB/contact-api/utils')
-
-      const data = await tryAndWait(
-        (_, u) =>
-          new Promise(res => u.get(Key.USER_TO_LAST_REQUEST_SENT).load(res)),
-        v => {
-          if (typeof v !== 'object') {
-            return true
-          }
-
-          if (v === null) {
-            return true
-          }
-
-          // load sometimes returns an empty set on the first try
-          return size(v) === 0
-        }
-      )
-
-      return res.status(200).json({
-        data
-      })
-    } catch (err) {
-      return res.status(500).json({
-        errorMessage: err.message
-      })
-    }
-  })
-
-  ap.get(`/api/gun/auth`, (_, res) => {
-    const { isAuthenticated } = require('../services/gunDB/Mediator')
-
-    return res.status(200).json({
-      data: isAuthenticated()
+        return res.status(200).json({
+          data
+        })
+      } catch (err) {
+        return res.status(500).json({
+          errorMessage: err.message
+        })
+      }
     })
-  })
 
-  /**
-   * @typedef {object} HandleGunFetchParams
-   * @prop {'once'|'load'} type
-   * @prop {boolean} startFromUserGraph
-   * @prop {string} path
-   * @prop {string=} publicKey
-   * @prop {string=} publicKeyForDecryption
-   */
-  /**
-   * @param {HandleGunFetchParams} args0
-   * @returns {Promise<unknown>}
-   */
-  const handleGunFetch = ({
-    type,
-    startFromUserGraph,
-    path,
-    publicKey,
-    publicKeyForDecryption
-  }) => {
-    const keys = path.split('>')
-    const { tryAndWait } = require('../services/gunDB/contact-api/utils')
-    return tryAndWait((gun, user) => {
-      // eslint-disable-next-line no-nested-ternary
-      let node = startFromUserGraph
-        ? user
-        : publicKey
-        ? gun.user(publicKey)
-        : gun
-      keys.forEach(key => (node = node.get(key)))
+    ap.get(`/api/gun/dev/recipientToOutgoing`, async (_, res) => {
+      try {
+        const { tryAndWait } = require('../services/gunDB/contact-api/utils')
 
-      return new Promise(res => {
-        const listener = async data => {
-          if (publicKeyForDecryption) {
-            res(
-              await GunWriteRPC.deepDecryptIfNeeded(
-                data,
-                publicKeyForDecryption
+        const data = await tryAndWait(
+          (_, u) =>
+            new Promise(res => {
+              u.get(GunKey.RECIPIENT_TO_OUTGOING).load(data => {
+                res(data)
+              })
+            }),
+          v => {
+            if (typeof v !== 'object') {
+              return true
+            }
+
+            if (v === null) {
+              return true
+            }
+
+            // load sometimes returns an empty set on the first try
+            return size(v) === 0
+          }
+        )
+
+        return res.status(200).json({
+          data
+        })
+      } catch (err) {
+        return res.status(500).json({
+          errorMessage: err.message
+        })
+      }
+    })
+
+    ap.get(`/api/gun/dev/outgoings`, async (_, res) => {
+      try {
+        const { tryAndWait } = require('../services/gunDB/contact-api/utils')
+
+        const data = await tryAndWait(
+          (_, u) =>
+            new Promise(res => {
+              u.get(GunKey.OUTGOINGS).load(data => {
+                res(data)
+              })
+            }),
+          v => {
+            if (typeof v !== 'object') {
+              return true
+            }
+
+            if (v === null) {
+              return true
+            }
+
+            // load sometimes returns an empty set on the first try
+            return size(v) === 0
+          }
+        )
+
+        return res.status(200).json({
+          data
+        })
+      } catch (err) {
+        return res.status(500).json({
+          errorMessage: err.message
+        })
+      }
+    })
+
+    ap.get(`/api/gun/dev/currentHandshakeAddress`, async (_, res) => {
+      try {
+        const { tryAndWait } = require('../services/gunDB/contact-api/utils')
+
+        const data = await tryAndWait((_, u) =>
+          u.get(GunKey.CURRENT_HANDSHAKE_ADDRESS).then()
+        )
+
+        return res.status(200).json({
+          data
+        })
+      } catch (err) {
+        return res.status(500).json({
+          errorMessage: err.message
+        })
+      }
+    })
+
+    ap.get(
+      `/api/gun/dev/handshakeNodes/:handshakeAddress`,
+      async (req, res) => {
+        try {
+          const { tryAndWait } = require('../services/gunDB/contact-api/utils')
+
+          const data = await tryAndWait(
+            g =>
+              new Promise(res => {
+                g.get(GunKey.HANDSHAKE_NODES)
+                  .get(req.params.handshakeAddress)
+                  .load(data => {
+                    res(data)
+                  })
+              }),
+            v => {
+              if (typeof v !== 'object') {
+                return true
+              }
+
+              if (v === null) {
+                return true
+              }
+
+              // load sometimes returns an empty set on the first try
+              return size(v) === 0
+            }
+          )
+
+          return res.status(200).json({
+            data
+          })
+        } catch (err) {
+          return res.status(500).json({
+            errorMessage: err.message
+          })
+        }
+      }
+    )
+
+    ap.get(`/api/gun/dev/user/:publicKey`, async (req, res) => {
+      try {
+        const { tryAndWait } = require('../services/gunDB/contact-api/utils')
+
+        const data = await tryAndWait(
+          g =>
+            new Promise(res => {
+              g.user(req.params.publicKey).load(data => {
+                res(data)
+              })
+            }),
+          v => {
+            if (typeof v !== 'object') {
+              return true
+            }
+
+            if (v === null) {
+              return true
+            }
+
+            // load sometimes returns an empty set on the first try
+            return size(v) === 0
+          }
+        )
+
+        return res.status(200).json({
+          data
+        })
+      } catch (err) {
+        return res.status(500).json({
+          errorMessage: err.message
+        })
+      }
+    })
+
+    ap.get(`/api/gun/dev/storedReqs`, async (req, res) => {
+      try {
+        const { tryAndWait } = require('../services/gunDB/contact-api/utils')
+
+        const data = await tryAndWait(
+          (_, u) => new Promise(res => u.get(Key.STORED_REQS).load(res)),
+          v => {
+            if (typeof v !== 'object') {
+              return true
+            }
+
+            if (v === null) {
+              return true
+            }
+
+            // load sometimes returns an empty set on the first try
+            return size(v) === 0
+          }
+        )
+
+        return res.status(200).json({
+          data
+        })
+      } catch (err) {
+        return res.status(500).json({
+          errorMessage: err.message
+        })
+      }
+    })
+
+    ap.get(`/api/gun/dev/userToLastReqSent`, async (req, res) => {
+      try {
+        const { tryAndWait } = require('../services/gunDB/contact-api/utils')
+
+        const data = await tryAndWait(
+          (_, u) =>
+            new Promise(res => u.get(Key.USER_TO_LAST_REQUEST_SENT).load(res)),
+          v => {
+            if (typeof v !== 'object') {
+              return true
+            }
+
+            if (v === null) {
+              return true
+            }
+
+            // load sometimes returns an empty set on the first try
+            return size(v) === 0
+          }
+        )
+
+        return res.status(200).json({
+          data
+        })
+      } catch (err) {
+        return res.status(500).json({
+          errorMessage: err.message
+        })
+      }
+    })
+
+    ap.get(`/api/gun/auth`, (_, res) => {
+      const { isAuthenticated } = require('../services/gunDB/Mediator')
+
+      return res.status(200).json({
+        data: isAuthenticated()
+      })
+    })
+
+    /**
+     * @typedef {object} HandleGunFetchParams
+     * @prop {'once'|'load'} type
+     * @prop {boolean} startFromUserGraph
+     * @prop {string} path
+     * @prop {string=} publicKey
+     * @prop {string=} publicKeyForDecryption
+     */
+    /**
+     * @param {HandleGunFetchParams} args0
+     * @returns {Promise<unknown>}
+     */
+    const handleGunFetch = ({
+      type,
+      startFromUserGraph,
+      path,
+      publicKey,
+      publicKeyForDecryption
+    }) => {
+      const keys = path.split('>')
+      const { tryAndWait } = require('../services/gunDB/contact-api/utils')
+      return tryAndWait((gun, user) => {
+        // eslint-disable-next-line no-nested-ternary
+        let node = startFromUserGraph
+          ? user
+          : publicKey
+          ? gun.user(publicKey)
+          : gun
+        keys.forEach(key => (node = node.get(key)))
+
+        return new Promise(res => {
+          const listener = async data => {
+            if (publicKeyForDecryption) {
+              res(
+                await GunWriteRPC.deepDecryptIfNeeded(
+                  data,
+                  publicKeyForDecryption
+                )
               )
-            )
-          } else {
-            res(data)
+            } else {
+              res(data)
+            }
           }
-        }
 
-        if (type === 'once') node.once(listener)
-        if (type === 'load') node.load(listener)
-      })
-    })
-  }
-
-  /**
-   * Used decryption of incoming data.
-   */
-  const PUBKEY_FOR_DECRYPT_HEADER = 'public-key-for-decryption'
-
-  ap.get('/api/gun/once/:path', async (req, res) => {
-    const publicKeyForDecryption = req.header(PUBKEY_FOR_DECRYPT_HEADER)
-    const { path } = req.params
-    try {
-      const data = await handleGunFetch({
-        path,
-        startFromUserGraph: false,
-        type: 'once',
-        publicKeyForDecryption
-      })
-      res.status(200).json({
-        data
-      })
-    } catch (err) {
-      logger.error('error in rpc once')
-      logger.error(err)
-      res
-        .status(err.message === Common.Constants.ErrorCode.NOT_AUTH ? 401 : 500)
-        .json({
-          errorMessage: err.message
+          if (type === 'once') node.once(listener)
+          if (type === 'load') node.load(listener)
         })
-    }
-  })
-
-  ap.get('/api/gun/load/:path', async (req, res) => {
-    const publicKeyForDecryption = req.header(PUBKEY_FOR_DECRYPT_HEADER)
-    const { path } = req.params
-    try {
-      const data = await handleGunFetch({
-        path,
-        startFromUserGraph: false,
-        type: 'load',
-        publicKeyForDecryption
       })
-      res.status(200).json({
-        data
-      })
-    } catch (err) {
-      logger.error('error in rpc load')
-      logger.error(err)
-      res
-        .status(err.message === Common.Constants.ErrorCode.NOT_AUTH ? 401 : 500)
-        .json({
-          errorMessage: err.message
-        })
-    }
-  })
-
-  ap.get('/api/gun/user/once/:path', async (req, res) => {
-    const publicKeyForDecryption = req.header(PUBKEY_FOR_DECRYPT_HEADER)
-    const { path } = req.params
-    try {
-      const data = await handleGunFetch({
-        path,
-        startFromUserGraph: true,
-        type: 'once',
-        publicKeyForDecryption
-      })
-      res.status(200).json({
-        data
-      })
-    } catch (err) {
-      logger.error('error in rpc once user')
-      logger.error(err)
-      res
-        .status(err.message === Common.Constants.ErrorCode.NOT_AUTH ? 401 : 500)
-        .json({
-          errorMessage: err.message
-        })
-    }
-  })
-
-  ap.get('/api/gun/user/load/:path', async (req, res) => {
-    const publicKeyForDecryption = req.header(PUBKEY_FOR_DECRYPT_HEADER)
-    const { path } = req.params
-    try {
-      const data = await handleGunFetch({
-        path,
-        startFromUserGraph: true,
-        type: 'load',
-        publicKeyForDecryption
-      })
-      res.status(200).json({
-        data
-      })
-    } catch (err) {
-      logger.error('error in rpc load user')
-      logger.error(err)
-      res
-        .status(err.message === Common.Constants.ErrorCode.NOT_AUTH ? 401 : 500)
-        .json({
-          errorMessage: err.message
-        })
-    }
-  })
-
-  ap.get('/api/gun/otheruser/:publicKey/:type/:path', async (req, res) => {
-    const allowedTypes = ['once', 'load', 'open']
-    const publicKeyForDecryption = req.header(PUBKEY_FOR_DECRYPT_HEADER)
-    const { path /*:rawPath*/, publicKey, type } = req.params
-    console.log(path)
-    // const path = decodeURI(rawPath)
-    if (!publicKey || publicKey === 'undefined') {
-      res.status(400).json({
-        errorMessage: 'Invalid publicKey specified'
-      })
-      return
     }
 
-    if (!allowedTypes.includes(type)) {
-      res.status(400).json({
-        errorMessage: 'Invalid type specified'
-      })
-      return
-    }
-    try {
-      res.status(200).json({
-        data: await handleGunFetch({
+    /**
+     * Used decryption of incoming data.
+     */
+    const PUBKEY_FOR_DECRYPT_HEADER = 'public-key-for-decryption'
+
+    ap.get('/api/gun/once/:path', async (req, res) => {
+      const publicKeyForDecryption = req.header(PUBKEY_FOR_DECRYPT_HEADER)
+      const { path } = req.params
+      try {
+        const data = await handleGunFetch({
           path,
           startFromUserGraph: false,
-          type,
-          publicKey,
+          type: 'once',
           publicKeyForDecryption
         })
-      })
-    } catch (err) {
-      res
-        .status(err.message === Common.Constants.ErrorCode.NOT_AUTH ? 401 : 500)
-        .json({
-          errorMessage: err.message
+        res.status(200).json({
+          data
         })
-    }
-  })
-
-  ap.post('/api/lnd/cb/:methodName', (req, res) => {
-    try {
-      const { lightning } = LightningServices.services
-      const { methodName } = req.params
-      const args = req.body
-
-      lightning[methodName](args, (err, lres) => {
-        if (err) {
-          res.status(500).json({
-            errorMessage: err.details
+      } catch (err) {
+        logger.error('error in rpc once')
+        logger.error(err)
+        res
+          .status(
+            err.message === Common.Constants.ErrorCode.NOT_AUTH ? 401 : 500
+          )
+          .json({
+            errorMessage: err.message
           })
-        } else if (lres) {
-          res.status(200).json(lres)
-        } else {
-          res.status(500).json({
-            errorMessage: 'Unknown error'
+      }
+    })
+
+    ap.get('/api/gun/load/:path', async (req, res) => {
+      const publicKeyForDecryption = req.header(PUBKEY_FOR_DECRYPT_HEADER)
+      const { path } = req.params
+      try {
+        const data = await handleGunFetch({
+          path,
+          startFromUserGraph: false,
+          type: 'load',
+          publicKeyForDecryption
+        })
+        res.status(200).json({
+          data
+        })
+      } catch (err) {
+        logger.error('error in rpc load')
+        logger.error(err)
+        res
+          .status(
+            err.message === Common.Constants.ErrorCode.NOT_AUTH ? 401 : 500
+          )
+          .json({
+            errorMessage: err.message
           })
-        }
-      })
-    } catch (err) {
-      logger.warn(`Error inside api cb:`)
-      logger.error(err)
-      logger.error(err.message)
+      }
+    })
 
-      return res.status(500).json({
-        errorMessage: err.message
-      })
-    }
-  })
-
-  ap.post('/api/gun/put', async (req, res) => {
-    try {
-      const { path, value } = req.body
-
-      await GunWriteRPC.put(path, value)
-
-      res.status(200).json({
-        ok: true
-      })
-    } catch (err) {
-      res
-        .status(err.message === Common.Constants.ErrorCode.NOT_AUTH ? 401 : 500)
-        .json({
-          errorMessage: err.message
+    ap.get('/api/gun/user/once/:path', async (req, res) => {
+      const publicKeyForDecryption = req.header(PUBKEY_FOR_DECRYPT_HEADER)
+      const { path } = req.params
+      try {
+        const data = await handleGunFetch({
+          path,
+          startFromUserGraph: true,
+          type: 'once',
+          publicKeyForDecryption
         })
-    }
-  })
-
-  ap.post('/api/gun/set', async (req, res) => {
-    try {
-      const { path, value } = req.body
-
-      const id = await GunWriteRPC.set(path, value)
-
-      res.status(200).json({
-        ok: true,
-        id
-      })
-    } catch (err) {
-      res
-        .status(err.message === Common.Constants.ErrorCode.NOT_AUTH ? 401 : 500)
-        .json({
-          errorMessage: err.message
+        res.status(200).json({
+          data
         })
-    }
-  })
+      } catch (err) {
+        logger.error('error in rpc once user')
+        logger.error(err)
+        res
+          .status(
+            err.message === Common.Constants.ErrorCode.NOT_AUTH ? 401 : 500
+          )
+          .json({
+            errorMessage: err.message
+          })
+      }
+    })
 
-  ap.get('/api/log', async (_, res) => {
-    try {
-      // https://github.com/winstonjs/winston#querying-logs
-      /**
-       * @type {import('winston').QueryOptions}
-       */
-      const options = {
-        from: new Date() - 1 * 60 * 60 * 1000,
-        until: new Date()
+    ap.get('/api/gun/user/load/:path', async (req, res) => {
+      const publicKeyForDecryption = req.header(PUBKEY_FOR_DECRYPT_HEADER)
+      const { path } = req.params
+      try {
+        const data = await handleGunFetch({
+          path,
+          startFromUserGraph: true,
+          type: 'load',
+          publicKeyForDecryption
+        })
+        res.status(200).json({
+          data
+        })
+      } catch (err) {
+        logger.error('error in rpc load user')
+        logger.error(err)
+        res
+          .status(
+            err.message === Common.Constants.ErrorCode.NOT_AUTH ? 401 : 500
+          )
+          .json({
+            errorMessage: err.message
+          })
+      }
+    })
+
+    ap.get('/api/gun/otheruser/:publicKey/:type/:path', async (req, res) => {
+      const allowedTypes = ['once', 'load', 'open']
+      const publicKeyForDecryption = req.header(PUBKEY_FOR_DECRYPT_HEADER)
+      const { path /*:rawPath*/, publicKey, type } = req.params
+      console.log(path)
+      // const path = decodeURI(rawPath)
+      if (!publicKey || publicKey === 'undefined') {
+        res.status(400).json({
+          errorMessage: 'Invalid publicKey specified'
+        })
+        return
       }
 
-      const results = await Common.Utils.makePromise((res, rej) => {
-        logger.query(options, (err, results) => {
+      if (!allowedTypes.includes(type)) {
+        res.status(400).json({
+          errorMessage: 'Invalid type specified'
+        })
+        return
+      }
+      try {
+        res.status(200).json({
+          data: await handleGunFetch({
+            path,
+            startFromUserGraph: false,
+            type,
+            publicKey,
+            publicKeyForDecryption
+          })
+        })
+      } catch (err) {
+        res
+          .status(
+            err.message === Common.Constants.ErrorCode.NOT_AUTH ? 401 : 500
+          )
+          .json({
+            errorMessage: err.message
+          })
+      }
+    })
+
+    ap.post('/api/lnd/cb/:methodName', (req, res) => {
+      try {
+        const { lightning } = LightningServices.services
+        const { methodName } = req.params
+        const args = req.body
+
+        lightning[methodName](args, (err, lres) => {
           if (err) {
-            rej(err)
+            res.status(500).json({
+              errorMessage: err.details
+            })
+          } else if (lres) {
+            res.status(200).json(lres)
           } else {
-            res(results)
+            res.status(500).json({
+              errorMessage: 'Unknown error'
+            })
           }
         })
-      })
+      } catch (err) {
+        logger.warn(`Error inside api cb:`)
+        logger.error(err)
+        logger.error(err.message)
 
-      res.status(200).json(results)
-    } catch (e) {
-      res
-        .status(e.message === Common.Constants.ErrorCode.NOT_AUTH ? 401 : 500)
-        .json({
-          errorMessage: e.message
+        return res.status(500).json({
+          errorMessage: err.message
         })
-    }
-  })
-  //this is for OBS notifications, not wired with UI.
-  ap.get('/api/subscribeStream', (req, res) => {
-    res.sendFile(path.join(__dirname, '/index.html'))
-  })
-  ap.post('/api/enableNotificationsOverlay', (req, res) => {
-    const { postID } = req.body
-    if (!postID) {
-      return res.status(400).json({
-        errorMessage: 'no post id provided'
-      })
-    }
-    const accessId = TipsForwarder.enablePostNotifications(postID)
-    res.json({
-      accessId
+      }
     })
-  })
-  //this is for wasLive/isLive status
-  ap.post('/api/listenStream', (req, res) => {
-    try {
-      startedStream(req.body)
-      return res.status(200).json({
-        ok: true
+
+    ap.post('/api/gun/put', async (req, res) => {
+      try {
+        const { path, value } = req.body
+
+        await GunWriteRPC.put(path, value)
+
+        res.status(200).json({
+          ok: true
+        })
+      } catch (err) {
+        res
+          .status(
+            err.message === Common.Constants.ErrorCode.NOT_AUTH ? 401 : 500
+          )
+          .json({
+            errorMessage: err.message
+          })
+      }
+    })
+
+    ap.post('/api/gun/set', async (req, res) => {
+      try {
+        const { path, value } = req.body
+
+        const id = await GunWriteRPC.set(path, value)
+
+        res.status(200).json({
+          ok: true,
+          id
+        })
+      } catch (err) {
+        res
+          .status(
+            err.message === Common.Constants.ErrorCode.NOT_AUTH ? 401 : 500
+          )
+          .json({
+            errorMessage: err.message
+          })
+      }
+    })
+
+    ap.get('/api/log', async (_, res) => {
+      try {
+        // https://github.com/winstonjs/winston#querying-logs
+        /**
+         * @type {import('winston').QueryOptions}
+         */
+        const options = {
+          from: new Date() - 1 * 60 * 60 * 1000,
+          until: new Date()
+        }
+
+        const results = await Common.Utils.makePromise((res, rej) => {
+          logger.query(options, (err, results) => {
+            if (err) {
+              rej(err)
+            } else {
+              res(results)
+            }
+          })
+        })
+
+        res.status(200).json(results)
+      } catch (e) {
+        res
+          .status(e.message === Common.Constants.ErrorCode.NOT_AUTH ? 401 : 500)
+          .json({
+            errorMessage: e.message
+          })
+      }
+    })
+    //this is for OBS notifications, not wired with UI.
+    ap.get('/api/subscribeStream', (req, res) => {
+      res.sendFile(path.join(__dirname, '/index.html'))
+    })
+    ap.post('/api/enableNotificationsOverlay', (req, res) => {
+      const { postID } = req.body
+      if (!postID) {
+        return res.status(400).json({
+          errorMessage: 'no post id provided'
+        })
+      }
+      const accessId = TipsForwarder.enablePostNotifications(postID)
+      res.json({
+        accessId
       })
-    } catch (e) {
-      console.log(e)
-      return res.status(500).json({
-        errorMessage:
-          (typeof e === 'string' ? e : e.message) || 'Unknown error.'
-      })
-    }
-  })
-  ap.post('/api/stopStream', (req, res) => {
-    try {
-      endStream(req.body)
-      return res.status(200).json({
-        ok: true
-      })
-    } catch (e) {
-      console.log(e)
-      return res.status(500).json({
-        errorMessage:
-          (typeof e === 'string' ? e : e.message) || 'Unknown error.'
-      })
-    }
-  })
+    })
+    //this is for wasLive/isLive status
+    ap.post('/api/listenStream', (req, res) => {
+      try {
+        startedStream(req.body)
+        return res.status(200).json({
+          ok: true
+        })
+      } catch (e) {
+        console.log(e)
+        return res.status(500).json({
+          errorMessage:
+            (typeof e === 'string' ? e : e.message) || 'Unknown error.'
+        })
+      }
+    })
+    ap.post('/api/stopStream', (req, res) => {
+      try {
+        endStream(req.body)
+        return res.status(200).json({
+          ok: true
+        })
+      } catch (e) {
+        console.log(e)
+        return res.status(500).json({
+          errorMessage:
+            (typeof e === 'string' ? e : e.message) || 'Unknown error.'
+        })
+      }
+    })
+  } catch (err) {
+    logger.warn('Unhandled rejection:', err)
+  }
 }

From 265e00679791a81f8c85ebf366012e1af0ddde87 Mon Sep 17 00:00:00 2001
From: Version Update Action <actions@shock.network>
Date: Sun, 18 Jul 2021 13:41:45 +0000
Subject: [PATCH 11/32] version upgraded to 2021.7.18

---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 36b51589..91000b67 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "shockapi",
-  "version": "2021.7.15-1",
+  "version": "2021.7.18",
   "description": "",
   "main": "src/server.js",
   "scripts": {

From 921097dea103ea94723c6996a50a902ff85a9380 Mon Sep 17 00:00:00 2001
From: Daniel Lugo <danlugo92@gmail.com>
Date: Tue, 8 Jun 2021 14:09:14 -0400
Subject: [PATCH 12/32] Accept epub for faster decrypting/encrypting

---
 services/gunDB/rpc/index.js | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/services/gunDB/rpc/index.js b/services/gunDB/rpc/index.js
index 114836d2..b3cca30a 100644
--- a/services/gunDB/rpc/index.js
+++ b/services/gunDB/rpc/index.js
@@ -81,6 +81,7 @@ async function deepEncryptIfNeeded(value) {
   }
 
   const pk = /** @type {string|undefined} */ (value.$$__ENCRYPT__FOR)
+  const epub = /** @type {string|undefined} */ (value.$$__EPUB__FOR)
 
   if (!pk) {
     return Bluebird.props(mapValues(value, deepEncryptIfNeeded))
@@ -93,7 +94,15 @@ async function deepEncryptIfNeeded(value) {
   if (pk === u.is.pub || pk === 'me') {
     encryptedValue = await SEA.encrypt(actualValue, getMySecret())
   } else {
-    const sec = await SEA.secret(await pubToEpub(pk), u._.sea)
+    const sec = await SEA.secret(
+      await (() => {
+        if (epub) {
+          return epub
+        }
+        return pubToEpub(pk)
+      })(),
+      u._.sea
+    )
 
     encryptedValue = await SEA.encrypt(actualValue, sec)
   }

From 495ec356558e13392648ca382ecfa667f77158fc Mon Sep 17 00:00:00 2001
From: Daniel Lugo <danlugo92@gmail.com>
Date: Tue, 8 Jun 2021 14:10:35 -0400
Subject: [PATCH 13/32] No longer spin up chat-related jobs at login

---
 services/gunDB/Mediator/index.js | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/services/gunDB/Mediator/index.js b/services/gunDB/Mediator/index.js
index 10174e58..6b130d91 100644
--- a/services/gunDB/Mediator/index.js
+++ b/services/gunDB/Mediator/index.js
@@ -375,16 +375,12 @@ const authenticate = async (alias, pass, __user) => {
     }))
 
     // move this to a subscription; implement off() ? todo
-    API.Jobs.onAcceptedRequests(_user, mySEA)
     API.Jobs.onOrders(_user, gun, mySEA)
     API.Jobs.lastSeenNode(_user)
 
-    API.Events.onChats(() => {})()
     API.Events.onCurrentHandshakeAddress(() => {}, user)()
     API.Events.onOutgoing(() => {})()
     API.Events.onSeedBackup(() => {}, user, mySEA)
-    API.Events.onSimplerReceivedRequests(() => {})()
-    API.Events.onSimplerSentRequests(() => {})()
 
     return _user._.sea.pub
   }
@@ -429,17 +425,11 @@ const authenticate = async (alias, pass, __user) => {
       )
     }))
 
-    API.Jobs.onAcceptedRequests(_user, mySEA)
     API.Jobs.onOrders(_user, gun, mySEA)
     API.Jobs.lastSeenNode(_user)
 
-    API.Events.onChats(() => {})()
     API.Events.onCurrentHandshakeAddress(() => {}, user)()
-
-    API.Events.onOutgoing(() => {})()
     API.Events.onSeedBackup(() => {}, user, mySEA)
-    API.Events.onSimplerReceivedRequests(() => {})()
-    API.Events.onSimplerSentRequests(() => {})()
 
     return ack.sea.pub
   } else {

From 5bf095469fa6d5901a160513c8a6036c88a39796 Mon Sep 17 00:00:00 2001
From: Daniel Lugo <danlugo92@gmail.com>
Date: Tue, 8 Jun 2021 14:11:05 -0400
Subject: [PATCH 14/32] onAcceptedRequests job no longer needed

---
 services/gunDB/contact-api/jobs/index.js      |   2 -
 .../contact-api/jobs/onAcceptedRequests.js    | 191 ------------------
 2 files changed, 193 deletions(-)
 delete mode 100644 services/gunDB/contact-api/jobs/onAcceptedRequests.js

diff --git a/services/gunDB/contact-api/jobs/index.js b/services/gunDB/contact-api/jobs/index.js
index 8818d047..96dcc67d 100644
--- a/services/gunDB/contact-api/jobs/index.js
+++ b/services/gunDB/contact-api/jobs/index.js
@@ -9,12 +9,10 @@
  * tasks accept factories that are homonymous to the events on this same module.
  */
 
-const onAcceptedRequests = require('./onAcceptedRequests')
 const onOrders = require('./onOrders')
 const lastSeenNode = require('./lastSeenNode')
 
 module.exports = {
-  onAcceptedRequests,
   onOrders,
   lastSeenNode
 }
diff --git a/services/gunDB/contact-api/jobs/onAcceptedRequests.js b/services/gunDB/contact-api/jobs/onAcceptedRequests.js
deleted file mode 100644
index b8a559f5..00000000
--- a/services/gunDB/contact-api/jobs/onAcceptedRequests.js
+++ /dev/null
@@ -1,191 +0,0 @@
-/**
- * @format
- */
-const logger = require('winston')
-const {
-  Constants: { ErrorCode },
-  Schema
-} = require('shock-common')
-const size = require('lodash/size')
-
-const Key = require('../key')
-const Utils = require('../utils')
-
-/**
- * @typedef {import('../SimpleGUN').GUNNode} GUNNode
- * @typedef {import('../SimpleGUN').ISEA} ISEA
- * @typedef {import('../SimpleGUN').UserGUNNode} UserGUNNode
- */
-
-let procid = 0
-
-/**
- * @throws {Error} NOT_AUTH
- * @param {UserGUNNode} user
- * @param {ISEA} SEA
- * @returns {void}
- */
-const onAcceptedRequests = (user, SEA) => {
-  if (!user.is) {
-    logger.warn('onAcceptedRequests() -> tried to sub without authing')
-    throw new Error(ErrorCode.NOT_AUTH)
-  }
-
-  procid++
-
-  user
-    .get(Key.STORED_REQS)
-    .map()
-    .on(async (storedReq, id) => {
-      logger.info(
-        `------------------------------------\nPROCID:${procid} (used for debugging memory leaks in jobs)\n---------------------------------------`
-      )
-
-      const mySecret = require('../../Mediator').getMySecret()
-
-      try {
-        if (!Schema.isStoredRequest(storedReq)) {
-          throw new Error(
-            'Stored request not an StoredRequest, instead got: ' +
-              JSON.stringify(storedReq) +
-              ' this can be due to nulling out an old request (if null) or something else happened (please look at the output)'
-          )
-        }
-        // get the recipient pub from the stored request to avoid an attacker
-        // overwriting the handshake request in the root graph
-        const recipientPub = await SEA.decrypt(storedReq.recipientPub, mySecret)
-
-        if (typeof recipientPub !== 'string') {
-          throw new TypeError(
-            `Expected storedReq.recipientPub to be an string, instead got: ${recipientPub}`
-          )
-        }
-
-        if (await Utils.successfulHandshakeAlreadyExists(recipientPub)) {
-          return
-        }
-
-        const requestAddress = await SEA.decrypt(
-          storedReq.handshakeAddress,
-          mySecret
-        )
-        if (typeof requestAddress !== 'string') {
-          throw new TypeError()
-        }
-        const sentReqID = await SEA.decrypt(storedReq.sentReqID, mySecret)
-        if (typeof sentReqID !== 'string') {
-          throw new TypeError()
-        }
-
-        const latestReqSentID = await Utils.recipientPubToLastReqSentID(
-          recipientPub
-        )
-
-        const isStaleRequest = latestReqSentID !== sentReqID
-        if (isStaleRequest) {
-          return
-        }
-
-        const gun = require('../../Mediator').getGun()
-        const user = require('../../Mediator').getUser()
-
-        const recipientEpub = await Utils.pubToEpub(recipientPub)
-        const ourSecret = await SEA.secret(recipientEpub, user._.sea)
-
-        await /** @type {Promise<void>} */ (new Promise((res, rej) => {
-          gun
-            .get(Key.HANDSHAKE_NODES)
-            .get(requestAddress)
-            .get(sentReqID)
-            .on(async sentReq => {
-              if (!Schema.isHandshakeRequest(sentReq)) {
-                rej(
-                  new Error(
-                    'sent request found in handshake node not a handshake request'
-                  )
-                )
-                return
-              }
-
-              // The response can be decrypted with the same secret regardless
-              // of who wrote to it last (see HandshakeRequest definition). This
-              // could be our feed ID for the recipient, or the recipient's feed
-              // id if he accepted the request.
-              const feedID = await SEA.decrypt(sentReq.response, ourSecret)
-
-              if (typeof feedID !== 'string') {
-                throw new TypeError("typeof feedID !== 'string'")
-              }
-
-              logger.info(`onAcceptedRequests -> decrypted feed ID: ${feedID}`)
-
-              logger.info(
-                'Will now try to access the other users outgoing feed'
-              )
-
-              const maybeFeedOnRecipientsOutgoings = await Utils.tryAndWait(
-                gun =>
-                  new Promise(res => {
-                    gun
-                      .user(recipientPub)
-                      .get(Key.OUTGOINGS)
-                      .get(feedID)
-                      .once(feed => {
-                        res(feed)
-                      })
-                  }),
-                // @ts-ignore
-                v => size(v) === 0
-              )
-
-              const feedIDExistsOnRecipientsOutgoings =
-                typeof maybeFeedOnRecipientsOutgoings === 'object' &&
-                maybeFeedOnRecipientsOutgoings !== null
-
-              if (!feedIDExistsOnRecipientsOutgoings) {
-                return
-              }
-
-              const encryptedForMeIncomingID = await SEA.encrypt(
-                feedID,
-                mySecret
-              )
-
-              await /** @type {Promise<void>} */ (new Promise((res, rej) => {
-                user
-                  .get(Key.USER_TO_INCOMING)
-                  .get(recipientPub)
-                  .put(encryptedForMeIncomingID, ack => {
-                    if (ack.err && typeof ack.err !== 'number') {
-                      rej(new Error(ack.err))
-                    } else {
-                      res()
-                    }
-                  })
-              }))
-
-              await /** @type {Promise<void>} */ (new Promise((res, rej) => {
-                user
-                  .get(Key.STORED_REQS)
-                  .get(id)
-                  .put(null, ack => {
-                    if (ack.err && typeof ack.err !== 'number') {
-                      rej(new Error(ack.err))
-                    } else {
-                      res()
-                    }
-                  })
-              }))
-
-              // ensure this listeners gets called at least once
-              res()
-            })
-        }))
-      } catch (err) {
-        logger.warn(`Jobs.onAcceptedRequests() -> ${err.message}`)
-        logger.error(err)
-      }
-    })
-}
-
-module.exports = onAcceptedRequests

From 9614c24856afa2788acf7be7eb5029e695d23ade Mon Sep 17 00:00:00 2001
From: Daniel Lugo <danlugo92@gmail.com>
Date: Tue, 8 Jun 2021 15:56:25 -0400
Subject: [PATCH 15/32] Add "pubkey" to dictionary

---
 .vscode/settings.json | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.vscode/settings.json b/.vscode/settings.json
index 2faaa640..f11f2b7c 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -7,6 +7,7 @@
   "cSpell.words": [
     "Epub",
     "ISEA",
+    "PUBKEY",
     "Reqs"
   ]
 }

From 37a466f9f38475be746c3e5d88dc15a12c00a448 Mon Sep 17 00:00:00 2001
From: Daniel Lugo <danlugo92@gmail.com>
Date: Tue, 8 Jun 2021 15:57:22 -0400
Subject: [PATCH 16/32] Allows client to provide epub for faster decrypt

---
 .vscode/settings.json           |   7 +--
 services/gunDB/rpc/index.js     |  13 +++-
 services/gunDB/sockets/index.js |  19 ++++--
 src/routes.js                   | 107 +++++++++++---------------------
 4 files changed, 62 insertions(+), 84 deletions(-)

diff --git a/.vscode/settings.json b/.vscode/settings.json
index f11f2b7c..f7a45822 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -4,10 +4,5 @@
   "debug.node.autoAttach": "on",
   "editor.formatOnSave": true,
   "editor.defaultFormatter": "esbenp.prettier-vscode",
-  "cSpell.words": [
-    "Epub",
-    "ISEA",
-    "PUBKEY",
-    "Reqs"
-  ]
+  "cSpell.words": ["Epub", "GUNRPC", "ISEA", "PUBKEY", "Reqs", "uuidv"]
 }
diff --git a/services/gunDB/rpc/index.js b/services/gunDB/rpc/index.js
index b3cca30a..b9ef24a1 100644
--- a/services/gunDB/rpc/index.js
+++ b/services/gunDB/rpc/index.js
@@ -27,9 +27,10 @@ const PATH_SEPARATOR = '>'
 /**
  * @param {ValidDataValue} value
  * @param {string} publicKey
+ * @param {string=} epubForDecryption
  * @returns {Promise<ValidDataValue>}
  */
-const deepDecryptIfNeeded = async (value, publicKey) => {
+const deepDecryptIfNeeded = async (value, publicKey, epubForDecryption) => {
   if (Schema.isObj(value)) {
     return Bluebird.props(
       mapValues(value, o => deepDecryptIfNeeded(o, publicKey))
@@ -49,7 +50,15 @@ const deepDecryptIfNeeded = async (value, publicKey) => {
     if (user.is.pub === publicKey || 'me' === publicKey) {
       sec = getMySecret()
     } else {
-      sec = await SEA.secret(await pubToEpub(publicKey), user._.sea)
+      sec = await SEA.secret(
+        await (() => {
+          if (epubForDecryption) {
+            return epubForDecryption
+          }
+          return pubToEpub(publicKey)
+        })(),
+        user._.sea
+      )
     }
 
     const decrypted = SEA.decrypt(value, sec)
diff --git a/services/gunDB/sockets/index.js b/services/gunDB/sockets/index.js
index a1427703..f4a2eee7 100644
--- a/services/gunDB/sockets/index.js
+++ b/services/gunDB/sockets/index.js
@@ -121,13 +121,15 @@ const executeGunQuery = (query, method, listener) => {
  * @param {string} queryData.publicKeyForDecryption
  * @param {string} queryData.subscriptionId
  * @param {string} queryData.deviceId
+ * @param {string=} queryData.epubForDecryption
  * @returns {GunListener}
  */
 const queryListenerCallback = ({
   emit,
   publicKeyForDecryption,
   subscriptionId,
-  deviceId
+  deviceId,
+  epubForDecryption
 }) => async (data, key, _msg, event) => {
   try {
     const subscription = Subscriptions.get({
@@ -142,8 +144,13 @@ const queryListenerCallback = ({
       })
     }
     const eventName = `query:data`
-    if (publicKeyForDecryption) {
-      const decData = await deepDecryptIfNeeded(data, publicKeyForDecryption)
+
+    if (publicKeyForDecryption?.length > 15) {
+      const decData = await deepDecryptIfNeeded(
+        data,
+        publicKeyForDecryption,
+        epubForDecryption
+      )
       emit(eventName, { subscriptionId, response: { data: decData, key } })
       return
     }
@@ -250,7 +257,8 @@ const startSocket = socket => {
       })
     }
 
-    on('subscribe:query', ({ $shock, publicKey }, response) => {
+    on('subscribe:query', (query, response) => {
+      const { $shock, publicKey, epubForDecryption } = query
       const subscriptionId = uuidv4()
       try {
         if (!isAuthenticated()) {
@@ -277,7 +285,8 @@ const startSocket = socket => {
           emit,
           publicKeyForDecryption: publicKey,
           subscriptionId,
-          deviceId: encryptionId
+          deviceId: encryptionId,
+          epubForDecryption
         })
 
         socketCallback(null, {
diff --git a/src/routes.js b/src/routes.js
index d0b3525c..e5b8acfb 100644
--- a/src/routes.js
+++ b/src/routes.js
@@ -3112,6 +3112,7 @@ module.exports = async (
      * @prop {string} path
      * @prop {string=} publicKey
      * @prop {string=} publicKeyForDecryption
+     * @prop {string=} epubForDecryption
      */
     /**
      * @param {HandleGunFetchParams} args0
@@ -3122,7 +3123,8 @@ module.exports = async (
       startFromUserGraph,
       path,
       publicKey,
-      publicKeyForDecryption
+      publicKeyForDecryption,
+      epubForDecryption
     }) => {
       const keys = path.split('>')
       const { tryAndWait } = require('../services/gunDB/contact-api/utils')
@@ -3141,7 +3143,8 @@ module.exports = async (
               res(
                 await GunWriteRPC.deepDecryptIfNeeded(
                   data,
-                  publicKeyForDecryption
+                  publicKeyForDecryption,
+                  epubForDecryption
                 )
               )
             } else {
@@ -3159,114 +3162,75 @@ module.exports = async (
      * Used decryption of incoming data.
      */
     const PUBKEY_FOR_DECRYPT_HEADER = 'public-key-for-decryption'
+    /**
+     * Used decryption of incoming data.
+     */
+    const EPUB_FOR_DECRYPT_HEADER = 'epub-for-decryption'
 
     ap.get('/api/gun/once/:path', async (req, res) => {
       const publicKeyForDecryption = req.header(PUBKEY_FOR_DECRYPT_HEADER)
+      const epubForDecryption = req.header(EPUB_FOR_DECRYPT_HEADER)
       const { path } = req.params
-      try {
-        const data = await handleGunFetch({
+      res.status(200).json({
+        data: await handleGunFetch({
           path,
           startFromUserGraph: false,
           type: 'once',
-          publicKeyForDecryption
+          publicKeyForDecryption,
+          epubForDecryption
         })
-        res.status(200).json({
-          data
-        })
-      } catch (err) {
-        logger.error('error in rpc once')
-        logger.error(err)
-        res
-          .status(
-            err.message === Common.Constants.ErrorCode.NOT_AUTH ? 401 : 500
-          )
-          .json({
-            errorMessage: err.message
-          })
-      }
+      })
     })
 
     ap.get('/api/gun/load/:path', async (req, res) => {
       const publicKeyForDecryption = req.header(PUBKEY_FOR_DECRYPT_HEADER)
+      const epubForDecryption = req.header(EPUB_FOR_DECRYPT_HEADER)
       const { path } = req.params
-      try {
-        const data = await handleGunFetch({
+      res.status(200).json({
+        data: await handleGunFetch({
           path,
           startFromUserGraph: false,
           type: 'load',
-          publicKeyForDecryption
+          publicKeyForDecryption,
+          epubForDecryption
         })
-        res.status(200).json({
-          data
-        })
-      } catch (err) {
-        logger.error('error in rpc load')
-        logger.error(err)
-        res
-          .status(
-            err.message === Common.Constants.ErrorCode.NOT_AUTH ? 401 : 500
-          )
-          .json({
-            errorMessage: err.message
-          })
-      }
+      })
     })
 
     ap.get('/api/gun/user/once/:path', async (req, res) => {
       const publicKeyForDecryption = req.header(PUBKEY_FOR_DECRYPT_HEADER)
+      const epubForDecryption = req.header(EPUB_FOR_DECRYPT_HEADER)
       const { path } = req.params
-      try {
-        const data = await handleGunFetch({
+      res.status(200).json({
+        data: await handleGunFetch({
           path,
           startFromUserGraph: true,
           type: 'once',
-          publicKeyForDecryption
+          publicKeyForDecryption,
+          epubForDecryption
         })
-        res.status(200).json({
-          data
-        })
-      } catch (err) {
-        logger.error('error in rpc once user')
-        logger.error(err)
-        res
-          .status(
-            err.message === Common.Constants.ErrorCode.NOT_AUTH ? 401 : 500
-          )
-          .json({
-            errorMessage: err.message
-          })
-      }
+      })
     })
 
     ap.get('/api/gun/user/load/:path', async (req, res) => {
       const publicKeyForDecryption = req.header(PUBKEY_FOR_DECRYPT_HEADER)
+      const epubForDecryption = req.header(EPUB_FOR_DECRYPT_HEADER)
       const { path } = req.params
-      try {
-        const data = await handleGunFetch({
+      res.status(200).json({
+        data: await handleGunFetch({
           path,
           startFromUserGraph: true,
           type: 'load',
-          publicKeyForDecryption
+          publicKeyForDecryption,
+          epubForDecryption
         })
-        res.status(200).json({
-          data
-        })
-      } catch (err) {
-        logger.error('error in rpc load user')
-        logger.error(err)
-        res
-          .status(
-            err.message === Common.Constants.ErrorCode.NOT_AUTH ? 401 : 500
-          )
-          .json({
-            errorMessage: err.message
-          })
-      }
+      })
     })
 
     ap.get('/api/gun/otheruser/:publicKey/:type/:path', async (req, res) => {
       const allowedTypes = ['once', 'load', 'open']
       const publicKeyForDecryption = req.header(PUBKEY_FOR_DECRYPT_HEADER)
+      const epubForDecryption = req.header(EPUB_FOR_DECRYPT_HEADER)
       const { path /*:rawPath*/, publicKey, type } = req.params
       console.log(path)
       // const path = decodeURI(rawPath)
@@ -3290,7 +3254,8 @@ module.exports = async (
             startFromUserGraph: false,
             type,
             publicKey,
-            publicKeyForDecryption
+            publicKeyForDecryption,
+            epubForDecryption
           })
         })
       } catch (err) {

From d95620096aa65cc61a308df96e8e6a24ba46718b Mon Sep 17 00:00:00 2001
From: Daniel Lugo <danlugo92@gmail.com>
Date: Thu, 10 Jun 2021 15:20:03 -0400
Subject: [PATCH 17/32] Better error (used to show up as [Object object])

---
 services/gunDB/Mediator/index.js | 30 +++++++++++++++++++++++++++---
 1 file changed, 27 insertions(+), 3 deletions(-)

diff --git a/services/gunDB/Mediator/index.js b/services/gunDB/Mediator/index.js
index 6b130d91..29e4530e 100644
--- a/services/gunDB/Mediator/index.js
+++ b/services/gunDB/Mediator/index.js
@@ -335,7 +335,15 @@ const authenticate = async (alias, pass, __user) => {
           },
           ack => {
             if (ack.err && typeof ack.err !== 'number') {
-              rej(new Error(`Error initializing follows: ${ack.err}`))
+              rej(
+                new Error(
+                  `Error initializing follows: ${JSON.stringify(
+                    ack.err,
+                    null,
+                    4
+                  )}`
+                )
+              )
             } else {
               res()
             }
@@ -366,7 +374,15 @@ const authenticate = async (alias, pass, __user) => {
         },
         ack => {
           if (ack.err && typeof ack.err !== 'number') {
-            rej(new Error(`Error initializing follows: ${ack.err}`))
+            rej(
+              new Error(
+                `Error initializing follows: ${JSON.stringify(
+                  ack.err,
+                  null,
+                  4
+                )}`
+              )
+            )
           } else {
             res()
           }
@@ -417,7 +433,15 @@ const authenticate = async (alias, pass, __user) => {
         },
         ack => {
           if (ack.err && typeof ack.err !== 'number') {
-            rej(new Error(`Error initializing follows: ${ack.err}`))
+            rej(
+              new Error(
+                `Error initializing follows: ${JSON.stringify(
+                  ack.err,
+                  null,
+                  4
+                )}`
+              )
+            )
           } else {
             res()
           }

From 79e569c32254f6b4a2ebc3cfacd7a2f3c00d5afa Mon Sep 17 00:00:00 2001
From: Daniel Lugo <danlugo92@gmail.com>
Date: Thu, 10 Jun 2021 16:08:15 -0400
Subject: [PATCH 18/32] Deprecate onOutgoings

---
 services/gunDB/Mediator/index.js           | 2 +-
 services/gunDB/contact-api/events/index.js | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/services/gunDB/Mediator/index.js b/services/gunDB/Mediator/index.js
index 29e4530e..66b2ed24 100644
--- a/services/gunDB/Mediator/index.js
+++ b/services/gunDB/Mediator/index.js
@@ -395,7 +395,7 @@ const authenticate = async (alias, pass, __user) => {
     API.Jobs.lastSeenNode(_user)
 
     API.Events.onCurrentHandshakeAddress(() => {}, user)()
-    API.Events.onOutgoing(() => {})()
+    // API.Events.onOutgoing(() => {})()
     API.Events.onSeedBackup(() => {}, user, mySEA)
 
     return _user._.sea.pub
diff --git a/services/gunDB/contact-api/events/index.js b/services/gunDB/contact-api/events/index.js
index 54e6725e..bd488978 100644
--- a/services/gunDB/contact-api/events/index.js
+++ b/services/gunDB/contact-api/events/index.js
@@ -404,7 +404,7 @@ const onChats = cb => {
 
   if (!onChatsSubbed) {
     const Streams = require('../streams')
-    onOutgoing(processChats)
+    // onOutgoing(processChats)
     Streams.onPubToFeed(processChats)
     onChatsSubbed = true
   }

From 33f889c8312d05ab48ae6a0f188d41bc1d5bd05c Mon Sep 17 00:00:00 2001
From: Daniel Lugo <danlugo92@gmail.com>
Date: Thu, 10 Jun 2021 16:47:45 -0400
Subject: [PATCH 19/32] Handle weird non-string errors from gun

---
 services/gunDB/rpc/index.js | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/services/gunDB/rpc/index.js b/services/gunDB/rpc/index.js
index b9ef24a1..a255e5c2 100644
--- a/services/gunDB/rpc/index.js
+++ b/services/gunDB/rpc/index.js
@@ -205,7 +205,13 @@ const put = async (rawPath, value) => {
     await makePromise((res, rej) => {
       node.put(/** @type {ValidDataValue} */ (theValue), ack => {
         if (ack.err && typeof ack.err !== 'number') {
-          rej(new Error(ack.err))
+          if (typeof ack.err === 'string') {
+            rej(new Error(ack.err))
+          } else {
+            console.log(`NON STANDARD GUN ERROR:`)
+            console.log(ack)
+            rej(new Error(JSON.stringify(ack.err, null, 4)))
+          }
         } else {
           res()
         }

From 03b957f15c5670c7cfd91a4c6487134004353c82 Mon Sep 17 00:00:00 2001
From: Daniel Lugo <danlugo92@gmail.com>
Date: Sat, 12 Jun 2021 11:52:49 -0400
Subject: [PATCH 20/32] Pass through arg to recursive call

---
 services/gunDB/rpc/index.js | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/services/gunDB/rpc/index.js b/services/gunDB/rpc/index.js
index a255e5c2..c33857cb 100644
--- a/services/gunDB/rpc/index.js
+++ b/services/gunDB/rpc/index.js
@@ -33,7 +33,9 @@ const PATH_SEPARATOR = '>'
 const deepDecryptIfNeeded = async (value, publicKey, epubForDecryption) => {
   if (Schema.isObj(value)) {
     return Bluebird.props(
-      mapValues(value, o => deepDecryptIfNeeded(o, publicKey))
+      mapValues(value, o =>
+        deepDecryptIfNeeded(o, publicKey, epubForDecryption)
+      )
     )
   }
 

From 1a15d204410de3c0f7d3cae91a983d6701f9fc4d Mon Sep 17 00:00:00 2001
From: Daniel Lugo <danlugo92@gmail.com>
Date: Sat, 12 Jun 2021 11:54:11 -0400
Subject: [PATCH 21/32] "epubField" mechanism for gun rpc

---
 services/gunDB/sockets/index.js | 41 ++++++++++++++++++++++++++++-----
 1 file changed, 35 insertions(+), 6 deletions(-)

diff --git a/services/gunDB/sockets/index.js b/services/gunDB/sockets/index.js
index f4a2eee7..4aa27d73 100644
--- a/services/gunDB/sockets/index.js
+++ b/services/gunDB/sockets/index.js
@@ -122,6 +122,8 @@ const executeGunQuery = (query, method, listener) => {
  * @param {string} queryData.subscriptionId
  * @param {string} queryData.deviceId
  * @param {string=} queryData.epubForDecryption
+ * @param {string=} queryData.epubField If the epub is included in the received
+ * data itself. Handshake requests for example, have an epub field.
  * @returns {GunListener}
  */
 const queryListenerCallback = ({
@@ -129,7 +131,8 @@ const queryListenerCallback = ({
   publicKeyForDecryption,
   subscriptionId,
   deviceId,
-  epubForDecryption
+  epubForDecryption,
+  epubField
 }) => async (data, key, _msg, event) => {
   try {
     const subscription = Subscriptions.get({
@@ -144,12 +147,37 @@ const queryListenerCallback = ({
       })
     }
     const eventName = `query:data`
-
-    if (publicKeyForDecryption?.length > 15) {
+    if (publicKeyForDecryption?.length > 15 || epubForDecryption || epubField) {
       const decData = await deepDecryptIfNeeded(
         data,
         publicKeyForDecryption,
-        epubForDecryption
+        (() => {
+          if (epubField) {
+            if (Common.isObj(data)) {
+              const epub = data[epubField]
+              if (Common.isPopulatedString(epub)) {
+                return epub
+              }
+
+              logger.error(
+                `Got epubField in a rifle query, but the resulting value obtained is not an string -> `,
+                {
+                  data,
+                  epub
+                }
+              )
+            } else {
+              logger.warn(
+                `Got epubField in a rifle query for a non-object data -> `,
+                {
+                  epubField,
+                  data
+                }
+              )
+            }
+          }
+          return epubForDecryption
+        })()
       )
       emit(eventName, { subscriptionId, response: { data: decData, key } })
       return
@@ -258,7 +286,7 @@ const startSocket = socket => {
     }
 
     on('subscribe:query', (query, response) => {
-      const { $shock, publicKey, epubForDecryption } = query
+      const { $shock, publicKey, epubForDecryption, epubField } = query
       const subscriptionId = uuidv4()
       try {
         if (!isAuthenticated()) {
@@ -286,7 +314,8 @@ const startSocket = socket => {
           publicKeyForDecryption: publicKey,
           subscriptionId,
           deviceId: encryptionId,
-          epubForDecryption
+          epubForDecryption,
+          epubField
         })
 
         socketCallback(null, {

From b87bcb6bcb77ea0a4268df4f6d5b0dbac45ca990 Mon Sep 17 00:00:00 2001
From: Daniel Lugo <danlugo92@gmail.com>
Date: Sun, 13 Jun 2021 12:21:00 -0400
Subject: [PATCH 22/32] No hardcoded events in gun socket rpc

---
 services/gunDB/sockets/index.js | 210 +-------------------------------
 1 file changed, 3 insertions(+), 207 deletions(-)

diff --git a/services/gunDB/sockets/index.js b/services/gunDB/sockets/index.js
index 4aa27d73..1166df21 100644
--- a/services/gunDB/sockets/index.js
+++ b/services/gunDB/sockets/index.js
@@ -9,14 +9,16 @@ const uuidv4 = require('uuid/v4')
 const { getGun, getUser, isAuthenticated } = require('../Mediator')
 const { deepDecryptIfNeeded } = require('../rpc')
 const Subscriptions = require('./subscriptions')
+<<<<<<< HEAD
 const GunEvents = require('../contact-api/events')
 const GunActions = require('../../gunDB/contact-api/actions')
+=======
+>>>>>>> a8235aa... No hardcoded events in gun socket rpc
 const {
   encryptedEmit,
   encryptedOn,
   encryptedCallback
 } = require('../../../utils/ECC/socket')
-const auth = require('../../auth/auth')
 
 const ALLOWED_GUN_METHODS = [
   'map',
@@ -37,28 +39,6 @@ const ALLOWED_GUN_METHODS = [
  * @typedef {{ reconnect: boolean, token: string }} SubscriptionOptions
  */
 
-/**
- * @param {string} token
- * @returns {Promise<boolean>}
- */
-const isValidToken = async token => {
-  const validation = await auth.validateToken(token)
-
-  if (typeof validation !== 'object') {
-    return false
-  }
-
-  if (validation === null) {
-    return false
-  }
-
-  if (typeof validation.valid !== 'boolean') {
-    return false
-  }
-
-  return validation.valid
-}
-
 /**
  * @param {string} root
  */
@@ -189,84 +169,6 @@ const queryListenerCallback = ({
   }
 }
 
-/**
- * @param {Object} GunSocketOptions
- * @param {() => (import('./subscriptions').Unsubscribe | void)} GunSocketOptions.handler
- * @param {string} GunSocketOptions.subscriptionId
- * @param {string} GunSocketOptions.encryptionId
- * @param {import('socket.io').Socket} GunSocketOptions.socket
- * @returns {(options: SubscriptionOptions, response: (error?: any, data?: any) => void) => Promise<void>}
- */
-const wrap = ({ handler, subscriptionId, encryptionId, socket }) => async (
-  { reconnect, token },
-  response
-) => {
-  try {
-    logger.info('Subscribe function executing...')
-    if (!isAuthenticated()) {
-      logger.warn('GunDB is not yet authenticated')
-      socket.emit(Common.Constants.ErrorCode.NOT_AUTH)
-      return
-    }
-
-    const callback = encryptedCallback(socket, response)
-    const emit = encryptedEmit(socket)
-    const subscription = Subscriptions.get({
-      deviceId: encryptionId,
-      subscriptionId
-    })
-
-    if (subscription && !reconnect) {
-      const error = {
-        field: 'subscription',
-        message:
-          "You're already subscribed to this event, you can re-subscribe again by setting 'reconnect' to true "
-      }
-      logger.error('Duplicate subscription:', error)
-      callback(error)
-      return
-    }
-
-    if (subscription && reconnect) {
-      if (subscription.unsubscribe) {
-        subscription.unsubscribe()
-      }
-
-      Subscriptions.remove({
-        deviceId: encryptionId,
-        subscriptionId
-      })
-    }
-
-    if (!subscription || reconnect) {
-      const isAuth = await isValidToken(token)
-
-      if (!isAuth) {
-        logger.warn('invalid token specified')
-        emit(Common.Constants.ErrorCode.NOT_AUTH)
-        return
-      }
-
-      const unsubscribe = handler()
-
-      if (unsubscribe) {
-        Subscriptions.attachUnsubscribe({
-          deviceId: encryptionId,
-          subscriptionId,
-          unsubscribe
-        })
-      }
-    }
-
-    callback(null, {
-      message: 'Subscribed successfully!',
-      success: true
-    })
-  } catch (error) {
-    logger.error('Socket wrapper error:', error)
-  }
-}
-
 /** @param {import('socket.io').Socket} socket */
 const startSocket = socket => {
   try {
@@ -331,112 +233,6 @@ const startSocket = socket => {
       }
     })
 
-    const onChats = () => {
-      return GunEvents.onChats(chats => {
-        const processed = chats.map(
-          ({
-            didDisconnect,
-            id,
-            lastSeenApp,
-            messages,
-            recipientPublicKey
-          }) => {
-            /** @type {Common.Schema.Chat} */
-            const stripped = {
-              didDisconnect,
-              id,
-              lastSeenApp,
-              messages,
-              recipientAvatar: null,
-              recipientDisplayName: null,
-              recipientPublicKey
-            }
-
-            return stripped
-          }
-        )
-
-        emit('chats', processed)
-      })
-    }
-
-    on(
-      'subscribe:chats',
-      wrap({
-        handler: onChats,
-        encryptionId,
-        subscriptionId: 'chats',
-        socket
-      })
-    )
-
-    const onSentRequests = () => {
-      return GunEvents.onSimplerSentRequests(sentReqs => {
-        const processed = sentReqs.map(
-          ({
-            id,
-            recipientChangedRequestAddress,
-            recipientPublicKey,
-            timestamp
-          }) => {
-            /**
-             * @type {Common.Schema.SimpleSentRequest}
-             */
-            const stripped = {
-              id,
-              recipientAvatar: null,
-              recipientChangedRequestAddress,
-              recipientDisplayName: null,
-              recipientPublicKey,
-              timestamp
-            }
-
-            return stripped
-          }
-        )
-        emit('sentRequests', processed)
-      })
-    }
-
-    on(
-      'subscribe:sentRequests',
-      wrap({
-        handler: onSentRequests,
-        encryptionId,
-        subscriptionId: 'sentRequests',
-        socket
-      })
-    )
-
-    const onReceivedRequests = () => {
-      return GunEvents.onSimplerReceivedRequests(receivedReqs => {
-        const processed = receivedReqs.map(({ id, requestorPK, timestamp }) => {
-          /** @type {Common.Schema.SimpleReceivedRequest} */
-          const stripped = {
-            id,
-            requestorAvatar: null,
-            requestorDisplayName: null,
-            requestorPK,
-            timestamp
-          }
-
-          return stripped
-        })
-
-        emit('receivedRequests', processed)
-      })
-    }
-
-    on(
-      'subscribe:receivedRequests',
-      wrap({
-        handler: onReceivedRequests,
-        encryptionId,
-        subscriptionId: 'receivedRequests',
-        socket
-      })
-    )
-
     on('unsubscribe', ({ subscriptionId }, response) => {
       const callback = encryptedCallback(socket, response)
       Subscriptions.remove({ deviceId: encryptionId, subscriptionId })

From 0681464817dc16301ca9c45c995c2a01b5f5eff2 Mon Sep 17 00:00:00 2001
From: Daniel Lugo <danlugo92@gmail.com>
Date: Sun, 13 Jun 2021 12:40:45 -0400
Subject: [PATCH 23/32] Remove outdated gun events

---
 services/gunDB/Mediator/index.js              |   3 -
 services/gunDB/contact-api/events/index.js    | 427 +-----------------
 .../contact-api/events/onReceivedReqs.js      | 138 ------
 .../gunDB/contact-api/events/onSentReqs.js    | 128 ------
 4 files changed, 5 insertions(+), 691 deletions(-)
 delete mode 100644 services/gunDB/contact-api/events/onReceivedReqs.js
 delete mode 100644 services/gunDB/contact-api/events/onSentReqs.js

diff --git a/services/gunDB/Mediator/index.js b/services/gunDB/Mediator/index.js
index 66b2ed24..d7e813a6 100644
--- a/services/gunDB/Mediator/index.js
+++ b/services/gunDB/Mediator/index.js
@@ -394,8 +394,6 @@ const authenticate = async (alias, pass, __user) => {
     API.Jobs.onOrders(_user, gun, mySEA)
     API.Jobs.lastSeenNode(_user)
 
-    API.Events.onCurrentHandshakeAddress(() => {}, user)()
-    // API.Events.onOutgoing(() => {})()
     API.Events.onSeedBackup(() => {}, user, mySEA)
 
     return _user._.sea.pub
@@ -452,7 +450,6 @@ const authenticate = async (alias, pass, __user) => {
     API.Jobs.onOrders(_user, gun, mySEA)
     API.Jobs.lastSeenNode(_user)
 
-    API.Events.onCurrentHandshakeAddress(() => {}, user)()
     API.Events.onSeedBackup(() => {}, user, mySEA)
 
     return ack.sea.pub
diff --git a/services/gunDB/contact-api/events/index.js b/services/gunDB/contact-api/events/index.js
index bd488978..29a44a2b 100644
--- a/services/gunDB/contact-api/events/index.js
+++ b/services/gunDB/contact-api/events/index.js
@@ -2,427 +2,22 @@
  * @prettier
  */
 const debounce = require('lodash/debounce')
-const logger = require('winston')
+
 const {
-  Constants: { ErrorCode },
-  Schema,
-  Utils: CommonUtils
+  Constants: { ErrorCode }
 } = require('shock-common')
 
 const Key = require('../key')
-const Utils = require('../utils')
-/**
- * @typedef {import('../SimpleGUN').UserGUNNode} UserGUNNode
- * @typedef {import('../SimpleGUN').GUNNode} GUNNode
- * @typedef {import('../SimpleGUN').ISEA} ISEA
- * @typedef {import('../SimpleGUN').ListenerData} ListenerData
- * @typedef {import('shock-common').Schema.HandshakeRequest} HandshakeRequest
- * @typedef {import('shock-common').Schema.Message} Message
- * @typedef {import('shock-common').Schema.Outgoing} Outgoing
- * @typedef {import('shock-common').Schema.PartialOutgoing} PartialOutgoing
- * @typedef {import('shock-common').Schema.Chat} Chat
- * @typedef {import('shock-common').Schema.ChatMessage} ChatMessage
- * @typedef {import('shock-common').Schema.SimpleSentRequest} SimpleSentRequest
- * @typedef {import('shock-common').Schema.SimpleReceivedRequest} SimpleReceivedRequest
- */
 
 const DEBOUNCE_WAIT_TIME = 500
 
-/**
- * @param {(userToIncoming: Record<string, string>) => void} cb
- * @param {UserGUNNode} user Pass only for testing purposes.
- * @param {ISEA} SEA
- * @returns {void}
- */
-const __onUserToIncoming = (cb, user, SEA) => {
-  if (!user.is) {
-    throw new Error(ErrorCode.NOT_AUTH)
-  }
-
-  const callb = debounce(cb, DEBOUNCE_WAIT_TIME)
-
-  /** @type {Record<string, string>} */
-  const userToIncoming = {}
-
-  const mySecret = require('../../Mediator').getMySecret()
-
-  user
-    .get(Key.USER_TO_INCOMING)
-    .map()
-    .on(async (encryptedIncomingID, userPub) => {
-      if (typeof encryptedIncomingID !== 'string') {
-        if (encryptedIncomingID === null) {
-          // on disconnect
-          delete userToIncoming[userPub]
-        } else {
-          logger.error(
-            'got a non string non null value inside user to incoming'
-          )
-        }
-        return
-      }
-
-      if (encryptedIncomingID.length === 0) {
-        logger.error('got an empty string value')
-        return
-      }
-
-      const incomingID = await SEA.decrypt(encryptedIncomingID, mySecret)
-
-      if (typeof incomingID === 'undefined') {
-        logger.warn('could not decrypt incomingID inside __onUserToIncoming')
-        return
-      }
-
-      userToIncoming[userPub] = incomingID
-
-      callb(userToIncoming)
-    })
-}
-
-/** @type {Set<(addr: string|null) => void>} */
-const addressListeners = new Set()
-
-/** @type {string|null} */
-let currentAddress = null
-
-const getHandshakeAddress = () => currentAddress
-
-/** @param {string|null} addr */
-const setAddress = addr => {
-  currentAddress = addr
-  addressListeners.forEach(l => l(currentAddress))
-}
-
-let addrSubbed = false
-
-/**
- * @param {(currentHandshakeAddress: string|null) => void} cb
- * @param {UserGUNNode} user
- * @returns {() => void}
- */
-const onCurrentHandshakeAddress = (cb, user) => {
-  if (!user.is) {
-    throw new Error(ErrorCode.NOT_AUTH)
-  }
-
-  addressListeners.add(cb)
-
-  cb(currentAddress)
-
-  if (!addrSubbed) {
-    addrSubbed = true
-
-    user.get(Key.CURRENT_HANDSHAKE_ADDRESS).on(addr => {
-      if (typeof addr !== 'string') {
-        logger.error('expected handshake address to be an string')
-
-        setAddress(null)
-
-        return
-      }
-
-      setAddress(addr)
-    })
-  }
-
-  return () => {
-    addressListeners.delete(cb)
-  }
-}
-
-/**
- * @param {(messages: Record<string, Message>) => void} cb
- * @param {string} userPK Public key of the user from whom the incoming
- * messages will be obtained.
- * @param {string} incomingFeedID ID of the outgoing feed from which the
- * incoming messages will be obtained.
- * @param {GUNNode} gun (Pass only for testing purposes)
- * @param {UserGUNNode} user
- * @param {ISEA} SEA
- * @returns {void}
- */
-const onIncomingMessages = (cb, userPK, incomingFeedID, gun, user, SEA) => {
-  if (!user.is) {
-    throw new Error(ErrorCode.NOT_AUTH)
-  }
-
-  const callb = debounce(cb, DEBOUNCE_WAIT_TIME)
-
-  const otherUser = gun.user(userPK)
-
-  /**
-   * @type {Record<string, Message>}
-   */
-  const messages = {}
-
-  callb(messages)
-
-  otherUser
-    .get(Key.OUTGOINGS)
-    .get(incomingFeedID)
-    .get(Key.MESSAGES)
-    .map()
-    .on(async (data, key) => {
-      if (!Schema.isMessage(data)) {
-        logger.warn('non-message received')
-        return
-      }
-
-      /** @type {string} */
-      const recipientEpub = await Utils.pubToEpub(userPK)
-
-      const secret = await SEA.secret(recipientEpub, user._.sea)
-
-      let { body } = data
-      body = await SEA.decrypt(body, secret)
-
-      messages[key] = {
-        body,
-        timestamp: data.timestamp
-      }
-
-      callb(messages)
-    })
-}
-
-/**
- * @typedef {Record<string, Outgoing|null>} Outgoings
- * @typedef {(outgoings: Outgoings) => void} OutgoingsListener
- */
-
-/**
- * @type {Outgoings}
- */
-let currentOutgoings = {}
-
-const getCurrentOutgoings = () => currentOutgoings
-
-/** @type {Set<OutgoingsListener>} */
-const outgoingsListeners = new Set()
-
-outgoingsListeners.add(o => {
-  const values = Object.values(o)
-  const nulls = values.filter(x => x === null).length
-  const nonNulls = values.length - nulls
-
-  logger.info(`new outgoings, ${nulls} nulls and ${nonNulls} nonNulls`)
-})
-
-const notifyOutgoingsListeners = () => {
-  outgoingsListeners.forEach(l => l(currentOutgoings))
-}
-
-let outSubbed = false
-
-/**
- * @param {OutgoingsListener} cb
- * @returns {() => void}
- */
-const onOutgoing = cb => {
-  outgoingsListeners.add(cb)
-  cb(currentOutgoings)
-
-  if (!outSubbed) {
-    const user = require('../../Mediator').getUser()
-    user.get(Key.OUTGOINGS).open(
-      debounce(async data => {
-        try {
-          if (typeof data !== 'object' || data === null) {
-            currentOutgoings = {}
-            notifyOutgoingsListeners()
-            return
-          }
-
-          /** @type {Record<string, Outgoing|null>} */
-          const newOuts = {}
-
-          const SEA = require('../../Mediator').mySEA
-          const mySecret = await Utils.mySecret()
-
-          await CommonUtils.asyncForEach(
-            Object.entries(data),
-            async ([id, out]) => {
-              if (typeof out !== 'object') {
-                return
-              }
-
-              if (out === null) {
-                newOuts[id] = null
-                return
-              }
-
-              const { with: encPub, messages } = out
-
-              if (typeof encPub !== 'string') {
-                return
-              }
-
-              const pub = await SEA.decrypt(encPub, mySecret)
-
-              if (!newOuts[id]) {
-                newOuts[id] = {
-                  with: pub,
-                  messages: {}
-                }
-              }
-
-              const ourSec = await SEA.secret(
-                await Utils.pubToEpub(pub),
-                user._.sea
-              )
-
-              if (typeof messages === 'object' && messages !== null) {
-                await CommonUtils.asyncForEach(
-                  Object.entries(messages),
-                  async ([mid, msg]) => {
-                    if (typeof msg === 'object' && msg !== null) {
-                      if (
-                        typeof msg.body === 'string' &&
-                        typeof msg.timestamp === 'number'
-                      ) {
-                        const newOut = newOuts[id]
-                        if (!newOut) {
-                          return
-                        }
-                        newOut.messages[mid] = {
-                          body: await SEA.decrypt(msg.body, ourSec),
-                          timestamp: msg.timestamp
-                        }
-                      }
-                    }
-                  }
-                )
-              }
-            }
-          )
-
-          currentOutgoings = newOuts
-          notifyOutgoingsListeners()
-        } catch (e) {
-          logger.info('--------------------------')
-          logger.info('Events -> onOutgoing')
-          logger.info(e)
-          logger.info('--------------------------')
-        }
-      }, 400)
-    )
-
-    outSubbed = true
-  }
-
-  return () => {
-    outgoingsListeners.delete(cb)
-  }
-}
-////////////////////////////////////////////////////////////////////////////////
-/**
- * @typedef {(chats: Chat[]) => void} ChatsListener
- */
-
-/** @type {Chat[]} */
-let currentChats = []
-
-const getChats = () => currentChats
-
-/** @type {Set<ChatsListener>} */
-const chatsListeners = new Set()
-
-chatsListeners.add(c => {
-  logger.info(`Chats: ${c.length}`)
-})
-
-const notifyChatsListeners = () => {
-  chatsListeners.forEach(l => l(currentChats))
-}
-
-const processChats = debounce(() => {
-  const Streams = require('../streams')
-  const currentOutgoings = getCurrentOutgoings()
-  const existingOutgoings = /** @type {[string, Outgoing][]} */ (Object.entries(
-    currentOutgoings
-  ).filter(([_, o]) => o !== null))
-  const pubToFeed = Streams.getPubToFeed()
-
-  /** @type {Chat[]} */
-  const newChats = []
-
-  for (const [outID, out] of existingOutgoings) {
-    /** @type {ChatMessage[]} */
-    let msgs = Object.entries(out.messages)
-      .map(([mid, m]) => ({
-        id: mid,
-        outgoing: true,
-        body: m.body,
-        timestamp: m.timestamp
-      }))
-      // filter out null messages
-      .filter(m => typeof m.body === 'string')
-
-    const incoming = pubToFeed[out.with]
-
-    if (Array.isArray(incoming)) {
-      msgs = [...msgs, ...incoming]
-    }
-
-    /** @type {Chat} */
-    const chat = {
-      recipientPublicKey: out.with,
-      didDisconnect: pubToFeed[out.with] === 'disconnected',
-      id: out.with + outID,
-      messages: msgs,
-      recipientAvatar: null,
-      recipientDisplayName: null,
-      lastSeenApp: null
-    }
-
-    newChats.push(chat)
-  }
-
-  currentChats = newChats.filter(
-    c =>
-      Array.isArray(pubToFeed[c.recipientPublicKey]) ||
-      pubToFeed[c.recipientPublicKey] === 'disconnected'
-  )
-
-  notifyChatsListeners()
-}, 750)
-
-let onChatsSubbed = false
-
-/**
- * Massages all of the more primitive data structures into a more manageable
- * 'Chat' paradigm.
- * @param {ChatsListener} cb
- * @returns {() => void}
- */
-const onChats = cb => {
-  if (!chatsListeners.add(cb)) {
-    throw new Error('Tried to subscribe twice')
-  }
-  cb(currentChats)
-
-  if (!onChatsSubbed) {
-    const Streams = require('../streams')
-    // onOutgoing(processChats)
-    Streams.onPubToFeed(processChats)
-    onChatsSubbed = true
-  }
-
-  return () => {
-    if (!chatsListeners.delete(cb)) {
-      throw new Error('Tried to unsubscribe twice')
-    }
-  }
-}
-
 /** @type {string|null} */
 let currentSeedBackup = null
 
 /**
  * @param {(seedBackup: string|null) => void} cb
- * @param {UserGUNNode} user
- * @param {ISEA} SEA
+ * @param {import('../SimpleGUN').UserGUNNode} user
+ * @param {import('../SimpleGUN').ISEA} SEA
  * @throws {Error} If user hasn't been auth.
  * @returns {void}
  */
@@ -445,17 +40,5 @@ const onSeedBackup = (cb, user, SEA) => {
 }
 
 module.exports = {
-  __onUserToIncoming,
-  onCurrentHandshakeAddress,
-  onIncomingMessages,
-  onOutgoing,
-  getCurrentOutgoings,
-  onSimplerReceivedRequests: require('./onReceivedReqs').onReceivedReqs,
-  onSimplerSentRequests: require('./onSentReqs').onSentReqs,
-  getCurrentSentReqs: require('./onSentReqs').getCurrentSentReqs,
-  getCurrentReceivedReqs: require('./onReceivedReqs').getReceivedReqs,
-  onSeedBackup,
-  onChats,
-  getHandshakeAddress,
-  getChats
+  onSeedBackup
 }
diff --git a/services/gunDB/contact-api/events/onReceivedReqs.js b/services/gunDB/contact-api/events/onReceivedReqs.js
deleted file mode 100644
index 8c5d3226..00000000
--- a/services/gunDB/contact-api/events/onReceivedReqs.js
+++ /dev/null
@@ -1,138 +0,0 @@
-/** @format */
-const debounce = require('lodash/debounce')
-const logger = require('winston')
-const { Schema } = require('shock-common')
-const size = require('lodash/size')
-
-const Key = require('../key')
-const Streams = require('../streams')
-
-/**
- * @typedef {Readonly<import('shock-common').Schema.SimpleReceivedRequest>} SimpleReceivedRequest
- * @typedef {(reqs: ReadonlyArray<SimpleReceivedRequest>) => void} Listener
- */
-
-/** @type {Set<Listener>} */
-const listeners = new Set()
-
-/** @type {string|null} */
-let currentAddress = null
-
-/** @type {Record<string, SimpleReceivedRequest>} */
-let currReceivedReqsMap = {}
-
-/**
- * Unprocessed requests in current handshake node.
- * @type {Record<string, import('shock-common').Schema.HandshakeRequest>}
- */
-let currAddressData = {}
-
-/** @returns {SimpleReceivedRequest[]} */
-const getReceivedReqs = () => Object.values(currReceivedReqsMap)
-/** @param {Record<string, SimpleReceivedRequest>} reqs */
-const setReceivedReqsMap = reqs => {
-  currReceivedReqsMap = reqs
-  listeners.forEach(l => l(getReceivedReqs()))
-}
-
-listeners.add(() => {
-  logger.info(`new received reqs: ${size(getReceivedReqs())}`)
-})
-
-const react = debounce(() => {
-  /** @type {Record<string, SimpleReceivedRequest>} */
-  const newReceivedReqsMap = {}
-
-  const pubToFeed = Streams.getPubToFeed()
-
-  for (const [id, req] of Object.entries(currAddressData)) {
-    const inContact = Array.isArray(pubToFeed[req.from])
-    const isDisconnected = pubToFeed[req.from] === 'disconnected'
-
-    if (!inContact && !isDisconnected) {
-      newReceivedReqsMap[req.from] = {
-        id,
-        requestorAvatar: null,
-        requestorDisplayName: null,
-        requestorPK: req.from,
-        timestamp: req.timestamp
-      }
-    }
-  }
-
-  setReceivedReqsMap(newReceivedReqsMap)
-}, 750)
-
-/**
- * @param {string} addr
- * @returns {(data: import('../SimpleGUN').OpenListenerData) => void}
- */
-const listenerForAddr = addr => data => {
-  // did invalidate
-  if (addr !== currentAddress) {
-    return
-  }
-
-  if (typeof data !== 'object' || data === null) {
-    currAddressData = {}
-  } else {
-    for (const [id, req] of Object.entries(data)) {
-      // no need to update them just write them once
-      if (Schema.isHandshakeRequest(req) && !currAddressData[id]) {
-        currAddressData[id] = req
-      }
-    }
-  }
-
-  logger.info('data for address length: ' + size(currAddressData))
-
-  react()
-}
-
-let subbed = false
-
-/**
- * @param {Listener} cb
- * @returns {() => void}
- */
-const onReceivedReqs = cb => {
-  listeners.add(cb)
-  cb(getReceivedReqs())
-
-  if (!subbed) {
-    const user = require('../../Mediator').getUser()
-    if (!user.is) {
-      logger.warn('Tried subscribing to onReceivedReqs without authing')
-    }
-    require('./index').onCurrentHandshakeAddress(addr => {
-      if (currentAddress === addr) {
-        return
-      }
-
-      currentAddress = addr
-      currAddressData = {}
-      setReceivedReqsMap({})
-
-      if (typeof addr === 'string') {
-        require('../../Mediator')
-          .getGun()
-          .get(Key.HANDSHAKE_NODES)
-          .get(addr)
-          .open(listenerForAddr(addr))
-      }
-    }, user)
-
-    Streams.onPubToFeed(react)
-
-    subbed = true
-  }
-
-  return () => {
-    listeners.delete(cb)
-  }
-}
-
-module.exports = {
-  getReceivedReqs,
-  onReceivedReqs
-}
diff --git a/services/gunDB/contact-api/events/onSentReqs.js b/services/gunDB/contact-api/events/onSentReqs.js
deleted file mode 100644
index 3aefb6ef..00000000
--- a/services/gunDB/contact-api/events/onSentReqs.js
+++ /dev/null
@@ -1,128 +0,0 @@
-/** @format */
-const debounce = require('lodash/debounce')
-const logger = require('winston')
-const size = require('lodash/size')
-
-const Streams = require('../streams')
-/**
- * @typedef {import('../SimpleGUN').UserGUNNode} UserGUNNode
- * @typedef {import('../SimpleGUN').GUNNode} GUNNode
- * @typedef {import('../SimpleGUN').ISEA} ISEA
- * @typedef {import('../SimpleGUN').ListenerData} ListenerData
- * @typedef {import('shock-common').Schema.HandshakeRequest} HandshakeRequest
- * @typedef {import('shock-common').Schema.Message} Message
- * @typedef {import('shock-common').Schema.Outgoing} Outgoing
- * @typedef {import('shock-common').Schema.PartialOutgoing} PartialOutgoing
- * @typedef {import('shock-common').Schema.Chat} Chat
- * @typedef {import('shock-common').Schema.ChatMessage} ChatMessage
- * @typedef {import('shock-common').Schema.SimpleSentRequest} SimpleSentRequest
- * @typedef {import('shock-common').Schema.SimpleReceivedRequest} SimpleReceivedRequest
- */
-
-/**
- * @typedef {(chats: SimpleSentRequest[]) => void} Listener
- */
-
-/** @type {Set<Listener>} */
-const listeners = new Set()
-
-/** @type {SimpleSentRequest[]} */
-let currentReqs = []
-
-listeners.add(() => {
-  logger.info(`new sent reqs length: ${size(currentReqs)}`)
-})
-
-const getCurrentSentReqs = () => currentReqs
-
-// any time any of the streams we use notifies us that it changed, we fire up
-// react()
-const react = debounce(() => {
-  /** @type {SimpleSentRequest[]} */
-  const newReqs = []
-
-  // reactive streams
-  // maps a pk to its current handshake address
-  const pubToHAddr = Streams.getAddresses()
-  // a set or list containing copies of sent requests
-  const storedReqs = Streams.getStoredReqs()
-  // maps a pk to the last request sent to it (so old stored reqs are invalidated)
-  const pubToLastSentReqID = Streams.getSentReqIDs()
-  // maps a pk to a feed, messages if subbed and pk is pubbing, null /
-  // 'disconnected' otherwise
-  const pubToFeed = Streams.getPubToFeed()
-
-  logger.info(`pubToLastSentREqID length: ${size(pubToLastSentReqID)}`)
-
-  for (const storedReq of storedReqs) {
-    const { handshakeAddress, recipientPub, sentReqID, timestamp } = storedReq
-    const currAddress = pubToHAddr[recipientPub]
-
-    const lastReqID = pubToLastSentReqID[recipientPub]
-    // invalidate if this stored request is not the last one sent to this
-    // particular pk
-    const isStale = typeof lastReqID !== 'undefined' && lastReqID !== sentReqID
-    // invalidate if we are in a pub/sub state to this pk (handshake in place)
-    const isConnected = Array.isArray(pubToFeed[recipientPub])
-
-    if (isStale || isConnected) {
-      // eslint-disable-next-line no-continue
-      continue
-    }
-
-    // no address for this pk? let's ask the corresponding stream to sub to
-    // gun.user(pk).get('currentAddr')
-    if (typeof currAddress === 'undefined') {
-      // eslint-disable-next-line no-empty-function
-      Streams.onAddresses(() => {}, recipientPub)()
-    }
-
-    newReqs.push({
-      id: sentReqID,
-      recipientAvatar: null,
-      recipientChangedRequestAddress:
-        // if we haven't received the other's user current handshake address,
-        // let's assume he hasn't changed it and that this request is still
-        // valid
-        typeof currAddress !== 'undefined' && handshakeAddress !== currAddress,
-      recipientDisplayName: null,
-      recipientPublicKey: recipientPub,
-      timestamp
-    })
-  }
-
-  currentReqs = newReqs
-
-  listeners.forEach(l => l(currentReqs))
-}, 750)
-
-let subbed = false
-
-/**
- * Massages all of the more primitive data structures into a more manageable
- * 'Chat' paradigm.
- * @param {Listener} cb
- * @returns {() => void}
- */
-const onSentReqs = cb => {
-  listeners.add(cb)
-  cb(currentReqs)
-
-  if (!subbed) {
-    Streams.onAddresses(react)
-    Streams.onStoredReqs(react)
-    Streams.onLastSentReqIDs(react)
-    Streams.onPubToFeed(react)
-
-    subbed = true
-  }
-
-  return () => {
-    listeners.delete(cb)
-  }
-}
-
-module.exports = {
-  onSentReqs,
-  getCurrentSentReqs
-}

From 45eeb2d672f5359b88242923e6a94319dd041358 Mon Sep 17 00:00:00 2001
From: Daniel Lugo <danlugo92@gmail.com>
Date: Sun, 13 Jun 2021 12:41:44 -0400
Subject: [PATCH 24/32] Remove outdated gun actions

---
 services/gunDB/contact-api/actions.js | 752 +-------------------------
 1 file changed, 1 insertion(+), 751 deletions(-)

diff --git a/services/gunDB/contact-api/actions.js b/services/gunDB/contact-api/actions.js
index b5365d54..d278bc62 100644
--- a/services/gunDB/contact-api/actions.js
+++ b/services/gunDB/contact-api/actions.js
@@ -26,262 +26,10 @@ const LNDHealthMananger = require('../../../utils/lightningServices/errors')
 const { enrollContentTokens, selfContentToken } = require('../../seed')
 
 /**
- * @typedef {import('./SimpleGUN').GUNNode} GUNNode
  * @typedef {import('./SimpleGUN').ISEA} ISEA
  * @typedef {import('./SimpleGUN').UserGUNNode} UserGUNNode
- * @typedef {import('shock-common').Schema.HandshakeRequest} HandshakeRequest
- * @typedef {import('shock-common').Schema.StoredRequest} StoredReq
- * @typedef {import('shock-common').Schema.Message} Message
- * @typedef {import('shock-common').Schema.Outgoing} Outgoing
- * @typedef {import('shock-common').Schema.PartialOutgoing} PartialOutgoing
- * @typedef {import('shock-common').Schema.Order} Order
- * @typedef {import('./SimpleGUN').Ack} Ack
  */
 
-/**
- * Create a an outgoing feed. The feed will have an initial special acceptance
- * message. Returns a promise that resolves to the id of the newly-created
- * outgoing feed.
- *
- * If an outgoing feed is already created for the recipient, then returns the id
- * of that one.
- * @param {string} withPublicKey Public key of the intended recipient of the
- * outgoing feed that will be created.
- * @throws {Error} If the outgoing feed cannot be created or if the initial
- * message for it also cannot be created. These errors aren't coded as they are
- * not meant to be caught outside of this module.
- * @param {UserGUNNode} user
- * @param {ISEA} SEA
- * @returns {Promise<string>}
- */
-const __createOutgoingFeed = async (withPublicKey, user, SEA) => {
-  if (!user.is) {
-    throw new Error(ErrorCode.NOT_AUTH)
-  }
-
-  const mySecret = require('../Mediator').getMySecret()
-  const encryptedForMeRecipientPub = await SEA.encrypt(withPublicKey, mySecret)
-  const ourSecret = await SEA.secret(
-    await Utils.pubToEpub(withPublicKey),
-    user._.sea
-  )
-
-  const maybeOutgoingID = await Utils.recipientToOutgoingID(withPublicKey)
-
-  let outgoingFeedID = ''
-
-  // if there was no stored outgoing, create an outgoing feed
-  if (typeof maybeOutgoingID !== 'string') {
-    /** @type {PartialOutgoing} */
-    const newPartialOutgoingFeed = {
-      with: encryptedForMeRecipientPub
-    }
-
-    /** @type {string} */
-    const newOutgoingFeedID = await new Promise((res, rej) => {
-      const _outFeedNode = user
-        .get(Key.OUTGOINGS)
-        //@ts-ignore
-        .set(newPartialOutgoingFeed, ack => {
-          if (ack.err && typeof ack.err !== 'number') {
-            rej(new Error(ack.err))
-          } else {
-            res(_outFeedNode._.get)
-          }
-        })
-    })
-
-    if (typeof newOutgoingFeedID !== 'string') {
-      throw new TypeError('typeof newOutgoingFeedID !== "string"')
-    }
-
-    /** @type {Message} */
-    const initialMsg = {
-      body: await SEA.encrypt(Constants.Misc.INITIAL_MSG, ourSecret),
-      timestamp: Date.now()
-    }
-
-    await /** @type {Promise<void>} */ (new Promise((res, rej) => {
-      user
-        .get(Key.OUTGOINGS)
-        .get(newOutgoingFeedID)
-        .get(Key.MESSAGES)
-        //@ts-ignore
-        .set(initialMsg, ack => {
-          if (ack.err && typeof ack.err !== 'number') {
-            rej(new Error(ack.err))
-          } else {
-            res()
-          }
-        })
-    }))
-
-    const encryptedForMeNewOutgoingFeedID = await SEA.encrypt(
-      newOutgoingFeedID,
-      mySecret
-    )
-
-    await /** @type {Promise<void>} */ (new Promise((res, rej) => {
-      user
-        .get(Key.RECIPIENT_TO_OUTGOING)
-        .get(withPublicKey)
-        .put(encryptedForMeNewOutgoingFeedID, ack => {
-          if (ack.err && typeof ack.err !== 'number') {
-            rej(Error(ack.err))
-          } else {
-            res()
-          }
-        })
-    }))
-
-    outgoingFeedID = newOutgoingFeedID
-  }
-
-  // otherwise decrypt stored outgoing
-  else {
-    outgoingFeedID = maybeOutgoingID
-  }
-
-  if (typeof outgoingFeedID === 'undefined') {
-    throw new TypeError(
-      '__createOutgoingFeed() -> typeof outgoingFeedID === "undefined"'
-    )
-  }
-
-  if (typeof outgoingFeedID !== 'string') {
-    throw new TypeError(
-      '__createOutgoingFeed() -> expected outgoingFeedID to be an string'
-    )
-  }
-
-  if (outgoingFeedID.length === 0) {
-    throw new TypeError(
-      '__createOutgoingFeed() -> expected outgoingFeedID to be a populated string.'
-    )
-  }
-
-  return outgoingFeedID
-}
-
-/**
- * Given a request's ID, that should be found on the user's current handshake
- * node, accept the request by creating an outgoing feed intended for the
- * requestor, then encrypting and putting the id of this newly created outgoing
- * feed on the response prop of the request.
- * @param {string} requestID The id for the request to accept.
- * @param {GUNNode} gun
- * @param {UserGUNNode} user Pass only for testing purposes.
- * @param {ISEA} SEA
- * @param {typeof __createOutgoingFeed} outgoingFeedCreator Pass only
- * for testing. purposes.
- * @throws {Error} Throws if trying to accept an invalid request, or an error on
- * gun's part.
- * @returns {Promise<void>}
- */
-const acceptRequest = async (
-  requestID,
-  gun,
-  user,
-  SEA,
-  outgoingFeedCreator = __createOutgoingFeed
-) => {
-  if (!user.is) {
-    throw new Error(ErrorCode.NOT_AUTH)
-  }
-
-  const handshakeAddress = await Utils.tryAndWait(async (_, user) => {
-    const addr = await user.get(Key.CURRENT_HANDSHAKE_ADDRESS).then()
-
-    if (typeof addr !== 'string') {
-      throw new TypeError("typeof addr !== 'string'")
-    }
-
-    return addr
-  })
-
-  const {
-    response: encryptedForUsIncomingID,
-    from: senderPublicKey
-  } = await Utils.tryAndWait(async gun => {
-    const hr = await gun
-      .get(Key.HANDSHAKE_NODES)
-      .get(handshakeAddress)
-      .get(requestID)
-      .then()
-
-    if (!Schema.isHandshakeRequest(hr)) {
-      throw new Error(ErrorCode.TRIED_TO_ACCEPT_AN_INVALID_REQUEST)
-    }
-
-    return hr
-  })
-
-  /** @type {string} */
-  const requestorEpub = await Utils.pubToEpub(senderPublicKey)
-
-  const ourSecret = await SEA.secret(requestorEpub, user._.sea)
-  if (typeof ourSecret !== 'string') {
-    throw new TypeError("typeof ourSecret !== 'string'")
-  }
-
-  const incomingID = await SEA.decrypt(encryptedForUsIncomingID, ourSecret)
-  if (typeof incomingID !== 'string') {
-    throw new TypeError("typeof incomingID !== 'string'")
-  }
-
-  const newlyCreatedOutgoingFeedID = await outgoingFeedCreator(
-    senderPublicKey,
-    user,
-    SEA
-  )
-
-  const mySecret = require('../Mediator').getMySecret()
-  const encryptedForMeIncomingID = await SEA.encrypt(incomingID, mySecret)
-
-  await /** @type {Promise<void>} */ (new Promise((res, rej) => {
-    user
-      .get(Key.USER_TO_INCOMING)
-      .get(senderPublicKey)
-      .put(encryptedForMeIncomingID, ack => {
-        if (ack.err && typeof ack.err !== 'number') {
-          rej(new Error(ack.err))
-        } else {
-          res()
-        }
-      })
-  }))
-
-  ////////////////////////////////////////////////////////////////////////////
-  // NOTE: perform non-reversable actions before destructive actions
-  // In case any of the non-reversable actions reject.
-  // In this case, writing to the response is the non-revesarble op.
-  ////////////////////////////////////////////////////////////////////////////
-
-  const encryptedForUsOutgoingID = await SEA.encrypt(
-    newlyCreatedOutgoingFeedID,
-    ourSecret
-  )
-  //why await if you dont need the response?
-  await /** @type {Promise<void>} */ (new Promise((res, rej) => {
-    gun
-      .get(Key.HANDSHAKE_NODES)
-      .get(handshakeAddress)
-      .get(requestID)
-      .put(
-        {
-          response: encryptedForUsOutgoingID
-        },
-        ack => {
-          if (ack.err && typeof ack.err !== 'number') {
-            rej(new Error(ack.err))
-          } else {
-            res()
-          }
-        }
-      )
-  }))
-}
-
 /**
  * @param {string} user
  * @param {string} pass
@@ -374,438 +122,6 @@ const generateHandshakeAddress = async () => {
   }))
 }
 
-/**
- *
- * @param {string} pub
- * @throws {Error}
- * @returns {Promise<void>}
- */
-const cleanup = async pub => {
-  const user = require('../Mediator').getUser()
-
-  const outGoingID = await Utils.recipientToOutgoingID(pub)
-
-  const promises = []
-
-  promises.push(
-    /** @type {Promise<void>} */ (new Promise((res, rej) => {
-      user
-        .get(Key.USER_TO_INCOMING)
-        .get(pub)
-        .put(null, ack => {
-          if (ack.err && typeof ack.err !== 'number') {
-            rej(new Error(ack.err))
-          } else {
-            res()
-          }
-        })
-    }))
-  )
-
-  promises.push(
-    /** @type {Promise<void>} */ (new Promise((res, rej) => {
-      user
-        .get(Key.RECIPIENT_TO_OUTGOING)
-        .get(pub)
-        .put(null, ack => {
-          if (ack.err && typeof ack.err !== 'number') {
-            rej(new Error(ack.err))
-          } else {
-            res()
-          }
-        })
-    }))
-  )
-
-  promises.push(
-    /** @type {Promise<void>} */ (new Promise((res, rej) => {
-      user
-        .get(Key.USER_TO_LAST_REQUEST_SENT)
-        .get(pub)
-        .put(null, ack => {
-          if (ack.err && typeof ack.err !== 'number') {
-            rej(new Error(ack.err))
-          } else {
-            res()
-          }
-        })
-    }))
-  )
-
-  if (outGoingID) {
-    promises.push(
-      /** @type {Promise<void>} */ (new Promise((res, rej) => {
-        user
-          .get(Key.OUTGOINGS)
-          .get(outGoingID)
-          .put(null, ack => {
-            if (ack.err && typeof ack.err !== 'number') {
-              rej(new Error(ack.err))
-            } else {
-              res()
-            }
-          })
-      }))
-    )
-  }
-
-  await Promise.all(promises)
-}
-
-/**
- * @param {string} recipientPublicKey
- * @param {GUNNode} gun
- * @param {UserGUNNode} user
- * @param {ISEA} SEA
- * @throws {Error|TypeError}
- * @returns {Promise<void>}
- */
-const sendHandshakeRequest = async (recipientPublicKey, gun, user, SEA) => {
-  if (!user.is) {
-    throw new Error(ErrorCode.NOT_AUTH)
-  }
-
-  await cleanup(recipientPublicKey)
-
-  if (typeof recipientPublicKey !== 'string') {
-    throw new TypeError(
-      `recipientPublicKey is not string, got: ${typeof recipientPublicKey}`
-    )
-  }
-
-  if (recipientPublicKey.length === 0) {
-    throw new TypeError('recipientPublicKey is an string of length 0')
-  }
-
-  if (recipientPublicKey === user.is.pub) {
-    throw new Error('Do not send a request to yourself')
-  }
-
-  logger.info('sendHR() -> before recipientEpub')
-
-  /** @type {string} */
-  const recipientEpub = await Utils.pubToEpub(recipientPublicKey)
-
-  logger.info('sendHR() -> before mySecret')
-
-  const mySecret = require('../Mediator').getMySecret()
-  logger.info('sendHR() -> before ourSecret')
-  const ourSecret = await SEA.secret(recipientEpub, user._.sea)
-
-  // check if successful handshake is present
-
-  logger.info('sendHR() -> before alreadyHandshaked')
-
-  /** @type {boolean} */
-  const alreadyHandshaked = await Utils.successfulHandshakeAlreadyExists(
-    recipientPublicKey
-  )
-
-  if (alreadyHandshaked) {
-    throw new Error(ErrorCode.ALREADY_HANDSHAKED)
-  }
-
-  logger.info('sendHR() -> before maybeLastRequestIDSentToUser')
-
-  // check that we have already sent a request to this user, on his current
-  // handshake node
-  const maybeLastRequestIDSentToUser = await Utils.tryAndWait((_, user) =>
-    user
-      .get(Key.USER_TO_LAST_REQUEST_SENT)
-      .get(recipientPublicKey)
-      .then()
-  )
-
-  logger.info('sendHR() -> before currentHandshakeAddress')
-
-  const currentHandshakeAddress = await Utils.tryAndWait(
-    gun =>
-      Common.Utils.makePromise(res => {
-        gun
-          .user(recipientPublicKey)
-          .get(Key.CURRENT_HANDSHAKE_ADDRESS)
-          .once(
-            data => {
-              res(data)
-            },
-            { wait: 1000 }
-          )
-      }),
-    data => typeof data !== 'string'
-  )
-
-  if (typeof currentHandshakeAddress !== 'string') {
-    throw new TypeError(
-      'expected current handshake address found on recipients user node to be an string'
-    )
-  }
-
-  if (typeof maybeLastRequestIDSentToUser === 'string') {
-    if (maybeLastRequestIDSentToUser.length < 5) {
-      throw new TypeError(
-        'sendHandshakeRequest() -> maybeLastRequestIDSentToUser.length < 5'
-      )
-    }
-
-    const lastRequestIDSentToUser = maybeLastRequestIDSentToUser
-
-    logger.info('sendHR() -> before alreadyContactedOnCurrHandshakeNode')
-
-    const hrInHandshakeNode = await Utils.tryAndWait(
-      gun =>
-        new Promise(res => {
-          gun
-            .get(Key.HANDSHAKE_NODES)
-            .get(currentHandshakeAddress)
-            .get(lastRequestIDSentToUser)
-            .once(data => {
-              res(data)
-            })
-        }),
-      // force retry on undefined in case the undefined was a false negative
-      v => typeof v === 'undefined'
-    )
-
-    const alreadyContactedOnCurrHandshakeNode =
-      typeof hrInHandshakeNode !== 'undefined'
-
-    if (alreadyContactedOnCurrHandshakeNode) {
-      throw new Error(ErrorCode.ALREADY_REQUESTED_HANDSHAKE)
-    }
-  }
-
-  logger.info('sendHR() -> before __createOutgoingFeed')
-
-  const outgoingFeedID = await __createOutgoingFeed(
-    recipientPublicKey,
-    user,
-    SEA
-  )
-
-  logger.info('sendHR() -> before encryptedForUsOutgoingFeedID')
-
-  const encryptedForUsOutgoingFeedID = await SEA.encrypt(
-    outgoingFeedID,
-    ourSecret
-  )
-
-  const timestamp = Date.now()
-
-  /** @type {HandshakeRequest} */
-  const handshakeRequestData = {
-    from: user.is.pub,
-    response: encryptedForUsOutgoingFeedID,
-    timestamp
-  }
-
-  const encryptedForMeRecipientPublicKey = await SEA.encrypt(
-    recipientPublicKey,
-    mySecret
-  )
-
-  logger.info('sendHR() -> before newHandshakeRequestID')
-  /** @type {string} */
-  const newHandshakeRequestID = await new Promise((res, rej) => {
-    const hr = gun
-      .get(Key.HANDSHAKE_NODES)
-      .get(currentHandshakeAddress)
-      //@ts-ignore
-      .set(handshakeRequestData, ack => {
-        if (ack.err && typeof ack.err !== 'number') {
-          rej(new Error(`Error trying to create request: ${ack.err}`))
-        } else {
-          res(hr._.get)
-        }
-      })
-  })
-
-  await /** @type {Promise<void>} */ (new Promise((res, rej) => {
-    user
-      .get(Key.USER_TO_LAST_REQUEST_SENT)
-      .get(recipientPublicKey)
-      .put(newHandshakeRequestID, ack => {
-        if (ack.err && typeof ack.err !== 'number') {
-          rej(new Error(ack.err))
-        } else {
-          res()
-        }
-      })
-  }))
-
-  // This needs to come before the write to sent requests. Because that write
-  // triggers Jobs.onAcceptedRequests and it in turn reads from request-to-user
-
-  /**
-   * @type {StoredReq}
-   */
-  const storedReq = {
-    sentReqID: await SEA.encrypt(newHandshakeRequestID, mySecret),
-    recipientPub: encryptedForMeRecipientPublicKey,
-    handshakeAddress: await SEA.encrypt(currentHandshakeAddress, mySecret),
-    timestamp
-  }
-  //why await if you dont need the response?
-  await /** @type {Promise<void>} */ (new Promise((res, rej) => {
-    //@ts-ignore
-    user.get(Key.STORED_REQS).set(storedReq, ack => {
-      if (ack.err && typeof ack.err !== 'number') {
-        rej(
-          new Error(
-            `Error saving newly created request to sent requests: ${ack.err}`
-          )
-        )
-      } else {
-        res()
-      }
-    })
-  }))
-}
-
-/**
- * Returns the message id.
- * @param {string} recipientPublicKey
- * @param {string} body
- * @param {UserGUNNode} user
- * @param {ISEA} SEA
- * @returns {Promise<import('shock-common').Schema.ChatMessage>} The message id.
- */
-const sendMessageNew = async (recipientPublicKey, body, user, SEA) => {
-  if (!user.is) {
-    throw new Error(ErrorCode.NOT_AUTH)
-  }
-
-  if (typeof recipientPublicKey !== 'string') {
-    throw new TypeError(
-      `expected recipientPublicKey to be an string, but instead got: ${typeof recipientPublicKey}`
-    )
-  }
-
-  if (recipientPublicKey.length === 0) {
-    throw new TypeError(
-      'expected recipientPublicKey to be an string of length greater than zero'
-    )
-  }
-
-  if (typeof body !== 'string') {
-    throw new TypeError(
-      `expected message to be an string, instead got: ${typeof body}`
-    )
-  }
-
-  if (body.length === 0) {
-    throw new TypeError(
-      'expected message to be an string of length greater than zero'
-    )
-  }
-
-  const outgoingID = await Utils.recipientToOutgoingID(recipientPublicKey)
-
-  if (outgoingID === null) {
-    throw new Error(
-      `Could not fetch an outgoing id for user: ${recipientPublicKey}`
-    )
-  }
-
-  const recipientEpub = await Utils.pubToEpub(recipientPublicKey)
-  const ourSecret = await SEA.secret(recipientEpub, user._.sea)
-  if (typeof ourSecret !== 'string') {
-    throw new TypeError("sendMessage() -> typeof ourSecret !== 'string'")
-  }
-  const encryptedBody = await SEA.encrypt(body, ourSecret)
-
-  const newMessage = {
-    body: encryptedBody,
-    timestamp: Date.now()
-  }
-
-  return new Promise((res, rej) => {
-    const msgNode = user
-      .get(Key.OUTGOINGS)
-      .get(outgoingID)
-      .get(Key.MESSAGES)
-      .set(newMessage, ack => {
-        if (ack.err && typeof ack.err !== 'number') {
-          rej(new Error(ack.err))
-        } else {
-          res({
-            body,
-            id: msgNode._.get,
-            outgoing: true,
-            timestamp: newMessage.timestamp
-          })
-        }
-      })
-  })
-}
-
-/**
- * Returns the message id.
- * @param {string} recipientPublicKey
- * @param {string} body
- * @param {UserGUNNode} user
- * @param {ISEA} SEA
- * @returns {Promise<string>} The message id.
- */
-const sendMessage = async (recipientPublicKey, body, user, SEA) =>
-  (await sendMessageNew(recipientPublicKey, body, user, SEA)).id
-
-/**
- * @param {string} recipientPub
- * @param {string} msgID
- * @param {UserGUNNode} user
- * @returns {Promise<void>}
- */
-const deleteMessage = async (recipientPub, msgID, user) => {
-  if (!user.is) {
-    throw new Error(ErrorCode.NOT_AUTH)
-  }
-
-  if (typeof recipientPub !== 'string') {
-    throw new TypeError(
-      `expected recipientPublicKey to be an string, but instead got: ${typeof recipientPub}`
-    )
-  }
-
-  if (recipientPub.length === 0) {
-    throw new TypeError(
-      'expected recipientPublicKey to be an string of length greater than zero'
-    )
-  }
-
-  if (typeof msgID !== 'string') {
-    throw new TypeError(
-      `expected msgID to be an string, instead got: ${typeof msgID}`
-    )
-  }
-
-  if (msgID.length === 0) {
-    throw new TypeError(
-      'expected msgID to be an string of length greater than zero'
-    )
-  }
-
-  const outgoingID = await Utils.recipientToOutgoingID(recipientPub)
-
-  if (outgoingID === null) {
-    throw new Error(`Could not fetch an outgoing id for user: ${recipientPub}`)
-  }
-
-  return new Promise((res, rej) => {
-    user
-      .get(Key.OUTGOINGS)
-      .get(outgoingID)
-      .get(Key.MESSAGES)
-      .get(msgID)
-      .put(null, ack => {
-        if (ack.err && typeof ack.err !== 'number') {
-          rej(new Error(ack.err))
-        } else {
-          res()
-        }
-      })
-  })
-}
-
 /**
  * @param {string|null} avatar
  * @param {UserGUNNode} user
@@ -924,52 +240,6 @@ const setSeedServiceData = (encryptedSeedServiceData, user) =>
     })
   })
 
-/**
- * @param {string} initialMsg
- * @param {string} recipientPublicKey
- * @param {GUNNode} gun
- * @param {UserGUNNode} user
- * @param {ISEA} SEA
- * @throws {Error|TypeError}
- * @returns {Promise<void>}
- */
-const sendHRWithInitialMsg = async (
-  initialMsg,
-  recipientPublicKey,
-  gun,
-  user,
-  SEA
-) => {
-  /** @type {boolean} */
-  const alreadyHandshaked = await Utils.tryAndWait(
-    (_, user) =>
-      new Promise((res, rej) => {
-        user
-          .get(Key.USER_TO_INCOMING)
-          .get(recipientPublicKey)
-          .once(inc => {
-            if (typeof inc !== 'string') {
-              res(false)
-            } else if (inc.length === 0) {
-              rej(
-                new Error(
-                  `sendHRWithInitialMsg()-> obtained encryptedIncomingId from user-to-incoming an string but of length 0`
-                )
-              )
-            } else {
-              res(true)
-            }
-          })
-      })
-  )
-
-  if (!alreadyHandshaked) {
-    await sendHandshakeRequest(recipientPublicKey, gun, user, SEA)
-  }
-
-  await sendMessage(recipientPublicKey, initialMsg, user, SEA)
-}
-
 /**
  * @typedef {object} SpontPaymentOptions
  * @prop {Common.Schema.OrderTargetType} type
@@ -1035,7 +305,7 @@ const sendSpontaneousPayment = async (
 
     logger.info('sendPayment() -> will now create order:')
 
-    /** @type {Order} */
+    /** @type {import('shock-common').Schema.Order} */
     const order = {
       amount: amount.toString(),
       from: getUser()._.sea.pub,
@@ -1395,18 +665,6 @@ const saveChannelsBackup = async (backups, user, SEA) => {
   })
 }
 
-/**
- * @param {string} pub
- * @returns {Promise<void>}
- */
-const disconnect = async pub => {
-  if (!(await Utils.successfulHandshakeAlreadyExists(pub))) {
-    throw new Error('No handshake exists for this pub')
-  }
-
-  await Promise.all([cleanup(pub), generateHandshakeAddress()])
-}
-
 /**
  * @returns {Promise<void>}
  */
@@ -1789,15 +1047,9 @@ const initWall = async () => {
 }
 
 module.exports = {
-  __createOutgoingFeed,
-  acceptRequest,
   authenticate,
   blacklist,
   generateHandshakeAddress,
-  sendHandshakeRequest,
-  deleteMessage,
-  sendMessage,
-  sendHRWithInitialMsg,
   setAvatar,
   setDisplayName,
   sendPayment,
@@ -1805,14 +1057,12 @@ module.exports = {
   setBio,
   saveSeedBackup,
   saveChannelsBackup,
-  disconnect,
   setLastSeenApp,
   createPost,
   deletePost,
   follow,
   unfollow,
   initWall,
-  sendMessageNew,
   sendSpontaneousPayment,
   createPostNew,
   setDefaultSeedProvider,

From ee229cace567409e8b4caa276d300a5fd26c8708 Mon Sep 17 00:00:00 2001
From: Daniel Lugo <danlugo92@gmail.com>
Date: Mon, 19 Jul 2021 17:08:36 -0400
Subject: [PATCH 25/32] Remove merge artifacts

---
 services/gunDB/sockets/index.js | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/services/gunDB/sockets/index.js b/services/gunDB/sockets/index.js
index 1166df21..883f370c 100644
--- a/services/gunDB/sockets/index.js
+++ b/services/gunDB/sockets/index.js
@@ -9,11 +9,7 @@ const uuidv4 = require('uuid/v4')
 const { getGun, getUser, isAuthenticated } = require('../Mediator')
 const { deepDecryptIfNeeded } = require('../rpc')
 const Subscriptions = require('./subscriptions')
-<<<<<<< HEAD
-const GunEvents = require('../contact-api/events')
 const GunActions = require('../../gunDB/contact-api/actions')
-=======
->>>>>>> a8235aa... No hardcoded events in gun socket rpc
 const {
   encryptedEmit,
   encryptedOn,

From c67677ede77eb994cad82240435d01a42c20d2ca Mon Sep 17 00:00:00 2001
From: hatim boufnichel <boufni95@gmail.com>
Date: Tue, 20 Jul 2021 20:03:13 +0200
Subject: [PATCH 26/32] mostly logs

---
 services/gunDB/contact-api/jobs/onOrders.js | 11 --------
 services/gunDB/contact-api/utils/index.js   |  3 +--
 services/gunDB/sockets/index.js             |  4 ++-
 src/routes.js                               | 29 +++++++--------------
 4 files changed, 13 insertions(+), 34 deletions(-)

diff --git a/services/gunDB/contact-api/jobs/onOrders.js b/services/gunDB/contact-api/jobs/onOrders.js
index 168758e2..7435e2b1 100644
--- a/services/gunDB/contact-api/jobs/onOrders.js
+++ b/services/gunDB/contact-api/jobs/onOrders.js
@@ -110,19 +110,12 @@ const listenerForAddr = (addr, SEA) => async (order, orderID) => {
 
     ordersProcessed.add(orderID)
 
-    logger.info(
-      `onOrders() -> processing order: ${orderID} -- ${JSON.stringify(
-        order
-      )} -- addr: ${addr}`
-    )
-
     const alreadyAnswered = await getUser()
       .get(Key.ORDER_TO_RESPONSE)
       .get(orderID)
       .then()
 
     if (alreadyAnswered) {
-      logger.info('this order is already answered, quitting')
       return
     }
 
@@ -209,10 +202,6 @@ const listenerForAddr = (addr, SEA) => async (order, orderID) => {
       private: true
     }
 
-    logger.info(
-      `onOrders() -> Will now create an invoice : ${JSON.stringify(invoiceReq)}`
-    )
-
     const invoice = await _addInvoice(invoiceReq)
 
     logger.info(
diff --git a/services/gunDB/contact-api/utils/index.js b/services/gunDB/contact-api/utils/index.js
index 530588e8..d9cbaf26 100644
--- a/services/gunDB/contact-api/utils/index.js
+++ b/services/gunDB/contact-api/utils/index.js
@@ -128,8 +128,7 @@ const tryAndWait = async (promGen, shouldRetry = () => false) => {
       return resolvedValue
     }
   } catch (e) {
-    logger.error(e)
-    logger.info(JSON.stringify(e))
+    console.log(e)
     if (e.message === Constants.ErrorCode.NOT_AUTH) {
       throw e
     }
diff --git a/services/gunDB/sockets/index.js b/services/gunDB/sockets/index.js
index a1427703..e966fd89 100644
--- a/services/gunDB/sockets/index.js
+++ b/services/gunDB/sockets/index.js
@@ -246,7 +246,9 @@ const startSocket = socket => {
 
     if (isAuthenticated()) {
       socket.onAny(() => {
-        GunActions.setLastSeenApp()
+        GunActions.setLastSeenApp().catch(e =>
+          console.log('error setting last seen app', e)
+        )
       })
     }
 
diff --git a/src/routes.js b/src/routes.js
index d0b3525c..a907bea5 100644
--- a/src/routes.js
+++ b/src/routes.js
@@ -74,11 +74,9 @@ module.exports = async (
     }
 
     const checkHealth = async () => {
-      logger.info('Getting service status...')
       let LNDStatus = {}
       try {
         const serviceStatus = await getAvailableService()
-        logger.info('Received status:', serviceStatus)
         LNDStatus = serviceStatus
       } catch (e) {
         LNDStatus = {
@@ -88,7 +86,6 @@ module.exports = async (
       }
 
       try {
-        logger.info('Getting API status...')
         const APIHealth = await Http.get(
           `${usetls ? 'https' : 'http'}://localhost:${serverPort}/ping`
         )
@@ -97,7 +94,6 @@ module.exports = async (
           responseTime: APIHealth.headers['x-response-time'],
           success: true
         }
-        logger.info('Received API status!', APIStatus)
         return {
           LNDStatus,
           APIStatus,
@@ -223,7 +219,6 @@ module.exports = async (
     app.use((req, res, next) => {
       const legacyDeviceId = req.headers['x-shockwallet-device-id']
       const deviceId = req.headers['encryption-device-id']
-      logger.debug('Decrypting route...')
       try {
         if (
           nonEncryptedRoutes.includes(req.path) ||
@@ -308,21 +303,12 @@ module.exports = async (
     app.use(async (req, res, next) => {
       const legacyDeviceId = req.headers['x-shockwallet-device-id']
       const deviceId = req.headers['encryption-device-id']
-      logger.info('Decrypting route...')
       try {
         if (
           nonEncryptedRoutes.includes(req.path) ||
           process.env.DISABLE_SHOCK_ENCRYPTION === 'true' ||
           (legacyDeviceId && !deviceId)
         ) {
-          logger.info(
-            'Unprotected route detected! ' +
-              req.path +
-              ' Legacy ID:' +
-              legacyDeviceId +
-              ' Device ID:' +
-              deviceId
-          )
           return next()
         }
 
@@ -371,7 +357,6 @@ module.exports = async (
     })
 
     app.use(async (req, res, next) => {
-      logger.info(`Route: ${req.path}`)
       if (unprotectedRoutes[req.method][req.path]) {
         next()
       } else {
@@ -502,7 +487,7 @@ module.exports = async (
      */
     app.get('/healthz', async (req, res) => {
       const health = await checkHealth()
-      logger.info('Healthz response:', health)
+      logger.info('Healthz response:', health.APIStatus.success)
       res.json(health)
     })
 
@@ -1112,7 +1097,6 @@ module.exports = async (
             res.json({ errorMessage: 'LND is down' })
           }
         }
-        logger.info('GetInfo:', response)
         if (!response.uris || response.uris.length === 0) {
           if (config.lndAddress) {
             response.uris = [response.identity_pubkey + '@' + config.lndAddress]
@@ -3163,6 +3147,7 @@ module.exports = async (
     ap.get('/api/gun/once/:path', async (req, res) => {
       const publicKeyForDecryption = req.header(PUBKEY_FOR_DECRYPT_HEADER)
       const { path } = req.params
+      logger.info(`gun ONCE: ${path}`)
       try {
         const data = await handleGunFetch({
           path,
@@ -3189,6 +3174,7 @@ module.exports = async (
     ap.get('/api/gun/load/:path', async (req, res) => {
       const publicKeyForDecryption = req.header(PUBKEY_FOR_DECRYPT_HEADER)
       const { path } = req.params
+      logger.info(`gun LOAD: ${path}`)
       try {
         const data = await handleGunFetch({
           path,
@@ -3215,6 +3201,7 @@ module.exports = async (
     ap.get('/api/gun/user/once/:path', async (req, res) => {
       const publicKeyForDecryption = req.header(PUBKEY_FOR_DECRYPT_HEADER)
       const { path } = req.params
+      logger.info(`gun otheruser ONCE: ${path}`)
       try {
         const data = await handleGunFetch({
           path,
@@ -3241,6 +3228,7 @@ module.exports = async (
     ap.get('/api/gun/user/load/:path', async (req, res) => {
       const publicKeyForDecryption = req.header(PUBKEY_FOR_DECRYPT_HEADER)
       const { path } = req.params
+      logger.info(`gun otheruser LOAD: ${path}`)
       try {
         const data = await handleGunFetch({
           path,
@@ -3268,7 +3256,7 @@ module.exports = async (
       const allowedTypes = ['once', 'load', 'open']
       const publicKeyForDecryption = req.header(PUBKEY_FOR_DECRYPT_HEADER)
       const { path /*:rawPath*/, publicKey, type } = req.params
-      console.log(path)
+      logger.info(`gun otheruser ${type}: ${path}`)
       // const path = decodeURI(rawPath)
       if (!publicKey || publicKey === 'undefined') {
         res.status(400).json({
@@ -3308,6 +3296,7 @@ module.exports = async (
       try {
         const { lightning } = LightningServices.services
         const { methodName } = req.params
+        logger.info(`lnd RPC: ${methodName}`)
         const args = req.body
 
         lightning[methodName](args, (err, lres) => {
@@ -3337,7 +3326,7 @@ module.exports = async (
     ap.post('/api/gun/put', async (req, res) => {
       try {
         const { path, value } = req.body
-
+        logger.info(`gun PUT: ${path}`)
         await GunWriteRPC.put(path, value)
 
         res.status(200).json({
@@ -3357,7 +3346,7 @@ module.exports = async (
     ap.post('/api/gun/set', async (req, res) => {
       try {
         const { path, value } = req.body
-
+        logger.info(`gun PUT: ${path}`)
         const id = await GunWriteRPC.set(path, value)
 
         res.status(200).json({

From 13a40d7511a4e74bc0058f8eba8be979132c43df Mon Sep 17 00:00:00 2001
From: hatim boufnichel <boufni95@gmail.com>
Date: Tue, 20 Jul 2021 22:43:45 +0200
Subject: [PATCH 27/32] logger->console

---
 services/gunDB/contact-api/utils/index.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/services/gunDB/contact-api/utils/index.js b/services/gunDB/contact-api/utils/index.js
index d9cbaf26..5e4261dd 100644
--- a/services/gunDB/contact-api/utils/index.js
+++ b/services/gunDB/contact-api/utils/index.js
@@ -160,7 +160,7 @@ const tryAndWait = async (promGen, shouldRetry = () => false) => {
       return resolvedValue
     }
   } catch (e) {
-    logger.error(e)
+    console.log(e)
     if (e.message === Constants.ErrorCode.NOT_AUTH) {
       throw e
     }
@@ -192,7 +192,7 @@ const tryAndWait = async (promGen, shouldRetry = () => false) => {
       return resolvedValue
     }
   } catch (e) {
-    logger.error(e)
+    console.log(e)
     if (e.message === Constants.ErrorCode.NOT_AUTH) {
       throw e
     }

From 148b42c5edc23c5a84266a0cc20a44901597dee4 Mon Sep 17 00:00:00 2001
From: Daniel Lugo <danlugo92@gmail.com>
Date: Wed, 21 Jul 2021 13:27:34 -0400
Subject: [PATCH 28/32] Remove old chat code

---
 services/gunDB/contact-api/utils/index.js |  75 ----
 src/routes.js                             | 396 ----------------------
 2 files changed, 471 deletions(-)

diff --git a/services/gunDB/contact-api/utils/index.js b/services/gunDB/contact-api/utils/index.js
index 5e4261dd..84efa706 100644
--- a/services/gunDB/contact-api/utils/index.js
+++ b/services/gunDB/contact-api/utils/index.js
@@ -238,78 +238,6 @@ const pubToEpub = async pub => {
   }
 }
 
-/**
- * Should only be called with a recipient pub that has already been contacted.
- * If returns null, a disconnect happened.
- * @param {string} recipientPub
- * @returns {Promise<string|null>}
- */
-const recipientPubToLastReqSentID = async recipientPub => {
-  const maybeLastReqSentID = await tryAndWait(
-    (_, user) => {
-      const userToLastReqSent = user.get(Key.USER_TO_LAST_REQUEST_SENT)
-      return userToLastReqSent.get(recipientPub).then()
-    },
-    // retry on undefined, in case it is a false negative
-    v => typeof v === 'undefined'
-  )
-
-  if (typeof maybeLastReqSentID !== 'string') {
-    return null
-  }
-
-  return maybeLastReqSentID
-}
-
-/**
- * @param {string} recipientPub
- * @returns {Promise<boolean>}
- */
-const successfulHandshakeAlreadyExists = async recipientPub => {
-  const maybeIncomingID = await tryAndWait((_, user) => {
-    const userToIncoming = user.get(Key.USER_TO_INCOMING)
-
-    return userToIncoming.get(recipientPub).then()
-  })
-
-  const maybeOutgoingID = await tryAndWait((_, user) => {
-    const recipientToOutgoing = user.get(Key.RECIPIENT_TO_OUTGOING)
-
-    return recipientToOutgoing.get(recipientPub).then()
-  })
-
-  return (
-    typeof maybeIncomingID === 'string' && typeof maybeOutgoingID === 'string'
-  )
-}
-
-/**
- * @param {string} recipientPub
- * @returns {Promise<string|null>}
- */
-const recipientToOutgoingID = async recipientPub => {
-  const maybeEncryptedOutgoingID = await tryAndWait(
-    (_, user) =>
-      user
-        .get(Key.RECIPIENT_TO_OUTGOING)
-        .get(recipientPub)
-        .then(),
-    // force retry in case undefined is a false negative
-    v => typeof v === 'undefined'
-  )
-
-  if (typeof maybeEncryptedOutgoingID === 'string') {
-    const outgoingID = await require('../../Mediator/index').mySEA.decrypt(
-      maybeEncryptedOutgoingID,
-      await mySecret()
-    )
-
-    return outgoingID || null
-  }
-
-  return null
-}
-
 /**
  * @param {import('../SimpleGUN').ListenerData} listenerData
  * @returns {listenerData is import('../SimpleGUN').ListenerObj}
@@ -350,9 +278,6 @@ module.exports = {
   dataHasSoul,
   delay,
   pubToEpub,
-  recipientPubToLastReqSentID,
-  successfulHandshakeAlreadyExists,
-  recipientToOutgoingID,
   tryAndWait,
   mySecret,
   promisifyGunNode: require('./promisifygun'),
diff --git a/src/routes.js b/src/routes.js
index a291e069..46fb6e99 100644
--- a/src/routes.js
+++ b/src/routes.js
@@ -2132,28 +2132,6 @@ module.exports = async (
 
     const Events = require('../services/gunDB/contact-api/events')
 
-    app.get(`/api/gun/${GunEvent.ON_CHATS}`, (_, res) => {
-      try {
-        const data = Events.getChats()
-        const noAvatar = data.map(mex => {
-          return { ...mex, recipientAvatar: null }
-        })
-        res.json({
-          data: noAvatar
-        })
-      } catch (err) {
-        logger.info('Error in Chats poll:')
-        logger.error(err)
-        res
-          .status(
-            err.message === Common.Constants.ErrorCode.NOT_AUTH ? 401 : 500
-          )
-          .json({
-            errorMessage: typeof err === 'string' ? err : err.message
-          })
-      }
-    })
-
     app.get(`/api/gun/${GunEvent.ON_DISPLAY_NAME}`, async (_, res) => {
       try {
         const user = require('../services/gunDB/Mediator').getUser()
@@ -2614,319 +2592,6 @@ module.exports = async (
     ap.get(`/api/gun/me`, apiGunMeGet)
     ap.put(`/api/gun/me`, apiGunMePut)
 
-    /**
-     * @typedef {object} ChatsRouteParams
-     * @prop {(string|undefined)=} publicKey
-     */
-
-    /**
-     * @type {RequestHandler<ChatsRouteParams>}
-     */
-    const apiGunChatsPost = async (req, res) => {
-      const { publicKey } = req.params
-      const { body } = req.body
-
-      if (!publicKey) {
-        return res.status(400).json({
-          errorMessage: `Must specify a publicKey route param for POSTing a message`
-        })
-      }
-
-      try {
-        const user = GunDB.getUser()
-        const SEA = GunDB.mySEA
-
-        return res
-          .status(200)
-          .json(await GunActions.sendMessageNew(publicKey, body, user, SEA))
-      } catch (err) {
-        logger.error(err)
-        return res.status(500).json({
-          errorMessage: err.message
-        })
-      }
-    }
-
-    /**
-     * @type {RequestHandler<ChatsRouteParams>}
-     */
-    const apiGunChatsDelete = async (req, res) => {
-      const { publicKey } = req.params
-
-      if (!publicKey) {
-        return res.status(400).json({
-          errorMessage: `Must specify a publicKey route param for DELETING a chat`
-        })
-      }
-
-      try {
-        await GunActions.disconnect(publicKey)
-
-        return res.status(200).json({
-          ok: true
-        })
-      } catch (err) {
-        logger.error(err)
-        return res.status(500).json({
-          errorMessage: err.message
-        })
-      }
-    }
-
-    ap.post(`/api/gun/chats/:publicKey?`, apiGunChatsPost)
-    ap.delete(`/api/gun/chats/:publicKey?`, apiGunChatsDelete)
-
-    /**
-     * @typedef {object} RequestsRouteParams
-     * @prop {(string|undefined)=} requestID
-     */
-
-    /**
-     * @type {RequestHandler<{}>}
-     */
-    const apiGunRequestsReceivedGet = (_, res) => {
-      try {
-        const data = Events.getCurrentReceivedReqs()
-        const noAvatar = data.map(req => {
-          return { ...req, recipientAvatar: null }
-        })
-        res.json({
-          data: noAvatar
-        })
-      } catch (err) {
-        logger.error(err)
-        return res.status(500).json({
-          errorMessage: err.message
-        })
-      }
-    }
-
-    /**
-     * @type {RequestHandler<{}>}
-     */
-    const apiGunRequestsSentGet = (_, res) => {
-      try {
-        const data = Events.getCurrentSentReqs()
-        const noAvatar = data.map(req => {
-          return { ...req, recipientAvatar: null }
-        })
-        res.json({
-          data: noAvatar
-        })
-      } catch (err) {
-        logger.error(err)
-        return res.status(500).json({
-          errorMessage: err.message
-        })
-      }
-    }
-
-    /**
-     * @typedef {object} RequestsRoutePOSTBody
-     * @prop {string=} initialMsg
-     * @prop {string} publicKey
-     */
-
-    /**
-     * @type {RequestHandler<{}>}
-     */
-    const apiGunRequestsPost = async (req, res) => {
-      const {
-        initialMsg,
-        publicKey
-      } = /** @type {RequestsRoutePOSTBody} */ (req.body)
-
-      if (!publicKey) {
-        return res.status(400).json({
-          errorMessage: `Must specify a publicKey route param for POSTing a message`
-        })
-      }
-
-      try {
-        const gun = require('../services/gunDB/Mediator').getGun()
-        const user = require('../services/gunDB/Mediator').getUser()
-        const SEA = require('../services/gunDB/Mediator').mySEA
-
-        if (initialMsg) {
-          await GunActions.sendHRWithInitialMsg(
-            initialMsg,
-            publicKey,
-            gun,
-            user,
-            SEA
-          )
-        } else {
-          await GunActions.sendHandshakeRequest(publicKey, gun, user, SEA)
-        }
-
-        return res.status(200).json({
-          ok: true
-        })
-      } catch (err) {
-        logger.error(err)
-        return res.status(500).json({
-          errorMessage: err.message
-        })
-      }
-    }
-
-    /**
-     * @typedef {object} RequestsRoutePUTBody
-     * @prop {boolean=} accept
-     */
-
-    /**
-     * @type {RequestHandler<RequestsRouteParams>}
-     */
-    const apiGunRequestsPut = async (req, res) => {
-      const { requestID } = req.params
-      const { accept } = /** @type {RequestsRoutePUTBody} */ (req.body)
-
-      if (!requestID) {
-        return res.status(400).json({
-          errorMessage: `Must specify a requestID route param for accepting a request`
-        })
-      }
-
-      if (!accept) {
-        return res.status(200).json({
-          ok: true
-        })
-      }
-
-      try {
-        const gun = require('../services/gunDB/Mediator').getGun()
-        const user = require('../services/gunDB/Mediator').getUser()
-        const SEA = require('../services/gunDB/Mediator').mySEA
-
-        await GunActions.acceptRequest(requestID, gun, user, SEA)
-
-        return res.status(200).json({
-          ok: true
-        })
-      } catch (err) {
-        logger.error(err)
-        return res.status(500).json({
-          errorMessage: err.message
-        })
-      }
-    }
-
-    ap.get(
-      `/api/gun/${GunEvent.ON_RECEIVED_REQUESTS}`,
-      apiGunRequestsReceivedGet
-    )
-    ap.get(`/api/gun/${GunEvent.ON_SENT_REQUESTS}`, apiGunRequestsSentGet)
-    ap.get(`/api/gun/requests/received`, apiGunRequestsReceivedGet)
-    ap.get(`/api/gun/requests/sent`, apiGunRequestsSentGet)
-    ap.post('/api/gun/requests/', apiGunRequestsPost)
-    ap.put(`/api/gun/requests/:requestID?`, apiGunRequestsPut)
-
-    ap.get(`/api/gun/dev/userToIncoming`, async (_, res) => {
-      try {
-        const { tryAndWait } = require('../services/gunDB/contact-api/utils')
-
-        const data = await tryAndWait(
-          (_, u) =>
-            new Promise(res => {
-              u.get(GunKey.USER_TO_INCOMING).load(data => {
-                res(data)
-              })
-            }),
-          v => {
-            if (typeof v !== 'object') {
-              return true
-            }
-
-            if (v === null) {
-              return true
-            }
-
-            // load sometimes returns an empty set on the first try
-            return size(v) === 0
-          }
-        )
-
-        return res.status(200).json({
-          data
-        })
-      } catch (err) {
-        return res.status(500).json({
-          errorMessage: err.message
-        })
-      }
-    })
-
-    ap.get(`/api/gun/dev/recipientToOutgoing`, async (_, res) => {
-      try {
-        const { tryAndWait } = require('../services/gunDB/contact-api/utils')
-
-        const data = await tryAndWait(
-          (_, u) =>
-            new Promise(res => {
-              u.get(GunKey.RECIPIENT_TO_OUTGOING).load(data => {
-                res(data)
-              })
-            }),
-          v => {
-            if (typeof v !== 'object') {
-              return true
-            }
-
-            if (v === null) {
-              return true
-            }
-
-            // load sometimes returns an empty set on the first try
-            return size(v) === 0
-          }
-        )
-
-        return res.status(200).json({
-          data
-        })
-      } catch (err) {
-        return res.status(500).json({
-          errorMessage: err.message
-        })
-      }
-    })
-
-    ap.get(`/api/gun/dev/outgoings`, async (_, res) => {
-      try {
-        const { tryAndWait } = require('../services/gunDB/contact-api/utils')
-
-        const data = await tryAndWait(
-          (_, u) =>
-            new Promise(res => {
-              u.get(GunKey.OUTGOINGS).load(data => {
-                res(data)
-              })
-            }),
-          v => {
-            if (typeof v !== 'object') {
-              return true
-            }
-
-            if (v === null) {
-              return true
-            }
-
-            // load sometimes returns an empty set on the first try
-            return size(v) === 0
-          }
-        )
-
-        return res.status(200).json({
-          data
-        })
-      } catch (err) {
-        return res.status(500).json({
-          errorMessage: err.message
-        })
-      }
-    })
-
     ap.get(`/api/gun/dev/currentHandshakeAddress`, async (_, res) => {
       try {
         const { tryAndWait } = require('../services/gunDB/contact-api/utils')
@@ -3020,67 +2685,6 @@ module.exports = async (
       }
     })
 
-    ap.get(`/api/gun/dev/storedReqs`, async (req, res) => {
-      try {
-        const { tryAndWait } = require('../services/gunDB/contact-api/utils')
-
-        const data = await tryAndWait(
-          (_, u) => new Promise(res => u.get(Key.STORED_REQS).load(res)),
-          v => {
-            if (typeof v !== 'object') {
-              return true
-            }
-
-            if (v === null) {
-              return true
-            }
-
-            // load sometimes returns an empty set on the first try
-            return size(v) === 0
-          }
-        )
-
-        return res.status(200).json({
-          data
-        })
-      } catch (err) {
-        return res.status(500).json({
-          errorMessage: err.message
-        })
-      }
-    })
-
-    ap.get(`/api/gun/dev/userToLastReqSent`, async (req, res) => {
-      try {
-        const { tryAndWait } = require('../services/gunDB/contact-api/utils')
-
-        const data = await tryAndWait(
-          (_, u) =>
-            new Promise(res => u.get(Key.USER_TO_LAST_REQUEST_SENT).load(res)),
-          v => {
-            if (typeof v !== 'object') {
-              return true
-            }
-
-            if (v === null) {
-              return true
-            }
-
-            // load sometimes returns an empty set on the first try
-            return size(v) === 0
-          }
-        )
-
-        return res.status(200).json({
-          data
-        })
-      } catch (err) {
-        return res.status(500).json({
-          errorMessage: err.message
-        })
-      }
-    })
-
     ap.get(`/api/gun/auth`, (_, res) => {
       const { isAuthenticated } = require('../services/gunDB/Mediator')
 

From c70062b86f2aee0894e608d4c726fe3770a598ab Mon Sep 17 00:00:00 2001
From: Daniel Lugo <danlugo92@gmail.com>
Date: Wed, 21 Jul 2021 13:40:48 -0400
Subject: [PATCH 29/32] Remove old chat code

---
 .../gunDB/contact-api/streams/addresses.js    |  56 ----
 services/gunDB/contact-api/streams/index.js   |  92 -------
 .../contact-api/streams/lastSentReqID.js      |  56 ----
 .../gunDB/contact-api/streams/pubToFeed.js    | 260 ------------------
 .../contact-api/streams/pubToIncoming.js      | 105 -------
 5 files changed, 569 deletions(-)
 delete mode 100644 services/gunDB/contact-api/streams/addresses.js
 delete mode 100644 services/gunDB/contact-api/streams/lastSentReqID.js
 delete mode 100644 services/gunDB/contact-api/streams/pubToFeed.js
 delete mode 100644 services/gunDB/contact-api/streams/pubToIncoming.js

diff --git a/services/gunDB/contact-api/streams/addresses.js b/services/gunDB/contact-api/streams/addresses.js
deleted file mode 100644
index 705e8b4c..00000000
--- a/services/gunDB/contact-api/streams/addresses.js
+++ /dev/null
@@ -1,56 +0,0 @@
-/** @format */
-const logger = require('winston')
-const size = require('lodash/size')
-
-const Key = require('../key')
-/**
- * @typedef {Record<string, string|null|undefined>} Addresses
- */
-
-/** @type {Addresses} */
-const pubToAddress = {}
-
-/** @type {Set<() => void>} */
-const listeners = new Set()
-
-listeners.add(() => {
-  logger.info(`pubToAddress length: ${size(pubToAddress)}`)
-})
-
-const notify = () => listeners.forEach(l => l())
-
-/** @type {Set<string>} */
-const subbedPublicKeys = new Set()
-
-/**
- * @param {() => void} cb
- * @param {string=} pub
- */
-const onAddresses = (cb, pub) => {
-  listeners.add(cb)
-  cb()
-  if (pub && subbedPublicKeys.add(pub)) {
-    require('../../Mediator')
-      .getGun()
-      .user(pub)
-      .get(Key.CURRENT_HANDSHAKE_ADDRESS)
-      .on(addr => {
-        if (typeof addr === 'string' || addr === null) {
-          pubToAddress[pub] = addr
-        } else {
-          pubToAddress[pub] = null
-        }
-        notify()
-      })
-  }
-  return () => {
-    listeners.delete(cb)
-  }
-}
-
-const getAddresses = () => pubToAddress
-
-module.exports = {
-  onAddresses,
-  getAddresses
-}
diff --git a/services/gunDB/contact-api/streams/index.js b/services/gunDB/contact-api/streams/index.js
index 3f586954..7ff4d7be 100644
--- a/services/gunDB/contact-api/streams/index.js
+++ b/services/gunDB/contact-api/streams/index.js
@@ -1,98 +1,6 @@
 /** @format */
-const { Schema, Utils: CommonUtils } = require('shock-common')
-
-const Key = require('../key')
-const Utils = require('../utils')
-
-/**
- * @typedef {import('shock-common').Schema.StoredRequest} StoredRequest
- * @typedef {(reqs: StoredRequest[]) => void} StoredRequestsListener
- */
-
-/** @type {Set<StoredRequestsListener>} */
-const storedRequestsListeners = new Set()
-
-/**
- * @type {StoredRequest[]}
- */
-let encryptedStoredReqs = []
-
-/**
- * @type {StoredRequest[]}
- */
-let currentStoredReqs = []
-
-const getStoredReqs = () => currentStoredReqs
-
-const processStoredReqs = async () => {
-  const ereqs = encryptedStoredReqs
-  encryptedStoredReqs = []
-  const mySecret = await Utils.mySecret()
-  const SEA = require('../../Mediator').mySEA
-  const finalReqs = await CommonUtils.asyncMap(ereqs, async er => {
-    /** @type {StoredRequest} */
-    const r = {
-      handshakeAddress: await SEA.decrypt(er.handshakeAddress, mySecret),
-      recipientPub: await SEA.decrypt(er.recipientPub, mySecret),
-      sentReqID: await SEA.decrypt(er.sentReqID, mySecret),
-      timestamp: er.timestamp
-    }
-
-    return r
-  })
-  currentStoredReqs = finalReqs
-  storedRequestsListeners.forEach(l => l(currentStoredReqs))
-}
-
-let storedReqsSubbed = false
-
-/**
- * @param {StoredRequestsListener} cb
- */
-const onStoredReqs = cb => {
-  storedRequestsListeners.add(cb)
-
-  if (!storedReqsSubbed) {
-    require('../../Mediator')
-      .getUser()
-      .get(Key.STORED_REQS)
-      .open(d => {
-        if (typeof d === 'object' && d !== null) {
-          //@ts-ignore
-          encryptedStoredReqs = /** @type {StoredRequest[]} */ (Object.values(
-            d
-          ).filter(i => Schema.isStoredRequest(i)))
-        }
-
-        processStoredReqs()
-      })
-
-    storedReqsSubbed = true
-  }
-
-  cb(currentStoredReqs)
-
-  return () => {
-    storedRequestsListeners.delete(cb)
-  }
-}
 
 module.exports = {
-  onPubToIncoming: require('./pubToIncoming').onPubToIncoming,
-  getPubToIncoming: require('./pubToIncoming').getPubToIncoming,
-  setPubToIncoming: require('./pubToIncoming').setPubToIncoming,
-
-  onPubToFeed: require('./pubToFeed').onPubToFeed,
-  getPubToFeed: require('./pubToFeed').getPubToFeed,
-
-  onStoredReqs,
-  getStoredReqs,
-  onAddresses: require('./addresses').onAddresses,
-  getAddresses: require('./addresses').getAddresses,
-  onLastSentReqIDs: require('./lastSentReqID').onLastSentReqIDs,
-  getSentReqIDs: require('./lastSentReqID').getSentReqIDs,
-  PubToIncoming: require('./pubToIncoming'),
-
   getPubToLastSeenApp: require('./pubToLastSeenApp').getPubToLastSeenApp,
   onPubToLastSeenApp: require('./pubToLastSeenApp').on
 }
diff --git a/services/gunDB/contact-api/streams/lastSentReqID.js b/services/gunDB/contact-api/streams/lastSentReqID.js
deleted file mode 100644
index 431adb58..00000000
--- a/services/gunDB/contact-api/streams/lastSentReqID.js
+++ /dev/null
@@ -1,56 +0,0 @@
-/** @format */
-const logger = require('winston')
-const { Constants } = require('shock-common')
-
-const Key = require('../key')
-
-/** @type {Record<string, string|null|undefined>} */
-let pubToLastSentReqID = {}
-
-/** @type {Set<() => void>} */
-const listeners = new Set()
-const notify = () => listeners.forEach(l => l())
-
-let subbed = false
-
-/**
- * @param {() => void} cb
- */
-const onLastSentReqIDs = cb => {
-  listeners.add(cb)
-  cb()
-
-  if (!subbed) {
-    const user = require('../../Mediator').getUser()
-    if (!user.is) {
-      logger.warn('lastSentReqID() -> tried to sub without authing')
-      throw new Error(Constants.ErrorCode.NOT_AUTH)
-    }
-
-    user.get(Key.USER_TO_LAST_REQUEST_SENT).open(data => {
-      if (typeof data === 'object' && data !== null) {
-        for (const [pub, id] of Object.entries(data)) {
-          if (typeof id === 'string' || id === null) {
-            pubToLastSentReqID[pub] = id
-          }
-        }
-      } else {
-        pubToLastSentReqID = {}
-      }
-
-      notify()
-    })
-    subbed = true
-  }
-
-  return () => {
-    listeners.delete(cb)
-  }
-}
-
-const getSentReqIDs = () => pubToLastSentReqID
-
-module.exports = {
-  onLastSentReqIDs,
-  getSentReqIDs
-}
diff --git a/services/gunDB/contact-api/streams/pubToFeed.js b/services/gunDB/contact-api/streams/pubToFeed.js
deleted file mode 100644
index f140aaea..00000000
--- a/services/gunDB/contact-api/streams/pubToFeed.js
+++ /dev/null
@@ -1,260 +0,0 @@
-/** @format */
-const uuidv1 = require('uuid/v1')
-const logger = require('winston')
-const debounce = require('lodash/debounce')
-const { Schema, Utils: CommonUtils } = require('shock-common')
-const size = require('lodash/size')
-
-const Key = require('../key')
-const Utils = require('../utils')
-/**
- * @typedef {import('shock-common').Schema.ChatMessage} Message
- * @typedef {import('../SimpleGUN').OpenListenerData} OpenListenerData
- */
-
-const PubToIncoming = require('./pubToIncoming')
-
-/**
- * @typedef {Record<string, Message[]|null|undefined|'disconnected'>} Feeds
- * @typedef {(feeds: Feeds) => void} FeedsListener
- */
-
-/** @type {Set<FeedsListener>} */
-const feedsListeners = new Set()
-
-/**
- * @type {Feeds}
- */
-let pubToFeed = {}
-
-const getPubToFeed = () => pubToFeed
-
-feedsListeners.add(() => {
-  logger.info(`new pubToFeed length: ${size(getPubToFeed())}`)
-})
-
-/** @param {Feeds} ptf */
-const setPubToFeed = ptf => {
-  pubToFeed = ptf
-  feedsListeners.forEach(l => {
-    l(pubToFeed)
-  })
-}
-
-/**
- * If at one point we subscribed to a feed, record it here. Keeps track of it
- * for unsubbing.
- *
- * Since we can't really unsub in GUN, what we do is that each listener created
- * checks the last incoming feed, if it was created for other feed that is not
- * the latest, it becomes inactive.
- * @type {Record<string, string|undefined|null>}
- */
-const pubToLastIncoming = {}
-
-/**
- * Any pub-feed pair listener will write its update id here when fired up. Avoid
- * race conditions between different listeners and between different invocations
- * of the same listener.
- * @type {Record<string, string>}
- */
-const pubToLastUpdate = {}
-
-/**
- * Performs a sub to a pub feed pair that will only emit if it is the last
- * subbed feed for that pub, according to `pubToLastIncoming`. This listener is
- * not in charge of writing to the cache.
- * @param {[ string , string ]} param0
- * @returns {(data: OpenListenerData) => void}
- */
-const onOpenForPubFeedPair = ([pub, feed]) =>
-  debounce(async data => {
-    try {
-      // did invalidate
-      if (pubToLastIncoming[pub] !== feed) {
-        return
-      }
-
-      if (
-        // did disconnect
-        data === null ||
-        // interpret as disconnect
-        typeof data !== 'object'
-      ) {
-        // invalidate this listener. If a reconnection happens it will be for a
-        // different pub-feed pair.
-        pubToLastIncoming[pub] = null
-        setImmediate(() => {
-          logger.info(
-            `onOpenForPubFeedPair -> didDisconnect -> pub: ${pub} - feed: ${feed}`
-          )
-        })
-        // signal disconnect to listeners listeners should rely on pubToFeed for
-        // disconnect status instead of pub-to-incoming. Only the latter will
-        // detect remote disconnection
-        setPubToFeed({
-          ...getPubToFeed(),
-          [pub]: /** @type {'disconnected'} */ ('disconnected')
-        })
-        return
-      }
-      //@ts-ignore
-      const incoming = /** @type {import('shock-common').Schema.Outgoing} */ (data)
-
-      // incomplete data, let's not assume anything
-      if (
-        typeof incoming.with !== 'string' ||
-        typeof incoming.messages !== 'object'
-      ) {
-        return
-      }
-
-      /** @type {import('shock-common').Schema.ChatMessage[]} */
-      const newMsgs = Object.entries(incoming.messages)
-        // filter out messages with incomplete data
-        .filter(([_, msg]) => Schema.isMessage(msg))
-        .map(([id, msg]) => {
-          /** @type {import('shock-common').Schema.ChatMessage} */
-          const m = {
-            // we'll decrypt later
-            body: msg.body,
-            id,
-            outgoing: false,
-            timestamp: msg.timestamp
-          }
-
-          return m
-        })
-
-      if (newMsgs.length === 0) {
-        setPubToFeed({
-          ...getPubToFeed(),
-          [pub]: []
-        })
-        return
-      }
-
-      const thisUpdate = uuidv1()
-      pubToLastUpdate[pub] = thisUpdate
-
-      const user = require('../../Mediator').getUser()
-      if (!user.is) {
-        logger.warn('pubToFeed -> onOpenForPubFeedPair() -> user is not auth')
-      }
-      const SEA = require('../../Mediator').mySEA
-
-      const ourSecret = await SEA.secret(await Utils.pubToEpub(pub), user._.sea)
-
-      const decryptedMsgs = await CommonUtils.asyncMap(newMsgs, async m => {
-        /** @type {import('shock-common').Schema.ChatMessage} */
-        const decryptedMsg = {
-          ...m,
-          body: await SEA.decrypt(m.body, ourSecret)
-        }
-
-        return decryptedMsg
-      })
-
-      // this listener got invalidated while we were awaiting the async operations
-      // above.
-      if (pubToLastUpdate[pub] !== thisUpdate) {
-        return
-      }
-
-      setPubToFeed({
-        ...getPubToFeed(),
-        [pub]: decryptedMsgs
-      })
-    } catch (err) {
-      logger.warn(`error inside pub to pk-feed pair: ${pub} -- ${feed}`)
-      logger.error(err)
-    }
-  }, 750)
-
-const react = () => {
-  const pubToIncoming = PubToIncoming.getPubToIncoming()
-
-  const gun = require('../../Mediator').getGun()
-
-  /** @type {Feeds} */
-  const newPubToFeed = {}
-
-  for (const [pub, inc] of Object.entries(pubToIncoming)) {
-    /**
-     * empty string -> null
-     * @type {string|null}
-     */
-    const newIncoming = inc || null
-
-    if (
-      // if disconnected, the same incoming feed will try to overwrite the
-      // nulled out pubToLastIncoming[pub] entry. Making the listener for that
-      // pub feed pair fire up again, etc. Now. When the user disconnects from
-      // this side of things. He will overwrite the pub to incoming with null.
-      // Let's allow that.
-      newIncoming === pubToLastIncoming[pub] &&
-      !(pubToFeed[pub] === 'disconnected' && newIncoming === null)
-    ) {
-      // eslint-disable-next-line no-continue
-      continue
-    }
-
-    // will invalidate stale listeners (a listener for an outdated incoming feed
-    // id)
-    pubToLastIncoming[pub] = newIncoming
-    // Invalidate pending writes from stale listener(s) for the old incoming
-    // address.
-    pubToLastUpdate[pub] = uuidv1()
-    newPubToFeed[pub] = newIncoming ? [] : null
-
-    // sub to this incoming feed
-    if (typeof newIncoming === 'string') {
-      // perform sub to pub-incoming_feed pair
-      // leave all of the sideffects from this for the next tick
-      setImmediate(() => {
-        gun
-          .user(pub)
-          .get(Key.OUTGOINGS)
-          .get(newIncoming)
-          .open(onOpenForPubFeedPair([pub, newIncoming]))
-      })
-    }
-  }
-
-  if (Object.keys(newPubToFeed).length > 0) {
-    setPubToFeed({
-      ...getPubToFeed(),
-      ...newPubToFeed
-    })
-  }
-}
-
-let subbed = false
-
-/**
- * Array.isArray(pubToFeed[pub]) means a Handshake is in place, look for
- * incoming  messages here.
- * pubToIncoming[pub] === null means a disconnection took place.
- * typeof pubToIncoming[pub] === 'undefined' means none of the above.
- * @param {FeedsListener} cb
- * @returns {() => void}
- */
-const onPubToFeed = cb => {
-  feedsListeners.add(cb)
-  cb(getPubToFeed())
-
-  if (!subbed) {
-    PubToIncoming.onPubToIncoming(react)
-    subbed = true
-  }
-
-  return () => {
-    feedsListeners.delete(cb)
-  }
-}
-
-module.exports = {
-  getPubToFeed,
-  setPubToFeed,
-  onPubToFeed
-}
diff --git a/services/gunDB/contact-api/streams/pubToIncoming.js b/services/gunDB/contact-api/streams/pubToIncoming.js
deleted file mode 100644
index 2834ca79..00000000
--- a/services/gunDB/contact-api/streams/pubToIncoming.js
+++ /dev/null
@@ -1,105 +0,0 @@
-/** @format */
-const uuidv1 = require('uuid/v1')
-const debounce = require('lodash/debounce')
-const logger = require('winston')
-const { Utils: CommonUtils } = require('shock-common')
-const size = require('lodash/size')
-
-const { USER_TO_INCOMING } = require('../key')
-/** @typedef {import('../SimpleGUN').OpenListenerData} OpenListenerData */
-
-/**
- * @typedef {Record<string, string|null|undefined>} PubToIncoming
- */
-
-/** @type {Set<() => void>} */
-const listeners = new Set()
-
-/** @type {PubToIncoming} */
-let pubToIncoming = {}
-
-const getPubToIncoming = () => pubToIncoming
-/**
- * @param {PubToIncoming} pti
- * @returns {void}
- */
-const setPubToIncoming = pti => {
-  pubToIncoming = pti
-  listeners.forEach(l => l())
-}
-
-let latestUpdate = uuidv1()
-
-listeners.add(() => {
-  logger.info(`new pubToIncoming length: ${size(getPubToIncoming())}`)
-})
-
-const onOpen = debounce(async uti => {
-  const SEA = require('../../Mediator').mySEA
-  const mySec = require('../../Mediator').getMySecret()
-  const thisUpdate = uuidv1()
-  latestUpdate = thisUpdate
-
-  if (typeof uti !== 'object' || uti === null) {
-    setPubToIncoming({})
-    return
-  }
-
-  /** @type {PubToIncoming} */
-  const newPubToIncoming = {}
-
-  await CommonUtils.asyncForEach(
-    Object.entries(uti),
-    async ([pub, encFeedID]) => {
-      if (encFeedID === null) {
-        newPubToIncoming[pub] = null
-        return
-      }
-
-      if (typeof encFeedID === 'string') {
-        newPubToIncoming[pub] = await SEA.decrypt(encFeedID, mySec)
-      }
-    }
-  )
-
-  // avoid old data from overwriting new data if decrypting took longer to
-  // process for the older open() call than for the newer open() call
-  if (latestUpdate === thisUpdate) {
-    setPubToIncoming(newPubToIncoming)
-  }
-}, 750)
-
-let subbed = false
-
-/**
- * @param {() => void} cb
- * @returns {() => void}
- */
-const onPubToIncoming = cb => {
-  if (!listeners.add(cb)) {
-    throw new Error('Tried to subscribe twice')
-  }
-
-  cb()
-
-  if (!subbed) {
-    const user = require('../../Mediator').getUser()
-    if (!user.is) {
-      logger.warn(`subscribing to pubToIncoming on a unauth user`)
-    }
-    user.get(USER_TO_INCOMING).open(onOpen)
-    subbed = true
-  }
-
-  return () => {
-    if (!listeners.delete(cb)) {
-      throw new Error('Tried to unsubscribe twice')
-    }
-  }
-}
-
-module.exports = {
-  getPubToIncoming,
-  setPubToIncoming,
-  onPubToIncoming
-}

From bbd90b5424f9d5d2f16fd229ca600b038f165793 Mon Sep 17 00:00:00 2001
From: Version Update Action <actions@shock.network>
Date: Wed, 21 Jul 2021 22:56:07 +0000
Subject: [PATCH 30/32] version upgraded to 2021.7.21

---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 91000b67..96800f81 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "shockapi",
-  "version": "2021.7.18",
+  "version": "2021.7.21",
   "description": "",
   "main": "src/server.js",
   "scripts": {

From cdfb7f73117125e67b3f32f7c9d65182dbbc577a Mon Sep 17 00:00:00 2001
From: emad-salah <emads14@gmail.com>
Date: Thu, 22 Jul 2021 11:36:54 +0100
Subject: [PATCH 31/32] Complete refactor of Winston logging

---
 config/log.js | 94 +++++++++++++++++++++++++--------------------------
 src/server.js |  5 +--
 2 files changed, 48 insertions(+), 51 deletions(-)

diff --git a/config/log.js b/config/log.js
index aaf62fe6..06214472 100644
--- a/config/log.js
+++ b/config/log.js
@@ -1,58 +1,58 @@
-// config/log.js
+/** @prettier */
 
-const winston = require("winston");
-const util = require("util")
-require("winston-daily-rotate-file");
+const { createLogger, transports, format } = require('winston')
+const util = require('util')
+require('winston-daily-rotate-file')
 
-const winstonAttached = new Map();
-
-const transform = (info) => {
-  const args = info[Symbol.for('splat')];
-  if (args) { 
-    return {...info, message: util.format(info.message, ...args)}; 
+// @ts-ignore
+const transform = info => {
+  const args = info[Symbol.for('splat')]
+  if (args) {
+    return { ...info, message: util.format(info.message, ...args) }
   }
-  return info;
+  return info
 }
 
 const logFormatter = () => ({ transform })
 
-/**
- * @param {string} logFileName
- * @param {string} logLevel
- * @returns {import("winston").Logger}
- */
-module.exports = (logFileName, logLevel) => {
-  if (!winstonAttached.has(logFileName)) {
-    winston.add(new (winston.transports.DailyRotateFile)({
-      filename: logFileName,
-      datePattern: "yyyy-MM-DD",
+const formatter = format.combine(
+  format.colorize(),
+  format.errors({ stack: true }),
+  logFormatter(),
+  format.prettyPrint(),
+  format.timestamp(),
+  format.simple(),
+  format.align(),
+  format.printf(info => {
+    const { timestamp, level, message, stack, exception } = info
+
+    const ts = timestamp.slice(0, 19).replace('T', ' ')
+    const isObject = typeof message === 'object'
+    const formattedJson = isObject ? JSON.stringify(message, null, 2) : message
+    const formattedException = exception ? exception.stack : ''
+    const errorMessage = stack || formattedException
+    const formattedMessage = errorMessage ? errorMessage : formattedJson
+
+    return `${ts} [${level}]: ${formattedMessage}`
+  })
+)
+
+const Logger = createLogger({
+  format: formatter,
+  transports: [
+    new transports.DailyRotateFile({
+      filename: 'shockapi.log',
+      datePattern: 'yyyy-MM-DD',
       // https://github.com/winstonjs/winston-daily-rotate-file/issues/188
-      json: true,
+      json: false,
       maxSize: 1000000,
       maxFiles: 7,
-      level: logLevel
-    }))
-    winston.add(new winston.transports.Console({
-      format: winston.format.combine(
-        winston.format.colorize(),
-        logFormatter(),
-        winston.format.prettyPrint(),
-        winston.format.timestamp(),
-        winston.format.simple(),
-        winston.format.align(),
-        winston.format.printf((info) => {
-          const {
-            timestamp, level, message
-          } = info;
+      handleExceptions: true
+    }),
+    new transports.Console({
+      handleExceptions: true
+    })
+  ]
+})
 
-          const ts = timestamp.slice(0, 19).replace('T', ' ');
-          return `${ts} [${level}]: ${typeof message === "object" ? JSON.stringify(message, null, 2) : message}`;
-        }),
-      )
-    }))
-    winston.level = logLevel
-    winstonAttached.set(logFileName, winston)
-  }
-  
-  return winstonAttached.get(logFileName)
-}
\ No newline at end of file
+module.exports = Logger
diff --git a/src/server.js b/src/server.js
index cd0edcba..64255072 100644
--- a/src/server.js
+++ b/src/server.js
@@ -47,10 +47,7 @@ const server = program => {
   const tunnelHost = process.env.LOCAL_TUNNEL_SERVER || defaults.localtunnelHost
 
   // setup winston logging ==========
-  const logger = require('../config/log')(
-    program.logfile || defaults.logfile,
-    program.loglevel || defaults.loglevel
-  )
+  const logger = require('../config/log')
 
   CommonLogger.setLogger(logger)
 

From 2eb61783cdbcabc9020bb16e5704724dffc7c3a7 Mon Sep 17 00:00:00 2001
From: emad-salah <emads14@gmail.com>
Date: Thu, 22 Jul 2021 11:37:58 +0100
Subject: [PATCH 32/32] Fix logger imports

---
 services/auth/auth.js                           | 2 +-
 services/gunDB/Mediator/index.js                | 2 +-
 services/gunDB/contact-api/actions.js           | 2 +-
 services/gunDB/contact-api/getters/follows.js   | 2 +-
 services/gunDB/contact-api/jobs/lastSeenNode.js | 2 +-
 services/gunDB/contact-api/jobs/onOrders.js     | 2 +-
 services/gunDB/contact-api/utils/index.js       | 2 +-
 services/gunDB/sockets/index.js                 | 2 +-
 services/schema/index.js                        | 2 +-
 src/routes.js                                   | 2 +-
 src/sockets.js                                  | 2 +-
 utils/ECC/socket.js                             | 2 +-
 utils/encryptionStore.js                        | 2 +-
 utils/lightningServices/channelRequests.js      | 2 +-
 utils/lightningServices/v2.js                   | 2 +-
 15 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/services/auth/auth.js b/services/auth/auth.js
index 8ffd8c1c..d44ac608 100644
--- a/services/auth/auth.js
+++ b/services/auth/auth.js
@@ -6,7 +6,7 @@ const jwt = require('jsonwebtoken')
 const uuidv1 = require('uuid/v1')
 const jsonfile = require('jsonfile')
 const path = require('path')
-const logger = require('winston')
+const logger = require('../../config/log')
 const Storage = require('node-persist')
 const FS = require('../../utils/fs')
 
diff --git a/services/gunDB/Mediator/index.js b/services/gunDB/Mediator/index.js
index d7e813a6..7bd6c0ca 100644
--- a/services/gunDB/Mediator/index.js
+++ b/services/gunDB/Mediator/index.js
@@ -5,7 +5,7 @@ const Common = require('shock-common')
 const Gun = require('gun')
 // @ts-ignore
 require('gun/nts')
-const logger = require('winston')
+const logger = require('../../../config/log')
 // @ts-ignore
 Gun.log = () => {}
 // @ts-ignore
diff --git a/services/gunDB/contact-api/actions.js b/services/gunDB/contact-api/actions.js
index d278bc62..9312f864 100644
--- a/services/gunDB/contact-api/actions.js
+++ b/services/gunDB/contact-api/actions.js
@@ -2,7 +2,7 @@
  * @format
  */
 const uuidv1 = require('uuid/v1')
-const logger = require('winston')
+const logger = require('../../../config/log')
 const Common = require('shock-common')
 const { Constants, Schema } = Common
 const Gun = require('gun')
diff --git a/services/gunDB/contact-api/getters/follows.js b/services/gunDB/contact-api/getters/follows.js
index da7de6e1..e7972276 100644
--- a/services/gunDB/contact-api/getters/follows.js
+++ b/services/gunDB/contact-api/getters/follows.js
@@ -2,7 +2,7 @@
  * @format
  */
 const Common = require('shock-common')
-const Logger = require('winston')
+const Logger = require('../../../../config/log')
 const size = require('lodash/size')
 
 const Utils = require('../utils')
diff --git a/services/gunDB/contact-api/jobs/lastSeenNode.js b/services/gunDB/contact-api/jobs/lastSeenNode.js
index 4bd070ee..c05c4738 100644
--- a/services/gunDB/contact-api/jobs/lastSeenNode.js
+++ b/services/gunDB/contact-api/jobs/lastSeenNode.js
@@ -2,7 +2,7 @@
  * @format
  */
 
-const logger = require('winston')
+const logger = require('../../../../config/log')
 
 const {
   Constants: {
diff --git a/services/gunDB/contact-api/jobs/onOrders.js b/services/gunDB/contact-api/jobs/onOrders.js
index 7435e2b1..3c33f2ed 100644
--- a/services/gunDB/contact-api/jobs/onOrders.js
+++ b/services/gunDB/contact-api/jobs/onOrders.js
@@ -2,7 +2,7 @@
  * @format
  */
 // @ts-check
-const logger = require('winston')
+const logger = require('../../../../config/log')
 const isFinite = require('lodash/isFinite')
 const isNumber = require('lodash/isNumber')
 const isNaN = require('lodash/isNaN')
diff --git a/services/gunDB/contact-api/utils/index.js b/services/gunDB/contact-api/utils/index.js
index 84efa706..19fdce65 100644
--- a/services/gunDB/contact-api/utils/index.js
+++ b/services/gunDB/contact-api/utils/index.js
@@ -2,7 +2,7 @@
  * @format
  */
 /* eslint-disable init-declarations */
-const logger = require('winston')
+const logger = require('../../../../config/log')
 const { Constants, Utils: CommonUtils } = require('shock-common')
 
 const Key = require('../key')
diff --git a/services/gunDB/sockets/index.js b/services/gunDB/sockets/index.js
index 5477cab1..e2f4d999 100644
--- a/services/gunDB/sockets/index.js
+++ b/services/gunDB/sockets/index.js
@@ -2,7 +2,7 @@
  * @format
  */
 
-const logger = require('winston')
+const logger = require('../../../config/log')
 const Common = require('shock-common')
 const uuidv4 = require('uuid/v4')
 
diff --git a/services/schema/index.js b/services/schema/index.js
index 145bf326..468c56a4 100644
--- a/services/schema/index.js
+++ b/services/schema/index.js
@@ -1,5 +1,5 @@
 const Crypto = require('crypto')
-const logger = require('winston')
+const logger = require('../../config/log')
 const Common = require('shock-common')
 const getGunUser = () => require('../gunDB/Mediator').getUser()
 const isAuthenticated = () => require('../gunDB/Mediator').isAuthenticated()
diff --git a/src/routes.js b/src/routes.js
index 46fb6e99..44b23076 100644
--- a/src/routes.js
+++ b/src/routes.js
@@ -6,7 +6,7 @@
 const Axios = require('axios')
 const Crypto = require('crypto')
 const Storage = require('node-persist')
-const logger = require('winston')
+const logger = require('../../config/log')
 const httpsAgent = require('https')
 const responseTime = require('response-time')
 const uuid = require('uuid/v4')
diff --git a/src/sockets.js b/src/sockets.js
index 9273d1a5..281b3eec 100644
--- a/src/sockets.js
+++ b/src/sockets.js
@@ -3,7 +3,7 @@
  */
 // @ts-check
 
-const logger = require('winston')
+const logger = require('../config/log')
 const Common = require('shock-common')
 const mapValues = require('lodash/mapValues')
 
diff --git a/utils/ECC/socket.js b/utils/ECC/socket.js
index 2f25e568..58539a67 100644
--- a/utils/ECC/socket.js
+++ b/utils/ECC/socket.js
@@ -2,7 +2,7 @@
  * @format
  */
 const Common = require('shock-common')
-const logger = require('winston')
+const logger = require('../../config/log')
 const { safeParseJSON } = require('../JSON')
 const ECC = require('./index')
 
diff --git a/utils/encryptionStore.js b/utils/encryptionStore.js
index 78745d1f..eb32f369 100644
--- a/utils/encryptionStore.js
+++ b/utils/encryptionStore.js
@@ -3,7 +3,7 @@
  */
 const Crypto = require('crypto')
 const { Buffer } = require('buffer')
-const logger = require('winston')
+const logger = require('../config/log')
 
 const APIKeyPair = new Map()
 const authorizedDevices = new Map()
diff --git a/utils/lightningServices/channelRequests.js b/utils/lightningServices/channelRequests.js
index 0d54c521..cf0583f0 100644
--- a/utils/lightningServices/channelRequests.js
+++ b/utils/lightningServices/channelRequests.js
@@ -1,4 +1,4 @@
-const logger = require('winston')
+const logger = require('../../config/log')
 const fetch = require('node-fetch')
 const Storage = require('node-persist')
 const { listPeers, connectPeer,getInfo } = require('./v2')
diff --git a/utils/lightningServices/v2.js b/utils/lightningServices/v2.js
index 5efede9c..edcee251 100644
--- a/utils/lightningServices/v2.js
+++ b/utils/lightningServices/v2.js
@@ -2,7 +2,7 @@
  * @format
  */
 const Crypto = require('crypto')
-const logger = require('winston')
+const logger = require('../../config/log')
 const Common = require('shock-common')
 const Ramda = require('ramda')