feature(lnd-config): simplify handling of macaroons

Use grpc.credentials.combineChannelCredentials to combine the ssl
credentials with the macaroons when initializing the lnd rcp client.
This avoids the need to pass the macaroon metadata throughout the
codebase.

app/lnd/index.js

@@ -1,5 +1,3 @@
-import grpc from 'grpc'
-import fs from 'fs'
 import config from './config'
 import lightning from './lib/lightning'
 import walletUnlocker from './lib/walletUnlocker'
@@ -8,14 +6,10 @@ import methods from './methods'
 import walletUnlockerMethods from './walletUnlockerMethods'
 
 const initLnd = (callback) => {
-  const macaroonFile = fs.readFileSync(config.macaroon)
-  const meta = new grpc.Metadata()
-  meta.add('macaroon', macaroonFile.toString('hex'))
-
   const lnd = lightning(config.lightningRpc, config.lightningHost)
 
-  const lndSubscribe = mainWindow => subscribe(mainWindow, lnd, meta)
+  const lndSubscribe = mainWindow => subscribe(mainWindow, lnd)
-  const lndMethods = (event, msg, data) => methods(lnd, meta, event, msg, data)
+  const lndMethods = (event, msg, data) => methods(lnd, event, msg, data)
 
   callback(lndSubscribe, lndMethods)
 }
@@ -27,7 +21,6 @@ const initWalletUnlocker = (callback) => {
   callback(walletUnlockerMethodsCallback)
 }
 
-
 export default {
   initLnd,
   initWalletUnlocker

app/lnd/lib/lightning.js

@@ -20,9 +20,16 @@ process.env.GRPC_SSL_CIPHER_SUITES = process.env.GRPC_SSL_CIPHER_SUITES || [
 
 const lightning = (rpcpath, host) => {
   const lndCert = fs.readFileSync(config.cert)
-  const credentials = grpc.credentials.createSsl(lndCert)
+  const sslCreds = grpc.credentials.createSsl(lndCert)
   const rpc = grpc.load(path.join(__dirname, 'rpc.proto'))
 
+  const metadata = new grpc.Metadata()
+  const macaroonHex = fs.readFileSync(config.macaroon).toString('hex')
+  metadata.add('macaroon', macaroonHex)
+
+  const macaroonCreds = grpc.credentials.createFromMetadataGenerator((params, callback) => callback(null, metadata))
+  const credentials = grpc.credentials.combineChannelCredentials(sslCreds, macaroonCreds)
+
   return new rpc.lnrpc.Lightning(host, credentials)
 }
 

app/lnd/methods/channelController.js

@@ -2,14 +2,13 @@ import find from 'lodash/find'
 import { listPeers, connectPeer } from './peersController'
 import pushopenchannel from '../push/openchannel'
 
-function ensurePeerConnected(lnd, meta, pubkey, host) {
+function ensurePeerConnected(lnd, pubkey, host) {
-  return listPeers(lnd, meta)
+  return listPeers(lnd).then(({ peers }) => {
-    .then(({ peers }) => {
     const peer = find(peers, { pub_key: pubkey })
     if (peer) {
       return peer
     }
-      return connectPeer(lnd, meta, { pubkey, host })
+    return connectPeer(lnd, { pubkey, host })
   })
 }
 
@@ -20,15 +19,15 @@ function ensurePeerConnected(lnd, meta, pubkey, host) {
  * @param  {[type]} payload [description]
  * @return {[type]}         [description]
  */
-export function connectAndOpen(lnd, meta, event, payload) {
+export function connectAndOpen(lnd, event, payload) {
   const { pubkey, host, localamt } = payload
 
-  return ensurePeerConnected(lnd, meta, pubkey, host)
+  return ensurePeerConnected(lnd, pubkey, host)
     .then(() => {
       const call = lnd.openChannel({
         node_pubkey: Buffer.from(pubkey, 'hex'),
         local_funding_amount: Number(localamt)
-      }, meta)
+      })
 
       call.on('data', data => event.sender.send('pushchannelupdated', { pubkey, data }))
       call.on('error', error => event.sender.send('pushchannelerror', { pubkey, error: error.toString() }))
@@ -48,7 +47,7 @@ export function connectAndOpen(lnd, meta, event, payload) {
  * @param  {[type]} payload [description]
  * @return {[type]}         [description]
  */
-export function openChannel(lnd, meta, event, payload) {
+export function openChannel(lnd, event, payload) {
   const { pubkey, localamt, pushamt } = payload
   const res = {
     node_pubkey: Buffer.from(pubkey, 'hex'),
@@ -57,44 +56,45 @@ export function openChannel(lnd, meta, event, payload) {
   }
 
   return new Promise((resolve, reject) =>
-    pushopenchannel(lnd, meta, event, res)
+    pushopenchannel(lnd, event, res)
       .then(data => resolve(data))
       .catch(error => reject(error)))
 }
 
-
 /**
  * Returns the total funds available across all open channels in satoshis
  * @param  {[type]} lnd [description]
  * @return {[type]}     [description]
  */
-export function channelBalance(lnd, meta) {
+export function channelBalance(lnd) {
   return new Promise((resolve, reject) => {
-    lnd.channelBalance({}, meta, (err, data) => {
+    lnd.channelBalance({}, (err, data) => {
-      if (err) { reject(err) }
+      if (err) {
+        reject(err)
+      }
 
       resolve(data)
     })
   })
 }
 
-
 /**
  * Returns a description of all the open channels that this node is a participant in
  * @param  {[type]} lnd [description]
  * @return {[type]}     [description]
  */
-export function listChannels(lnd, meta) {
+export function listChannels(lnd) {
   return new Promise((resolve, reject) => {
-    lnd.listChannels({}, meta, (err, data) => {
+    lnd.listChannels({}, (err, data) => {
-      if (err) { reject(err) }
+      if (err) {
+        reject(err)
+      }
 
       resolve(data)
     })
   })
 }
 
-
 /**
  * Attempts to close an active channel identified by its channel outpoint (ChannelPoint)
  * @param  {[type]} lnd     [description]
@@ -102,7 +102,7 @@ export function listChannels(lnd, meta) {
  * @param  {[type]} payload [description]
  * @return {[type]}         [description]
  */
-export function closeChannel(lnd, meta, event, payload) {
+export function closeChannel(lnd, event, payload) {
   const { channel_point: { funding_txid, output_index }, chan_id, force } = payload
   const tx = funding_txid.match(/.{2}/g).reverse().join('')
 
@@ -116,7 +116,7 @@ export function closeChannel(lnd, meta, event, payload) {
 
   return new Promise((resolve, reject) => {
     try {
-      const call = lnd.closeChannel(res, meta)
+      const call = lnd.closeChannel(res)
 
       call.on('data', data => event.sender.send('pushclosechannelupdated', { data, chan_id }))
       call.on('end', () => event.sender.send('pushclosechannelend'))
@@ -130,33 +130,35 @@ export function closeChannel(lnd, meta, event, payload) {
   })
 }
 
-
 /**
  * Returns a list of all the channels that are currently considered “pending"
  * @param  {[type]} lnd [description]
  * @return {[type]}     [description]
  */
-export function pendingChannels(lnd, meta) {
+export function pendingChannels(lnd) {
   return new Promise((resolve, reject) => {
-    lnd.pendingChannels({}, meta, (err, data) => {
+    lnd.pendingChannels({}, (err, data) => {
-      if (err) { reject(err) }
+      if (err) {
+        reject(err)
+      }
 
       resolve(data)
     })
   })
 }
 
-
 /**
  * Returns the latest authenticated network announcement for the given channel
  * @param  {[type]} lnd       [description]
  * @param  {[type]} channelId [description]
  * @return {[type]}           [description]
  */
-export function getChanInfo(lnd, meta, { chanId }) {
+export function getChanInfo(lnd, { chanId }) {
   return new Promise((resolve, reject) => {
-    lnd.getChanInfo({ chan_id: chanId }, meta, (err, data) => {
+    lnd.getChanInfo({ chan_id: chanId }, (err, data) => {
-      if (err) { reject(err) }
+      if (err) {
+        reject(err)
+      }
 
       resolve(data)
     })

app/lnd/methods/index.js

@@ -18,10 +18,11 @@ import * as networkController from './networkController'
 // TODO - SendPayment
 // TODO - DeleteAllPayments
 
-export default function (lnd, meta, event, msg, data) {
+export default function (lnd, event, msg, data) {
   switch (msg) {
     case 'info':
-      networkController.getInfo(lnd, meta)
+      networkController
+        .getInfo(lnd)
         .then((infoData) => {
           event.sender.send('receiveInfo', infoData)
           event.sender.send('receiveCryptocurrency', infoData.chains[0])
@@ -30,21 +31,24 @@ export default function (lnd, meta, event, msg, data) {
         .catch(() => event.sender.send('infoFailed'))
       break
     case 'describeNetwork':
-      networkController.describeGraph(lnd, meta)
+      networkController
+        .describeGraph(lnd)
         .then(networkData => event.sender.send('receiveDescribeNetwork', networkData))
         .catch(error => console.log('describeGraph error: ', error))
       break
     case 'queryRoutes':
       // Data looks like { pubkey: String, amount: Number }
-      networkController.queryRoutes(lnd, meta, data)
+      networkController
+        .queryRoutes(lnd, data)
         .then(routes => event.sender.send('receiveQueryRoutes', routes))
         .catch(error => console.log('queryRoutes error: ', error))
       break
     case 'getInvoiceAndQueryRoutes':
       // Data looks like { pubkey: String, amount: Number }
-      invoicesController.getInvoice(lnd, meta, { pay_req: data.payreq })
+      invoicesController
+        .getInvoice(lnd, { pay_req: data.payreq })
         .then(invoiceData =>
-          networkController.queryRoutes(lnd, meta, {
+          networkController.queryRoutes(lnd, {
             pubkey: invoiceData.destination,
             amount: invoiceData.num_satoshis
           }))
@@ -53,57 +57,63 @@ export default function (lnd, meta, event, msg, data) {
       break
     case 'newaddress':
       // Data looks like { address: '' }
-      walletController.newAddress(lnd, meta, data.type)
+      walletController
+        .newAddress(lnd, data.type)
         .then(({ address }) => event.sender.send('receiveAddress', address))
         .catch(error => console.log('newaddress error: ', error))
       break
     case 'setAlias':
       // Data looks like { new_alias: '' }
-      walletController.setAlias(lnd, meta, data)
+      walletController
+        .setAlias(lnd, data)
         .then(() => event.sender.send('aliasSet'))
         .catch(error => console.log('setAlias error: ', error))
       break
     case 'peers':
       // Data looks like { peers: [] }
-      peersController.listPeers(lnd, meta)
+      peersController
+        .listPeers(lnd)
         .then(peersData => event.sender.send('receivePeers', peersData))
         .catch(error => console.log('peers error: ', error))
       break
     case 'channels':
       // Data looks like
       // [ { channels: [] }, { total_limbo_balance: 0, pending_open_channels: [], pending_closing_channels: [], pending_force_closing_channels: [] } ]
-      Promise.all([channelController.listChannels, channelController.pendingChannels].map(func => func(lnd, meta)))
+      Promise.all([channelController.listChannels, channelController.pendingChannels].map(func => func(lnd)))
-        .then(channelsData =>
+        .then(channelsData => event.sender.send('receiveChannels', { channels: channelsData[0].channels, pendingChannels: channelsData[1] }))
-          event.sender.send('receiveChannels', { channels: channelsData[0].channels, pendingChannels: channelsData[1] }))
         .catch(error => console.log('channels error: ', error))
       break
     case 'transactions':
       // Data looks like { transactions: [] }
-      walletController.getTransactions(lnd, meta)
+      walletController
+        .getTransactions(lnd)
         .then(transactionsData => event.sender.send('receiveTransactions', transactionsData))
         .catch(error => console.log('transactions error: ', error))
       break
     case 'payments':
       // Data looks like { payments: [] }
-      paymentsController.listPayments(lnd, meta)
+      paymentsController
+        .listPayments(lnd)
         .then(paymentsData => event.sender.send('receivePayments', paymentsData))
         .catch(error => console.log('payments error: ', error))
       break
     case 'invoices':
       // Data looks like { invoices: [] }
-      invoicesController.listInvoices(lnd, meta)
+      invoicesController
+        .listInvoices(lnd)
         .then(invoicesData => event.sender.send('receiveInvoices', invoicesData))
         .catch(error => console.log('invoices error: ', error))
       break
     case 'invoice':
       // Data looks like { invoices: [] }
-      invoicesController.getInvoice(lnd, meta, { pay_req: data.payreq })
+      invoicesController
+        .getInvoice(lnd, { pay_req: data.payreq })
         .then(invoiceData => event.sender.send('receiveInvoice', invoiceData))
         .catch(error => console.log('invoice error: ', error))
       break
     case 'balance':
       // Balance looks like [ { balance: '129477456' }, { balance: '243914' } ]
-      Promise.all([walletController.walletBalance, channelController.channelBalance].map(func => func(lnd, meta)))
+      Promise.all([walletController.walletBalance, channelController.channelBalance].map(func => func(lnd)))
         .then((balance) => {
           event.sender.send('receiveBalance', { walletBalance: balance[0].total_balance, channelBalance: balance[1].balance })
           return balance
@@ -113,7 +123,8 @@ export default function (lnd, meta, event, msg, data) {
     case 'createInvoice':
       // Invoice looks like { r_hash: Buffer, payment_request: '' }
       // { memo, value } = data
-      invoicesController.addInvoice(lnd, meta, data)
+      invoicesController
+        .addInvoice(lnd, data)
         .then(newinvoice =>
           event.sender.send(
             'createdInvoice',
@@ -132,7 +143,8 @@ export default function (lnd, meta, event, msg, data) {
     case 'sendPayment':
       // Payment looks like { payment_preimage: Buffer, payment_route: Object }
       // { paymentRequest } = data
-      paymentsController.sendPaymentSync(lnd, meta, data)
+      paymentsController
+        .sendPaymentSync(lnd, data)
         .then((payment) => {
           const { payment_route } = payment
           console.log('payinvoice success: ', payment_route)
@@ -147,7 +159,8 @@ export default function (lnd, meta, event, msg, data) {
     case 'sendCoins':
       // Transaction looks like { txid: String }
       // { amount, addr } = data
-      walletController.sendCoins(lnd, meta, data)
+      walletController
+        .sendCoins(lnd, data)
         .then(({ txid }) => event.sender.send('transactionSuccessful', { amount: data.amount, addr: data.addr, txid }))
         .catch((error) => {
           console.log('error: ', error)
@@ -157,7 +170,8 @@ export default function (lnd, meta, event, msg, data) {
     case 'openChannel':
       // Response is empty. Streaming updates on channel status and updates
       // { pubkey, localamt, pushamt } = data
-      channelController.openChannel(lnd, meta, event, data)
+      channelController
+        .openChannel(lnd, event, data)
         .then((channel) => {
           console.log('CHANNEL: ', channel)
           event.sender.send('channelSuccessful', { channel })
@@ -168,7 +182,8 @@ export default function (lnd, meta, event, msg, data) {
     case 'closeChannel':
       // Response is empty. Streaming updates on channel status and updates
       // { channel_point, force } = data
-      channelController.closeChannel(lnd, meta, event, data)
+      channelController
+        .closeChannel(lnd, event, data)
         .then((result) => {
           console.log('CLOSE CHANNEL: ', result)
           event.sender.send('closeChannelSuccessful')
@@ -179,7 +194,8 @@ export default function (lnd, meta, event, msg, data) {
     case 'connectPeer':
       // Returns a peer_id. Pass the pubkey, host and peer_id so we can add a new peer to the list
       // { pubkey, host } = data
-      peersController.connectPeer(lnd, meta, data)
+      peersController
+        .connectPeer(lnd, data)
         .then((peer) => {
           const { peer_id } = peer
           console.log('peer_id: ', peer_id)
@@ -194,7 +210,8 @@ export default function (lnd, meta, event, msg, data) {
     case 'disconnectPeer':
       // Empty response. Pass back pubkey on success to remove it from the peers list
       // { pubkey } = data
-      peersController.disconnectPeer(lnd, meta, data)
+      peersController
+        .disconnectPeer(lnd, data)
         .then(() => {
           console.log('pubkey: ', data.pubkey)
           event.sender.send('disconnectSuccess', { pubkey: data.pubkey })
@@ -205,7 +222,8 @@ export default function (lnd, meta, event, msg, data) {
     case 'connectAndOpen':
       // Connects to a peer if we aren't connected already and then attempt to open a channel
       // {} = data
-      channelController.connectAndOpen(lnd, meta, event, data)
+      channelController
+        .connectAndOpen(lnd, event, data)
         .then((channelData) => {
           console.log('connectAndOpen data: ', channelData)
           // event.sender.send('connectSuccess', { pub_key: data.pubkey, address: data.host, peer_id })

app/lnd/methods/invoicesController.js

@@ -7,9 +7,9 @@ import pushinvoices from '../push/subscribeinvoice'
  * @param  value [description]
  * @return     [description]
  */
-export function addInvoice(lnd, meta, { memo, value }) {
+export function addInvoice(lnd, { memo, value }) {
   return new Promise((resolve, reject) => {
-    lnd.addInvoice({ memo, value }, meta, (err, data) => {
+    lnd.addInvoice({ memo, value }, (err, data) => {
       if (err) { reject(err) }
 
       resolve(data)
@@ -22,9 +22,9 @@ export function addInvoice(lnd, meta, { memo, value }) {
  * @param  {[type]} lnd [description]
  * @return {[type]}     [description]
  */
-export function listInvoices(lnd, meta) {
+export function listInvoices(lnd) {
   return new Promise((resolve, reject) => {
-    lnd.listInvoices({}, meta, (err, data) => {
+    lnd.listInvoices({}, (err, data) => {
       if (err) { reject(err) }
 
       resolve(data)
@@ -36,9 +36,9 @@ export function listInvoices(lnd, meta) {
  * @param  {[type]} payreq [description]
  * @return {[type]}        [description]
  */
-export function getInvoice(lnd, meta, { pay_req }) {
+export function getInvoice(lnd, { pay_req }) {
   return new Promise((resolve, reject) => {
-    lnd.decodePayReq({ pay_req }, meta, (err, data) => {
+    lnd.decodePayReq({ pay_req }, (err, data) => {
       if (err) { reject(err) }
 
       resolve(data)
@@ -53,9 +53,9 @@ export function getInvoice(lnd, meta, { pay_req }) {
  * @param  {[type]} rhash [description]
  * @return {[type]}       [description]
  */
-export function lookupInvoice(lnd, meta, { rhash }) {
+export function lookupInvoice(lnd, { rhash }) {
   return new Promise((resolve, reject) => {
-    lnd.lookupInvoice({ r_hash: rhash }, meta, (err, data) => {
+    lnd.lookupInvoice({ r_hash: rhash }, (err, data) => {
       if (err) { reject(err) }
 
       resolve(data)
@@ -70,9 +70,9 @@ export function lookupInvoice(lnd, meta, { rhash }) {
  * @param  {[type]} event [description]
  * @return {[type]}       [description]
  */
-export function subscribeInvoices(lnd, meta, event) {
+export function subscribeInvoices(lnd, event) {
   return new Promise((resolve, reject) => {
-    pushinvoices(lnd, meta, event)
+    pushinvoices(lnd, event)
       .then(data => resolve(data))
       .catch(error => reject(error))
   })

app/lnd/methods/networkController.js

@@ -3,9 +3,9 @@
  * @param  {[type]} lnd [description]
  * @return {[type]}     [description]
  */
-export function getInfo(lnd, meta) {
+export function getInfo(lnd) {
   return new Promise((resolve, reject) => {
-    lnd.getInfo({}, meta, (err, data) => {
+    lnd.getInfo({}, (err, data) => {
       if (err) { reject(err) }
 
       resolve(data)
@@ -20,9 +20,9 @@ export function getInfo(lnd, meta) {
  * @param  {[type]} pubkey [description]
  * @return {[type]}        [description]
  */
-export function getNodeInfo(lnd, meta, { pubkey }) {
+export function getNodeInfo(lnd, { pubkey }) {
   return new Promise((resolve, reject) => {
-    lnd.getNodeInfo({ pub_key: pubkey }, meta, (err, data) => {
+    lnd.getNodeInfo({ pub_key: pubkey }, (err, data) => {
       if (err) { reject(err) }
 
       resolve(data)
@@ -36,9 +36,9 @@ export function getNodeInfo(lnd, meta, { pubkey }) {
  * @param  {[type]} lnd [description]
  * @return {[type]}     [description]
  */
-export function describeGraph(lnd, meta) {
+export function describeGraph(lnd) {
   return new Promise((resolve, reject) => {
-    lnd.describeGraph({}, meta, (err, data) => {
+    lnd.describeGraph({}, (err, data) => {
       if (err) { reject(err) }
 
       resolve(data)
@@ -54,9 +54,9 @@ export function describeGraph(lnd, meta) {
  * @param  {[type]} amount [description]
  * @return {[type]}        [description]
  */
-export function queryRoutes(lnd, meta, { pubkey, amount }) {
+export function queryRoutes(lnd, { pubkey, amount }) {
   return new Promise((resolve, reject) => {
-    lnd.queryRoutes({ pub_key: pubkey, amt: amount }, meta, (err, data) => {
+    lnd.queryRoutes({ pub_key: pubkey, amt: amount }, (err, data) => {
       if (err) { reject(err) }
 
       resolve(data)
@@ -70,9 +70,9 @@ export function queryRoutes(lnd, meta, { pubkey, amount }) {
  * @param  {[type]} lnd [description]
  * @return {[type]}     [description]
  */
-export function getNetworkInfo(lnd, meta) {
+export function getNetworkInfo(lnd) {
   return new Promise((resolve, reject) => {
-    lnd.getNetworkInfo({}, meta, (err, data) => {
+    lnd.getNetworkInfo({}, (err, data) => {
       if (err) { reject(err) }
 
       resolve(data)

app/lnd/methods/paymentsController.js

@@ -4,9 +4,9 @@
  * @param  {[type]} paymentRequest [description]
  * @return {[type]}                [description]
  */
-export function sendPaymentSync(lnd, meta, { paymentRequest }) {
+export function sendPaymentSync(lnd, { paymentRequest }) {
   return new Promise((resolve, reject) => {
-    lnd.sendPaymentSync({ payment_request: paymentRequest }, meta, (error, data) => {
+    lnd.sendPaymentSync({ payment_request: paymentRequest }, (error, data) => {
       if (error) {
         reject({ error })
         return
@@ -27,9 +27,9 @@ export function sendPaymentSync(lnd, meta, { paymentRequest }) {
  * @param  {[type]} paymentRequest [description]
  * @return {[type]}                [description]
  */
-export function sendPayment(lnd, meta, { paymentRequest }) {
+export function sendPayment(lnd, { paymentRequest }) {
   return new Promise((resolve, reject) => {
-    lnd.sendPayment({ payment_request: paymentRequest }, meta, (err, data) => {
+    lnd.sendPayment({ payment_request: paymentRequest }, (err, data) => {
       if (err) { reject(err) }
 
       resolve(data)
@@ -43,9 +43,9 @@ export function sendPayment(lnd, meta, { paymentRequest }) {
  * @param  {[type]} payReq [description]
  * @return {[type]}        [description]
  */
-export function decodePayReq(lnd, meta, { payReq }) {
+export function decodePayReq(lnd, { payReq }) {
   return new Promise((resolve, reject) => {
-    lnd.decodePayReq({ pay_req: payReq }, meta, (err, data) => {
+    lnd.decodePayReq({ pay_req: payReq }, (err, data) => {
       if (err) { reject(err) }
 
       resolve(data)
@@ -58,9 +58,9 @@ export function decodePayReq(lnd, meta, { payReq }) {
  * @param  {[type]} lnd [description]
  * @return {[type]}     [description]
  */
-export function listPayments(lnd, meta) {
+export function listPayments(lnd) {
   return new Promise((resolve, reject) => {
-    lnd.listPayments({}, meta, (err, data) => {
+    lnd.listPayments({}, (err, data) => {
       if (err) { reject(err) }
 
       resolve(data)
@@ -73,9 +73,9 @@ export function listPayments(lnd, meta) {
  * @param  {[type]} lnd [description]
  * @return {[type]}     [description]
  */
-export function deleteAllPayments(lnd, meta) {
+export function deleteAllPayments(lnd) {
   return new Promise((resolve, reject) => {
-    lnd.deleteAllPayments({}, meta, (err, data) => {
+    lnd.deleteAllPayments({}, (err, data) => {
       if (err) { reject(err) }
 
       resolve(data)

app/lnd/methods/peersController.js

@@ -5,9 +5,9 @@
  * @param  {[type]} host   [description]
  * @return {[type]}        [description]
  */
-export function connectPeer(lnd, meta, { pubkey, host }) {
+export function connectPeer(lnd, { pubkey, host }) {
   return new Promise((resolve, reject) => {
-    lnd.connectPeer({ addr: { pubkey, host } }, meta, (err, data) => {
+    lnd.connectPeer({ addr: { pubkey, host } }, (err, data) => {
       if (err) { reject(err) }
 
       resolve(data)
@@ -22,9 +22,9 @@ export function connectPeer(lnd, meta, { pubkey, host }) {
  * @param  {[type]} pubkey [description]
  * @return {[type]}        [description]
  */
-export function disconnectPeer(lnd, meta, { pubkey }) {
+export function disconnectPeer(lnd, { pubkey }) {
   return new Promise((resolve, reject) => {
-    lnd.disconnectPeer({ pub_key: pubkey }, meta, (err, data) => {
+    lnd.disconnectPeer({ pub_key: pubkey }, (err, data) => {
       if (err) { reject(err) }
 
       resolve(data)
@@ -38,9 +38,9 @@ export function disconnectPeer(lnd, meta, { pubkey }) {
  * @param  {[type]} lnd [description]
  * @return {[type]}     [description]
  */
-export function listPeers(lnd, meta) {
+export function listPeers(lnd) {
   return new Promise((resolve, reject) => {
-    lnd.listPeers({}, meta, (err, data) => {
+    lnd.listPeers({}, (err, data) => {
       if (err) { reject(err) }
 
       resolve(data)

app/lnd/methods/walletController.js

@@ -3,9 +3,9 @@
  * @param  {[type]} lnd [description]
  * @return {[type]}     [description]
  */
-export function walletBalance(lnd, meta) {
+export function walletBalance(lnd) {
   return new Promise((resolve, reject) => {
-    lnd.walletBalance({}, meta, (err, data) => {
+    lnd.walletBalance({}, (err, data) => {
       if (err) { reject(err) }
 
       resolve(data)
@@ -20,9 +20,9 @@ export function walletBalance(lnd, meta) {
  * @param  {[type]} type [description]
  * @return {[type]}      [description]
  */
-export function newAddress(lnd, meta, type) {
+export function newAddress(lnd, type) {
   return new Promise((resolve, reject) => {
-    lnd.newAddress({ type }, meta, (err, data) => {
+    lnd.newAddress({ type }, (err, data) => {
       if (err) { reject(err) }
 
       resolve(data)
@@ -35,9 +35,9 @@ export function newAddress(lnd, meta, type) {
  * @param  {[type]} lnd [description]
  * @return {[type]}     [description]
  */
-export function newWitnessAddress(lnd, meta, { addr }) {
+export function newWitnessAddress(lnd, { addr }) {
   return new Promise((resolve, reject) => {
-    lnd.newWitnessAddress({ address: addr }, meta, (err, data) => {
+    lnd.newWitnessAddress({ address: addr }, (err, data) => {
       if (err) { reject(err) }
 
       resolve(data)
@@ -51,9 +51,9 @@ export function newWitnessAddress(lnd, meta, { addr }) {
  * @param  {[type]} lnd [description]
  * @return {[type]}     [description]
  */
-export function getTransactions(lnd, meta) {
+export function getTransactions(lnd) {
   return new Promise((resolve, reject) => {
-    lnd.getTransactions({}, meta, (err, data) => {
+    lnd.getTransactions({}, (err, data) => {
       if (err) { reject(err) }
 
       resolve(data)
@@ -69,9 +69,9 @@ export function getTransactions(lnd, meta) {
  * @param  {[type]} amount [description]
  * @return {[type]}        [description]
  */
-export function sendCoins(lnd, meta, { addr, amount }) {
+export function sendCoins(lnd, { addr, amount }) {
   return new Promise((resolve, reject) => {
-    lnd.sendCoins({ addr, amount }, meta, (err, data) => {
+    lnd.sendCoins({ addr, amount }, (err, data) => {
       if (err) { reject(err) }
 
       resolve(data)
@@ -83,7 +83,7 @@ export function sendCoins(lnd, meta, { addr, amount }) {
  * Executes a request to set the alias for the node
  * @param  {[type]} new_alias [description]
  */
-export function setAlias(lnd, meta, { new_alias }) {
+export function setAlias(lnd, { new_alias }) {
   return new Promise((resolve, reject) => {
     lnd.setAlias({ new_alias }, (err, data) => {
       if (err) { reject(err) }

app/lnd/push/closechannel.js

@@ -1,7 +1,7 @@
-export default function pushclosechannel(lnd, meta, event, payload) {
+export default function pushclosechannel(lnd, event, payload) {
   return new Promise((resolve, reject) => {
     try {
-      const call = lnd.closeChannel(payload, meta)
+      const call = lnd.closeChannel(payload)
 
       call.on('data', data => event.sender.send('pushclosechannelupdated', { data }))
       call.on('end', () => event.sender.send('pushclosechannelend'))

app/lnd/push/openchannel.js

@@ -1,7 +1,7 @@
-export default function pushopenchannel(lnd, meta, event, payload) {
+export default function pushopenchannel(lnd, event, payload) {
   return new Promise((resolve, reject) => {
     try {
-      const call = lnd.openChannel(payload, meta)
+      const call = lnd.openChannel(payload)
 
       call.on('data', data => event.sender.send('pushchannelupdated', { data }))
       call.on('end', () => event.sender.send('pushchannelend'))

app/lnd/push/subscribeinvoice.js

@@ -1,7 +1,7 @@
-export default function pushinvoices(lnd, meta, event) {
+export default function pushinvoices(lnd, event) {
   return new Promise((resolve, reject) => {
     try {
-      const call = lnd.subscribeInvoices({}, meta)
+      const call = lnd.subscribeInvoices({})
 
       call.on('data', data => event.sender.send('pushinvoicesupdated', { data }))
       call.on('end', () => event.sender.send('pushinvoicesend'))

app/lnd/subscribe/channelgraph.js

@@ -1,5 +1,5 @@
-export default function subscribeToChannelGraph(mainWindow, lnd, meta) {
+export default function subscribeToChannelGraph(mainWindow, lnd) {
-  const call = lnd.subscribeChannelGraph({}, meta)
+  const call = lnd.subscribeChannelGraph({})
 
   call.on('data', channelGraphData => mainWindow.send('channelGraphData', { channelGraphData }))
   call.on('status', channelGraphStatus => mainWindow.send('channelGraphStatus', { channelGraphStatus }))

app/lnd/subscribe/index.js

@@ -2,8 +2,8 @@ import subscribeToTransactions from './transactions'
 import subscribeToInvoices from './invoices'
 import subscribeToChannelGraph from './channelgraph'
 
-export default (mainWindow, lnd, meta) => {
+export default (mainWindow, lnd) => {
-  subscribeToTransactions(mainWindow, lnd, meta)
+  subscribeToTransactions(mainWindow, lnd)
-  subscribeToInvoices(mainWindow, lnd, meta)
+  subscribeToInvoices(mainWindow, lnd)
-  subscribeToChannelGraph(mainWindow, lnd, meta)
+  subscribeToChannelGraph(mainWindow, lnd)
 }

app/lnd/subscribe/invoices.js

@@ -1,5 +1,5 @@
-export default function subscribeToInvoices(mainWindow, lnd, meta) {
+export default function subscribeToInvoices(mainWindow, lnd) {
-  const call = lnd.subscribeInvoices({}, meta)
+  const call = lnd.subscribeInvoices({})
 
   call.on('data', invoice => mainWindow.send('invoiceUpdate', { invoice }))
   call.on('end', () => console.log('end'))

app/lnd/subscribe/transactions.js

@@ -1,5 +1,5 @@
-export default function subscribeToTransactions(mainWindow, lnd, meta) {
+export default function subscribeToTransactions(mainWindow, lnd) {
-  const call = lnd.subscribeTransactions({}, meta)
+  const call = lnd.subscribeTransactions({})
   call.on('data', (transaction) => {
     console.log('TRANSACTION: ', transaction)
     mainWindow.send('newTransaction', { transaction })