diff --git a/ChangeLog.md b/ChangeLog.md
new file mode 100644
--- /dev/null
+++ b/ChangeLog.md
@@ -0,0 +1,3 @@
+# Version 0.1
+
+- Initial version.
diff --git a/LICENSE b/LICENSE
new file mode 100644
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,30 @@
+Copyright Author name here (c) 2020
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+
+    * Neither the name of Author name here nor the names of other
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/README.md b/README.md
new file mode 100644
--- /dev/null
+++ b/README.md
@@ -0,0 +1,28 @@
+# lnd-client
+
+Lightning Network Daemon (LND) client library for Haskell. Docker is the only thing required to get started. Development environment is packed into [nix-shell](https://nixos.org/nixos/nix-pills/developing-with-nix-shell.html)
+
+```bash
+# start nix-shell
+./nix/shell.sh
+
+# run tests in nix-shell
+stack test
+
+# develop in nix-shell
+vi .
+```
+
+Optional nix-shell environment variables
+
+```bash
+vi ~/.zshrc
+
+export VIM_BACKGROUND="light" # or "dark"
+export VIM_COLOR_SCHEME="PaperColor" # or "jellybeans"
+```
+
+# gRPC schema upgrade
+- we are using lnd version 0.13.1-beta.rc2
+- download fresh grpc files to proto directory
+- run `./script/generate-protoc.sh`
diff --git a/Setup.hs b/Setup.hs
new file mode 100644
--- /dev/null
+++ b/Setup.hs
@@ -0,0 +1,2 @@
+import Distribution.Simple
+main = defaultMain
diff --git a/lnd-client.cabal b/lnd-client.cabal
new file mode 100644
--- /dev/null
+++ b/lnd-client.cabal
@@ -0,0 +1,183 @@
+cabal-version: 1.12
+
+-- This file has been generated from package.yaml by hpack version 0.34.2.
+--
+-- see: https://github.com/sol/hpack
+
+name:           lnd-client
+version:        0.1.0.0
+synopsis:       Lightning Network Daemon (LND) client library for Haskell
+description:    You can find documentation at <https://hackage.haskell.org/package/lnd-client>
+category:       Lightning, Bitcoin, Finance, Network, Payments
+homepage:       https://github.com/coingaming/lnd-client#readme
+bug-reports:    https://github.com/coingaming/lnd-client/issues
+author:         Mikhail Prushinskiy <mprushinsky@gmail.com>
+maintainer:     Mikhail Prushinskiy <mprushinsky@gmail.com>, Ilja Tkachuk <tkachuk.labs@gmail.com>, Artem Markov <drownbes@gmail.com>
+copyright:      2020 Coingaming <hello@coingaming.io>
+license:        BSD3
+license-file:   LICENSE
+build-type:     Simple
+extra-source-files:
+    README.md
+    ChangeLog.md
+
+source-repository head
+  type: git
+  location: https://github.com/coingaming/lnd-client
+
+library
+  exposed-modules:
+      LndClient
+      LndClient.Class
+      LndClient.Data.AddHodlInvoice
+      LndClient.Data.AddInvoice
+      LndClient.Data.Channel
+      LndClient.Data.ChannelPoint
+      LndClient.Data.CloseChannel
+      LndClient.Data.ClosedChannel
+      LndClient.Data.ClosedChannels
+      LndClient.Data.ForceClosedChannel
+      LndClient.Data.GetInfo
+      LndClient.Data.HtlcEvent
+      LndClient.Data.InitWallet
+      LndClient.Data.Invoice
+      LndClient.Data.Kind
+      LndClient.Data.ListChannels
+      LndClient.Data.ListInvoices
+      LndClient.Data.LndEnv
+      LndClient.Data.NewAddress
+      LndClient.Data.Newtype
+      LndClient.Data.OpenChannel
+      LndClient.Data.Payment
+      LndClient.Data.PayReq
+      LndClient.Data.Peer
+      LndClient.Data.PendingChannel
+      LndClient.Data.PendingChannels
+      LndClient.Data.PendingOpenChannel
+      LndClient.Data.SendPayment
+      LndClient.Data.SubscribeChannelEvents
+      LndClient.Data.SubscribeInvoices
+      LndClient.Data.TrackPayment
+      LndClient.Data.Type
+      LndClient.Data.UnlockWallet
+      LndClient.Data.WaitingCloseChannel
+      LndClient.Import
+      LndClient.Import.External
+      LndClient.LndTest
+      LndClient.QRCode
+      LndClient.RPC.Generic
+      LndClient.RPC.Katip
+      LndClient.RPC.Silent
+      LndClient.RPC.TH
+      LndClient.Util
+      LndClient.Watcher
+      LndGrpc.Client
+      Proto.InvoiceGrpc
+      Proto.InvoiceGrpc_Fields
+      Proto.LndGrpc
+      Proto.LndGrpc_Fields
+      Proto.RouterGrpc
+      Proto.RouterGrpc_Fields
+      Proto.WalletUnlockerGrpc
+      Proto.WalletUnlockerGrpc_Fields
+  other-modules:
+      Paths_lnd_client
+  hs-source-dirs:
+      src
+  default-extensions: NoImplicitPrelude MultiParamTypeClasses LambdaCase OverloadedStrings ScopedTypeVariables DataKinds KindSignatures
+  ghc-options: -Weverything -Wno-missing-export-lists -Wno-missing-exported-signatures -Wno-missing-import-lists -Wno-missed-specialisations -Wno-all-missed-specialisations -Wno-unsafe -Wno-safe -Wno-missing-local-signatures -Wno-monomorphism-restriction
+  build-depends:
+      JuicyPixels >=3.3.3 && <3.4
+    , aeson >=1.4.4.0 && <1.4.8
+    , asn1-encoding >=0.9.6 && <0.10
+    , asn1-types >=0.3 && <0.4
+    , async >=2.2.2 && <2.2.3
+    , base >=4.7 && <5
+    , base16-bytestring >=1.0.1.0 && <1.0.2
+    , base64-bytestring >=1.0.0.2 && <1.0.1
+    , bytestring >=0.10.8.2 && <0.10.9
+    , chronos >=1.0.7 && <1.0.10
+    , containers >=0.6.0.1 && <0.6.1
+    , cryptohash-sha256 >=0.11.101.0 && <0.11.102
+    , cryptonite >=0.25 && <0.29
+    , deepseq >=1.4.4.0 && <1.4.5
+    , envparse >=0.4.1 && <0.4.2
+    , extra >=1.6.18 && <1.6.20
+    , hspec >=2.7.1 && <2.7.2
+    , http2 >=2.0.3 && <3.0.3
+    , http2-client >=0.10.0.0 && <0.10.1
+    , http2-client-grpc >=0.8.0.0 && <0.8.1
+    , http2-grpc-proto-lens >=0.1.0.0 && <0.1.1
+    , http2-grpc-types >=0.5.0.0 && <0.5.1
+    , katip >=0.8.3.0 && <0.8.4
+    , microlens >=0.4.10 && <0.5
+    , network-bitcoin >=1.8.3 && <1.9.2
+    , pem >=0.2.4 && <0.3
+    , persistent >=2.11.0.2 && <2.11.1
+    , proto-lens >=0.7.0 && <0.8
+    , proto-lens-runtime >=0.7.0 && <0.8
+    , qrcode-core >=0.9 && <0.9.3
+    , qrcode-juicypixels >=0.8.0 && <0.8.1
+    , scientific >=0.3.6.2 && <0.3.7
+    , stm >=2.5.0.0 && <2.5.1
+    , template-haskell >=2.14.0.0 && <2.14.1
+    , text >=1.2.3.1 && <1.2.4
+    , unbounded-delays >=0.1.1.0 && <0.1.2
+    , universum >=1.5.0 && <1.5.1
+    , unliftio >=0.2.12 && <0.2.13
+    , x509 >=1.7.5 && <1.7.6
+  default-language: Haskell2010
+
+test-suite lnd-client-test
+  type: exitcode-stdio-1.0
+  main-is: Spec.hs
+  other-modules:
+      LndClient.RPCSpec
+      LndClient.TestApp
+      Paths_lnd_client
+  hs-source-dirs:
+      test
+  default-extensions: NoImplicitPrelude MultiParamTypeClasses LambdaCase OverloadedStrings ScopedTypeVariables DataKinds KindSignatures
+  ghc-options: -Weverything -Wno-missing-exported-signatures -Wno-missing-import-lists -Wno-missed-specialisations -Wno-all-missed-specialisations -Wno-unsafe -Wno-safe -Wno-missing-local-signatures -Wno-monomorphism-restriction -threaded -rtsopts -with-rtsopts=-N
+  build-depends:
+      JuicyPixels >=3.3.3 && <3.4
+    , aeson >=1.4.4.0 && <1.4.8
+    , asn1-encoding >=0.9.6 && <0.10
+    , asn1-types >=0.3 && <0.4
+    , async >=2.2.2 && <2.2.3
+    , base >=4.7 && <5
+    , base16-bytestring >=1.0.1.0 && <1.0.2
+    , base64-bytestring >=1.0.0.2 && <1.0.1
+    , bytestring >=0.10.8.2 && <0.10.9
+    , chronos >=1.0.7 && <1.0.10
+    , containers >=0.6.0.1 && <0.6.1
+    , cryptohash-sha256 >=0.11.101.0 && <0.11.102
+    , cryptonite >=0.25 && <0.29
+    , deepseq >=1.4.4.0 && <1.4.5
+    , envparse >=0.4.1 && <0.4.2
+    , extra >=1.6.18 && <1.6.20
+    , hspec >=2.7.1 && <2.7.2
+    , http2 >=2.0.3 && <3.0.3
+    , http2-client >=0.10.0.0 && <0.10.1
+    , http2-client-grpc >=0.8.0.0 && <0.8.1
+    , http2-grpc-proto-lens >=0.1.0.0 && <0.1.1
+    , http2-grpc-types >=0.5.0.0 && <0.5.1
+    , katip >=0.8.3.0 && <0.8.4
+    , lnd-client
+    , microlens >=0.4.10 && <0.5
+    , network-bitcoin >=1.8.3 && <1.9.2
+    , pem >=0.2.4 && <0.3
+    , persistent >=2.11.0.2 && <2.11.1
+    , proto-lens >=0.7.0 && <0.8
+    , proto-lens-runtime >=0.7.0 && <0.8
+    , qrcode-core >=0.9 && <0.9.3
+    , qrcode-juicypixels >=0.8.0 && <0.8.1
+    , scientific >=0.3.6.2 && <0.3.7
+    , stm >=2.5.0.0 && <2.5.1
+    , template-haskell >=2.14.0.0 && <2.14.1
+    , text >=1.2.3.1 && <1.2.4
+    , unbounded-delays >=0.1.1.0 && <0.1.2
+    , universum >=1.5.0 && <1.5.1
+    , unliftio >=0.2.12 && <0.2.13
+    , x509 >=1.7.5 && <1.7.6
+  default-language: Haskell2010
diff --git a/src/LndClient.hs b/src/LndClient.hs
new file mode 100644
--- /dev/null
+++ b/src/LndClient.hs
@@ -0,0 +1,13 @@
+-- | Lightning Network Daemon (LND) client library for Haskell.
+-- Please use LndClient.RPC.Silent or LndClient.RPC.Katip to send/receive/subscribe to LND.
+module LndClient
+  ( module Import,
+  )
+where
+
+import LndClient.Class as Import
+import LndClient.Data.Kind as Import
+import LndClient.Data.LndEnv as Import
+import LndClient.Data.Newtype as Import
+import LndClient.Data.Type as Import
+import LndClient.Util as Import
diff --git a/src/LndClient/Class.hs b/src/LndClient/Class.hs
new file mode 100644
--- /dev/null
+++ b/src/LndClient/Class.hs
@@ -0,0 +1,48 @@
+{-# LANGUAGE FlexibleInstances #-}
+
+module LndClient.Class
+  ( FromGrpc (..),
+    ToGrpc (..),
+  )
+where
+
+import Data.ProtoLens.Message
+import LndClient.Data.Type
+import LndClient.Import.External
+
+class ToGrpc a b where
+  toGrpc :: a -> Either LndError b
+
+class Eq b => FromGrpc a b where
+  fromGrpc :: b -> Either LndError a
+
+--
+-- ToGrpc instances
+--
+
+instance ToGrpc a a where
+  toGrpc = Right
+
+instance (FieldDefault b, ToGrpc a b) => ToGrpc (Maybe a) b where
+  toGrpc = \case
+    Nothing -> Right fieldDefault
+    Just x -> toGrpc x
+
+--
+-- FromGrpc instances
+--
+
+instance Eq a => FromGrpc a a where
+  fromGrpc = Right
+
+instance Eq b => FromGrpc () b where
+  fromGrpc = const $ Right ()
+
+instance (FieldDefault b, FromGrpc a b) => FromGrpc (Maybe a) b where
+  fromGrpc x =
+    if x == fieldDefault
+      then Right Nothing
+      else Just <$> fromGrpc x
+
+instance FromGrpc a b => FromGrpc [a] [b] where
+  fromGrpc x = sequence $ fromGrpc <$> x
diff --git a/src/LndClient/Data/AddHodlInvoice.hs b/src/LndClient/Data/AddHodlInvoice.hs
new file mode 100644
--- /dev/null
+++ b/src/LndClient/Data/AddHodlInvoice.hs
@@ -0,0 +1,35 @@
+{-# LANGUAGE FlexibleContexts #-}
+
+module LndClient.Data.AddHodlInvoice
+  ( AddHodlInvoiceRequest (..),
+  )
+where
+
+import Data.ProtoLens.Message
+import LndClient.Import
+import qualified Proto.InvoiceGrpc as LnGRPC
+import qualified Proto.InvoiceGrpc_Fields as LnGRPC
+
+data AddHodlInvoiceRequest
+  = AddHodlInvoiceRequest
+      { memo :: Maybe Text,
+        hash :: RHash,
+        valueMsat :: MSat,
+        expiry :: Maybe Seconds
+      }
+  deriving (Eq, Show)
+
+instance ToGrpc AddHodlInvoiceRequest LnGRPC.AddHoldInvoiceRequest where
+  toGrpc x =
+    msg
+      <$> toGrpc (memo x)
+      <*> toGrpc (hash x)
+      <*> toGrpc (valueMsat x)
+      <*> toGrpc (expiry x)
+    where
+      msg gMemo gHash gValue gExp =
+        defMessage
+          & LnGRPC.memo .~ gMemo
+          & LnGRPC.hash .~ gHash
+          & LnGRPC.valueMsat .~ gValue
+          & LnGRPC.expiry .~ gExp
diff --git a/src/LndClient/Data/AddInvoice.hs b/src/LndClient/Data/AddInvoice.hs
new file mode 100644
--- /dev/null
+++ b/src/LndClient/Data/AddInvoice.hs
@@ -0,0 +1,48 @@
+{-# LANGUAGE FlexibleContexts #-}
+
+module LndClient.Data.AddInvoice
+  ( AddInvoiceRequest (..),
+    AddInvoiceResponse (..),
+  )
+where
+
+import Data.ProtoLens.Message
+import LndClient.Import
+import qualified Proto.LndGrpc as LnGRPC
+import qualified Proto.LndGrpc_Fields as LnGRPC
+
+data AddInvoiceRequest
+  = AddInvoiceRequest
+      { valueMsat :: MSat,
+        memo :: Maybe Text,
+        expiry :: Maybe Seconds
+      }
+  deriving (Eq, Show)
+
+data AddInvoiceResponse
+  = AddInvoiceResponse
+      { rHash :: RHash,
+        paymentRequest :: PaymentRequest,
+        addIndex :: AddIndex
+      }
+  deriving (Eq, Show)
+
+instance ToGrpc AddInvoiceRequest LnGRPC.Invoice where
+  toGrpc x =
+    msg
+      <$> toGrpc (memo x)
+      <*> toGrpc (valueMsat x)
+      <*> toGrpc (expiry x)
+    where
+      msg gMemo gValue gExp =
+        defMessage
+          & LnGRPC.memo .~ gMemo
+          & LnGRPC.valueMsat .~ gValue
+          & LnGRPC.expiry .~ gExp
+
+instance FromGrpc AddInvoiceResponse LnGRPC.AddInvoiceResponse where
+  fromGrpc x =
+    AddInvoiceResponse
+      <$> fromGrpc (x ^. LnGRPC.rHash)
+      <*> fromGrpc (x ^. LnGRPC.paymentRequest)
+      <*> fromGrpc (x ^. LnGRPC.addIndex)
diff --git a/src/LndClient/Data/Channel.hs b/src/LndClient/Data/Channel.hs
new file mode 100644
--- /dev/null
+++ b/src/LndClient/Data/Channel.hs
@@ -0,0 +1,55 @@
+{-# LANGUAGE FlexibleInstances #-}
+
+module LndClient.Data.Channel
+  ( Channel (..),
+    PendingUpdate (..),
+  )
+where
+
+import LndClient.Data.ChannelPoint
+  ( ChannelPoint (..),
+    channelPointParser,
+  )
+import LndClient.Data.Newtype
+import LndClient.Import
+import qualified Proto.LndGrpc as LnGRPC
+import qualified Proto.LndGrpc_Fields as LnGRPC
+
+data Channel
+  = Channel
+      { remotePubkey :: NodePubKey,
+        channelPoint :: ChannelPoint,
+        capacity :: MSat,
+        localBalance :: MSat,
+        remoteBalance :: MSat,
+        commitFee :: MSat,
+        active :: Bool
+      }
+  deriving (Eq, Ord, Show)
+
+data PendingUpdate (a :: TxKind)
+  = PendingUpdate
+      { txid :: TxId a,
+        outputIndex :: Vout a
+      }
+  deriving (Eq, Ord, Show)
+
+instance FromGrpc Channel LnGRPC.Channel where
+  fromGrpc x =
+    Channel
+      <$> fromGrpc (x ^. LnGRPC.remotePubkey)
+      <*> channelPointParser (x ^. LnGRPC.channelPoint)
+      <*> fromGrpc (x ^. LnGRPC.capacity)
+      <*> fromGrpc (x ^. LnGRPC.localBalance)
+      <*> fromGrpc (x ^. LnGRPC.remoteBalance)
+      <*> fromGrpc (x ^. LnGRPC.commitFee)
+      <*> fromGrpc (x ^. LnGRPC.active)
+
+instance FromGrpc [Channel] LnGRPC.ListChannelsResponse where
+  fromGrpc x = fromGrpc (x ^. LnGRPC.channels)
+
+instance FromGrpc (PendingUpdate a) LnGRPC.PendingUpdate where
+  fromGrpc x =
+    PendingUpdate
+      <$> fromGrpc (x ^. LnGRPC.txid)
+      <*> fromGrpc (x ^. LnGRPC.outputIndex)
diff --git a/src/LndClient/Data/ChannelPoint.hs b/src/LndClient/Data/ChannelPoint.hs
new file mode 100644
--- /dev/null
+++ b/src/LndClient/Data/ChannelPoint.hs
@@ -0,0 +1,64 @@
+{-# LANGUAGE FlexibleContexts #-}
+
+module LndClient.Data.ChannelPoint
+  ( ChannelPoint (..),
+    channelPointParser,
+  )
+where
+
+import qualified Data.ByteString as BS (reverse)
+import qualified Data.ByteString.Base16 as B16 (decode)
+import qualified Data.ByteString.Char8 as C8 (split)
+import Data.ProtoLens.Message
+import qualified Data.Text as TS (unpack)
+import LndClient.Import
+import qualified Proto.LndGrpc as LnGRPC
+import qualified Proto.LndGrpc_Fields as LnGRPC
+
+data ChannelPoint
+  = ChannelPoint
+      { fundingTxId :: TxId 'Funding,
+        outputIndex :: Vout 'Funding
+      }
+  deriving (Eq, Ord, Show)
+
+instance FromGrpc ChannelPoint LnGRPC.ChannelPoint where
+  fromGrpc x =
+    ChannelPoint
+      <$> fromGrpc (x ^. LnGRPC.fundingTxidBytes)
+      <*> fromGrpc (x ^. LnGRPC.outputIndex)
+
+instance ToGrpc ChannelPoint LnGRPC.ChannelPoint where
+  toGrpc x =
+    msg
+      <$> toGrpc (fundingTxId x)
+      <*> toGrpc (outputIndex x)
+    where
+      msg gFundingTxIdBytes gOutputIndex =
+        defMessage
+          & LnGRPC.fundingTxidBytes .~ gFundingTxIdBytes
+          & LnGRPC.outputIndex .~ gOutputIndex
+
+channelPointParser :: Text -> Either LndError ChannelPoint
+channelPointParser x =
+  case C8.split ':' str of
+    [txid, idxBS] ->
+      case B16.decode txid of
+        Right txidHex -> do
+          idxTS <-
+            first
+              ( const $
+                  FromGrpcError "Invalid ChannelPoint outputIndex"
+              )
+              $ decodeUtf8' idxBS
+          ChannelPoint
+            <$> (pure . TxId $ BS.reverse txidHex)
+            <*> maybeToRight
+              (FromGrpcError "Invalid ChannelPoint outputIndex")
+              (readMaybe $ TS.unpack idxTS)
+        Left {} ->
+          Left $ FromGrpcError "Invalid ChannelPoint fundingTxidBytes"
+    _ ->
+      Left $ FromGrpcError "Invalid ChannelPoint text"
+  where
+    str = encodeUtf8 x
diff --git a/src/LndClient/Data/CloseChannel.hs b/src/LndClient/Data/CloseChannel.hs
new file mode 100644
--- /dev/null
+++ b/src/LndClient/Data/CloseChannel.hs
@@ -0,0 +1,90 @@
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module LndClient.Data.CloseChannel
+  ( CloseChannelRequest (..),
+    CloseStatusUpdate (..),
+    ChannelCloseUpdate (..),
+    ChannelCloseSummary (..),
+  )
+where
+
+import Data.ProtoLens.Message
+import LndClient.Data.Channel (PendingUpdate)
+import LndClient.Data.ChannelPoint
+import LndClient.Import
+import qualified Proto.LndGrpc as LnGRPC
+import qualified Proto.LndGrpc_Fields as LnGRPC
+
+data CloseChannelRequest
+  = CloseChannelRequest
+      { channelPoint :: ChannelPoint,
+        force :: Bool,
+        targetConf :: Maybe Int32,
+        satPerByte :: Maybe Int64,
+        deliveryAddress :: Maybe Text
+      }
+  deriving (Eq, Ord, Show)
+
+data CloseStatusUpdate
+  = Pending (PendingUpdate 'Closing)
+  | Close ChannelCloseUpdate
+  | NothingUpdate
+  deriving (Eq, Ord, Show)
+
+data ChannelCloseUpdate
+  = ChannelCloseUpdate
+      { closingTxid :: TxId 'Closing,
+        success :: Bool
+      }
+  deriving (Eq, Ord, Show)
+
+data ChannelCloseSummary
+  = ChannelCloseSummary
+      { remotePubkey :: NodePubKey,
+        chPoint :: ChannelPoint,
+        settledBalance :: MSat,
+        closingTxId :: TxId 'Closing
+      }
+  deriving (Eq, Ord, Show)
+
+instance FromGrpc [ChannelCloseSummary] LnGRPC.ClosedChannelsResponse where
+  fromGrpc x = sequence $ fromGrpc <$> (x ^. LnGRPC.channels)
+
+instance ToGrpc CloseChannelRequest LnGRPC.CloseChannelRequest where
+  toGrpc x =
+    msg
+      <$> toGrpc (channelPoint x)
+      <*> toGrpc (LndClient.Data.CloseChannel.force x)
+      <*> toGrpc (targetConf x)
+      <*> toGrpc (satPerByte x)
+      <*> toGrpc (deliveryAddress x)
+    where
+      msg gChannelPoint gForce gTargetConf gSatPerByte gDeliveryAddress =
+        defMessage
+          & LnGRPC.channelPoint .~ gChannelPoint
+          & LnGRPC.force .~ gForce
+          & LnGRPC.targetConf .~ gTargetConf
+          & LnGRPC.satPerByte .~ gSatPerByte
+          & LnGRPC.deliveryAddress .~ gDeliveryAddress
+
+instance FromGrpc CloseStatusUpdate LnGRPC.CloseStatusUpdate where
+  fromGrpc x =
+    case x ^. LnGRPC.maybe'update of
+      Just (LnGRPC.CloseStatusUpdate'ClosePending a) -> Pending <$> fromGrpc a
+      Just (LnGRPC.CloseStatusUpdate'ChanClose a) -> Close <$> fromGrpc a
+      Nothing -> Right NothingUpdate
+
+instance FromGrpc ChannelCloseUpdate LnGRPC.ChannelCloseUpdate where
+  fromGrpc x =
+    ChannelCloseUpdate
+      <$> fromGrpc (x ^. LnGRPC.closingTxid)
+      <*> fromGrpc (x ^. LnGRPC.success)
+
+instance FromGrpc ChannelCloseSummary LnGRPC.ChannelCloseSummary where
+  fromGrpc x =
+    ChannelCloseSummary
+      <$> fromGrpc (x ^. LnGRPC.remotePubkey)
+      <*> channelPointParser (x ^. LnGRPC.channelPoint)
+      <*> fromGrpc (x ^. LnGRPC.settledBalance)
+      <*> fromGrpc (x ^. LnGRPC.closingTxHash)
diff --git a/src/LndClient/Data/ClosedChannel.hs b/src/LndClient/Data/ClosedChannel.hs
new file mode 100644
--- /dev/null
+++ b/src/LndClient/Data/ClosedChannel.hs
@@ -0,0 +1,35 @@
+module LndClient.Data.ClosedChannel
+  ( ClosedChannel (..),
+  )
+where
+
+import LndClient.Data.PendingChannel
+import LndClient.Import
+import qualified Proto.LndGrpc as LnGRPC
+import qualified Proto.LndGrpc_Fields as LnGRPC
+
+data ClosedChannel
+  = ClosedChannel
+      { channel :: PendingChannel,
+        closingTxid :: TxId 'Closing
+      }
+  deriving (Eq, Show)
+
+instance
+  FromGrpc
+    ClosedChannel
+    LnGRPC.PendingChannelsResponse'ClosedChannel
+  where
+  fromGrpc x =
+    ClosedChannel
+      <$> ( case pendingChannel of
+              Nothing ->
+                Left $ FromGrpcError "PendingChannel is required"
+              Just this ->
+                fromGrpc this
+          )
+      <*> fromGrpc
+        (x ^. LnGRPC.closingTxid)
+    where
+      pendingChannel =
+        x ^. LnGRPC.maybe'channel
diff --git a/src/LndClient/Data/ClosedChannels.hs b/src/LndClient/Data/ClosedChannels.hs
new file mode 100644
--- /dev/null
+++ b/src/LndClient/Data/ClosedChannels.hs
@@ -0,0 +1,53 @@
+{-# LANGUAGE FlexibleContexts #-}
+
+module LndClient.Data.ClosedChannels
+  ( ClosedChannelsRequest (..),
+    defReq,
+  )
+where
+
+import Data.ProtoLens.Message
+import LndClient.Import
+import qualified Proto.LndGrpc as LnGRPC
+import qualified Proto.LndGrpc_Fields as LnGRPC
+
+data ClosedChannelsRequest
+  = ClosedChannelsRequest
+      { cooperative :: Bool,
+        localForce :: Bool,
+        remoteForce :: Bool,
+        breach :: Bool,
+        fundingCanceled :: Bool,
+        abandoned :: Bool
+      }
+  deriving (Eq, Ord, Show)
+
+instance ToGrpc ClosedChannelsRequest LnGRPC.ClosedChannelsRequest where
+  toGrpc x =
+    msg
+      <$> toGrpc (cooperative x)
+      <*> toGrpc (localForce x)
+      <*> toGrpc (remoteForce x)
+      <*> toGrpc (breach x)
+      <*> toGrpc (fundingCanceled x)
+      <*> toGrpc (abandoned x)
+    where
+      msg gCooperative gLocalForce gRemoteForce gBreach gFundingCanceled gAbandoned =
+        defMessage
+          & LnGRPC.cooperative .~ gCooperative
+          & LnGRPC.localForce .~ gLocalForce
+          & LnGRPC.remoteForce .~ gRemoteForce
+          & LnGRPC.breach .~ gBreach
+          & LnGRPC.fundingCanceled .~ gFundingCanceled
+          & LnGRPC.abandoned .~ gAbandoned
+
+defReq :: ClosedChannelsRequest
+defReq =
+  ClosedChannelsRequest
+    { cooperative = True,
+      localForce = True,
+      remoteForce = True,
+      breach = True,
+      fundingCanceled = True,
+      abandoned = True
+    }
diff --git a/src/LndClient/Data/ForceClosedChannel.hs b/src/LndClient/Data/ForceClosedChannel.hs
new file mode 100644
--- /dev/null
+++ b/src/LndClient/Data/ForceClosedChannel.hs
@@ -0,0 +1,50 @@
+module LndClient.Data.ForceClosedChannel
+  ( ForceClosedChannel (..),
+  )
+where
+
+import LndClient.Data.PendingChannel
+import LndClient.Import
+import qualified Proto.LndGrpc as LnGRPC
+import qualified Proto.LndGrpc_Fields as LnGRPC
+
+data ForceClosedChannel
+  = ForceClosedChannel
+      { channel :: PendingChannel,
+        closingTxid :: TxId 'Closing,
+        limboBalance :: MSat,
+        maturityHeight :: Word32,
+        blocksTilMaturity :: Int32,
+        recoveredBalance :: MSat
+      }
+  deriving (Eq, Show)
+
+instance
+  FromGrpc
+    ForceClosedChannel
+    LnGRPC.PendingChannelsResponse'ForceClosedChannel
+  where
+  fromGrpc x =
+    ForceClosedChannel
+      <$> ( case pendingChannel of
+              Nothing ->
+                Left $ FromGrpcError "PendingChannel is required"
+              Just this ->
+                fromGrpc this
+          )
+      <*> fromGrpc (x ^. LnGRPC.closingTxid)
+      <*> ( toMSat
+              <$> fromGrpc
+                (x ^. LnGRPC.limboBalance)
+          )
+      <*> fromGrpc
+        (x ^. LnGRPC.maturityHeight)
+      <*> fromGrpc
+        (x ^. LnGRPC.blocksTilMaturity)
+      <*> ( toMSat
+              <$> fromGrpc
+                (x ^. LnGRPC.recoveredBalance)
+          )
+    where
+      pendingChannel =
+        x ^. LnGRPC.maybe'channel
diff --git a/src/LndClient/Data/GetInfo.hs b/src/LndClient/Data/GetInfo.hs
new file mode 100644
--- /dev/null
+++ b/src/LndClient/Data/GetInfo.hs
@@ -0,0 +1,25 @@
+{-# LANGUAGE FlexibleContexts #-}
+
+module LndClient.Data.GetInfo
+  ( GetInfoResponse (..),
+  )
+where
+
+import LndClient.Import
+import qualified Proto.LndGrpc as LnGRPC
+import qualified Proto.LndGrpc_Fields as LnGRPC
+
+data GetInfoResponse
+  = GetInfoResponse
+      { identityPubkey :: NodePubKey,
+        syncedToChain :: Bool,
+        syncedToGraph :: Bool
+      }
+  deriving (Eq, Show)
+
+instance FromGrpc GetInfoResponse LnGRPC.GetInfoResponse where
+  fromGrpc x =
+    GetInfoResponse
+      <$> fromGrpc (x ^. LnGRPC.identityPubkey)
+      <*> fromGrpc (x ^. LnGRPC.syncedToChain)
+      <*> fromGrpc (x ^. LnGRPC.syncedToGraph)
diff --git a/src/LndClient/Data/HtlcEvent.hs b/src/LndClient/Data/HtlcEvent.hs
new file mode 100644
--- /dev/null
+++ b/src/LndClient/Data/HtlcEvent.hs
@@ -0,0 +1,45 @@
+module LndClient.Data.HtlcEvent
+  ( HtlcEvent (..),
+  )
+where
+
+import LndClient.Import
+import qualified Proto.RouterGrpc as LnGRPC
+import qualified Proto.RouterGrpc_Fields as LnGRPC
+
+data HtlcEvent
+  = HtlcEvent
+      { incomingChannelId :: Word64,
+        outgoingChannelId :: Word64,
+        incomingHtlcId :: Word64,
+        outgoingHtlcId :: Word64,
+        timestampNs :: Word64,
+        eventType :: EventType
+      }
+  deriving (Eq)
+
+data EventType
+  = UNKNOWN
+  | SEND
+  | RECEIVE
+  | FORWARD
+  deriving (Eq)
+
+instance FromGrpc HtlcEvent LnGRPC.HtlcEvent where
+  fromGrpc x =
+    HtlcEvent
+      <$> fromGrpc (x ^. LnGRPC.incomingChannelId)
+      <*> fromGrpc (x ^. LnGRPC.outgoingChannelId)
+      <*> fromGrpc (x ^. LnGRPC.incomingHtlcId)
+      <*> fromGrpc (x ^. LnGRPC.outgoingHtlcId)
+      <*> fromGrpc (x ^. LnGRPC.timestampNs)
+      <*> fromGrpc (x ^. LnGRPC.eventType)
+
+instance FromGrpc EventType LnGRPC.HtlcEvent'EventType where
+  fromGrpc x =
+    case x of
+      LnGRPC.HtlcEvent'UNKNOWN -> Right UNKNOWN
+      LnGRPC.HtlcEvent'SEND -> Right SEND
+      LnGRPC.HtlcEvent'RECEIVE -> Right RECEIVE
+      LnGRPC.HtlcEvent'FORWARD -> Right FORWARD
+      LnGRPC.HtlcEvent'EventType'Unrecognized v -> Left $ FromGrpcError ("Cannot parse EventType, value:" <> show v)
diff --git a/src/LndClient/Data/InitWallet.hs b/src/LndClient/Data/InitWallet.hs
new file mode 100644
--- /dev/null
+++ b/src/LndClient/Data/InitWallet.hs
@@ -0,0 +1,37 @@
+{-# LANGUAGE FlexibleContexts #-}
+
+module LndClient.Data.InitWallet
+  ( InitWalletRequest (..),
+  )
+where
+
+import Data.ProtoLens.Message
+import LndClient.Import
+import qualified Proto.WalletUnlockerGrpc as LnGRPC
+import qualified Proto.WalletUnlockerGrpc_Fields as LnGRPC
+import Prelude (Show (..))
+
+data InitWalletRequest
+  = InitWalletRequest
+      { walletPassword :: LndWalletPassword,
+        cipherSeedMnemonic :: CipherSeedMnemonic,
+        aezeedPassphrase :: Maybe AezeedPassphrase
+      }
+  deriving (Eq)
+
+instance Show InitWalletRequest where
+  show = const "SECRET"
+
+instance ToGrpc InitWalletRequest LnGRPC.InitWalletRequest where
+  toGrpc x =
+    msg
+      <$> toGrpc (walletPassword x)
+      <*> toGrpc (cipherSeedMnemonic x)
+      <*> toGrpc (aezeedPassphrase x)
+    where
+      msg :: ByteString -> [Text] -> ByteString -> LnGRPC.InitWalletRequest
+      msg gWalletPassword gCipherSeedMnemonic gAezeedPassphrase =
+        defMessage
+          & LnGRPC.walletPassword .~ gWalletPassword
+          & LnGRPC.cipherSeedMnemonic .~ gCipherSeedMnemonic
+          & LnGRPC.aezeedPassphrase .~ gAezeedPassphrase
diff --git a/src/LndClient/Data/Invoice.hs b/src/LndClient/Data/Invoice.hs
new file mode 100644
--- /dev/null
+++ b/src/LndClient/Data/Invoice.hs
@@ -0,0 +1,54 @@
+module LndClient.Data.Invoice
+  ( Invoice (..),
+    InvoiceState (..),
+  )
+where
+
+import LndClient.Import
+import qualified Proto.LndGrpc as LnGRPC
+import qualified Proto.LndGrpc_Fields as LnGRPC
+
+data Invoice
+  = Invoice
+      { rHash :: RHash,
+        amtPaidMsat :: MSat,
+        valueMsat :: MSat,
+        settled :: Bool,
+        settleIndex :: Maybe SettleIndex,
+        memo :: Text,
+        paymentRequest :: PaymentRequest,
+        private :: Bool,
+        addIndex :: AddIndex,
+        state :: InvoiceState
+      }
+  deriving (Eq, Show)
+
+data InvoiceState
+  = OPEN
+  | SETTLED
+  | CANCELED
+  | ACCEPTED
+  deriving (Eq, Show)
+
+instance FromGrpc Invoice LnGRPC.Invoice where
+  fromGrpc x =
+    Invoice
+      <$> fromGrpc (x ^. LnGRPC.rHash)
+      <*> fromGrpc (x ^. LnGRPC.amtPaidMsat)
+      <*> fromGrpc (x ^. LnGRPC.valueMsat)
+      <*> fromGrpc (x ^. LnGRPC.settled)
+      <*> fromGrpc (x ^. LnGRPC.settleIndex)
+      <*> fromGrpc (x ^. LnGRPC.memo)
+      <*> fromGrpc (x ^. LnGRPC.paymentRequest)
+      <*> fromGrpc (x ^. LnGRPC.private)
+      <*> fromGrpc (x ^. LnGRPC.addIndex)
+      <*> fromGrpc (x ^. LnGRPC.state)
+
+instance FromGrpc InvoiceState LnGRPC.Invoice'InvoiceState where
+  fromGrpc x =
+    case x of
+      LnGRPC.Invoice'OPEN -> Right OPEN
+      LnGRPC.Invoice'SETTLED -> Right SETTLED
+      LnGRPC.Invoice'CANCELED -> Right CANCELED
+      LnGRPC.Invoice'ACCEPTED -> Right ACCEPTED
+      LnGRPC.Invoice'InvoiceState'Unrecognized v -> Left $ FromGrpcError ("Cannot parse InvoiceState, value:" <> show v)
diff --git a/src/LndClient/Data/Kind.hs b/src/LndClient/Data/Kind.hs
new file mode 100644
--- /dev/null
+++ b/src/LndClient/Data/Kind.hs
@@ -0,0 +1,11 @@
+module LndClient.Data.Kind
+  ( TxKind (..),
+  )
+where
+
+import LndClient.Import.External
+
+data TxKind
+  = Funding
+  | Closing
+  deriving (Eq, Show)
diff --git a/src/LndClient/Data/ListChannels.hs b/src/LndClient/Data/ListChannels.hs
new file mode 100644
--- /dev/null
+++ b/src/LndClient/Data/ListChannels.hs
@@ -0,0 +1,40 @@
+{-# LANGUAGE DeriveGeneric #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module LndClient.Data.ListChannels
+  ( ListChannelsRequest (..),
+  )
+where
+
+import Data.ProtoLens.Message
+import LndClient.Import
+import qualified Proto.LndGrpc as LnGRPC
+import qualified Proto.LndGrpc_Fields as LnGRPC
+
+data ListChannelsRequest
+  = ListChannelsRequest
+      { activeOnly :: Bool,
+        inactiveOnly :: Bool,
+        publicOnly :: Bool,
+        privateOnly :: Bool,
+        peer :: Maybe NodePubKey
+      }
+  deriving (Generic, Show)
+
+instance ToGrpc ListChannelsRequest LnGRPC.ListChannelsRequest where
+  toGrpc x =
+    msg
+      <$> toGrpc (activeOnly x)
+      <*> toGrpc (inactiveOnly x)
+      <*> toGrpc (privateOnly x)
+      <*> toGrpc (publicOnly x)
+      <*> toGrpc (peer x)
+    where
+      msg gActiveOnly gInactiveOnly gPrivateOnly gPublicOnly gPeer =
+        defMessage
+          & LnGRPC.activeOnly .~ gActiveOnly
+          & LnGRPC.inactiveOnly .~ gInactiveOnly
+          & LnGRPC.privateOnly .~ gPrivateOnly
+          & LnGRPC.publicOnly .~ gPublicOnly
+          & LnGRPC.peer .~ gPeer
diff --git a/src/LndClient/Data/ListInvoices.hs b/src/LndClient/Data/ListInvoices.hs
new file mode 100644
--- /dev/null
+++ b/src/LndClient/Data/ListInvoices.hs
@@ -0,0 +1,54 @@
+{-# LANGUAGE DeriveGeneric #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module LndClient.Data.ListInvoices
+  ( ListInvoiceRequest (..),
+    ListInvoiceResponse (..),
+  )
+where
+
+import Data.ProtoLens.Message
+import LndClient.Data.Invoice (Invoice)
+import LndClient.Import
+import qualified Proto.LndGrpc as LnGRPC
+import qualified Proto.LndGrpc_Fields as LnGRPC
+
+data ListInvoiceRequest
+  = ListInvoiceRequest
+      { pendingOnly :: Bool,
+        indexOffset :: AddIndex,
+        numMaxInvoices :: Word64,
+        reversed :: Bool
+      }
+  deriving (Generic, Show)
+
+data ListInvoiceResponse
+  = ListInvoiceResponse
+      { invoices :: [Invoice],
+        lastIndexOffset :: AddIndex,
+        firstIndexOffset :: AddIndex
+      }
+  deriving (Generic, Show)
+
+instance ToGrpc ListInvoiceRequest LnGRPC.ListInvoiceRequest where
+  toGrpc x =
+    msg
+      <$> toGrpc (pendingOnly x)
+      <*> toGrpc (indexOffset x)
+      <*> toGrpc (numMaxInvoices x)
+      <*> toGrpc (reversed x)
+    where
+      msg gPendingOnly gIndexOffset gNumMaxInvoices gReversed =
+        defMessage
+          & LnGRPC.pendingOnly .~ gPendingOnly
+          & LnGRPC.indexOffset .~ gIndexOffset
+          & LnGRPC.numMaxInvoices .~ gNumMaxInvoices
+          & LnGRPC.reversed .~ gReversed
+
+instance FromGrpc ListInvoiceResponse LnGRPC.ListInvoiceResponse where
+  fromGrpc x =
+    ListInvoiceResponse
+      <$> fromGrpc (x ^. LnGRPC.invoices)
+      <*> fromGrpc (x ^. LnGRPC.lastIndexOffset)
+      <*> fromGrpc (x ^. LnGRPC.firstIndexOffset)
diff --git a/src/LndClient/Data/LndEnv.hs b/src/LndClient/Data/LndEnv.hs
new file mode 100644
--- /dev/null
+++ b/src/LndClient/Data/LndEnv.hs
@@ -0,0 +1,225 @@
+{-# LANGUAGE DeriveGeneric #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module LndClient.Data.LndEnv
+  ( LndEnv (..),
+    RawConfig,
+    LndWalletPassword (..),
+    LndTlsCert,
+    LndHexMacaroon (..),
+    LndHost (..),
+    LndPort,
+    LndConfig (..),
+    newLndEnv,
+    readLndEnv,
+    createLndTlsCert,
+    unLndTlsCert,
+    createLndPort,
+    katipAddLndContext,
+    newSeverity,
+    newSev,
+  )
+where
+
+import Data.Aeson as A
+  ( (.:?),
+    Result (..),
+    Value (..),
+    camelTo2,
+    defaultOptions,
+    eitherDecodeStrict,
+    fieldLabelModifier,
+    genericParseJSON,
+    withObject,
+  )
+import qualified Data.ByteString.Char8 as C8
+import qualified Data.PEM as Pem
+import Data.Scientific
+import Data.X509
+import Env
+import LndClient.Class
+import LndClient.Data.Newtype
+import LndClient.Data.Type
+import LndClient.Import.External as Ex
+import LndClient.Util as U
+import Network.GRPC.Client.Helpers (GrpcClientConfig (..), grpcClientConfigSimple)
+import Network.GRPC.HTTP2.Encoding (uncompressed)
+import Network.HTTP2.Client
+
+newtype LndWalletPassword = LndWalletPassword Text
+  deriving (PersistField, PersistFieldSql, Eq, FromJSON, IsString)
+
+newtype LndTlsCert = LndTlsCert ByteString
+  deriving (PersistField, PersistFieldSql, Eq)
+
+newtype LndHexMacaroon = LndHexMacaroon Text
+  deriving (PersistField, PersistFieldSql, Eq, FromJSON, IsString)
+
+newtype LndHost = LndHost Text
+  deriving (PersistField, PersistFieldSql, Eq, FromJSON, IsString)
+
+newtype LndPort = LndPort Int
+  deriving (PersistField, PersistFieldSql, Eq)
+
+data LndConfig
+  = LndConfig
+      { lndConfigHost :: HostName,
+        lndConfigPort :: PortNumber,
+        lndConfigTlsEnabled :: Bool,
+        lndConfigCompression :: Bool
+      }
+  deriving (Show)
+
+data RawConfig
+  = RawConfig
+      { rawConfigLndWalletPassword :: LndWalletPassword,
+        rawConfigLndTlsCert :: LndTlsCert,
+        rawConfigLndHexMacaroon :: LndHexMacaroon,
+        rawConfigLndHost :: LndHost,
+        rawConfigLndPort :: LndPort,
+        rawConfigLndCipherSeedMnemonic :: Maybe CipherSeedMnemonic,
+        rawConfigLndAezeedPassphrase :: Maybe AezeedPassphrase
+      }
+  deriving (Eq, Generic)
+
+data LndEnv
+  = LndEnv
+      { envLndWalletPassword :: LndWalletPassword,
+        envLndHexMacaroon :: LndHexMacaroon,
+        envLndLogStrategy :: LoggingStrategy,
+        envLndCipherSeedMnemonic :: Maybe CipherSeedMnemonic,
+        envLndAezeedPassphrase :: Maybe AezeedPassphrase,
+        envLndSyncGrpcTimeout :: Maybe GrpcTimeoutSeconds,
+        envLndAsyncGrpcTimeout :: Maybe GrpcTimeoutSeconds,
+        envLndConfig :: GrpcClientConfig
+      }
+
+instance ToGrpc LndWalletPassword ByteString where
+  toGrpc x = Right $ encodeUtf8 (coerce x :: Text)
+
+instance FromJSON LndTlsCert where
+  parseJSON x =
+    case x of
+      A.String s ->
+        case createLndTlsCert $ encodeUtf8 s of
+          Right cert -> return cert
+          Left e -> failure e
+      e -> failure e
+    where
+      failure err = fail $ "Json certificate parsing error: " <> " " <> show err
+
+instance FromJSON LndPort where
+  parseJSON x =
+    case x of
+      A.Number s -> do
+        let ePort =
+              maybeToRight
+                (LndEnvError "Port should be Int")
+                $ toBoundedInteger s
+        case ePort >>= createLndPort of
+          Right lndPort -> return lndPort
+          Left err -> failure err
+      err -> failure err
+    where
+      failure err = fail $ "Json port loading error: " <> " " <> show err
+
+instance FromJSON RawConfig where
+  parseJSON =
+    genericParseJSON
+      defaultOptions
+        { fieldLabelModifier = camelTo2 '_' . Ex.drop 9
+        }
+
+instance FromJSON LndEnv where
+  parseJSON arg =
+    case fromJSON arg :: Result RawConfig of
+      Error e -> fail e
+      Success rc -> do
+        let res =
+              newLndEnv
+                (rawConfigLndWalletPassword rc)
+                (rawConfigLndTlsCert rc)
+                (rawConfigLndHexMacaroon rc)
+                (rawConfigLndHost rc)
+                (rawConfigLndPort rc)
+                (rawConfigLndCipherSeedMnemonic rc)
+                (rawConfigLndAezeedPassphrase rc)
+        withObject
+          "LndEnv"
+          ( \obj ->
+              (\x y -> res {envLndSyncGrpcTimeout = x, envLndAsyncGrpcTimeout = y})
+                <$> obj .:? "lnd_sync_grpc_timeout_seconds"
+                <*> obj .:? "lnd_async_grpc_timeout_seconds"
+          )
+          arg
+
+createLndTlsCert :: ByteString -> Either LndError LndTlsCert
+createLndTlsCert bs = do
+  pemsM <- first (LndEnvError . pack) $ Pem.pemParseBS bs
+  pem <-
+    note (LndEnvError $ pack "No pem found") $ safeHead pemsM
+  bimap
+    (LndEnvError . pack . ("Certificate is not valid: " <>))
+    (const $ LndTlsCert bs)
+    (decodeSignedCertificate $ Pem.pemContent pem)
+
+unLndTlsCert :: LndTlsCert -> ByteString
+unLndTlsCert = coerce
+
+createLndPort :: Word32 -> Either LndError LndPort
+createLndPort p = do
+  let maybePort :: Maybe Int = U.safeFromIntegral p
+  maybeToRight (LndEnvError "Wrong port") $ LndPort <$> maybePort
+
+readLndEnv :: IO LndEnv
+readLndEnv =
+  parse
+    (header "LndEnv")
+    $ var
+      (parser <=< nonempty)
+      "LND_CLIENT_ENV_DATA"
+      (keep <> help "")
+  where
+    parser :: String -> Either Error LndEnv
+    parser x =
+      first UnreadError $ eitherDecodeStrict $ C8.pack x
+
+newLndEnv ::
+  LndWalletPassword ->
+  LndTlsCert ->
+  LndHexMacaroon ->
+  LndHost ->
+  LndPort ->
+  Maybe CipherSeedMnemonic ->
+  Maybe AezeedPassphrase ->
+  LndEnv
+newLndEnv pwd _cert mac host port seed aezeed =
+  LndEnv
+    { envLndWalletPassword = pwd,
+      envLndHexMacaroon = mac,
+      envLndLogStrategy = logDefault,
+      envLndCipherSeedMnemonic = seed,
+      envLndAezeedPassphrase = aezeed,
+      envLndSyncGrpcTimeout = Nothing,
+      envLndAsyncGrpcTimeout = Nothing,
+      envLndConfig =
+        (grpcClientConfigSimple (unpack $ coerce host) (fromInteger (toInteger (coerce port :: Int))) True)
+          { _grpcClientConfigCompression = uncompressed,
+            _grpcClientConfigHeaders = [("macaroon", encodeUtf8 (coerce mac :: Text))]
+          }
+    }
+
+katipAddLndContext :: (KatipContext m) => LndEnv -> m a -> m a
+katipAddLndContext env =
+  katipAddContext (sl "LndHost:" h)
+    . katipAddContext (sl "LndPort" p)
+  where
+    h = _grpcClientConfigHost $ envLndConfig env
+    p = toInteger $ _grpcClientConfigPort $ envLndConfig env
+
+newSeverity :: LndEnv -> Severity -> Maybe Timespan -> Maybe LndError -> Severity
+newSeverity = coerce . envLndLogStrategy
+
+newSev :: LndEnv -> Severity -> Severity
+newSev env sev = newSeverity env sev Nothing Nothing
diff --git a/src/LndClient/Data/NewAddress.hs b/src/LndClient/Data/NewAddress.hs
new file mode 100644
--- /dev/null
+++ b/src/LndClient/Data/NewAddress.hs
@@ -0,0 +1,57 @@
+{-# LANGUAGE FlexibleContexts #-}
+
+module LndClient.Data.NewAddress
+  ( NewAddressResponse (..),
+    NewAddressRequest (..),
+    AddressType (..),
+  )
+where
+
+import Data.ProtoLens.Message
+import Data.Text (pack)
+import LndClient.Import
+import qualified Proto.LndGrpc as LnGRPC
+import qualified Proto.LndGrpc_Fields as LnGRPC
+
+data NewAddressRequest
+  = NewAddressRequest
+      { addrType :: AddressType,
+        account :: Maybe String
+      }
+  deriving (Show, Eq)
+
+data AddressType
+  = WITNESS_PUBKEY_HASH
+  | NESTED_PUBKEY_HASH
+  | UNUSED_WITNESS_PUBKEY_HASH
+  | UNUSED_NESTED_PUBKEY_HASH
+  deriving (Show, Eq)
+
+newtype NewAddressResponse
+  = NewAddressResponse
+      { address :: Text
+      }
+  deriving (Show, Eq)
+
+instance ToGrpc NewAddressRequest LnGRPC.NewAddressRequest where
+  toGrpc x =
+    msg
+      <$> toGrpc (addrType x)
+      <*> toGrpc (pack <$> account x)
+    where
+      msg gAddrType gAccount =
+        defMessage
+          & LnGRPC.type' .~ gAddrType
+          & LnGRPC.account .~ gAccount
+
+instance ToGrpc AddressType LnGRPC.AddressType where
+  toGrpc x =
+    Right $ case x of
+      WITNESS_PUBKEY_HASH -> LnGRPC.WITNESS_PUBKEY_HASH
+      NESTED_PUBKEY_HASH -> LnGRPC.NESTED_PUBKEY_HASH
+      UNUSED_WITNESS_PUBKEY_HASH -> LnGRPC.UNUSED_WITNESS_PUBKEY_HASH
+      UNUSED_NESTED_PUBKEY_HASH -> LnGRPC.UNUSED_NESTED_PUBKEY_HASH
+
+instance FromGrpc NewAddressResponse LnGRPC.NewAddressResponse where
+  fromGrpc x =
+    NewAddressResponse <$> Right (x ^. LnGRPC.address)
diff --git a/src/LndClient/Data/Newtype.hs b/src/LndClient/Data/Newtype.hs
new file mode 100644
--- /dev/null
+++ b/src/LndClient/Data/Newtype.hs
@@ -0,0 +1,289 @@
+{-# LANGUAGE DerivingStrategies #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
+
+module LndClient.Data.Newtype
+  ( AddIndex (..),
+    SettleIndex (..),
+    PaymentRequest (..),
+    RHash (..),
+    RPreimage (..),
+    MSat (..),
+    Sat (..),
+    toSat,
+    toMSat,
+    CipherSeedMnemonic (..),
+    AezeedPassphrase (..),
+    Seconds (..),
+    NodePubKey (..),
+    NodeLocation (..),
+    GrpcTimeoutSeconds,
+    newRHash,
+    newRPreimage,
+    newGrpcTimeout,
+    unGrpcTimeout,
+    defaultSyncGrpcTimeout,
+    defaultAsyncGrpcTimeout,
+    TxId (..),
+    Vout (..),
+  )
+where
+
+import Codec.QRCode as QR (ToText)
+import qualified Crypto.Hash.SHA256 as SHA256 (hash)
+import Crypto.Random (getRandomBytes)
+import Data.Aeson (FromJSON (..))
+import Data.ByteString.Base16 as B16 (decode, encode)
+import Data.ByteString.Char8 as C8
+import Data.ProtoLens.Message
+import LndClient.Class
+import LndClient.Data.Kind
+import LndClient.Data.Type
+import LndClient.Import.External
+import LndClient.Util
+import qualified Proto.InvoiceGrpc as IGrpc
+import qualified Proto.InvoiceGrpc_Fields as IGrpc
+import qualified Proto.LndGrpc as LnGrpc
+import qualified Proto.LndGrpc_Fields as LnGrpc
+import Prelude (Show)
+
+newtype Vout (a :: TxKind) = Vout Word32
+  deriving newtype (PersistField, PersistFieldSql, Eq, Ord, Show, Read)
+
+newtype TxId (a :: TxKind) = TxId ByteString
+  deriving (PersistField, PersistFieldSql, Eq, Ord, Show)
+
+newtype NodePubKey = NodePubKey ByteString
+  deriving (PersistField, PersistFieldSql, Eq, Ord, Show, Read)
+
+newtype NodeLocation = NodeLocation Text
+  deriving (PersistField, PersistFieldSql, Eq, Ord, Show, Read)
+
+newtype AddIndex = AddIndex Word64
+  deriving (PersistField, PersistFieldSql, Eq, Ord, Show)
+
+newtype SettleIndex = SettleIndex Word64
+  deriving (PersistField, PersistFieldSql, Eq, Ord, Show)
+
+newtype PaymentRequest = PaymentRequest Text
+  deriving (PersistField, PersistFieldSql, Eq, QR.ToText, Show)
+
+newtype RHash = RHash ByteString
+  deriving (PersistField, PersistFieldSql, Eq, Ord, Show)
+
+newtype RPreimage = RPreimage ByteString
+  deriving (PersistField, PersistFieldSql, Eq, Ord, Show)
+
+newtype MSat = MSat Word64
+  deriving
+    ( PersistField,
+      PersistFieldSql,
+      Eq,
+      Num,
+      Ord,
+      FromJSON,
+      Show
+    )
+
+newtype Sat = Sat Word64
+  deriving
+    (Eq, Num, Ord, FromJSON, Show)
+
+newtype CipherSeedMnemonic = CipherSeedMnemonic [Text]
+  deriving (PersistField, PersistFieldSql, Eq, FromJSON, Show)
+
+newtype AezeedPassphrase = AezeedPassphrase Text
+  deriving (PersistField, PersistFieldSql, Eq, FromJSON, Show)
+
+newtype Seconds = Seconds Word64
+  deriving (PersistField, PersistFieldSql, Eq, FromJSON, Show)
+
+newtype GrpcTimeoutSeconds = GrpcTimeoutSeconds Int
+  deriving (Eq, Ord, FromJSON, Show)
+
+instance ToGrpc NodePubKey ByteString where
+  toGrpc = Right . coerce
+
+instance ToGrpc NodePubKey Text where
+  toGrpc =
+    first (const $ ToGrpcError "UTF8_DECODE_ERROR")
+      . decodeUtf8'
+      . B16.encode
+      . coerce
+
+instance ToGrpc NodeLocation Text where
+  toGrpc = Right . coerce
+
+--
+-- TODO : smart constructors for NodePubKey and NodeLocation ???
+--
+
+instance FromGrpc (TxId a) ByteString where
+  fromGrpc = Right . TxId
+
+instance FromGrpc (TxId a) Text where
+  fromGrpc = (TxId <$>) . txIdParser
+
+instance FromGrpc (Vout a) Word32 where
+  fromGrpc = Right . Vout
+
+instance FromGrpc NodePubKey ByteString where
+  fromGrpc = Right . NodePubKey
+
+instance FromGrpc NodePubKey Text where
+  fromGrpc =
+    bimap (const $ FromGrpcError "NodePubKey hex decoding error") NodePubKey . B16.decode . encodeUtf8
+
+instance FromGrpc NodeLocation Text where
+  fromGrpc = Right . NodeLocation
+
+instance ToGrpc (TxId a) ByteString where
+  toGrpc = Right . coerce
+
+instance ToGrpc (Vout a) Word32 where
+  toGrpc = Right . coerce
+
+instance ToGrpc AddIndex Word64 where
+  toGrpc = Right . coerce
+
+instance ToGrpc SettleIndex Word64 where
+  toGrpc = Right . coerce
+
+instance ToGrpc MSat Int64 where
+  toGrpc x =
+    maybeToRight
+      (ToGrpcError "MSat overflow")
+      $ safeFromIntegral (coerce x :: Word64)
+
+instance FromGrpc MSat Int64 where
+  fromGrpc x =
+    maybeToRight
+      (ToGrpcError "MSat overflow")
+      $ MSat <$> safeFromIntegral x
+
+instance FromGrpc MSat Word64 where
+  fromGrpc x =
+    maybeToRight
+      (ToGrpcError "MSat overflow")
+      $ MSat <$> safeFromIntegral x
+
+instance ToGrpc Sat Int64 where
+  toGrpc x =
+    maybeToRight
+      (ToGrpcError "Sat overflow")
+      $ safeFromIntegral (coerce x :: Word64)
+
+instance FromGrpc Sat Int64 where
+  fromGrpc x =
+    maybeToRight
+      (ToGrpcError "Sat overflow")
+      $ Sat <$> safeFromIntegral x
+
+instance FromGrpc RHash ByteString where
+  fromGrpc = Right . RHash
+
+instance FromGrpc RPreimage ByteString where
+  fromGrpc = Right . RPreimage
+
+instance FromGrpc AddIndex Word64 where
+  fromGrpc = Right . AddIndex
+
+instance FromGrpc SettleIndex Word64 where
+  fromGrpc = Right . SettleIndex
+
+instance FromGrpc PaymentRequest Text where
+  fromGrpc = Right . PaymentRequest
+
+instance FromGrpc PaymentRequest IGrpc.AddHoldInvoiceResp where
+  fromGrpc x = fromGrpc (x ^. IGrpc.paymentRequest)
+
+instance FromGrpc Seconds Int64 where
+  fromGrpc =
+    (Seconds <$>)
+      . maybeToRight (FromGrpcError "Seconds overflow")
+      . safeFromIntegral
+
+instance FromGrpc RHash Text where
+  fromGrpc x0 =
+    case B16.decode $ encodeUtf8 x0 of
+      Right x1 -> Right $ RHash x1
+      Left {} -> Left $ FromGrpcError "NON_HEX_RHASH"
+
+instance FromGrpc RPreimage Text where
+  fromGrpc x0 =
+    case B16.decode $ encodeUtf8 x0 of
+      Right x1 -> Right $ RPreimage x1
+      Left {} -> Left $ FromGrpcError "NON_HEX_RPREIMAGE"
+
+instance ToGrpc PaymentRequest Text where
+  toGrpc x = Right (coerce x :: Text)
+
+instance ToGrpc Seconds Int64 where
+  toGrpc x =
+    maybeToRight
+      (ToGrpcError "Seconds overflow")
+      $ safeFromIntegral (coerce x :: Word64)
+
+instance ToGrpc CipherSeedMnemonic [Text] where
+  toGrpc = Right . coerce
+
+instance ToGrpc AezeedPassphrase ByteString where
+  toGrpc x = Right $ encodeUtf8 (coerce x :: Text)
+
+instance ToGrpc RHash ByteString where
+  toGrpc = Right . coerce
+
+instance ToGrpc RHash IGrpc.CancelInvoiceMsg where
+  toGrpc x = do
+    ph <- toGrpc x
+    Right $ defMessage & IGrpc.paymentHash .~ ph
+
+instance ToGrpc RPreimage ByteString where
+  toGrpc = Right . coerce
+
+instance ToGrpc RPreimage IGrpc.SettleInvoiceMsg where
+  toGrpc x = do
+    p <- toGrpc x
+    Right $ defMessage & IGrpc.preimage .~ p
+
+instance ToGrpc PaymentRequest LnGrpc.PayReqString where
+  toGrpc x = Right $ defMessage & LnGrpc.payReq .~ coerce x
+
+instance ToGrpc RHash LnGrpc.PaymentHash where
+  toGrpc x = Right $ defMessage & LnGrpc.rHash .~ coerce x
+
+instance ToGrpc RHash IGrpc.SubscribeSingleInvoiceRequest where
+  toGrpc x = do
+    rh <- toGrpc x
+    Right $ defMessage & IGrpc.rHash .~ rh
+
+newRHash :: RPreimage -> RHash
+newRHash = RHash . SHA256.hash . coerce
+
+newRPreimage :: MonadIO m => m RPreimage
+newRPreimage = RPreimage <$> liftIO (getRandomBytes 32)
+
+newGrpcTimeout :: Int -> Maybe GrpcTimeoutSeconds
+newGrpcTimeout x =
+  if x > 0
+    then Just $ GrpcTimeoutSeconds x
+    else Nothing
+
+unGrpcTimeout :: GrpcTimeoutSeconds -> Int
+unGrpcTimeout = coerce
+
+defaultSyncGrpcTimeout :: GrpcTimeoutSeconds
+defaultSyncGrpcTimeout = GrpcTimeoutSeconds 60
+
+defaultAsyncGrpcTimeout :: GrpcTimeoutSeconds
+defaultAsyncGrpcTimeout = GrpcTimeoutSeconds 3600
+
+toSat :: MSat -> Either LndError Sat
+toSat mSat = do
+  let mVal :: Word64 = coerce mSat
+  case divMod mVal 1000 of
+    (val, 0) -> Right $ Sat val
+    _ -> Left $ ToGrpcError ("Cannot convert " <> show mVal <> " to Sat")
+
+toMSat :: Sat -> MSat
+toMSat sat = MSat $ 1000 * coerce sat
diff --git a/src/LndClient/Data/OpenChannel.hs b/src/LndClient/Data/OpenChannel.hs
new file mode 100644
--- /dev/null
+++ b/src/LndClient/Data/OpenChannel.hs
@@ -0,0 +1,108 @@
+{-# LANGUAGE FlexibleContexts #-}
+
+module LndClient.Data.OpenChannel
+  ( OpenChannelRequest (..),
+    OpenStatusUpdate (..),
+  )
+where
+
+import Data.ProtoLens.Message
+import LndClient.Data.Channel
+import LndClient.Data.ChannelPoint
+import LndClient.Import
+import qualified Proto.LndGrpc as LnGRPC
+import qualified Proto.LndGrpc_Fields as LnGRPC
+
+data OpenChannelRequest
+  = OpenChannelRequest
+      { nodePubkey :: NodePubKey,
+        localFundingAmount :: MSat,
+        pushSat :: Maybe MSat,
+        targetConf :: Maybe Int32,
+        satPerByte :: Maybe MSat,
+        private :: Maybe Bool,
+        minHtlcMsat :: Maybe MSat,
+        remoteCsvDelay :: Maybe Word32,
+        minConfs :: Maybe Int32,
+        spendUnconfirmed :: Maybe Bool,
+        closeAddress :: Maybe Text
+      }
+  deriving (Eq, Show)
+
+data OpenStatusUpdate
+  = OpenStatusUpdate
+      { pendingChanId :: ByteString,
+        update :: Maybe OpenStatusUpdate'
+      }
+  deriving (Eq, Show)
+
+data OpenStatusUpdate'
+  = OpenStatusUpdateChanPending (PendingUpdate 'Funding)
+  | OpenStatusUpdateChanOpen ChannelOpenUpdate
+  | OpenStatusUpdatePsbtFund ReadyForPsbtFunding
+  deriving (Eq, Show)
+
+newtype ChannelOpenUpdate = ChannelOpenUpdate ChannelPoint
+  deriving (Eq, Show)
+
+data ReadyForPsbtFunding
+  = ReadyForPsbtFunding
+      { fundingAddress :: Text,
+        fundingAmount :: MSat,
+        psbt :: ByteString
+      }
+  deriving (Eq, Show)
+
+instance FromGrpc OpenStatusUpdate LnGRPC.OpenStatusUpdate where
+  fromGrpc x =
+    OpenStatusUpdate
+      <$> fromGrpc (x ^. LnGRPC.pendingChanId)
+      <*> case x ^. LnGRPC.maybe'update of
+        Just upd -> Just <$> fromGrpc upd
+        Nothing -> Right Nothing
+
+instance FromGrpc OpenStatusUpdate' LnGRPC.OpenStatusUpdate'Update where
+  fromGrpc x =
+    case x of
+      LnGRPC.OpenStatusUpdate'ChanPending pu -> OpenStatusUpdateChanPending <$> fromGrpc pu
+      LnGRPC.OpenStatusUpdate'ChanOpen cou -> OpenStatusUpdateChanOpen <$> fromGrpc cou
+      LnGRPC.OpenStatusUpdate'PsbtFund pf -> OpenStatusUpdatePsbtFund <$> fromGrpc pf
+
+instance FromGrpc ChannelOpenUpdate LnGRPC.ChannelOpenUpdate where
+  fromGrpc x = ChannelOpenUpdate <$> fromGrpc (x ^. LnGRPC.channelPoint)
+
+instance FromGrpc ReadyForPsbtFunding LnGRPC.ReadyForPsbtFunding where
+  fromGrpc x =
+    ReadyForPsbtFunding
+      <$> fromGrpc (x ^. LnGRPC.fundingAddress)
+      <*> fromGrpc (x ^. LnGRPC.fundingAmount)
+      <*> fromGrpc (x ^. LnGRPC.psbt)
+
+instance ToGrpc OpenChannelRequest LnGRPC.OpenChannelRequest where
+  toGrpc x =
+    msg
+      <$> toGrpc (nodePubkey x)
+      <*> (toGrpc =<< toSat (localFundingAmount x))
+      <*> maybe (Right fieldDefault) (toGrpc <=< toSat) (pushSat x)
+      <*> toGrpc (targetConf x)
+      <*> maybe (Right fieldDefault) (toGrpc <=< toSat) (satPerByte x)
+      <*> toGrpc (private x)
+      <*> toGrpc (minHtlcMsat x)
+      <*> toGrpc (remoteCsvDelay x)
+      <*> toGrpc (minConfs x)
+      <*> toGrpc (spendUnconfirmed x)
+      <*> toGrpc (closeAddress x)
+    where
+      msg gNodePubKey gLocalFindingAmount gPushSat gTargetConf gSatPerByte gPrivate gMinHtlcMsat gRemoteCsvDelay gMinConfs gSpendUnconfirmed gCloseAddress =
+        defMessage
+          & LnGRPC.nodePubkey .~ gNodePubKey
+          & LnGRPC.localFundingAmount .~ gLocalFindingAmount
+          & LnGRPC.pushSat .~ gPushSat
+          & LnGRPC.targetConf .~ gTargetConf
+          & LnGRPC.satPerByte .~ gSatPerByte
+          & LnGRPC.private .~ gPrivate
+          & LnGRPC.minHtlcMsat .~ gMinHtlcMsat
+          & LnGRPC.remoteCsvDelay .~ gRemoteCsvDelay
+          & LnGRPC.minConfs .~ gMinConfs
+          & LnGRPC.spendUnconfirmed .~ gSpendUnconfirmed
+          & LnGRPC.closeAddress .~ gCloseAddress
diff --git a/src/LndClient/Data/PayReq.hs b/src/LndClient/Data/PayReq.hs
new file mode 100644
--- /dev/null
+++ b/src/LndClient/Data/PayReq.hs
@@ -0,0 +1,23 @@
+module LndClient.Data.PayReq
+  ( PayReq (..),
+  )
+where
+
+import LndClient.Import
+import qualified Proto.LndGrpc as LnGRPC
+import qualified Proto.LndGrpc_Fields as LnGRPC
+
+data PayReq
+  = PayReq
+      { paymentHash :: RHash,
+        numMsat :: MSat,
+        expiry :: Seconds
+      }
+  deriving (Eq, Show)
+
+instance FromGrpc PayReq LnGRPC.PayReq where
+  fromGrpc x =
+    PayReq
+      <$> fromGrpc (x ^. LnGRPC.paymentHash)
+      <*> fromGrpc (x ^. LnGRPC.numMsat)
+      <*> fromGrpc (x ^. LnGRPC.expiry)
diff --git a/src/LndClient/Data/Payment.hs b/src/LndClient/Data/Payment.hs
new file mode 100644
--- /dev/null
+++ b/src/LndClient/Data/Payment.hs
@@ -0,0 +1,41 @@
+module LndClient.Data.Payment
+  ( Payment (..),
+  )
+where
+
+import LndClient.Import
+import qualified Proto.LndGrpc as LnGRPC
+import qualified Proto.LndGrpc_Fields as LnGRPC
+
+data Payment
+  = Payment
+      { paymentHash :: RHash,
+        paymentPreimage :: RPreimage,
+        valueMsat :: MSat,
+        state :: PaymentStatus
+      }
+  deriving (Eq, Show)
+
+data PaymentStatus
+  = UNKNOWN
+  | IN_FLIGHT
+  | SUCCEEDED
+  | FAILED
+  deriving (Eq, Show)
+
+instance FromGrpc Payment LnGRPC.Payment where
+  fromGrpc x =
+    Payment
+      <$> fromGrpc (x ^. LnGRPC.paymentHash)
+      <*> fromGrpc (x ^. LnGRPC.paymentPreimage)
+      <*> fromGrpc (x ^. LnGRPC.valueMsat)
+      <*> fromGrpc (x ^. LnGRPC.status)
+
+instance FromGrpc PaymentStatus LnGRPC.Payment'PaymentStatus where
+  fromGrpc x =
+    case x of
+      LnGRPC.Payment'UNKNOWN -> Right UNKNOWN
+      LnGRPC.Payment'IN_FLIGHT -> Right IN_FLIGHT
+      LnGRPC.Payment'SUCCEEDED -> Right SUCCEEDED
+      LnGRPC.Payment'FAILED -> Right FAILED
+      LnGRPC.Payment'PaymentStatus'Unrecognized v -> Left $ FromGrpcError ("Cannot parse PaymentStatus, value:" <> show v)
diff --git a/src/LndClient/Data/Peer.hs b/src/LndClient/Data/Peer.hs
new file mode 100644
--- /dev/null
+++ b/src/LndClient/Data/Peer.hs
@@ -0,0 +1,66 @@
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module LndClient.Data.Peer
+  ( Peer (..),
+    LightningAddress (..),
+    ConnectPeerRequest (..),
+  )
+where
+
+import Data.ProtoLens.Message
+import LndClient.Import
+import qualified Proto.LndGrpc as LnGRPC
+import qualified Proto.LndGrpc_Fields as LnGRPC
+
+data Peer
+  = Peer
+      { pubKey :: NodePubKey,
+        address :: NodeLocation
+      }
+  deriving (Eq, Show)
+
+instance FromGrpc Peer LnGRPC.Peer where
+  fromGrpc x =
+    Peer
+      <$> fromGrpc (x ^. LnGRPC.pubKey)
+      <*> fromGrpc (x ^. LnGRPC.address)
+
+data LightningAddress
+  = LightningAddress
+      { pubkey :: NodePubKey,
+        host :: NodeLocation
+      }
+  deriving (Eq, Show, Read)
+
+instance ToGrpc LightningAddress LnGRPC.LightningAddress where
+  toGrpc x =
+    msg
+      <$> toGrpc (pubkey x)
+      <*> toGrpc (host x)
+    where
+      msg gPubkey gHost =
+        defMessage
+          & LnGRPC.pubkey .~ gPubkey
+          & LnGRPC.host .~ gHost
+
+data ConnectPeerRequest
+  = ConnectPeerRequest
+      { addr :: LightningAddress,
+        perm :: Bool
+      }
+  deriving (Eq, Show)
+
+instance ToGrpc ConnectPeerRequest LnGRPC.ConnectPeerRequest where
+  toGrpc x =
+    msg
+      <$> toGrpc (addr x)
+      <*> toGrpc (perm x)
+    where
+      msg gAddr gPerm =
+        defMessage
+          & LnGRPC.addr .~ gAddr
+          & LnGRPC.perm .~ gPerm
+
+instance FromGrpc [Peer] LnGRPC.ListPeersResponse where
+  fromGrpc x = sequence $ fromGrpc <$> (x ^. LnGRPC.peers)
diff --git a/src/LndClient/Data/PendingChannel.hs b/src/LndClient/Data/PendingChannel.hs
new file mode 100644
--- /dev/null
+++ b/src/LndClient/Data/PendingChannel.hs
@@ -0,0 +1,50 @@
+module LndClient.Data.PendingChannel
+  ( PendingChannel (..),
+  )
+where
+
+import LndClient.Data.ChannelPoint
+import LndClient.Import
+import qualified Proto.LndGrpc as LnGRPC
+import qualified Proto.LndGrpc_Fields as LnGRPC
+
+data PendingChannel
+  = PendingChannel
+      { remoteNodePub :: NodePubKey,
+        channelPoint :: ChannelPoint,
+        capacity :: MSat,
+        localBalance :: MSat,
+        remoteBalance :: MSat,
+        localChanReserveSat :: MSat,
+        remoteChanReserveSat :: MSat
+      }
+  deriving (Eq, Show)
+
+instance
+  FromGrpc
+    PendingChannel
+    LnGRPC.PendingChannelsResponse'PendingChannel
+  where
+  fromGrpc x =
+    PendingChannel
+      <$> fromGrpc
+        (x ^. LnGRPC.remoteNodePub)
+      <*> channelPointParser
+        (x ^. LnGRPC.channelPoint)
+      <*> (toMSat <$> fromGrpc (x ^. LnGRPC.capacity))
+      <*> ( toMSat
+              <$> fromGrpc
+                (x ^. LnGRPC.localBalance)
+          )
+      <*> ( toMSat
+              <$> fromGrpc
+                (x ^. LnGRPC.remoteBalance)
+          )
+      <*> ( toMSat
+              <$> fromGrpc
+                (x ^. LnGRPC.localChanReserveSat)
+          )
+      <*> ( toMSat
+              <$> fromGrpc
+                (x ^. LnGRPC.remoteChanReserveSat)
+          )
diff --git a/src/LndClient/Data/PendingChannels.hs b/src/LndClient/Data/PendingChannels.hs
new file mode 100644
--- /dev/null
+++ b/src/LndClient/Data/PendingChannels.hs
@@ -0,0 +1,40 @@
+{-# LANGUAGE FlexibleInstances #-}
+
+module LndClient.Data.PendingChannels
+  ( PendingChannelsResponse (..),
+  )
+where
+
+import LndClient.Data.ClosedChannel
+import LndClient.Data.ForceClosedChannel
+import LndClient.Data.PendingOpenChannel
+import LndClient.Data.WaitingCloseChannel
+import LndClient.Import
+import qualified Proto.LndGrpc as LnGRPC
+import qualified Proto.LndGrpc_Fields as LnGRPC
+
+data PendingChannelsResponse
+  = PendingChannelsResponse
+      { totalLimboBalance :: MSat,
+        pendingOpenChannels :: [PendingOpenChannel],
+        pendingClosingChannels :: [ClosedChannel],
+        pendingForceClosingChannels :: [ForceClosedChannel],
+        waitingCloseChannels :: [WaitingCloseChannel]
+      }
+  deriving (Eq, Show)
+
+instance FromGrpc PendingChannelsResponse LnGRPC.PendingChannelsResponse where
+  fromGrpc x =
+    PendingChannelsResponse
+      <$> ( toMSat
+              <$> fromGrpc
+                (x ^. LnGRPC.totalLimboBalance)
+          )
+      <*> fromGrpc
+        (x ^. LnGRPC.pendingOpenChannels)
+      <*> fromGrpc
+        (x ^. LnGRPC.pendingClosingChannels)
+      <*> fromGrpc
+        (x ^. LnGRPC.pendingForceClosingChannels)
+      <*> fromGrpc
+        (x ^. LnGRPC.waitingCloseChannels)
diff --git a/src/LndClient/Data/PendingOpenChannel.hs b/src/LndClient/Data/PendingOpenChannel.hs
new file mode 100644
--- /dev/null
+++ b/src/LndClient/Data/PendingOpenChannel.hs
@@ -0,0 +1,41 @@
+module LndClient.Data.PendingOpenChannel
+  ( PendingOpenChannel (..),
+  )
+where
+
+import LndClient.Data.PendingChannel
+import LndClient.Import
+import qualified Proto.LndGrpc as LnGRPC
+import qualified Proto.LndGrpc_Fields as LnGRPC
+
+data PendingOpenChannel
+  = PendingOpenChannel
+      { channel :: PendingChannel,
+        confirmationHeight :: Word32,
+        commitFee :: MSat,
+        commitWeight :: Int64,
+        feePerKw :: MSat
+      }
+  deriving (Eq, Show)
+
+instance
+  FromGrpc
+    PendingOpenChannel
+    LnGRPC.PendingChannelsResponse'PendingOpenChannel
+  where
+  fromGrpc x =
+    PendingOpenChannel
+      <$> fromGrpc
+        (x ^. LnGRPC.channel)
+      <*> fromGrpc
+        (x ^. LnGRPC.confirmationHeight)
+      <*> ( toMSat
+              <$> fromGrpc
+                (x ^. LnGRPC.commitFee)
+          )
+      <*> fromGrpc
+        (x ^. LnGRPC.commitWeight)
+      <*> ( toMSat
+              <$> fromGrpc
+                (x ^. LnGRPC.feePerKw)
+          )
diff --git a/src/LndClient/Data/SendPayment.hs b/src/LndClient/Data/SendPayment.hs
new file mode 100644
--- /dev/null
+++ b/src/LndClient/Data/SendPayment.hs
@@ -0,0 +1,52 @@
+{-# LANGUAGE FlexibleContexts #-}
+
+module LndClient.Data.SendPayment
+  ( SendPaymentRequest (..),
+    SendPaymentResponse (..),
+  )
+where
+
+import Data.ProtoLens.Message
+import LndClient.Import
+import qualified Proto.LndGrpc as LnGRPC
+import qualified Proto.LndGrpc_Fields as LnGRPC
+
+data SendPaymentRequest
+  = SendPaymentRequest
+      { paymentRequest :: PaymentRequest,
+        amt :: MSat
+      }
+  deriving (Eq, Show)
+
+data SendPaymentResponse
+  = SendPaymentResponse
+      { paymentError :: Text,
+        paymentPreimage :: RPreimage,
+        paymentHash :: RHash
+      }
+  deriving (Eq, Show)
+
+instance ToGrpc SendPaymentRequest LnGRPC.SendRequest where
+  toGrpc x =
+    msg
+      <$> toGrpc (amt x)
+      <*> toGrpc (paymentRequest x)
+    where
+      msg gAmt gPaymentRequest =
+        defMessage
+          & LnGRPC.amtMsat .~ gAmt
+          & LnGRPC.paymentRequest .~ gPaymentRequest
+
+instance FromGrpc SendPaymentResponse LnGRPC.SendResponse where
+  fromGrpc x = do
+    res <-
+      SendPaymentResponse
+        <$> fromGrpc (x ^. LnGRPC.paymentError)
+        <*> fromGrpc (x ^. LnGRPC.paymentPreimage)
+        <*> fromGrpc (x ^. LnGRPC.paymentHash)
+    if newRHash (paymentPreimage res) == paymentHash res
+      then Right res
+      else
+        Left . LndError $
+          "paymentPreimage doesn't match paymentHash, error: "
+            <> paymentError res
diff --git a/src/LndClient/Data/SubscribeChannelEvents.hs b/src/LndClient/Data/SubscribeChannelEvents.hs
new file mode 100644
--- /dev/null
+++ b/src/LndClient/Data/SubscribeChannelEvents.hs
@@ -0,0 +1,66 @@
+{-# LANGUAGE FlexibleInstances #-}
+
+module LndClient.Data.SubscribeChannelEvents
+  ( ChannelEventUpdate (..),
+    UpdateChannel (..),
+  )
+where
+
+import Data.Either.Extra (maybeToEither)
+import LndClient.Data.Channel
+import LndClient.Data.ChannelPoint
+import LndClient.Data.CloseChannel
+import LndClient.Import
+import qualified Proto.LndGrpc as LnGRPC
+import qualified Proto.LndGrpc_Fields as LnGRPC
+
+data ChannelEventUpdate
+  = ChannelEventUpdate
+      { channelEvent :: UpdateChannel,
+        eventType :: UpdateType
+      }
+  deriving (Eq, Ord, Show)
+
+data UpdateChannel
+  = ChannelEventUpdateChannelOpenChannel Channel
+  | ChannelEventUpdateChannelClosedChannel ChannelCloseSummary
+  | ChannelEventUpdateChannelActiveChannel ChannelPoint
+  | ChannelEventUpdateChannelInactiveChannel ChannelPoint
+  | ChannelEventUpdateChannelPendingOpenChannel (PendingUpdate 'Funding)
+  deriving (Eq, Ord, Show)
+
+data UpdateType
+  = OPEN_CHANNEL
+  | CLOSED_CHANNEL
+  | ACTIVE_CHANNEL
+  | INACTIVE_CHANNEL
+  | PENDING_OPEN_CHANNEL
+  deriving (Eq, Ord, Show)
+
+instance FromGrpc UpdateType LnGRPC.ChannelEventUpdate'UpdateType where
+  fromGrpc x = case x of
+    LnGRPC.ChannelEventUpdate'OPEN_CHANNEL -> Right OPEN_CHANNEL
+    LnGRPC.ChannelEventUpdate'ACTIVE_CHANNEL -> Right ACTIVE_CHANNEL
+    LnGRPC.ChannelEventUpdate'INACTIVE_CHANNEL -> Right INACTIVE_CHANNEL
+    LnGRPC.ChannelEventUpdate'PENDING_OPEN_CHANNEL -> Right PENDING_OPEN_CHANNEL
+    LnGRPC.ChannelEventUpdate'CLOSED_CHANNEL -> Right CLOSED_CHANNEL
+    LnGRPC.ChannelEventUpdate'UpdateType'Unrecognized v -> Left $ FromGrpcError ("Cannot parse ChannelUpdateType, value:" <> show v)
+
+instance FromGrpc UpdateChannel LnGRPC.ChannelEventUpdate'Channel where
+  fromGrpc x = case x of
+    LnGRPC.ChannelEventUpdate'OpenChannel c -> ChannelEventUpdateChannelOpenChannel <$> fromGrpc c
+    LnGRPC.ChannelEventUpdate'ActiveChannel cp -> ChannelEventUpdateChannelActiveChannel <$> fromGrpc cp
+    LnGRPC.ChannelEventUpdate'InactiveChannel cp -> ChannelEventUpdateChannelActiveChannel <$> fromGrpc cp
+    LnGRPC.ChannelEventUpdate'PendingOpenChannel pa -> ChannelEventUpdateChannelPendingOpenChannel <$> fromGrpc pa
+    LnGRPC.ChannelEventUpdate'ClosedChannel cc -> ChannelEventUpdateChannelClosedChannel <$> fromGrpc cc
+
+instance FromGrpc ChannelEventUpdate LnGRPC.ChannelEventUpdate where
+  fromGrpc x =
+    ChannelEventUpdate
+      <$> join
+        ( fromGrpc
+            <$> maybeToEither
+              (FromGrpcError "Empty channelUpdate")
+              (x ^. LnGRPC.maybe'channel)
+        )
+        <*> fromGrpc (x ^. LnGRPC.type')
diff --git a/src/LndClient/Data/SubscribeInvoices.hs b/src/LndClient/Data/SubscribeInvoices.hs
new file mode 100644
--- /dev/null
+++ b/src/LndClient/Data/SubscribeInvoices.hs
@@ -0,0 +1,29 @@
+{-# LANGUAGE FlexibleContexts #-}
+
+module LndClient.Data.SubscribeInvoices
+  ( SubscribeInvoicesRequest (..),
+  )
+where
+
+import Data.ProtoLens.Message
+import LndClient.Import
+import qualified Proto.LndGrpc as LnGRPC
+import qualified Proto.LndGrpc_Fields as LnGRPC
+
+data SubscribeInvoicesRequest
+  = SubscribeInvoicesRequest
+      { addIndex :: Maybe AddIndex,
+        settleIndex :: Maybe SettleIndex
+      }
+  deriving (Eq, Ord, Show)
+
+instance ToGrpc SubscribeInvoicesRequest LnGRPC.InvoiceSubscription where
+  toGrpc x =
+    msg
+      <$> toGrpc (addIndex x)
+      <*> toGrpc (settleIndex x)
+    where
+      msg gAddIndex gSettleIndex =
+        defMessage
+          & LnGRPC.addIndex .~ gAddIndex
+          & LnGRPC.settleIndex .~ gSettleIndex
diff --git a/src/LndClient/Data/TrackPayment.hs b/src/LndClient/Data/TrackPayment.hs
new file mode 100644
--- /dev/null
+++ b/src/LndClient/Data/TrackPayment.hs
@@ -0,0 +1,29 @@
+{-# LANGUAGE FlexibleContexts #-}
+
+module LndClient.Data.TrackPayment
+  ( TrackPaymentRequest (..),
+  )
+where
+
+import Data.ProtoLens.Message
+import LndClient.Import
+import qualified Proto.RouterGrpc as LnGRPC
+import qualified Proto.RouterGrpc_Fields as LnGRPC
+
+data TrackPaymentRequest
+  = TrackPaymentRequest
+      { paymentHash :: RHash,
+        noInflightUpdates :: Bool
+      }
+  deriving (Eq, Ord, Show)
+
+instance ToGrpc TrackPaymentRequest LnGRPC.TrackPaymentRequest where
+  toGrpc x =
+    msg
+      <$> toGrpc (paymentHash x)
+      <*> toGrpc (noInflightUpdates x)
+    where
+      msg x0 x1 =
+        defMessage
+          & LnGRPC.paymentHash .~ x0
+          & LnGRPC.noInflightUpdates .~ x1
diff --git a/src/LndClient/Data/Type.hs b/src/LndClient/Data/Type.hs
new file mode 100644
--- /dev/null
+++ b/src/LndClient/Data/Type.hs
@@ -0,0 +1,40 @@
+{-# LANGUAGE DeriveLift #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
+
+module LndClient.Data.Type
+  ( LndError (..),
+    LoggingStrategy (..),
+    logDefault,
+    logDebug,
+  )
+where
+
+import Chronos (Timespan)
+import Control.Exception (Exception)
+import LndClient.Import.External
+import Network.HTTP2.Client.Exceptions as E
+
+data LndError
+  = ToGrpcError Text
+  | FromGrpcError Text
+  | LndGrpcError E.ClientError
+  | GrpcUnexpectedResult Text
+  | GrpcEmptyResult
+  | LndError Text
+  | LndEnvError Text
+  | TChanTimeout Text
+  deriving (Eq, Show)
+
+newtype LoggingStrategy
+  = LoggingStrategy
+      (Severity -> Maybe Timespan -> Maybe LndError -> Severity)
+
+logDefault :: LoggingStrategy
+logDefault =
+  LoggingStrategy $ \x _ _ -> x
+
+logDebug :: LoggingStrategy
+logDebug =
+  LoggingStrategy $ \_ _ _ -> DebugS
+
+instance Exception LndError
diff --git a/src/LndClient/Data/UnlockWallet.hs b/src/LndClient/Data/UnlockWallet.hs
new file mode 100644
--- /dev/null
+++ b/src/LndClient/Data/UnlockWallet.hs
@@ -0,0 +1,35 @@
+module LndClient.Data.UnlockWallet
+  ( UnlockWalletRequest (..),
+  )
+where
+
+import Data.ProtoLens.Message
+import LndClient.Import
+import qualified Proto.WalletUnlockerGrpc as LnGRPC
+import qualified Proto.WalletUnlockerGrpc_Fields as LnGRPC
+import Prelude (Show (..))
+
+data UnlockWalletRequest
+  = UnlockWalletRequest
+      { walletPassword :: LndWalletPassword,
+        recoveryWindow :: Int32
+        --
+        --  TODO : channel_backups
+        --
+      }
+  deriving (Eq)
+
+instance Show UnlockWalletRequest where
+  show = const "SECRET"
+
+instance ToGrpc UnlockWalletRequest LnGRPC.UnlockWalletRequest where
+  toGrpc x =
+    msg
+      <$> toGrpc (walletPassword x)
+      <*> toGrpc (recoveryWindow x)
+    where
+      msg :: ByteString -> Int32 -> LnGRPC.UnlockWalletRequest
+      msg gWalletPassword gRecoveryWindow =
+        defMessage
+          & LnGRPC.walletPassword .~ gWalletPassword
+          & LnGRPC.recoveryWindow .~ gRecoveryWindow
diff --git a/src/LndClient/Data/WaitingCloseChannel.hs b/src/LndClient/Data/WaitingCloseChannel.hs
new file mode 100644
--- /dev/null
+++ b/src/LndClient/Data/WaitingCloseChannel.hs
@@ -0,0 +1,37 @@
+module LndClient.Data.WaitingCloseChannel
+  ( WaitingCloseChannel (..),
+  )
+where
+
+import LndClient.Data.PendingChannel
+import LndClient.Import
+import qualified Proto.LndGrpc as LnGRPC
+import qualified Proto.LndGrpc_Fields as LnGRPC
+
+data WaitingCloseChannel
+  = WaitingCloseChannel
+      { channel :: PendingChannel,
+        limboBalance :: MSat
+      }
+  deriving (Eq, Show)
+
+instance
+  FromGrpc
+    WaitingCloseChannel
+    LnGRPC.PendingChannelsResponse'WaitingCloseChannel
+  where
+  fromGrpc x =
+    WaitingCloseChannel
+      <$> ( case pendingChannel of
+              Nothing ->
+                Left $ FromGrpcError "PendingChannel is required"
+              Just this ->
+                fromGrpc this
+          )
+      <*> ( toMSat
+              <$> fromGrpc
+                (x ^. LnGRPC.limboBalance)
+          )
+    where
+      pendingChannel =
+        x ^. LnGRPC.maybe'channel
diff --git a/src/LndClient/Import.hs b/src/LndClient/Import.hs
new file mode 100644
--- /dev/null
+++ b/src/LndClient/Import.hs
@@ -0,0 +1,9 @@
+module LndClient.Import (module Import) where
+
+import LndClient.Class as Import
+import LndClient.Data.Kind as Import
+import LndClient.Data.LndEnv as Import
+import LndClient.Data.Newtype as Import
+import LndClient.Data.Type as Import
+import LndClient.Import.External as Import
+import LndClient.Util as Import
diff --git a/src/LndClient/Import/External.hs b/src/LndClient/Import/External.hs
new file mode 100644
--- /dev/null
+++ b/src/LndClient/Import/External.hs
@@ -0,0 +1,65 @@
+module LndClient.Import.External (module Import) where
+
+import Chronos as Import
+  ( SubsecondPrecision (SubsecondPrecisionAuto),
+    Timespan (..),
+    encodeTimespan,
+    stopwatch,
+  )
+import Control.Concurrent.Async as Import
+  ( Async,
+    async,
+    asyncThreadId,
+    cancel,
+    link,
+    wait,
+    waitAnySTM,
+    withAsync,
+  )
+import Control.Concurrent.STM as Import (check)
+import Control.Concurrent.STM.TChan as Import
+  ( TChan,
+    dupTChan,
+    newBroadcastTChan,
+    readTChan,
+    writeTChan,
+  )
+import Control.Concurrent.STM.TVar as Import (registerDelay)
+import Control.Concurrent.Thread.Delay as Import (delay)
+import Control.Monad.Extra as Import (fromMaybeM)
+import Data.Aeson as Import (FromJSON (..), ToJSON, fromJSON)
+import Data.ByteString as Import (ByteString)
+import Data.Coerce as Import (coerce)
+import Data.List.Extra as Import (enumerate)
+import Data.Text as Import (Text, pack, unpack)
+import Data.Text.Lazy as Import (fromStrict, toStrict)
+import Data.Word as Import (Word64)
+import Database.Persist.Class as Import (PersistField)
+import Database.Persist.Sql as Import (PersistFieldSql)
+import GHC.Generics as Import (Generic, Rep (..))
+import Katip as Import
+  ( ColorStrategy (..),
+    Katip (..),
+    KatipContext (..),
+    KatipContextT,
+    LogContexts,
+    LogEnv (..),
+    Namespace,
+    Severity (..),
+    Verbosity (..),
+    bracketFormat,
+    closeScribes,
+    defaultScribeSettings,
+    initLogEnv,
+    jsonFormat,
+    katipAddContext,
+    logStr,
+    logTM,
+    mkHandleScribeWithFormatter,
+    permitItem,
+    registerScribe,
+    runKatipContextT,
+    sl,
+  )
+import Universum as Import hiding (Text)
+import UnliftIO as Import (MonadUnliftIO (..), UnliftIO (..))
diff --git a/src/LndClient/LndTest.hs b/src/LndClient/LndTest.hs
new file mode 100644
--- /dev/null
+++ b/src/LndClient/LndTest.hs
@@ -0,0 +1,603 @@
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE TemplateHaskell #-}
+
+module LndClient.LndTest
+  ( -- * BTC
+    BtcUrl (..),
+    BtcLogin (..),
+    BtcPassword (..),
+    BtcEnv (..),
+    newBtcClient,
+
+    -- * TestEnv
+    TestEnv,
+    newTestEnv,
+    spawnLinkChannelWatcher,
+    spawnLinkInvoiceWatcher,
+    spawnLinkSingleInvoiceWatcher,
+
+    -- * Class
+    LndTest (..),
+
+    -- * TestUtils
+    mine,
+    mine1,
+    syncWallets,
+    syncPendingChannels,
+    syncPendingChannelsFor,
+    sendTestPayment,
+    receiveClosedChannels,
+    receiveActiveChannel,
+    receiveInvoice,
+
+    -- * LowLevel setup
+    lazyMineInitialCoins,
+    lazyConnectNodes,
+    watchDefaults,
+    cancelAllInvoices,
+    closeAllChannels,
+
+    -- * HighLevel setip
+    setupZeroChannels,
+    setupOneChannel,
+
+    -- * Misc
+    liftLndResult,
+    liftMaybe,
+    purgeChan,
+    ignore2,
+    ignore3,
+  )
+where
+
+import LndClient.Data.AddInvoice as AddInvoice
+  ( AddInvoiceRequest (..),
+    AddInvoiceResponse (..),
+  )
+import LndClient.Data.Channel as Channel (Channel (..))
+import LndClient.Data.ChannelPoint as ChannelPoint (ChannelPoint (..))
+import LndClient.Data.CloseChannel
+  ( ChannelCloseSummary (..),
+    CloseChannelRequest (..),
+  )
+import LndClient.Data.ClosedChannels as ClosedChannels
+import LndClient.Data.GetInfo (GetInfoResponse (..))
+import qualified LndClient.Data.GetInfo as Lnd (GetInfoResponse (..))
+import LndClient.Data.Invoice as Invoice (Invoice (..), InvoiceState (..))
+import LndClient.Data.ListChannels as LC (ListChannelsRequest (..))
+import qualified LndClient.Data.ListInvoices as ListInvoices
+import qualified LndClient.Data.NewAddress as Lnd
+  ( AddressType (..),
+    NewAddressRequest (..),
+    NewAddressResponse (..),
+  )
+import LndClient.Data.OpenChannel as OpenChannel
+  ( OpenChannelRequest (..),
+  )
+import LndClient.Data.Peer
+  ( ConnectPeerRequest (..),
+    LightningAddress (..),
+  )
+import LndClient.Data.PendingChannels (PendingChannelsResponse (..))
+import LndClient.Data.SendPayment as SendPayment
+  ( SendPaymentRequest (..),
+  )
+import LndClient.Data.SubscribeChannelEvents
+import LndClient.Data.SubscribeInvoices
+  ( SubscribeInvoicesRequest (..),
+  )
+import LndClient.Import
+import qualified LndClient.RPC.Katip as Lnd
+import LndClient.Watcher as Watcher
+import qualified Network.Bitcoin as BTC (Client, getClient)
+import qualified Network.Bitcoin.BlockChain as BTC (getBlockCount)
+import qualified Network.Bitcoin.Mining as BTC (generateToAddress)
+
+newtype BtcUrl = BtcUrl String
+
+newtype BtcLogin = BtcLogin ByteString
+
+newtype BtcPassword = BtcPassword ByteString
+
+data BtcEnv
+  = BtcEnv
+      { btcUrl :: BtcUrl,
+        btcLogin :: BtcLogin,
+        btcPassword :: BtcPassword
+      }
+
+data TestEnv
+  = TestEnv
+      { testLndEnv :: LndEnv,
+        testNodeLocation :: NodeLocation,
+        testChannelWatcher :: Watcher () ChannelEventUpdate,
+        testInvoiceWatcher :: Watcher SubscribeInvoicesRequest Invoice,
+        testSingleInvoiceWatcher :: Watcher RHash Invoice
+      }
+
+uniquePairs :: (Ord a, Enum a, Bounded a) => [(a, a)]
+uniquePairs = [(x0, x1) | x0 <- enumerate, x1 <- enumerate, x0 < x1]
+
+newBtcClient :: MonadIO m => BtcEnv -> m BTC.Client
+newBtcClient x =
+  liftIO $
+    BTC.getClient
+      (coerce $ btcUrl x)
+      (coerce $ btcLogin x)
+      (coerce $ btcPassword x)
+
+newTestEnv ::
+  ( KatipContext m,
+    MonadUnliftIO m
+  ) =>
+  LndEnv ->
+  NodeLocation ->
+  m TestEnv
+newTestEnv lnd loc = do
+  cw <- spawnLinkChannelWatcher lnd
+  iw <- spawnLinkInvoiceWatcher lnd
+  siw <- spawnLinkSingleInvoiceWatcher lnd
+  pure $
+    TestEnv
+      { testLndEnv = lnd,
+        testNodeLocation = loc,
+        testChannelWatcher = cw,
+        testInvoiceWatcher = iw,
+        testSingleInvoiceWatcher = siw
+      }
+
+class
+  ( KatipContext m,
+    MonadUnliftIO m,
+    Ord owner,
+    Enum owner,
+    Bounded owner,
+    Show owner
+  ) =>
+  LndTest m owner where
+  getBtcClient :: owner -> m BTC.Client
+  getTestEnv :: owner -> m TestEnv
+  getLndEnv :: owner -> m LndEnv
+  getLndEnv = (testLndEnv <$>) . getTestEnv
+  getSev :: owner -> Severity -> m Severity
+  getSev owner sev = do
+    env <- testLndEnv <$> getTestEnv owner
+    pure $ newSev env sev
+  getNodeLocation :: owner -> m NodeLocation
+  getNodeLocation = (testNodeLocation <$>) . getTestEnv
+  getChannelTChan :: owner -> m (TChan ((), ChannelEventUpdate))
+  getChannelTChan =
+    (Watcher.dupLndTChan =<<)
+      . (testChannelWatcher <$>)
+      . getTestEnv
+  getInvoiceTChan :: owner -> m (TChan (SubscribeInvoicesRequest, Invoice))
+  getInvoiceTChan =
+    (Watcher.dupLndTChan =<<)
+      . (testInvoiceWatcher <$>)
+      . getTestEnv
+  getSingleInvoiceTChan :: owner -> m (TChan (RHash, Invoice))
+  getSingleInvoiceTChan =
+    (Watcher.dupLndTChan =<<)
+      . (testSingleInvoiceWatcher <$>)
+      . getTestEnv
+
+  --
+  -- TODO : embed getSingleInvoiceTChan here
+  -- because it's really not used separately
+  --
+  watchSingleInvoice :: owner -> RHash -> m ()
+  watchSingleInvoice owner rh = do
+    env <- getTestEnv owner
+    Watcher.watch (testSingleInvoiceWatcher env) rh
+
+walletAddress :: LndTest m owner => owner -> m Text
+walletAddress owner = do
+  lnd <- getLndEnv owner
+  Lnd.NewAddressResponse x <-
+    liftLndResult
+      =<< Lnd.newAddress
+        lnd
+        (Lnd.NewAddressRequest Lnd.WITNESS_PUBKEY_HASH Nothing)
+  pure x
+
+lazyMineInitialCoins :: forall m owner. LndTest m owner => Proxy owner -> m ()
+lazyMineInitialCoins = const $ do
+  mapM_ (liftLndResult <=< Lnd.lazyInitWallet <=< getLndEnv) xs
+  bc <- getBtcClient someone
+  h <- liftIO $ BTC.getBlockCount bc
+  -- reward coins are spendable only after 100 blocks
+  when (h < 101 + numOwners) $ do
+    mapM_ (mine 1) xs
+    mine 101 someone
+  where
+    xs = enumerate :: [owner]
+    someone = minBound :: owner
+    numOwners = fromIntegral $ length xs
+
+lazyConnectNodes :: forall m owner. LndTest m owner => Proxy owner -> m ()
+lazyConnectNodes = const $ mapM_ this uniquePairs
+  where
+    this :: (owner, owner) -> m ()
+    this (owner0, owner1) = do
+      testEnvOwner0 <- getTestEnv owner0
+      Lnd.GetInfoResponse pubKeyOwner0 _ _ <-
+        liftLndResult =<< Lnd.getInfo (testLndEnv testEnvOwner0)
+      let req =
+            ConnectPeerRequest
+              { addr =
+                  LightningAddress
+                    { pubkey = pubKeyOwner0,
+                      host = testNodeLocation testEnvOwner0
+                    },
+                perm = False
+              }
+      lndEnvOwner1 <- getLndEnv owner1
+      liftLndResult =<< Lnd.lazyConnectPeer lndEnvOwner1 req
+
+watchDefaults :: forall m owner. LndTest m owner => Proxy owner -> m ()
+watchDefaults = const $ mapM_ this (enumerate :: [owner])
+  where
+    this owner = do
+      testEnv <- getTestEnv owner
+      Watcher.watchUnit $ testChannelWatcher testEnv
+      Watcher.watch (testInvoiceWatcher testEnv) iReq
+    iReq =
+      --
+      -- TODO : this is related to LND bug
+      -- https://github.com/lightningnetwork/lnd/issues/2469
+      --
+      SubscribeInvoicesRequest (Just $ AddIndex 1) Nothing
+
+mine :: forall m owner. LndTest m owner => Int -> owner -> m ()
+mine blocks owner = do
+  btcAddr <- walletAddress owner
+  bc <- getBtcClient owner
+  sev <- getSev owner InfoS
+  $(logTM) sev $ logStr $
+    ("Mining " :: Text)
+      <> show blocks
+      <> " blocks to "
+      <> show owner
+      <> " wallet"
+  void . liftIO $
+    BTC.generateToAddress
+      bc
+      blocks
+      btcAddr
+      Nothing
+  liftLndResult =<< syncWallets (Proxy :: Proxy owner)
+
+mine1 :: forall m owner. LndTest m owner => Proxy owner -> m ()
+mine1 = const $ mine 1 (minBound :: owner)
+
+liftLndResult :: MonadIO m => Either LndError a -> m a
+liftLndResult (Right x) =
+  pure x
+liftLndResult (Left x) =
+  liftIO $ fail $ "LiftLndResult failed " <> show x
+
+syncWallets ::
+  forall m owner.
+  LndTest m owner =>
+  Proxy owner ->
+  m (Either LndError ())
+syncWallets = const $ this 0
+  where
+    this 30 = do
+      let msg = "SyncWallets attempt limit exceeded"
+      sev <- getSev (minBound :: owner) ErrorS
+      $(logTM) sev $ logStr msg
+      pure . Left $ LndError msg
+    this (attempt :: Int) = do
+      sev <- getSev (minBound :: owner) InfoS
+      $(logTM) sev "SyncWallets is running"
+      rs <- mapM (Lnd.getInfo <=< getLndEnv) (enumerate :: [owner])
+      if all isInSync rs
+        then pure $ Right ()
+        else liftIO (delay 1000000) >> this (attempt + 1)
+    isInSync = \case
+      Left {} -> False
+      Right x -> Lnd.syncedToChain x
+
+syncPendingChannels :: forall m owner. LndTest m owner => Proxy owner -> m ()
+syncPendingChannels =
+  const $ mapM_ (liftLndResult <=< syncPendingChannelsFor) (enumerate :: [owner])
+
+syncPendingChannelsFor ::
+  forall m owner.
+  LndTest m owner =>
+  owner ->
+  m (Either LndError ())
+syncPendingChannelsFor owner = this 0
+  where
+    this 30 = do
+      let msg =
+            "SyncPendingChannelsFor "
+              <> show owner
+              <> " attempt limit exceeded"
+      sev <- getSev owner ErrorS
+      $(logTM) sev $ logStr msg
+      pure . Left $ LndError msg
+    this (attempt :: Int) = do
+      sev <- getSev owner InfoS
+      $(logTM) sev $ logStr $
+        "SyncPendingChannelsFor "
+          <> (show owner :: Text)
+          <> " is running"
+      res <- Lnd.pendingChannels =<< getLndEnv owner
+      case res of
+        Left {} -> this (attempt + 1)
+        Right (PendingChannelsResponse _ x0 x1 x2 x3) ->
+          if null x0
+            && null x1
+            && null x2
+            && null x3
+            then pure $ Right ()
+            else mine1 (Proxy :: Proxy owner) >> this (attempt + 1)
+
+receiveClosedChannels ::
+  forall m owner.
+  LndTest m owner =>
+  Proxy owner ->
+  [ChannelPoint] ->
+  m (Either LndError ())
+receiveClosedChannels po = this 0
+  where
+    this _ [] =
+      pure $ Right ()
+    this 30 _ =
+      pure
+        $ Left
+        $ LndError "receiveClosedChannels - exceeded"
+    this (attempt :: Integer) cps = do
+      let owners = enumerate :: [owner]
+      xs <- rights <$> mapM getOwnersCloseCPs owners
+      let filteredCps = filter (checkTwiceCP $ concat xs) cps
+      if null filteredCps
+        then pure $ Right ()
+        else mine1 po >> liftIO (delay 1000000) >> this (attempt + 1) filteredCps
+    checkTwiceCP :: [ChannelPoint] -> ChannelPoint -> Bool
+    checkTwiceCP cps cp = length (filter (cp ==) cps) < 2
+    getOwnersCloseCPs :: owner -> m (Either LndError [ChannelPoint])
+    getOwnersCloseCPs o = do
+      lnd <- getLndEnv o
+      ccs <- liftLndResult =<< Lnd.closedChannels lnd ClosedChannels.defReq
+      pure $ Right $ chPoint <$> ccs
+
+cancelAllInvoices ::
+  forall m owner.
+  LndTest m owner =>
+  Proxy owner ->
+  m ()
+cancelAllInvoices =
+  const $ mapM_ (this 0) (enumerate :: [owner])
+  where
+    listReq =
+      ListInvoices.ListInvoiceRequest
+        { ListInvoices.pendingOnly = False,
+          ListInvoices.indexOffset = AddIndex 0,
+          ListInvoices.numMaxInvoices = 0,
+          ListInvoices.reversed = False
+        }
+    this :: Int -> owner -> m ()
+    this 30 owner =
+      error $ "CancelAllInvoices attempt limit exceeded for " <> show owner
+    this attempt owner = do
+      lnd <- getLndEnv owner
+      let getInvoices =
+            filter
+              ( \x ->
+                  Invoice.state x
+                    `elem` [ Invoice.OPEN,
+                             Invoice.ACCEPTED
+                           ]
+              )
+              . ListInvoices.invoices
+              <$> (liftLndResult =<< Lnd.listInvoices lnd listReq)
+      is0 <- getInvoices
+      res <- mapM (Lnd.cancelInvoice lnd) (Invoice.rHash <$> is0)
+      is1 <- getInvoices
+      if all isRight res && null is1
+        then pure ()
+        else liftIO (delay 1000000) >> this (attempt + 1) owner
+
+closeAllChannels :: forall m owner. LndTest m owner => Proxy owner -> m ()
+closeAllChannels po = do
+  cancelAllInvoices po
+  mapM_ (this 0) uniquePairs
+  where
+    this :: Int -> (owner, owner) -> m ()
+    this 30 owners =
+      error $ "CloseAllChannels - limit exceeded for " <> show owners
+    this attempt (owner0, owner1) = do
+      sev <- getSev owner0 InfoS
+      $(logTM) sev "CloseAllChannels - closing channels"
+      lnd0 <- getLndEnv owner0
+      peerLocation <- getNodeLocation owner1
+      GetInfoResponse peerPubKey _ _ <-
+        liftLndResult =<< Lnd.getInfo =<< getLndEnv owner1
+      let getChannels =
+            liftLndResult
+              =<< Lnd.listChannels
+                lnd0
+                (ListChannelsRequest False False False False (Just peerPubKey))
+      cs0 <- getChannels
+      let cps = Channel.channelPoint <$> cs0
+      res <-
+        mapM
+          ( \cp ->
+              Lnd.closeChannelSync
+                lnd0
+                (ConnectPeerRequest (LightningAddress peerPubKey peerLocation) False)
+                (CloseChannelRequest cp False Nothing Nothing Nothing)
+          )
+          cps
+      cs1 <- getChannels
+      if all isRight res && null cs1
+        then liftLndResult =<< receiveClosedChannels po cps
+        else liftIO (delay 1000000) >> this (attempt + 1) (owner0, owner1)
+
+receiveActiveChannel ::
+  LndTest m owner =>
+  Proxy owner ->
+  ChannelPoint ->
+  TChan ((), ChannelEventUpdate) ->
+  m (Either LndError ())
+receiveActiveChannel po = this 0
+  where
+    this (attempt :: Integer) cp cq =
+      if attempt > 30
+        then pure $ Left $ LndError "receiveActiveChannel - exceeded"
+        else do
+          x <- readTChanTimeout (MicroSecondsDelay 1000000) cq
+          case channelEvent . snd <$> x of
+            Just (ChannelEventUpdateChannelActiveChannel gcp) ->
+              if cp == gcp
+                then pure $ Right ()
+                else mine1 po >> this (attempt + 1) cp cq
+            _ ->
+              mine1 po >> this (attempt + 1) cp cq
+
+setupZeroChannels :: LndTest m owner => Proxy owner -> m ()
+setupZeroChannels x = do
+  lazyMineInitialCoins x
+  lazyConnectNodes x
+  watchDefaults x
+  closeAllChannels x
+  syncPendingChannels x
+
+setupOneChannel ::
+  forall m owner.
+  LndTest m owner =>
+  owner ->
+  owner ->
+  m ChannelPoint
+setupOneChannel ownerFrom ownerTo = do
+  lndFrom <- getLndEnv ownerFrom
+  lndTo <- getLndEnv ownerTo
+  mq <- getChannelTChan ownerTo
+  cq <- getChannelTChan ownerFrom
+  --
+  -- Open channel from Customer to Merchant
+  --
+  sev <- getSev ownerFrom InfoS
+  $(logTM) sev "SetupOneChannel - opening channel"
+  GetInfoResponse merchantPubKey _ _ <-
+    liftLndResult =<< Lnd.getInfo lndTo
+  let openChannelRequest =
+        OpenChannel.OpenChannelRequest
+          { OpenChannel.nodePubkey = merchantPubKey,
+            OpenChannel.localFundingAmount = MSat 200000000,
+            OpenChannel.pushSat = Just $ MSat 10000000,
+            OpenChannel.targetConf = Nothing,
+            OpenChannel.satPerByte = Nothing,
+            OpenChannel.private = Nothing,
+            OpenChannel.minHtlcMsat = Nothing,
+            OpenChannel.remoteCsvDelay = Nothing,
+            OpenChannel.minConfs = Nothing,
+            OpenChannel.spendUnconfirmed = Nothing,
+            OpenChannel.closeAddress = Nothing
+          }
+  cp <-
+    liftLndResult
+      =<< Lnd.openChannelSync lndFrom openChannelRequest
+  let po = Proxy :: Proxy owner
+  liftLndResult =<< receiveActiveChannel po cp mq
+  liftLndResult =<< receiveActiveChannel po cp cq
+  --
+  -- TODO : these invoices are added and settled to
+  -- raise invoice index to 1 to be able to receive
+  -- notifications about all next invoices
+  -- remove when LND bug will be fixed
+  -- https://github.com/lightningnetwork/lnd/issues/2469
+  --
+  () <- sendTestPayment (MSat 1000000) ownerFrom ownerTo
+  () <- sendTestPayment (MSat 1000000) ownerTo ownerFrom
+  $(logTM) sev "SetupOneChannel - finished"
+  pure cp
+
+sendTestPayment :: LndTest m owner => MSat -> owner -> owner -> m ()
+sendTestPayment amt0 sender0 recepient0 = do
+  sender <- getLndEnv sender0
+  recepient <- getLndEnv recepient0
+  let addInvoiceRequest =
+        AddInvoice.AddInvoiceRequest
+          { AddInvoice.memo = Just "HELLO",
+            AddInvoice.valueMsat = amt0,
+            AddInvoice.expiry = Just $ Seconds 1000
+          }
+  invoice <-
+    liftLndResult =<< Lnd.addInvoice recepient addInvoiceRequest
+  let payReq =
+        SendPayment.SendPaymentRequest
+          { SendPayment.paymentRequest =
+              AddInvoice.paymentRequest invoice,
+            SendPayment.amt = amt0
+          }
+  void . liftLndResult =<< Lnd.sendPayment sender payReq
+
+receiveInvoice ::
+  ( MonadUnliftIO m,
+    KatipContext m
+  ) =>
+  RHash ->
+  Invoice.InvoiceState ->
+  TChan (a, Invoice) ->
+  m (Either LndError ())
+receiveInvoice rh s q = do
+  mx0 <- readTChanTimeout (MicroSecondsDelay 30000000) q
+  let mx = snd <$> mx0
+  $(logTM) DebugS $ logStr $
+    "receiveInvoice - " <> (show mx :: Text)
+  case (\x -> Invoice.rHash x == rh && Invoice.state x == s) <$> mx of
+    Just True -> return $ Right ()
+    Just False -> receiveInvoice rh s q
+    Nothing -> return . Left $ TChanTimeout "receiveInvoice"
+
+liftMaybe :: MonadIO m => String -> Maybe a -> m a
+liftMaybe msg mx =
+  case mx of
+    Just x -> pure x
+    Nothing -> liftIO $ fail msg
+
+purgeChan :: MonadUnliftIO m => TChan a -> m ()
+purgeChan chan = do
+  x <- readTChanTimeout (MicroSecondsDelay 500000) chan
+  when (isJust x) $ purgeChan chan
+
+ignore2 :: Monad m => a -> b -> m ()
+ignore2 _ _ = pure ()
+
+ignore3 :: Monad m => a -> b -> c -> m ()
+ignore3 _ _ _ = pure ()
+
+spawnLinkChannelWatcher ::
+  (KatipContext m, MonadUnliftIO m) =>
+  LndEnv ->
+  m (Watcher () ChannelEventUpdate)
+spawnLinkChannelWatcher lnd =
+  Watcher.spawnLinkUnit
+    lnd
+    Lnd.subscribeChannelEventsChan
+    ignore2
+
+spawnLinkInvoiceWatcher ::
+  (KatipContext m, MonadUnliftIO m) =>
+  LndEnv ->
+  m (Watcher SubscribeInvoicesRequest Invoice)
+spawnLinkInvoiceWatcher lnd =
+  Watcher.spawnLink
+    lnd
+    Lnd.subscribeInvoicesChan
+    ignore3
+
+spawnLinkSingleInvoiceWatcher ::
+  (KatipContext m, MonadUnliftIO m) =>
+  LndEnv ->
+  m (Watcher RHash Invoice)
+spawnLinkSingleInvoiceWatcher lnd =
+  Watcher.spawnLink
+    lnd
+    Lnd.subscribeSingleInvoiceChan
+    ignore3
diff --git a/src/LndClient/QRCode.hs b/src/LndClient/QRCode.hs
new file mode 100644
--- /dev/null
+++ b/src/LndClient/QRCode.hs
@@ -0,0 +1,53 @@
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
+
+module LndClient.QRCode
+  ( qrGeneric,
+    qrPixels,
+    qrPngDataUrl,
+    qrDefOpts,
+    QROpts (..),
+    QRPixels (..),
+    QRPngDataUrl (..),
+  )
+where
+
+import Codec.Picture (Image (..), Pixel8)
+import Codec.QRCode as QR
+  ( ErrorLevel (L),
+    QRImage,
+    TextEncoding (Iso8859_1OrUtf8WithoutECI),
+    ToText,
+    defaultQRCodeOptions,
+    encodeAutomatic,
+  )
+import Codec.QRCode.JuicyPixels (toImage, toPngDataUrlT)
+import LndClient.Import.External
+
+newtype QRPixels = QRPixels (Image Pixel8)
+
+newtype QRPngDataUrl = QRPngDataUrl Text
+  deriving (PersistField, PersistFieldSql, Show, Eq)
+
+data QROpts
+  = QROpts
+      { qrBorder :: Int,
+        qrScale :: Int
+      }
+
+qrDefOpts :: QROpts
+qrDefOpts =
+  QROpts
+    { qrBorder = 4,
+      qrScale = 5
+    }
+
+qrGeneric :: QR.ToText a => a -> Maybe QRImage
+qrGeneric = encodeAutomatic (defaultQRCodeOptions L) Iso8859_1OrUtf8WithoutECI
+
+qrPixels :: QR.ToText a => QROpts -> a -> Maybe QRPixels
+qrPixels opts x = QRPixels . toImage (qrBorder opts) (qrScale opts) <$> qrGeneric x
+
+qrPngDataUrl :: QR.ToText a => QROpts -> a -> Maybe QRPngDataUrl
+qrPngDataUrl opts x =
+  QRPngDataUrl . toStrict . toPngDataUrlT (qrBorder opts) (qrScale opts)
+    <$> qrGeneric x
diff --git a/src/LndClient/RPC/Generic.hs b/src/LndClient/RPC/Generic.hs
new file mode 100644
--- /dev/null
+++ b/src/LndClient/RPC/Generic.hs
@@ -0,0 +1,170 @@
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE DeriveGeneric #-}
+{-# LANGUAGE GADTs #-}
+{-# LANGUAGE OverloadedLists #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeFamilies #-}
+
+module LndClient.RPC.Generic
+  ( grpcSyncSilent,
+    grpcSyncKatip,
+    grpcSubscribeSilent,
+    grpcSubscribeKatip,
+    RpcName (..),
+  )
+where
+
+import Data.ProtoLens.Service.Types (HasMethod, HasMethodImpl (..))
+import qualified Data.Text.Lazy as T
+import GHC.TypeLits
+import LndClient.Import
+import LndGrpc.Client
+import qualified Network.GRPC.HTTP2.ProtoLens as PL
+
+data RpcName
+  = UnlockWallet
+  | InitWallet
+  | LazyUnlockWallet
+  | LazyInitWallet
+  | NewAddress
+  | AddInvoice
+  | AddHodlInvoice
+  | CancelInvoice
+  | SettleInvoice
+  | SubscribeInvoices
+  | SubscribeChannelEvents
+  | SubscribeHtlcEvents
+  | OpenChannelSync
+  | OpenChannel
+  | ListChannels
+  | CloseChannel
+  | ListPeers
+  | ConnectPeer
+  | GetInfo
+  | SendPayment
+  | WaitForGrpc
+  | DecodePayReq
+  | LookupInvoice
+  | EnsureHodlInvoice
+  | TrackPaymentV2
+  | PendingChannels
+  | ClosedChannels
+  | ListInvoices
+  | SubscribeSingleInvoice
+  deriving (Generic)
+
+instance ToJSON RpcName
+
+showElapsedSeconds :: Timespan -> Text
+showElapsedSeconds = encodeTimespan SubsecondPrecisionAuto
+
+grpcSyncSilent ::
+  ( MonadIO m,
+    ToGrpc a gA,
+    FromGrpc b gB,
+    HasMethod s rm,
+    gA ~ MethodInput s rm,
+    gB ~ MethodOutput s rm
+  ) =>
+  PL.RPC s (rm :: Symbol) ->
+  LndEnv ->
+  a ->
+  m (Either LndError b)
+grpcSyncSilent rpc env req =
+  case toGrpc req of
+    Right gReq -> join . second fromGrpc <$> runUnary rpc env gReq
+    Left err -> return $ Left err
+
+grpcSyncKatip ::
+  ( MonadIO m,
+    KatipContext m,
+    ToGrpc a gA,
+    FromGrpc b gB,
+    HasMethod s rm,
+    gA ~ MethodInput s rm,
+    gB ~ MethodOutput s rm,
+    Show a,
+    Show b
+  ) =>
+  PL.RPC s (rm :: Symbol) ->
+  LndEnv ->
+  a ->
+  m (Either LndError b)
+grpcSyncKatip rpc env req =
+  katipAddContext (sl "RpcName" (T.pack $ symbolVal rpc))
+    $ katipAddContext (sl "RpcRequest" (show req :: Text))
+    $ katipAddLndContext env
+    $ do
+      $(logTM) (newSev env InfoS) "RPC is running"
+      (ts, res) <-
+        liftIO $ stopwatch $
+          grpcSyncSilent rpc env req
+      katipAddContext (sl "ElapsedSeconds" (showElapsedSeconds ts)) $
+        case res of
+          Left e ->
+            katipAddContext (sl "RpcResponse" (show e :: Text)) $
+              $(logTM) (newSeverity env ErrorS (Just ts) (Just e)) "RPC failed"
+          Right x ->
+            katipAddContext (sl "RpcResponse" (show x :: Text)) $
+              $(logTM) (newSeverity env InfoS (Just ts) Nothing) "RPC succeded"
+      pure res
+
+grpcSubscribeSilent ::
+  ( MonadIO m,
+    ToGrpc a gA,
+    FromGrpc b gB,
+    HasMethod s rm,
+    gA ~ MethodInput s rm,
+    gB ~ MethodOutput s rm
+  ) =>
+  PL.RPC s (rm :: Symbol) ->
+  (b -> IO ()) ->
+  LndEnv ->
+  a ->
+  m (Either LndError ())
+grpcSubscribeSilent rpc handler env req =
+  case toGrpc req of
+    Right grpcReq -> second (const ()) <$> runStreamServer rpc env grpcReq gHandler
+    Left err -> return $ Left err
+  where
+    gHandler _ x =
+      case fromGrpc x of
+        Right b -> liftIO $ handler b
+        Left _ -> return ()
+
+grpcSubscribeKatip ::
+  ( MonadIO m,
+    KatipContext m,
+    ToGrpc a gA,
+    FromGrpc b gB,
+    HasMethod s rm,
+    Show a,
+    gA ~ MethodInput s rm,
+    gB ~ MethodOutput s rm
+  ) =>
+  PL.RPC s (rm :: Symbol) ->
+  (b -> IO ()) ->
+  LndEnv ->
+  a ->
+  m (Either LndError ())
+grpcSubscribeKatip rpc handler env req =
+  katipAddContext (sl "RpcName" (T.pack $ symbolVal rpc))
+    $ katipAddContext (sl "RpcRequest" (show req :: Text))
+    $ katipAddLndContext env
+    $ do
+      $(logTM) (newSev env InfoS) "RPC is running"
+      (ts, res) <-
+        liftIO $ stopwatch $ grpcSubscribeSilent rpc handler env req
+      katipAddContext (sl "ElapsedSeconds" (showElapsedSeconds ts))
+        $ uncurry katipAddContext
+        $ case res of
+          Left e ->
+            ( sl "RpcResponse" (show e :: Text),
+              $(logTM) (newSeverity env ErrorS (Just ts) (Just e)) "RPC failed"
+            )
+          Right x ->
+            ( sl "RpcResponse" (show x :: Text),
+              $(logTM) (newSeverity env InfoS (Just ts) Nothing) "RPC succeded"
+            )
+      pure res
diff --git a/src/LndClient/RPC/Katip.hs b/src/LndClient/RPC/Katip.hs
new file mode 100644
--- /dev/null
+++ b/src/LndClient/RPC/Katip.hs
@@ -0,0 +1,164 @@
+{-# LANGUAGE TemplateHaskell #-}
+
+-- | List of functions, used to communicate with LND via gRPC.
+-- Method names are corresponding to gRPC method names, see LND gRPC api docs <https://api.lightning.community>.
+-- Katip is used for function calls logging.
+module LndClient.RPC.Katip
+  ( waitForGrpc,
+    unlockWallet,
+    lazyUnlockWallet,
+    lazyInitWallet,
+    newAddress,
+    addInvoice,
+    addHodlInvoice,
+    cancelInvoice,
+    settleInvoice,
+    initWallet,
+    openChannelSync,
+    openChannel,
+    listChannels,
+    closeChannel,
+    listPeers,
+    connectPeer,
+    lazyConnectPeer,
+    sendPayment,
+    getInfo,
+    subscribeInvoices,
+    subscribeInvoicesChan,
+    subscribeChannelEvents,
+    subscribeChannelEventsChan,
+    subscribeHtlcEvents,
+    decodePayReq,
+    lookupInvoice,
+    ensureHodlInvoice,
+    trackPaymentV2,
+    trackPaymentV2Chan,
+    pendingChannels,
+    closedChannels,
+    closeChannelSync,
+    listInvoices,
+    subscribeSingleInvoice,
+    subscribeSingleInvoiceChan,
+  )
+where
+
+import Data.ProtoLens.Message
+import LndClient.Data.AddHodlInvoice as AddHodlInvoice (AddHodlInvoiceRequest (..))
+import LndClient.Data.AddInvoice as AddInvoice (AddInvoiceResponse (..))
+import qualified LndClient.Data.Channel as Channel
+import LndClient.Data.CloseChannel as CloseChannel (CloseChannelRequest (..))
+import LndClient.Data.Invoice as Invoice (Invoice (..))
+import LndClient.Data.ListChannels as ListChannels (ListChannelsRequest (..))
+import LndClient.Data.Peer (ConnectPeerRequest (..))
+import LndClient.Import
+import LndClient.RPC.Generic
+import LndClient.RPC.TH
+import LndClient.Util as Util
+
+$(mkRpc RpcKatip)
+
+waitForGrpc ::
+  (KatipContext m) =>
+  LndEnv ->
+  m (Either LndError ())
+waitForGrpc env =
+  katipAddContext (sl "RpcName" WaitForGrpc) $ this 30
+  where
+    this (x :: Int) =
+      if x > 0
+        then do
+          $(logTM) (newSev env InfoS) "Waiting for GRPC..."
+          res <- getInfo $ env {envLndLogStrategy = logDebug}
+          if isRight res
+            then return $ Right ()
+            else liftIO (delay 1000000) >> this (x - 1)
+        else do
+          let msg = "waitForGrpc attempt limit exceeded"
+          $(logTM) (newSev env ErrorS) $ logStr msg
+          return . Left $ LndError msg
+
+lazyUnlockWallet ::
+  (KatipContext m) =>
+  LndEnv ->
+  m (Either LndError ())
+lazyUnlockWallet env =
+  katipAddContext (sl "RpcName" LazyUnlockWallet) $ do
+    $(logTM) (newSev env InfoS) "RPC is running..."
+    unlocked <- isRight <$> getInfo (env {envLndLogStrategy = logDebug})
+    if unlocked
+      then do
+        $(logTM) (newSev env InfoS) "Wallet is already unlocked, doing nothing"
+        return $ Right ()
+      else unlockWallet env
+
+lazyInitWallet ::
+  (KatipContext m) =>
+  LndEnv ->
+  m (Either LndError ())
+lazyInitWallet env =
+  katipAddContext (sl "RpcName" LazyInitWallet) $ do
+    $(logTM) (newSev env InfoS) "RPC is running..."
+    unlockRes <-
+      lazyUnlockWallet $
+        env {envLndLogStrategy = logDebug}
+    if isRight unlockRes
+      then do
+        $(logTM) (newSev env InfoS) "Wallet is already initialized, doing nothing"
+        return unlockRes
+      else initWallet env
+
+ensureHodlInvoice ::
+  (KatipContext m) =>
+  LndEnv ->
+  AddHodlInvoiceRequest ->
+  m (Either LndError AddInvoiceResponse)
+ensureHodlInvoice env req =
+  katipAddContext (sl "RpcName" EnsureHodlInvoice) $ do
+    $(logTM) (newSev env InfoS) "RPC is running..."
+    let rh = AddHodlInvoice.hash req
+    _ <- addHodlInvoice (env {envLndLogStrategy = logDebug}) req
+    res <- lookupInvoice env rh
+    return $ case res of
+      Left x -> Left x
+      Right x ->
+        Right $
+          AddInvoice.AddInvoiceResponse
+            { AddInvoice.rHash = rh,
+              AddInvoice.paymentRequest = Invoice.paymentRequest x,
+              AddInvoice.addIndex = Invoice.addIndex x
+            }
+
+closeChannelSync ::
+  (KatipContext m, MonadUnliftIO m) =>
+  LndEnv ->
+  ConnectPeerRequest ->
+  CloseChannelRequest ->
+  m (Either LndError ())
+closeChannelSync env conn req = do
+  cs0 <- listChannels env (ListChannels.ListChannelsRequest False False False False Nothing)
+  case cs0 of
+    Left err -> pure $ Left err
+    Right x ->
+      case filter (\ch -> channelPoint req == Channel.channelPoint ch) x of
+        [] -> do
+          $(logTM) (newSev env WarningS) "Cannot close channel that is not active"
+          return $ Right ()
+        _ -> do
+          mVar <- newEmptyMVar
+          closeChannelRecursive mVar 10
+  where
+    closeChannelRecursive _ (0 :: Int) = do
+      $(logTM) (newSev env ErrorS) "Channel couldn't be closed."
+      return $ Left $ LndError "Cannot close channel"
+    closeChannelRecursive mVar0 n = do
+      void $ lazyConnectPeer env conn
+      void $ Util.spawnLink $
+        closeChannel
+          (void . tryPutMVar mVar0)
+          env
+          req
+      liftIO $ delay 1000000
+      upd <- tryTakeMVar mVar0
+      case upd of
+        Just _ -> return $ Right ()
+        Nothing -> closeChannelRecursive mVar0 (n -1)
diff --git a/src/LndClient/RPC/Silent.hs b/src/LndClient/RPC/Silent.hs
new file mode 100644
--- /dev/null
+++ b/src/LndClient/RPC/Silent.hs
@@ -0,0 +1,143 @@
+{-# LANGUAGE TemplateHaskell #-}
+
+-- | List of functions, used to communicate with LND via gRPC.
+-- Method names are corresponding to gRPC method names, see LND gRPC api docs <https://api.lightning.community>.
+module LndClient.RPC.Silent
+  ( waitForGrpc,
+    unlockWallet,
+    lazyUnlockWallet,
+    lazyInitWallet,
+    newAddress,
+    addInvoice,
+    addHodlInvoice,
+    cancelInvoice,
+    settleInvoice,
+    initWallet,
+    openChannelSync,
+    openChannel,
+    listChannels,
+    closeChannel,
+    listPeers,
+    connectPeer,
+    lazyConnectPeer,
+    sendPayment,
+    getInfo,
+    subscribeInvoices,
+    subscribeInvoicesChan,
+    subscribeChannelEvents,
+    subscribeChannelEventsChan,
+    subscribeHtlcEvents,
+    decodePayReq,
+    lookupInvoice,
+    ensureHodlInvoice,
+    trackPaymentV2,
+    trackPaymentV2Chan,
+    pendingChannels,
+    closedChannels,
+    closeChannelSync,
+    listInvoices,
+    subscribeSingleInvoice,
+    subscribeSingleInvoiceChan,
+  )
+where
+
+import Data.ProtoLens.Message
+import LndClient.Data.AddHodlInvoice as AddHodlInvoice (AddHodlInvoiceRequest (..))
+import LndClient.Data.AddInvoice as AddInvoice (AddInvoiceResponse (..))
+import qualified LndClient.Data.Channel as Channel
+import LndClient.Data.CloseChannel as CloseChannel (CloseChannelRequest (..))
+import LndClient.Data.Invoice as Invoice (Invoice (..))
+import LndClient.Data.ListChannels as ListChannels (ListChannelsRequest (..))
+import LndClient.Data.Peer (ConnectPeerRequest (..))
+import LndClient.Import
+import LndClient.RPC.TH
+import LndClient.Util as Util
+
+$(mkRpc RpcSilent)
+
+waitForGrpc ::
+  (MonadIO m) =>
+  LndEnv ->
+  m (Either LndError ())
+waitForGrpc env = this 30
+  where
+    this (x :: Int) =
+      if x > 0
+        then do
+          res <- getInfo $ env {envLndLogStrategy = logDebug}
+          if isRight res
+            then return $ Right ()
+            else liftIO (delay 1000000) >> this (x - 1)
+        else do
+          let msg = "waitForGrpc attempt limit exceeded"
+          return . Left $ LndError msg
+
+lazyUnlockWallet ::
+  (MonadIO m) =>
+  LndEnv ->
+  m (Either LndError ())
+lazyUnlockWallet env = do
+  unlocked <- isRight <$> getInfo (env {envLndLogStrategy = logDebug})
+  if unlocked
+    then return $ Right ()
+    else unlockWallet env
+
+lazyInitWallet ::
+  (MonadIO m) =>
+  LndEnv ->
+  m (Either LndError ())
+lazyInitWallet env = do
+  unlockRes <- lazyUnlockWallet $ env {envLndLogStrategy = logDebug}
+  if isRight unlockRes
+    then return unlockRes
+    else initWallet env
+
+ensureHodlInvoice ::
+  (MonadIO m) =>
+  LndEnv ->
+  AddHodlInvoiceRequest ->
+  m (Either LndError AddInvoiceResponse)
+ensureHodlInvoice env req = do
+  let rh = AddHodlInvoice.hash req
+  _ <- addHodlInvoice env req
+  res <- lookupInvoice env rh
+  return $ case res of
+    Left x -> Left x
+    Right x ->
+      Right $
+        AddInvoice.AddInvoiceResponse
+          { AddInvoice.rHash = rh,
+            AddInvoice.paymentRequest = Invoice.paymentRequest x,
+            AddInvoice.addIndex = Invoice.addIndex x
+          }
+
+closeChannelSync ::
+  (MonadUnliftIO m) =>
+  LndEnv ->
+  ConnectPeerRequest ->
+  CloseChannelRequest ->
+  m (Either LndError ())
+closeChannelSync env conn req = do
+  cs0 <- listChannels env (ListChannels.ListChannelsRequest False False False False Nothing)
+  case cs0 of
+    Left err -> pure $ Left err
+    Right x ->
+      case filter (\ch -> channelPoint req == Channel.channelPoint ch) x of
+        [] -> return $ Right ()
+        _ -> do
+          mVar <- newEmptyMVar
+          closeChannelRecursive mVar 10
+  where
+    closeChannelRecursive _ (0 :: Int) = return $ Left $ LndError "Cannot close channel"
+    closeChannelRecursive mVar0 n = do
+      void $ lazyConnectPeer env conn
+      void $ Util.spawnLink $
+        closeChannel
+          (void . tryPutMVar mVar0)
+          env
+          req
+      liftIO $ delay 1000000
+      upd <- tryTakeMVar mVar0
+      case upd of
+        Just _ -> return $ Right ()
+        Nothing -> closeChannelRecursive mVar0 (n -1)
diff --git a/src/LndClient/RPC/TH.hs b/src/LndClient/RPC/TH.hs
new file mode 100644
--- /dev/null
+++ b/src/LndClient/RPC/TH.hs
@@ -0,0 +1,429 @@
+{-# LANGUAGE DuplicateRecordFields #-}
+{-# LANGUAGE TemplateHaskell #-}
+
+module LndClient.RPC.TH
+  ( mkRpc,
+    RpcKind (..),
+  )
+where
+
+import Language.Haskell.TH.Syntax
+import LndClient.Data.AddHodlInvoice (AddHodlInvoiceRequest (..))
+import LndClient.Data.AddInvoice (AddInvoiceRequest (..), AddInvoiceResponse (..))
+import LndClient.Data.Channel (Channel (..))
+import LndClient.Data.ChannelPoint (ChannelPoint (..))
+import LndClient.Data.CloseChannel
+  ( ChannelCloseSummary (..),
+    CloseChannelRequest (..),
+    CloseStatusUpdate (..),
+  )
+import LndClient.Data.ClosedChannels (ClosedChannelsRequest (..))
+import qualified LndClient.Data.GetInfo as GI
+import LndClient.Data.HtlcEvent (HtlcEvent (..))
+import qualified LndClient.Data.InitWallet as IW
+import LndClient.Data.Invoice (Invoice (..))
+import LndClient.Data.ListChannels (ListChannelsRequest (..))
+import LndClient.Data.ListInvoices (ListInvoiceRequest (..), ListInvoiceResponse (..))
+import LndClient.Data.NewAddress (NewAddressRequest (..), NewAddressResponse (..))
+import LndClient.Data.OpenChannel
+import LndClient.Data.OpenChannel (OpenChannelRequest (..))
+import LndClient.Data.PayReq (PayReq (..))
+import LndClient.Data.Payment (Payment (..))
+import LndClient.Data.Peer
+  ( ConnectPeerRequest (..),
+    LightningAddress (..),
+    Peer (..),
+  )
+import LndClient.Data.PendingChannels (PendingChannelsResponse (..))
+import LndClient.Data.SendPayment (SendPaymentRequest (..), SendPaymentResponse (..))
+import LndClient.Data.SubscribeChannelEvents (ChannelEventUpdate (..))
+import LndClient.Data.SubscribeInvoices
+  ( SubscribeInvoicesRequest (..),
+  )
+import LndClient.Data.TrackPayment (TrackPaymentRequest (..))
+import qualified LndClient.Data.UnlockWallet as UW
+import LndClient.Import
+import LndClient.RPC.Generic
+import Network.GRPC.HTTP2.ProtoLens (RPC (..))
+import qualified Proto.InvoiceGrpc as LnGRPC
+import qualified Proto.LndGrpc as LnGRPC
+import qualified Proto.RouterGrpc as LnGRPC
+import qualified Proto.WalletUnlockerGrpc as LnGRPC
+
+data RpcKind = RpcSilent | RpcKatip
+
+mkRpc :: RpcKind -> Q [Dec]
+mkRpc k = do
+  [d|
+    getInfo ::
+      ($(tcc) m) =>
+      LndEnv ->
+      m (Either LndError GI.GetInfoResponse)
+    getInfo env =
+      $(grpcRetry) $
+        $(grpcSync)
+          (RPC :: RPC LnGRPC.Lightning "getInfo")
+          env
+          (defMessage :: LnGRPC.GetInfoRequest)
+
+    initWallet ::
+      ($(tcc) m) =>
+      LndEnv ->
+      m (Either LndError ())
+    initWallet env = do
+      case envLndCipherSeedMnemonic env of
+        Nothing -> pure . Left $ LndEnvError "CipherSeed is required for initWallet"
+        Just seed -> do
+          res <-
+            $(grpcRetry) $
+              $(grpcSync)
+                (RPC :: RPC LnGRPC.WalletUnlocker "initWallet")
+                env
+                IW.InitWalletRequest
+                  { IW.walletPassword =
+                      coerce $ envLndWalletPassword env,
+                    IW.cipherSeedMnemonic =
+                      coerce seed,
+                    IW.aezeedPassphrase =
+                      coerce $ envLndAezeedPassphrase env
+                  }
+          if isRight res
+            then waitForGrpc env
+            else return res
+
+    unlockWallet ::
+      ($(tcc) m) =>
+      LndEnv ->
+      m (Either LndError ())
+    unlockWallet env = do
+      res <-
+        $(grpcRetry) $
+          $(grpcSync)
+            (RPC :: RPC LnGRPC.WalletUnlocker "unlockWallet")
+            env
+            UW.UnlockWalletRequest
+              { UW.walletPassword = coerce $ envLndWalletPassword env,
+                UW.recoveryWindow = 100
+              }
+      if isRight res
+        then waitForGrpc env
+        else return res
+
+    newAddress ::
+      ($(tcc) m) =>
+      LndEnv ->
+      NewAddressRequest ->
+      m (Either LndError NewAddressResponse)
+    newAddress env =
+      $(grpcRetry)
+        . $(grpcSync)
+          (RPC :: RPC LnGRPC.Lightning "newAddress")
+          env
+
+    addInvoice ::
+      ($(tcc) m) =>
+      LndEnv ->
+      AddInvoiceRequest ->
+      m (Either LndError AddInvoiceResponse)
+    addInvoice env =
+      $(grpcRetry)
+        . $(grpcSync)
+          (RPC :: RPC LnGRPC.Lightning "addInvoice")
+          env
+
+    addHodlInvoice ::
+      ($(tcc) m) =>
+      LndEnv ->
+      AddHodlInvoiceRequest ->
+      m (Either LndError PaymentRequest)
+    addHodlInvoice env =
+      $(grpcRetry)
+        . $(grpcSync)
+          (RPC :: RPC LnGRPC.Invoices "addHoldInvoice")
+          env
+
+    cancelInvoice ::
+      ($(tcc) m) =>
+      LndEnv ->
+      RHash ->
+      m (Either LndError ())
+    cancelInvoice env =
+      $(grpcRetry)
+        . $(grpcSync)
+          (RPC :: RPC LnGRPC.Invoices "cancelInvoice")
+          env
+
+    settleInvoice ::
+      ($(tcc) m) =>
+      LndEnv ->
+      RPreimage ->
+      m (Either LndError ())
+    settleInvoice env =
+      $(grpcRetry)
+        . $(grpcSync)
+          (RPC :: RPC LnGRPC.Invoices "settleInvoice")
+          env
+
+    subscribeSingleInvoice ::
+      ($(tcc) m) =>
+      (Invoice -> IO ()) ->
+      LndEnv ->
+      RHash ->
+      m (Either LndError ())
+    subscribeSingleInvoice =
+      $(grpcSubscribe)
+        (RPC :: RPC LnGRPC.Invoices "subscribeSingleInvoice")
+
+    subscribeSingleInvoiceChan ::
+      ($(tcc) m) =>
+      Maybe (TChan (RHash, Invoice)) ->
+      LndEnv ->
+      RHash ->
+      m (Either LndError ())
+    subscribeSingleInvoiceChan mq env req = do
+      q <- fromMaybeM (atomically newBroadcastTChan) $ pure mq
+      subscribeSingleInvoice
+        (\x -> atomically $ writeTChan q (req, x))
+        env
+        req
+
+    subscribeInvoices ::
+      ($(tcc) m) =>
+      (Invoice -> IO ()) ->
+      LndEnv ->
+      SubscribeInvoicesRequest ->
+      m (Either LndError ())
+    subscribeInvoices =
+      $(grpcSubscribe)
+        (RPC :: RPC LnGRPC.Lightning "subscribeInvoices")
+
+    subscribeInvoicesChan ::
+      ($(tcc) m) =>
+      Maybe (TChan (SubscribeInvoicesRequest, Invoice)) ->
+      LndEnv ->
+      SubscribeInvoicesRequest ->
+      m (Either LndError ())
+    subscribeInvoicesChan mq env req = do
+      q <- fromMaybeM (atomically newBroadcastTChan) $ pure mq
+      subscribeInvoices
+        (\x -> atomically $ writeTChan q (req, x))
+        env
+        req
+
+    subscribeChannelEvents ::
+      ($(tcc) m) =>
+      (ChannelEventUpdate -> IO ()) ->
+      LndEnv ->
+      m (Either LndError ())
+    subscribeChannelEvents handler env =
+      $(grpcSubscribe)
+        (RPC :: RPC LnGRPC.Lightning "subscribeChannelEvents")
+        handler
+        env
+        (defMessage :: LnGRPC.ChannelEventSubscription)
+
+    subscribeChannelEventsChan ::
+      ($(tcc) m) =>
+      Maybe (TChan ((), ChannelEventUpdate)) ->
+      LndEnv ->
+      m (Either LndError ())
+    subscribeChannelEventsChan mq env = do
+      q <- fromMaybeM (atomically newBroadcastTChan) $ pure mq
+      subscribeChannelEvents
+        (\x -> atomically $ writeTChan q ((), x))
+        env
+
+    openChannel ::
+      ($(tcc) m) =>
+      (OpenStatusUpdate -> IO ()) ->
+      LndEnv ->
+      OpenChannelRequest ->
+      m (Either LndError ())
+    openChannel =
+      $(grpcSubscribe)
+        (RPC :: RPC LnGRPC.Lightning "openChannel")
+
+    openChannelSync ::
+      ($(tcc) m) =>
+      LndEnv ->
+      OpenChannelRequest ->
+      m (Either LndError ChannelPoint)
+    openChannelSync env =
+      $(grpcSync)
+        (RPC :: RPC LnGRPC.Lightning "openChannelSync")
+        env
+
+    listChannels ::
+      ($(tcc) m) =>
+      LndEnv ->
+      ListChannelsRequest ->
+      m (Either LndError [Channel])
+    listChannels env =
+      $(grpcRetry)
+        . $(grpcSync)
+          (RPC :: RPC LnGRPC.Lightning "listChannels")
+          env
+
+    listInvoices ::
+      ($(tcc) m) =>
+      LndEnv ->
+      ListInvoiceRequest ->
+      m (Either LndError ListInvoiceResponse)
+    listInvoices env =
+      $(grpcRetry)
+        . $(grpcSync)
+          (RPC :: RPC LnGRPC.Lightning "listInvoices")
+          env
+
+    closedChannels ::
+      ($(tcc) m) =>
+      LndEnv ->
+      ClosedChannelsRequest ->
+      m (Either LndError [ChannelCloseSummary])
+    closedChannels env =
+      $(grpcRetry)
+        . $(grpcSync)
+          (RPC :: RPC LnGRPC.Lightning "closedChannels")
+          env
+
+    closeChannel ::
+      ($(tcc) m) =>
+      (CloseStatusUpdate -> IO ()) ->
+      LndEnv ->
+      CloseChannelRequest ->
+      m (Either LndError ())
+    closeChannel =
+      $(grpcSubscribe)
+        (RPC :: RPC LnGRPC.Lightning "closeChannel")
+
+    listPeers ::
+      ($(tcc) m) =>
+      LndEnv ->
+      m (Either LndError [Peer])
+    listPeers env =
+      $(grpcRetry) $
+        $(grpcSync)
+          (RPC :: RPC LnGRPC.Lightning "listPeers")
+          env
+          (defMessage :: LnGRPC.ListPeersRequest)
+
+    connectPeer ::
+      ($(tcc) m) =>
+      LndEnv ->
+      ConnectPeerRequest ->
+      m (Either LndError ())
+    connectPeer env =
+      $(grpcRetry)
+        . $(grpcSync)
+          (RPC :: RPC LnGRPC.Lightning "connectPeer")
+          env
+
+    lazyConnectPeer ::
+      ($(tcc) m) =>
+      LndEnv ->
+      ConnectPeerRequest ->
+      m (Either LndError ())
+    lazyConnectPeer env cpr = do
+      eps <- listPeers env
+      case eps of
+        Left e ->
+          return $ Left e
+        Right ps ->
+          if any ((== pk) . pubKey) ps
+            then return $ Right ()
+            else connectPeer env cpr
+      where
+        pk = pubkey $ addr cpr
+
+    sendPayment ::
+      ($(tcc) m) =>
+      LndEnv ->
+      SendPaymentRequest ->
+      m (Either LndError SendPaymentResponse)
+    sendPayment env =
+      $(grpcRetry)
+        . $(grpcSync)
+          (RPC :: RPC LnGRPC.Lightning "sendPaymentSync")
+          env
+
+    subscribeHtlcEvents ::
+      ($(tcc) m) =>
+      (HtlcEvent -> IO ()) ->
+      LndEnv ->
+      m (Either LndError ())
+    subscribeHtlcEvents handler env =
+      $(grpcSubscribe)
+        (RPC :: RPC LnGRPC.Router "subscribeHtlcEvents")
+        handler
+        env
+        (defMessage :: LnGRPC.SubscribeHtlcEventsRequest)
+
+    decodePayReq ::
+      ($(tcc) m) =>
+      LndEnv ->
+      PaymentRequest ->
+      m (Either LndError PayReq)
+    decodePayReq env =
+      $(grpcRetry)
+        . $(grpcSync)
+          (RPC :: RPC LnGRPC.Lightning "decodePayReq")
+          env
+
+    lookupInvoice ::
+      ($(tcc) m) =>
+      LndEnv ->
+      RHash ->
+      m (Either LndError Invoice)
+    lookupInvoice env =
+      $(grpcRetry)
+        . $(grpcSync)
+          (RPC :: RPC LnGRPC.Lightning "lookupInvoice")
+          env
+
+    trackPaymentV2 ::
+      ($(tcc) m) =>
+      (Payment -> IO ()) ->
+      LndEnv ->
+      TrackPaymentRequest ->
+      m (Either LndError ())
+    trackPaymentV2 =
+      $(grpcSubscribe)
+        (RPC :: RPC LnGRPC.Router "trackPaymentV2")
+
+    trackPaymentV2Chan ::
+      ($(tcc) m) =>
+      Maybe (TChan (TrackPaymentRequest, Payment)) ->
+      LndEnv ->
+      TrackPaymentRequest ->
+      m (Either LndError ())
+    trackPaymentV2Chan mc env req = do
+      q <- fromMaybeM (atomically newBroadcastTChan) $ pure mc
+      trackPaymentV2
+        (\x -> atomically $ writeTChan q (req, x))
+        env
+        req
+
+    pendingChannels ::
+      ($(tcc) m) =>
+      LndEnv ->
+      m (Either LndError PendingChannelsResponse)
+    pendingChannels env =
+      $(grpcRetry) $
+        $(grpcSync)
+          (RPC :: RPC LnGRPC.Lightning "pendingChannels")
+          env
+          (defMessage :: LnGRPC.PendingChannelsRequest)
+    |]
+  where
+    tcc = case k of
+      RpcSilent -> [t|MonadIO|]
+      RpcKatip -> [t|KatipContext|]
+    grpcRetry = case k of
+      RpcSilent -> [e|retrySilent|]
+      RpcKatip -> [e|retryKatip|]
+    grpcSync = case k of
+      RpcSilent -> [e|grpcSyncSilent|]
+      RpcKatip -> [e|grpcSyncKatip|]
+    grpcSubscribe = case k of
+      RpcSilent -> [e|grpcSubscribeSilent|]
+      RpcKatip -> [e|grpcSubscribeKatip|]
diff --git a/src/LndClient/Util.hs b/src/LndClient/Util.hs
new file mode 100644
--- /dev/null
+++ b/src/LndClient/Util.hs
@@ -0,0 +1,109 @@
+{-# LANGUAGE FlexibleContexts #-}
+
+module LndClient.Util
+  ( retrySilent,
+    retryKatip,
+    safeFromIntegral,
+    spawnLink,
+    withSpawnLink,
+    readTChanTimeout,
+    maybeDeadlock,
+    txIdParser,
+    MicroSecondsDelay (..),
+  )
+where
+
+import Control.Exception
+import qualified Data.ByteString as BS (reverse)
+import qualified Data.ByteString.Base16 as B16 (decode)
+import LndClient.Data.Type
+import LndClient.Import.External
+
+newtype MicroSecondsDelay = MicroSecondsDelay Int
+
+txIdParser :: Text -> Either LndError ByteString
+txIdParser xr =
+  case B16.decode $ encodeUtf8 xr of
+    Right x -> Right $ BS.reverse x
+    Left {} -> Left $ FromGrpcError "TX_ID_NON_HEX_BYTES"
+
+retrySilent ::
+  MonadIO m => m (Either LndError a) -> m (Either LndError a)
+retrySilent = this 0
+  where
+    this (attempt0 :: Integer) f = do
+      let attempt = attempt0 + 1
+      res <- f
+      case res of
+        Left (LndError _) ->
+          if attempt > 5
+            then pure res
+            else do
+              liftIO $ delay 300000
+              this attempt f
+        _ ->
+          pure res
+
+retryKatip ::
+  KatipContext m => m (Either LndError a) -> m (Either LndError a)
+retryKatip = this 0
+  where
+    this (attempt0 :: Integer) f = do
+      let attempt = attempt0 + 1
+      res <- f
+      case res of
+        Left (LndError _) ->
+          if attempt > 5
+            then pure res
+            else do
+              liftIO $ delay 300000
+              this attempt f
+        _ ->
+          pure res
+
+safeFromIntegral ::
+  forall a b. (Integral a, Integral b, Bounded b) => a -> Maybe b
+safeFromIntegral x =
+  if (intX >= intMin) && (intX <= intMax)
+    then Just $ fromIntegral x
+    else Nothing
+  where
+    intX = fromIntegral x :: Integer
+    intMin = fromIntegral (minBound :: b) :: Integer
+    intMax = fromIntegral (maxBound :: b) :: Integer
+
+spawnLink :: (MonadUnliftIO m) => m a -> m (Async a)
+spawnLink x =
+  withRunInIO $ \run -> do
+    pid <- async $ run x
+    link pid
+    pure pid
+
+withSpawnLink :: (MonadUnliftIO m) => m a -> (Async a -> m b) -> m b
+withSpawnLink action inner =
+  withRunInIO $ \run ->
+    withAsync
+      (run action)
+      ( \pid -> do
+          link pid
+          run $ inner pid
+      )
+
+readTChanTimeout ::
+  MonadUnliftIO m => MicroSecondsDelay -> TChan a -> m (Maybe a)
+readTChanTimeout t x = do
+  t0 <- liftIO . registerDelay $ coerce t
+  (join <$>) . maybeDeadlock . atomically $
+    Just <$> readTChan x
+      <|> Nothing <$ fini t0
+
+maybeDeadlock :: MonadUnliftIO m => m a -> m (Maybe a)
+maybeDeadlock x =
+  withRunInIO $ \run ->
+    (Just <$> run x)
+      `catches` [ Handler $
+                    \BlockedIndefinitelyOnSTM -> pure Nothing
+                ]
+
+fini :: TVar Bool -> STM ()
+fini = check <=< readTVar
diff --git a/src/LndClient/Watcher.hs b/src/LndClient/Watcher.hs
new file mode 100644
--- /dev/null
+++ b/src/LndClient/Watcher.hs
@@ -0,0 +1,231 @@
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TupleSections #-}
+
+-- | Generic async worker to automate LND gRPC subscriptions.
+-- It watches any amount of subscriptions of the same type,
+-- and re-subscribes if subscription was not terminated properly.
+-- The only way to terminate subscription is to apply `unWatch` or
+-- `unWatchUnit` function.
+module LndClient.Watcher
+  ( Watcher,
+    spawnLink,
+    spawnLinkUnit,
+    watch,
+    watchUnit,
+    unWatch,
+    unWatchUnit,
+    dupLndTChan,
+    delete,
+  )
+where
+
+import qualified Data.Map as Map
+import LndClient.Import hiding (newSev, spawnLink)
+
+--
+-- TODO : maybe pass OnSub | OnExit callbacks?
+--
+
+data Watcher a b
+  = Watcher
+      { watcherCmdChan :: TChan (Cmd a),
+        watcherLndChan :: TChan (a, b),
+        watcherProc :: Async ()
+      }
+
+--
+-- TODO : introduce UnWatchAll
+-- and use it in withEnv etc
+--
+data Cmd a
+  = Watch a
+  | UnWatch a
+
+data Event a b
+  = EventCmd (Cmd a)
+  | EventLnd b
+  | EventTask (a, Either LndError ())
+
+data WatcherState a b m
+  = WatcherState
+      { watcherStateCmdChan :: TChan (Cmd a),
+        watcherStateLndChan :: TChan (a, b),
+        watcherStateSub :: a -> m (Either LndError ()),
+        watcherStateHandler :: a -> Either LndError b -> m (),
+        watcherStateTasks :: Map a (Async (a, Either LndError ())),
+        watcherStateLndEnv :: LndEnv
+      }
+
+newSev :: WatcherState a b m -> Severity -> Severity
+newSev w s = newSeverity (watcherStateLndEnv w) s Nothing Nothing
+
+-- Spawn watcher where subscription accepts argument
+-- for example `subscribeInvoicesChan`
+spawnLink ::
+  (Ord a, MonadUnliftIO m, KatipContext m) =>
+  LndEnv ->
+  (Maybe (TChan (a, b)) -> LndEnv -> a -> m (Either LndError ())) ->
+  (Watcher a b -> a -> Either LndError b -> m ()) ->
+  m (Watcher a b)
+spawnLink env sub handler = do
+  w <- withRunInIO $ \run -> do
+    ( writeCmdChan,
+      writeLndChan,
+      readCmdChan,
+      readLndChan
+      ) <- atomically $ do
+      writeCmdChan <- newBroadcastTChan
+      writeLndChan <- newBroadcastTChan
+      readCmdChan <- dupTChan writeCmdChan
+      readLndChan <- dupTChan writeLndChan
+      pure (writeCmdChan, writeLndChan, readCmdChan, readLndChan)
+    let w =
+          Watcher
+            { watcherCmdChan = writeCmdChan,
+              watcherLndChan = writeLndChan,
+              watcherProc = error "PARTIAL_WATCHER"
+            }
+    varProc <- newEmptyMVar
+    proc <-
+      async . run $ do
+        proc <- takeMVar varProc
+        loop $
+          WatcherState
+            { watcherStateCmdChan = readCmdChan,
+              watcherStateLndChan = readLndChan,
+              watcherStateSub = sub (Just writeLndChan) env,
+              watcherStateHandler = handler $ w {watcherProc = proc},
+              watcherStateTasks = mempty,
+              watcherStateLndEnv = env
+            }
+    liftIO $ putMVar varProc proc
+    pure $ w {watcherProc = proc}
+  let proc = watcherProc w
+  liftIO $ link proc
+  $(logTM) (newSeverity env InfoS Nothing Nothing)
+    $ logStr
+    $ ("Watcher spawned as " :: Text)
+      <> show (asyncThreadId proc)
+  pure w
+
+-- Spawn watcher where subscription don't accept argument
+-- for example `subscribeChannelEventsChan`
+spawnLinkUnit ::
+  (MonadUnliftIO m, KatipContext m) =>
+  LndEnv ->
+  (Maybe (TChan ((), b)) -> LndEnv -> m (Either LndError ())) ->
+  (Watcher () b -> Either LndError b -> m ()) ->
+  m (Watcher () b)
+spawnLinkUnit env0 sub handler =
+  spawnLink
+    env0
+    (\mChan env1 _ -> sub mChan env1)
+    (\chan _ x -> handler chan x)
+
+watch :: (MonadUnliftIO m) => Watcher a b -> a -> m ()
+watch w = atomically . writeTChan (watcherCmdChan w) . Watch
+
+watchUnit :: (MonadUnliftIO m) => Watcher () b -> m ()
+watchUnit w = watch w ()
+
+unWatch :: (MonadUnliftIO m) => Watcher a b -> a -> m ()
+unWatch w = atomically . writeTChan (watcherCmdChan w) . UnWatch
+
+unWatchUnit :: (MonadUnliftIO m) => Watcher () b -> m ()
+unWatchUnit w = unWatch w ()
+
+dupLndTChan :: (MonadIO m) => Watcher a b -> m (TChan (a, b))
+dupLndTChan = atomically . dupTChan . watcherLndChan
+
+--
+-- TODO : atomically cancel all linked processes
+--
+delete :: (MonadUnliftIO m) => Watcher a b -> m ()
+delete (Watcher _ _ proc) = liftIO $ cancel proc
+
+loop ::
+  (Ord a, MonadUnliftIO m, KatipContext m) =>
+  WatcherState a b m ->
+  m ()
+loop w = do
+  -- Here is the trick. Async watcher task can be already
+  -- terminated, and runtime detects that there are no any references
+  -- to watcherStateLndChan anymore.
+  -- This may cause `BlockedIndefinitelyOnSTM`
+  -- async exception, because all alternative <|> expressions are
+  -- evaluated independently. In this case we need to retry
+  -- alternative computation but without reading from
+  -- watcherStateLndChan.
+  $(logTM) (newSev w InfoS) "Watcher - cmd <|> lnd <|> task"
+  me <- maybeDeadlock . atomically $ cmd <|> lnd <|> task
+  event <- case me of
+    Nothing -> do
+      $(logTM) (newSev w InfoS) "Watcher - cmd <|> task"
+      atomically $ cmd <|> task
+    Just x -> return x
+  $(logTM) (newSev w InfoS) "Watcher - applying event"
+  case event of
+    EventCmd x -> applyCmd w x
+    EventLnd x -> applyLnd w (second Right x)
+    EventTask x -> applyTask w x
+  where
+    cmd = EventCmd <$> readTChan (watcherStateCmdChan w)
+    lnd = EventLnd <$> readTChan (watcherStateLndChan w)
+    task =
+      EventTask . snd
+        <$> waitAnySTM (Map.elems $ watcherStateTasks w)
+
+applyCmd ::
+  (Ord a, MonadUnliftIO m, KatipContext m) =>
+  WatcherState a b m ->
+  Cmd a ->
+  m ()
+applyCmd w = \case
+  Watch x -> do
+    $(logTM) (newSev w InfoS) "Watcher - applying Cmd Watch"
+    if isJust $ Map.lookup x ts
+      then loop w
+      else do
+        t <-
+          withRunInIO $ \run -> do
+            t <- async . run $ (x,) <$> watcherStateSub w x
+            link t
+            return t
+        loop w {watcherStateTasks = Map.insert x t ts}
+  UnWatch x -> do
+    $(logTM) (newSev w InfoS) "Watcher - applying Cmd UnWatch"
+    case Map.lookup x ts of
+      Nothing -> loop w
+      Just t -> do
+        liftIO $ cancel t
+        loop w {watcherStateTasks = Map.delete x ts}
+  where
+    ts = watcherStateTasks w
+
+applyLnd ::
+  (Ord a, MonadUnliftIO m, KatipContext m) =>
+  WatcherState a b m ->
+  (a, Either LndError b) ->
+  m ()
+applyLnd w (x0, x1) = do
+  $(logTM) (newSev w InfoS) "Watcher - applying Lnd"
+  watcherStateHandler w x0 x1
+  loop w
+
+applyTask ::
+  (Ord a, MonadUnliftIO m, KatipContext m) =>
+  WatcherState a b m ->
+  (a, Either LndError ()) ->
+  m ()
+applyTask w0 (x, res) = do
+  $(logTM) (newSev w0 InfoS) "Watcher - applying Task"
+  case Map.lookup x ts of
+    Nothing -> loop w0
+    Just t -> do
+      case res of
+        Left (e :: LndError) -> watcherStateHandler w0 x $ Left e
+        Right () -> liftIO $ cancel t
+      loop w1
+  where
+    ts = watcherStateTasks w0
+    w1 = w0 {watcherStateTasks = Map.delete x ts}
diff --git a/src/LndGrpc/Client.hs b/src/LndGrpc/Client.hs
new file mode 100644
--- /dev/null
+++ b/src/LndGrpc/Client.hs
@@ -0,0 +1,60 @@
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TypeFamilies #-}
+
+module LndGrpc.Client
+  ( runUnary,
+    runStreamServer,
+  )
+where
+
+import Data.ProtoLens.Message
+import Data.ProtoLens.Service.Types (HasMethod, HasMethodImpl (..))
+import GHC.TypeLits (Symbol)
+import LndClient.Data.LndEnv
+import LndClient.Import
+import Network.GRPC.Client.Helpers
+import qualified Network.GRPC.HTTP2.ProtoLens as ProtoLens
+import Network.HPACK (HeaderList)
+import Network.HTTP2.Client
+
+runUnary ::
+  ( MonadIO p,
+    HasMethod s m,
+    req ~ MethodInput s m,
+    res ~ MethodOutput s m
+  ) =>
+  ProtoLens.RPC s (m :: Symbol) ->
+  LndEnv ->
+  req ->
+  p (Either LndError res)
+runUnary rpc env req = do
+  res <- liftIO $ runClientIO $ do
+    grpc <- setupGrpcClient $ envLndConfig env
+    rawUnary rpc grpc req
+  return $ case res of
+    Right (Right (Right (_, _, (Right x)))) -> Right x
+    Right (Right (Right (_, _, (Left e)))) -> Left $ LndError $ pack e
+    Right (Right (Left e)) -> Left $ LndError ("LndGrpc response error, code: " <> show e)
+    Right (Left e) -> Left $ LndError ("LndGrpc, TooMuchConcurrency error: " <> show e)
+    Left e -> Left $ LndGrpcError e
+
+runStreamServer ::
+  ( MonadIO p,
+    HasMethod s m,
+    req ~ MethodInput s m,
+    res ~ MethodOutput s m
+  ) =>
+  ProtoLens.RPC s (m :: Symbol) ->
+  LndEnv ->
+  req ->
+  (HeaderList -> res -> ClientIO ()) ->
+  p (Either LndError res)
+runStreamServer rpc env req handler = do
+  r <- liftIO $ runClientIO $ do
+    grpc <- setupGrpcClient $ envLndConfig env
+    rawStreamServer rpc grpc () req $ const handler
+  return $ case r of
+    Right (Right ((), _, _)) -> Right defMessage
+    Right (Left e) -> Left $ LndError ("LndGrpc response error: " <> show e)
+    Left e -> Left $ LndGrpcError e
diff --git a/src/Proto/InvoiceGrpc.hs b/src/Proto/InvoiceGrpc.hs
new file mode 100644
--- /dev/null
+++ b/src/Proto/InvoiceGrpc.hs
@@ -0,0 +1,1568 @@
+{- This file was auto-generated from invoice_grpc.proto by the proto-lens-protoc program. -}
+{-# LANGUAGE ScopedTypeVariables, DataKinds, TypeFamilies, UndecidableInstances, GeneralizedNewtypeDeriving, MultiParamTypeClasses, FlexibleContexts, FlexibleInstances, PatternSynonyms, MagicHash, NoImplicitPrelude, DataKinds, BangPatterns, TypeApplications, OverloadedStrings, DerivingStrategies#-}
+{-# OPTIONS_GHC -Wno-unused-imports#-}
+{-# OPTIONS_GHC -Wno-duplicate-exports#-}
+{-# OPTIONS_GHC -Wno-dodgy-exports#-}
+module Proto.InvoiceGrpc (
+        Invoices(..), AddHoldInvoiceRequest(), AddHoldInvoiceResp(),
+        CancelInvoiceMsg(), CancelInvoiceResp(), SettleInvoiceMsg(),
+        SettleInvoiceResp(), SubscribeSingleInvoiceRequest()
+    ) where
+import qualified Data.ProtoLens.Runtime.Control.DeepSeq as Control.DeepSeq
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Prism as Data.ProtoLens.Prism
+import qualified Data.ProtoLens.Runtime.Prelude as Prelude
+import qualified Data.ProtoLens.Runtime.Data.Int as Data.Int
+import qualified Data.ProtoLens.Runtime.Data.Monoid as Data.Monoid
+import qualified Data.ProtoLens.Runtime.Data.Word as Data.Word
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens as Data.ProtoLens
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Bytes as Data.ProtoLens.Encoding.Bytes
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Growing as Data.ProtoLens.Encoding.Growing
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Parser.Unsafe as Data.ProtoLens.Encoding.Parser.Unsafe
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Wire as Data.ProtoLens.Encoding.Wire
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Field as Data.ProtoLens.Field
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Message.Enum as Data.ProtoLens.Message.Enum
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Service.Types as Data.ProtoLens.Service.Types
+import qualified Data.ProtoLens.Runtime.Lens.Family2 as Lens.Family2
+import qualified Data.ProtoLens.Runtime.Lens.Family2.Unchecked as Lens.Family2.Unchecked
+import qualified Data.ProtoLens.Runtime.Data.Text as Data.Text
+import qualified Data.ProtoLens.Runtime.Data.Map as Data.Map
+import qualified Data.ProtoLens.Runtime.Data.ByteString as Data.ByteString
+import qualified Data.ProtoLens.Runtime.Data.ByteString.Char8 as Data.ByteString.Char8
+import qualified Data.ProtoLens.Runtime.Data.Text.Encoding as Data.Text.Encoding
+import qualified Data.ProtoLens.Runtime.Data.Vector as Data.Vector
+import qualified Data.ProtoLens.Runtime.Data.Vector.Generic as Data.Vector.Generic
+import qualified Data.ProtoLens.Runtime.Data.Vector.Unboxed as Data.Vector.Unboxed
+import qualified Data.ProtoLens.Runtime.Text.Read as Text.Read
+import qualified Proto.LndGrpc
+{- | Fields :
+     
+         * 'Proto.InvoiceGrpc_Fields.memo' @:: Lens' AddHoldInvoiceRequest Data.Text.Text@
+         * 'Proto.InvoiceGrpc_Fields.hash' @:: Lens' AddHoldInvoiceRequest Data.ByteString.ByteString@
+         * 'Proto.InvoiceGrpc_Fields.value' @:: Lens' AddHoldInvoiceRequest Data.Int.Int64@
+         * 'Proto.InvoiceGrpc_Fields.valueMsat' @:: Lens' AddHoldInvoiceRequest Data.Int.Int64@
+         * 'Proto.InvoiceGrpc_Fields.descriptionHash' @:: Lens' AddHoldInvoiceRequest Data.ByteString.ByteString@
+         * 'Proto.InvoiceGrpc_Fields.expiry' @:: Lens' AddHoldInvoiceRequest Data.Int.Int64@
+         * 'Proto.InvoiceGrpc_Fields.fallbackAddr' @:: Lens' AddHoldInvoiceRequest Data.Text.Text@
+         * 'Proto.InvoiceGrpc_Fields.cltvExpiry' @:: Lens' AddHoldInvoiceRequest Data.Word.Word64@
+         * 'Proto.InvoiceGrpc_Fields.routeHints' @:: Lens' AddHoldInvoiceRequest [Proto.LndGrpc.RouteHint]@
+         * 'Proto.InvoiceGrpc_Fields.vec'routeHints' @:: Lens' AddHoldInvoiceRequest (Data.Vector.Vector Proto.LndGrpc.RouteHint)@
+         * 'Proto.InvoiceGrpc_Fields.private' @:: Lens' AddHoldInvoiceRequest Prelude.Bool@ -}
+data AddHoldInvoiceRequest
+  = AddHoldInvoiceRequest'_constructor {_AddHoldInvoiceRequest'memo :: !Data.Text.Text,
+                                        _AddHoldInvoiceRequest'hash :: !Data.ByteString.ByteString,
+                                        _AddHoldInvoiceRequest'value :: !Data.Int.Int64,
+                                        _AddHoldInvoiceRequest'valueMsat :: !Data.Int.Int64,
+                                        _AddHoldInvoiceRequest'descriptionHash :: !Data.ByteString.ByteString,
+                                        _AddHoldInvoiceRequest'expiry :: !Data.Int.Int64,
+                                        _AddHoldInvoiceRequest'fallbackAddr :: !Data.Text.Text,
+                                        _AddHoldInvoiceRequest'cltvExpiry :: !Data.Word.Word64,
+                                        _AddHoldInvoiceRequest'routeHints :: !(Data.Vector.Vector Proto.LndGrpc.RouteHint),
+                                        _AddHoldInvoiceRequest'private :: !Prelude.Bool,
+                                        _AddHoldInvoiceRequest'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show AddHoldInvoiceRequest where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Field.HasField AddHoldInvoiceRequest "memo" Data.Text.Text where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _AddHoldInvoiceRequest'memo
+           (\ x__ y__ -> x__ {_AddHoldInvoiceRequest'memo = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField AddHoldInvoiceRequest "hash" Data.ByteString.ByteString where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _AddHoldInvoiceRequest'hash
+           (\ x__ y__ -> x__ {_AddHoldInvoiceRequest'hash = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField AddHoldInvoiceRequest "value" Data.Int.Int64 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _AddHoldInvoiceRequest'value
+           (\ x__ y__ -> x__ {_AddHoldInvoiceRequest'value = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField AddHoldInvoiceRequest "valueMsat" Data.Int.Int64 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _AddHoldInvoiceRequest'valueMsat
+           (\ x__ y__ -> x__ {_AddHoldInvoiceRequest'valueMsat = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField AddHoldInvoiceRequest "descriptionHash" Data.ByteString.ByteString where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _AddHoldInvoiceRequest'descriptionHash
+           (\ x__ y__ -> x__ {_AddHoldInvoiceRequest'descriptionHash = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField AddHoldInvoiceRequest "expiry" Data.Int.Int64 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _AddHoldInvoiceRequest'expiry
+           (\ x__ y__ -> x__ {_AddHoldInvoiceRequest'expiry = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField AddHoldInvoiceRequest "fallbackAddr" Data.Text.Text where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _AddHoldInvoiceRequest'fallbackAddr
+           (\ x__ y__ -> x__ {_AddHoldInvoiceRequest'fallbackAddr = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField AddHoldInvoiceRequest "cltvExpiry" Data.Word.Word64 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _AddHoldInvoiceRequest'cltvExpiry
+           (\ x__ y__ -> x__ {_AddHoldInvoiceRequest'cltvExpiry = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField AddHoldInvoiceRequest "routeHints" [Proto.LndGrpc.RouteHint] where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _AddHoldInvoiceRequest'routeHints
+           (\ x__ y__ -> x__ {_AddHoldInvoiceRequest'routeHints = y__}))
+        (Lens.Family2.Unchecked.lens
+           Data.Vector.Generic.toList
+           (\ _ y__ -> Data.Vector.Generic.fromList y__))
+instance Data.ProtoLens.Field.HasField AddHoldInvoiceRequest "vec'routeHints" (Data.Vector.Vector Proto.LndGrpc.RouteHint) where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _AddHoldInvoiceRequest'routeHints
+           (\ x__ y__ -> x__ {_AddHoldInvoiceRequest'routeHints = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField AddHoldInvoiceRequest "private" Prelude.Bool where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _AddHoldInvoiceRequest'private
+           (\ x__ y__ -> x__ {_AddHoldInvoiceRequest'private = y__}))
+        Prelude.id
+instance Data.ProtoLens.Message AddHoldInvoiceRequest where
+  messageName _ = Data.Text.pack "invoicesrpc.AddHoldInvoiceRequest"
+  packedMessageDescriptor _
+    = "\n\
+      \\NAKAddHoldInvoiceRequest\DC2\DC2\n\
+      \\EOTmemo\CAN\SOH \SOH(\tR\EOTmemo\DC2\DC2\n\
+      \\EOThash\CAN\STX \SOH(\fR\EOThash\DC2\DC4\n\
+      \\ENQvalue\CAN\ETX \SOH(\ETXR\ENQvalue\DC2\GS\n\
+      \\n\
+      \value_msat\CAN\n\
+      \ \SOH(\ETXR\tvalueMsat\DC2)\n\
+      \\DLEdescription_hash\CAN\EOT \SOH(\fR\SIdescriptionHash\DC2\SYN\n\
+      \\ACKexpiry\CAN\ENQ \SOH(\ETXR\ACKexpiry\DC2#\n\
+      \\rfallback_addr\CAN\ACK \SOH(\tR\ffallbackAddr\DC2\US\n\
+      \\vcltv_expiry\CAN\a \SOH(\EOTR\n\
+      \cltvExpiry\DC21\n\
+      \\vroute_hints\CAN\b \ETX(\v2\DLE.lnrpc.RouteHintR\n\
+      \routeHints\DC2\CAN\n\
+      \\aprivate\CAN\t \SOH(\bR\aprivate"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag
+    = let
+        memo__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "memo"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional (Data.ProtoLens.Field.field @"memo")) ::
+              Data.ProtoLens.FieldDescriptor AddHoldInvoiceRequest
+        hash__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "hash"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional (Data.ProtoLens.Field.field @"hash")) ::
+              Data.ProtoLens.FieldDescriptor AddHoldInvoiceRequest
+        value__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "value"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.Int64Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional (Data.ProtoLens.Field.field @"value")) ::
+              Data.ProtoLens.FieldDescriptor AddHoldInvoiceRequest
+        valueMsat__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "value_msat"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.Int64Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"valueMsat")) ::
+              Data.ProtoLens.FieldDescriptor AddHoldInvoiceRequest
+        descriptionHash__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "description_hash"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"descriptionHash")) ::
+              Data.ProtoLens.FieldDescriptor AddHoldInvoiceRequest
+        expiry__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "expiry"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.Int64Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional (Data.ProtoLens.Field.field @"expiry")) ::
+              Data.ProtoLens.FieldDescriptor AddHoldInvoiceRequest
+        fallbackAddr__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "fallback_addr"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"fallbackAddr")) ::
+              Data.ProtoLens.FieldDescriptor AddHoldInvoiceRequest
+        cltvExpiry__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "cltv_expiry"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.UInt64Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Word.Word64)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"cltvExpiry")) ::
+              Data.ProtoLens.FieldDescriptor AddHoldInvoiceRequest
+        routeHints__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "route_hints"
+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
+                 Data.ProtoLens.FieldTypeDescriptor Proto.LndGrpc.RouteHint)
+              (Data.ProtoLens.RepeatedField
+                 Data.ProtoLens.Unpacked
+                 (Data.ProtoLens.Field.field @"routeHints")) ::
+              Data.ProtoLens.FieldDescriptor AddHoldInvoiceRequest
+        private__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "private"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::
+                 Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional (Data.ProtoLens.Field.field @"private")) ::
+              Data.ProtoLens.FieldDescriptor AddHoldInvoiceRequest
+      in
+        Data.Map.fromList
+          [(Data.ProtoLens.Tag 1, memo__field_descriptor),
+           (Data.ProtoLens.Tag 2, hash__field_descriptor),
+           (Data.ProtoLens.Tag 3, value__field_descriptor),
+           (Data.ProtoLens.Tag 10, valueMsat__field_descriptor),
+           (Data.ProtoLens.Tag 4, descriptionHash__field_descriptor),
+           (Data.ProtoLens.Tag 5, expiry__field_descriptor),
+           (Data.ProtoLens.Tag 6, fallbackAddr__field_descriptor),
+           (Data.ProtoLens.Tag 7, cltvExpiry__field_descriptor),
+           (Data.ProtoLens.Tag 8, routeHints__field_descriptor),
+           (Data.ProtoLens.Tag 9, private__field_descriptor)]
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _AddHoldInvoiceRequest'_unknownFields
+        (\ x__ y__ -> x__ {_AddHoldInvoiceRequest'_unknownFields = y__})
+  defMessage
+    = AddHoldInvoiceRequest'_constructor
+        {_AddHoldInvoiceRequest'memo = Data.ProtoLens.fieldDefault,
+         _AddHoldInvoiceRequest'hash = Data.ProtoLens.fieldDefault,
+         _AddHoldInvoiceRequest'value = Data.ProtoLens.fieldDefault,
+         _AddHoldInvoiceRequest'valueMsat = Data.ProtoLens.fieldDefault,
+         _AddHoldInvoiceRequest'descriptionHash = Data.ProtoLens.fieldDefault,
+         _AddHoldInvoiceRequest'expiry = Data.ProtoLens.fieldDefault,
+         _AddHoldInvoiceRequest'fallbackAddr = Data.ProtoLens.fieldDefault,
+         _AddHoldInvoiceRequest'cltvExpiry = Data.ProtoLens.fieldDefault,
+         _AddHoldInvoiceRequest'routeHints = Data.Vector.Generic.empty,
+         _AddHoldInvoiceRequest'private = Data.ProtoLens.fieldDefault,
+         _AddHoldInvoiceRequest'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          AddHoldInvoiceRequest
+          -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld Proto.LndGrpc.RouteHint
+             -> Data.ProtoLens.Encoding.Bytes.Parser AddHoldInvoiceRequest
+        loop x mutable'routeHints
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do frozen'routeHints <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
+                                             (Data.ProtoLens.Encoding.Growing.unsafeFreeze
+                                                mutable'routeHints)
+                      (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields
+                           (\ !t -> Prelude.reverse t)
+                           (Lens.Family2.set
+                              (Data.ProtoLens.Field.field @"vec'routeHints")
+                              frozen'routeHints
+                              x))
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of
+                        10
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                                       Data.ProtoLens.Encoding.Bytes.getBytes
+                                                         (Prelude.fromIntegral len)
+                                           Data.ProtoLens.Encoding.Bytes.runEither
+                                             (case Data.Text.Encoding.decodeUtf8' value of
+                                                (Prelude.Left err)
+                                                  -> Prelude.Left (Prelude.show err)
+                                                (Prelude.Right r) -> Prelude.Right r))
+                                       "memo"
+                                loop
+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"memo") y x)
+                                  mutable'routeHints
+                        18
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.getBytes
+                                             (Prelude.fromIntegral len))
+                                       "hash"
+                                loop
+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"hash") y x)
+                                  mutable'routeHints
+                        24
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          Prelude.fromIntegral
+                                          Data.ProtoLens.Encoding.Bytes.getVarInt)
+                                       "value"
+                                loop
+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"value") y x)
+                                  mutable'routeHints
+                        80
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          Prelude.fromIntegral
+                                          Data.ProtoLens.Encoding.Bytes.getVarInt)
+                                       "value_msat"
+                                loop
+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"valueMsat") y x)
+                                  mutable'routeHints
+                        34
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.getBytes
+                                             (Prelude.fromIntegral len))
+                                       "description_hash"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"descriptionHash") y x)
+                                  mutable'routeHints
+                        40
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          Prelude.fromIntegral
+                                          Data.ProtoLens.Encoding.Bytes.getVarInt)
+                                       "expiry"
+                                loop
+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"expiry") y x)
+                                  mutable'routeHints
+                        50
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                                       Data.ProtoLens.Encoding.Bytes.getBytes
+                                                         (Prelude.fromIntegral len)
+                                           Data.ProtoLens.Encoding.Bytes.runEither
+                                             (case Data.Text.Encoding.decodeUtf8' value of
+                                                (Prelude.Left err)
+                                                  -> Prelude.Left (Prelude.show err)
+                                                (Prelude.Right r) -> Prelude.Right r))
+                                       "fallback_addr"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"fallbackAddr") y x)
+                                  mutable'routeHints
+                        56
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       Data.ProtoLens.Encoding.Bytes.getVarInt "cltv_expiry"
+                                loop
+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"cltvExpiry") y x)
+                                  mutable'routeHints
+                        66
+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                        (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                            Data.ProtoLens.Encoding.Bytes.isolate
+                                              (Prelude.fromIntegral len)
+                                              Data.ProtoLens.parseMessage)
+                                        "route_hints"
+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
+                                       (Data.ProtoLens.Encoding.Growing.append mutable'routeHints y)
+                                loop x v
+                        72
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt)
+                                       "private"
+                                loop
+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"private") y x)
+                                  mutable'routeHints
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)
+                                  mutable'routeHints
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do mutable'routeHints <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
+                                      Data.ProtoLens.Encoding.Growing.new
+              loop Data.ProtoLens.defMessage mutable'routeHints)
+          "AddHoldInvoiceRequest"
+  buildMessage
+    = \ _x
+        -> (Data.Monoid.<>)
+             (let _v = Lens.Family2.view (Data.ProtoLens.Field.field @"memo") _x
+              in
+                if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                    Data.Monoid.mempty
+                else
+                    (Data.Monoid.<>)
+                      (Data.ProtoLens.Encoding.Bytes.putVarInt 10)
+                      ((Prelude..)
+                         (\ bs
+                            -> (Data.Monoid.<>)
+                                 (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                    (Prelude.fromIntegral (Data.ByteString.length bs)))
+                                 (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                         Data.Text.Encoding.encodeUtf8
+                         _v))
+             ((Data.Monoid.<>)
+                (let _v = Lens.Family2.view (Data.ProtoLens.Field.field @"hash") _x
+                 in
+                   if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                       Data.Monoid.mempty
+                   else
+                       (Data.Monoid.<>)
+                         (Data.ProtoLens.Encoding.Bytes.putVarInt 18)
+                         ((\ bs
+                             -> (Data.Monoid.<>)
+                                  (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                     (Prelude.fromIntegral (Data.ByteString.length bs)))
+                                  (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                            _v))
+                ((Data.Monoid.<>)
+                   (let
+                      _v = Lens.Family2.view (Data.ProtoLens.Field.field @"value") _x
+                    in
+                      if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                          Data.Monoid.mempty
+                      else
+                          (Data.Monoid.<>)
+                            (Data.ProtoLens.Encoding.Bytes.putVarInt 24)
+                            ((Prelude..)
+                               Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v))
+                   ((Data.Monoid.<>)
+                      (let
+                         _v = Lens.Family2.view (Data.ProtoLens.Field.field @"valueMsat") _x
+                       in
+                         if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                             Data.Monoid.mempty
+                         else
+                             (Data.Monoid.<>)
+                               (Data.ProtoLens.Encoding.Bytes.putVarInt 80)
+                               ((Prelude..)
+                                  Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v))
+                      ((Data.Monoid.<>)
+                         (let
+                            _v
+                              = Lens.Family2.view
+                                  (Data.ProtoLens.Field.field @"descriptionHash") _x
+                          in
+                            if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                                Data.Monoid.mempty
+                            else
+                                (Data.Monoid.<>)
+                                  (Data.ProtoLens.Encoding.Bytes.putVarInt 34)
+                                  ((\ bs
+                                      -> (Data.Monoid.<>)
+                                           (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                              (Prelude.fromIntegral (Data.ByteString.length bs)))
+                                           (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                                     _v))
+                         ((Data.Monoid.<>)
+                            (let
+                               _v = Lens.Family2.view (Data.ProtoLens.Field.field @"expiry") _x
+                             in
+                               if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                                   Data.Monoid.mempty
+                               else
+                                   (Data.Monoid.<>)
+                                     (Data.ProtoLens.Encoding.Bytes.putVarInt 40)
+                                     ((Prelude..)
+                                        Data.ProtoLens.Encoding.Bytes.putVarInt
+                                        Prelude.fromIntegral
+                                        _v))
+                            ((Data.Monoid.<>)
+                               (let
+                                  _v
+                                    = Lens.Family2.view
+                                        (Data.ProtoLens.Field.field @"fallbackAddr") _x
+                                in
+                                  if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                                      Data.Monoid.mempty
+                                  else
+                                      (Data.Monoid.<>)
+                                        (Data.ProtoLens.Encoding.Bytes.putVarInt 50)
+                                        ((Prelude..)
+                                           (\ bs
+                                              -> (Data.Monoid.<>)
+                                                   (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                                      (Prelude.fromIntegral
+                                                         (Data.ByteString.length bs)))
+                                                   (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                                           Data.Text.Encoding.encodeUtf8
+                                           _v))
+                               ((Data.Monoid.<>)
+                                  (let
+                                     _v
+                                       = Lens.Family2.view
+                                           (Data.ProtoLens.Field.field @"cltvExpiry") _x
+                                   in
+                                     if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                                         Data.Monoid.mempty
+                                     else
+                                         (Data.Monoid.<>)
+                                           (Data.ProtoLens.Encoding.Bytes.putVarInt 56)
+                                           (Data.ProtoLens.Encoding.Bytes.putVarInt _v))
+                                  ((Data.Monoid.<>)
+                                     (Data.ProtoLens.Encoding.Bytes.foldMapBuilder
+                                        (\ _v
+                                           -> (Data.Monoid.<>)
+                                                (Data.ProtoLens.Encoding.Bytes.putVarInt 66)
+                                                ((Prelude..)
+                                                   (\ bs
+                                                      -> (Data.Monoid.<>)
+                                                           (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                                              (Prelude.fromIntegral
+                                                                 (Data.ByteString.length bs)))
+                                                           (Data.ProtoLens.Encoding.Bytes.putBytes
+                                                              bs))
+                                                   Data.ProtoLens.encodeMessage
+                                                   _v))
+                                        (Lens.Family2.view
+                                           (Data.ProtoLens.Field.field @"vec'routeHints") _x))
+                                     ((Data.Monoid.<>)
+                                        (let
+                                           _v
+                                             = Lens.Family2.view
+                                                 (Data.ProtoLens.Field.field @"private") _x
+                                         in
+                                           if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                                               Data.Monoid.mempty
+                                           else
+                                               (Data.Monoid.<>)
+                                                 (Data.ProtoLens.Encoding.Bytes.putVarInt 72)
+                                                 ((Prelude..)
+                                                    Data.ProtoLens.Encoding.Bytes.putVarInt
+                                                    (\ b -> if b then 1 else 0)
+                                                    _v))
+                                        (Data.ProtoLens.Encoding.Wire.buildFieldSet
+                                           (Lens.Family2.view
+                                              Data.ProtoLens.unknownFields _x)))))))))))
+instance Control.DeepSeq.NFData AddHoldInvoiceRequest where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_AddHoldInvoiceRequest'_unknownFields x__)
+             (Control.DeepSeq.deepseq
+                (_AddHoldInvoiceRequest'memo x__)
+                (Control.DeepSeq.deepseq
+                   (_AddHoldInvoiceRequest'hash x__)
+                   (Control.DeepSeq.deepseq
+                      (_AddHoldInvoiceRequest'value x__)
+                      (Control.DeepSeq.deepseq
+                         (_AddHoldInvoiceRequest'valueMsat x__)
+                         (Control.DeepSeq.deepseq
+                            (_AddHoldInvoiceRequest'descriptionHash x__)
+                            (Control.DeepSeq.deepseq
+                               (_AddHoldInvoiceRequest'expiry x__)
+                               (Control.DeepSeq.deepseq
+                                  (_AddHoldInvoiceRequest'fallbackAddr x__)
+                                  (Control.DeepSeq.deepseq
+                                     (_AddHoldInvoiceRequest'cltvExpiry x__)
+                                     (Control.DeepSeq.deepseq
+                                        (_AddHoldInvoiceRequest'routeHints x__)
+                                        (Control.DeepSeq.deepseq
+                                           (_AddHoldInvoiceRequest'private x__) ()))))))))))
+{- | Fields :
+     
+         * 'Proto.InvoiceGrpc_Fields.paymentRequest' @:: Lens' AddHoldInvoiceResp Data.Text.Text@ -}
+data AddHoldInvoiceResp
+  = AddHoldInvoiceResp'_constructor {_AddHoldInvoiceResp'paymentRequest :: !Data.Text.Text,
+                                     _AddHoldInvoiceResp'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show AddHoldInvoiceResp where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Field.HasField AddHoldInvoiceResp "paymentRequest" Data.Text.Text where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _AddHoldInvoiceResp'paymentRequest
+           (\ x__ y__ -> x__ {_AddHoldInvoiceResp'paymentRequest = y__}))
+        Prelude.id
+instance Data.ProtoLens.Message AddHoldInvoiceResp where
+  messageName _ = Data.Text.pack "invoicesrpc.AddHoldInvoiceResp"
+  packedMessageDescriptor _
+    = "\n\
+      \\DC2AddHoldInvoiceResp\DC2'\n\
+      \\SIpayment_request\CAN\SOH \SOH(\tR\SOpaymentRequest"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag
+    = let
+        paymentRequest__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "payment_request"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"paymentRequest")) ::
+              Data.ProtoLens.FieldDescriptor AddHoldInvoiceResp
+      in
+        Data.Map.fromList
+          [(Data.ProtoLens.Tag 1, paymentRequest__field_descriptor)]
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _AddHoldInvoiceResp'_unknownFields
+        (\ x__ y__ -> x__ {_AddHoldInvoiceResp'_unknownFields = y__})
+  defMessage
+    = AddHoldInvoiceResp'_constructor
+        {_AddHoldInvoiceResp'paymentRequest = Data.ProtoLens.fieldDefault,
+         _AddHoldInvoiceResp'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          AddHoldInvoiceResp
+          -> Data.ProtoLens.Encoding.Bytes.Parser AddHoldInvoiceResp
+        loop x
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of
+                        10
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                                       Data.ProtoLens.Encoding.Bytes.getBytes
+                                                         (Prelude.fromIntegral len)
+                                           Data.ProtoLens.Encoding.Bytes.runEither
+                                             (case Data.Text.Encoding.decodeUtf8' value of
+                                                (Prelude.Left err)
+                                                  -> Prelude.Left (Prelude.show err)
+                                                (Prelude.Right r) -> Prelude.Right r))
+                                       "payment_request"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"paymentRequest") y x)
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do loop Data.ProtoLens.defMessage) "AddHoldInvoiceResp"
+  buildMessage
+    = \ _x
+        -> (Data.Monoid.<>)
+             (let
+                _v
+                  = Lens.Family2.view
+                      (Data.ProtoLens.Field.field @"paymentRequest") _x
+              in
+                if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                    Data.Monoid.mempty
+                else
+                    (Data.Monoid.<>)
+                      (Data.ProtoLens.Encoding.Bytes.putVarInt 10)
+                      ((Prelude..)
+                         (\ bs
+                            -> (Data.Monoid.<>)
+                                 (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                    (Prelude.fromIntegral (Data.ByteString.length bs)))
+                                 (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                         Data.Text.Encoding.encodeUtf8
+                         _v))
+             (Data.ProtoLens.Encoding.Wire.buildFieldSet
+                (Lens.Family2.view Data.ProtoLens.unknownFields _x))
+instance Control.DeepSeq.NFData AddHoldInvoiceResp where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_AddHoldInvoiceResp'_unknownFields x__)
+             (Control.DeepSeq.deepseq
+                (_AddHoldInvoiceResp'paymentRequest x__) ())
+{- | Fields :
+     
+         * 'Proto.InvoiceGrpc_Fields.paymentHash' @:: Lens' CancelInvoiceMsg Data.ByteString.ByteString@ -}
+data CancelInvoiceMsg
+  = CancelInvoiceMsg'_constructor {_CancelInvoiceMsg'paymentHash :: !Data.ByteString.ByteString,
+                                   _CancelInvoiceMsg'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show CancelInvoiceMsg where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Field.HasField CancelInvoiceMsg "paymentHash" Data.ByteString.ByteString where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _CancelInvoiceMsg'paymentHash
+           (\ x__ y__ -> x__ {_CancelInvoiceMsg'paymentHash = y__}))
+        Prelude.id
+instance Data.ProtoLens.Message CancelInvoiceMsg where
+  messageName _ = Data.Text.pack "invoicesrpc.CancelInvoiceMsg"
+  packedMessageDescriptor _
+    = "\n\
+      \\DLECancelInvoiceMsg\DC2!\n\
+      \\fpayment_hash\CAN\SOH \SOH(\fR\vpaymentHash"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag
+    = let
+        paymentHash__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "payment_hash"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"paymentHash")) ::
+              Data.ProtoLens.FieldDescriptor CancelInvoiceMsg
+      in
+        Data.Map.fromList
+          [(Data.ProtoLens.Tag 1, paymentHash__field_descriptor)]
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _CancelInvoiceMsg'_unknownFields
+        (\ x__ y__ -> x__ {_CancelInvoiceMsg'_unknownFields = y__})
+  defMessage
+    = CancelInvoiceMsg'_constructor
+        {_CancelInvoiceMsg'paymentHash = Data.ProtoLens.fieldDefault,
+         _CancelInvoiceMsg'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          CancelInvoiceMsg
+          -> Data.ProtoLens.Encoding.Bytes.Parser CancelInvoiceMsg
+        loop x
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of
+                        10
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.getBytes
+                                             (Prelude.fromIntegral len))
+                                       "payment_hash"
+                                loop
+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"paymentHash") y x)
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do loop Data.ProtoLens.defMessage) "CancelInvoiceMsg"
+  buildMessage
+    = \ _x
+        -> (Data.Monoid.<>)
+             (let
+                _v
+                  = Lens.Family2.view (Data.ProtoLens.Field.field @"paymentHash") _x
+              in
+                if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                    Data.Monoid.mempty
+                else
+                    (Data.Monoid.<>)
+                      (Data.ProtoLens.Encoding.Bytes.putVarInt 10)
+                      ((\ bs
+                          -> (Data.Monoid.<>)
+                               (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                  (Prelude.fromIntegral (Data.ByteString.length bs)))
+                               (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                         _v))
+             (Data.ProtoLens.Encoding.Wire.buildFieldSet
+                (Lens.Family2.view Data.ProtoLens.unknownFields _x))
+instance Control.DeepSeq.NFData CancelInvoiceMsg where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_CancelInvoiceMsg'_unknownFields x__)
+             (Control.DeepSeq.deepseq (_CancelInvoiceMsg'paymentHash x__) ())
+{- | Fields :
+      -}
+data CancelInvoiceResp
+  = CancelInvoiceResp'_constructor {_CancelInvoiceResp'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show CancelInvoiceResp where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Message CancelInvoiceResp where
+  messageName _ = Data.Text.pack "invoicesrpc.CancelInvoiceResp"
+  packedMessageDescriptor _
+    = "\n\
+      \\DC1CancelInvoiceResp"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag = let in Data.Map.fromList []
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _CancelInvoiceResp'_unknownFields
+        (\ x__ y__ -> x__ {_CancelInvoiceResp'_unknownFields = y__})
+  defMessage
+    = CancelInvoiceResp'_constructor
+        {_CancelInvoiceResp'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          CancelInvoiceResp
+          -> Data.ProtoLens.Encoding.Bytes.Parser CancelInvoiceResp
+        loop x
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of {
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) }
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do loop Data.ProtoLens.defMessage) "CancelInvoiceResp"
+  buildMessage
+    = \ _x
+        -> Data.ProtoLens.Encoding.Wire.buildFieldSet
+             (Lens.Family2.view Data.ProtoLens.unknownFields _x)
+instance Control.DeepSeq.NFData CancelInvoiceResp where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_CancelInvoiceResp'_unknownFields x__) ()
+{- | Fields :
+     
+         * 'Proto.InvoiceGrpc_Fields.preimage' @:: Lens' SettleInvoiceMsg Data.ByteString.ByteString@ -}
+data SettleInvoiceMsg
+  = SettleInvoiceMsg'_constructor {_SettleInvoiceMsg'preimage :: !Data.ByteString.ByteString,
+                                   _SettleInvoiceMsg'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show SettleInvoiceMsg where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Field.HasField SettleInvoiceMsg "preimage" Data.ByteString.ByteString where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _SettleInvoiceMsg'preimage
+           (\ x__ y__ -> x__ {_SettleInvoiceMsg'preimage = y__}))
+        Prelude.id
+instance Data.ProtoLens.Message SettleInvoiceMsg where
+  messageName _ = Data.Text.pack "invoicesrpc.SettleInvoiceMsg"
+  packedMessageDescriptor _
+    = "\n\
+      \\DLESettleInvoiceMsg\DC2\SUB\n\
+      \\bpreimage\CAN\SOH \SOH(\fR\bpreimage"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag
+    = let
+        preimage__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "preimage"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"preimage")) ::
+              Data.ProtoLens.FieldDescriptor SettleInvoiceMsg
+      in
+        Data.Map.fromList
+          [(Data.ProtoLens.Tag 1, preimage__field_descriptor)]
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _SettleInvoiceMsg'_unknownFields
+        (\ x__ y__ -> x__ {_SettleInvoiceMsg'_unknownFields = y__})
+  defMessage
+    = SettleInvoiceMsg'_constructor
+        {_SettleInvoiceMsg'preimage = Data.ProtoLens.fieldDefault,
+         _SettleInvoiceMsg'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          SettleInvoiceMsg
+          -> Data.ProtoLens.Encoding.Bytes.Parser SettleInvoiceMsg
+        loop x
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of
+                        10
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.getBytes
+                                             (Prelude.fromIntegral len))
+                                       "preimage"
+                                loop
+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"preimage") y x)
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do loop Data.ProtoLens.defMessage) "SettleInvoiceMsg"
+  buildMessage
+    = \ _x
+        -> (Data.Monoid.<>)
+             (let
+                _v = Lens.Family2.view (Data.ProtoLens.Field.field @"preimage") _x
+              in
+                if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                    Data.Monoid.mempty
+                else
+                    (Data.Monoid.<>)
+                      (Data.ProtoLens.Encoding.Bytes.putVarInt 10)
+                      ((\ bs
+                          -> (Data.Monoid.<>)
+                               (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                  (Prelude.fromIntegral (Data.ByteString.length bs)))
+                               (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                         _v))
+             (Data.ProtoLens.Encoding.Wire.buildFieldSet
+                (Lens.Family2.view Data.ProtoLens.unknownFields _x))
+instance Control.DeepSeq.NFData SettleInvoiceMsg where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_SettleInvoiceMsg'_unknownFields x__)
+             (Control.DeepSeq.deepseq (_SettleInvoiceMsg'preimage x__) ())
+{- | Fields :
+      -}
+data SettleInvoiceResp
+  = SettleInvoiceResp'_constructor {_SettleInvoiceResp'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show SettleInvoiceResp where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Message SettleInvoiceResp where
+  messageName _ = Data.Text.pack "invoicesrpc.SettleInvoiceResp"
+  packedMessageDescriptor _
+    = "\n\
+      \\DC1SettleInvoiceResp"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag = let in Data.Map.fromList []
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _SettleInvoiceResp'_unknownFields
+        (\ x__ y__ -> x__ {_SettleInvoiceResp'_unknownFields = y__})
+  defMessage
+    = SettleInvoiceResp'_constructor
+        {_SettleInvoiceResp'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          SettleInvoiceResp
+          -> Data.ProtoLens.Encoding.Bytes.Parser SettleInvoiceResp
+        loop x
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of {
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) }
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do loop Data.ProtoLens.defMessage) "SettleInvoiceResp"
+  buildMessage
+    = \ _x
+        -> Data.ProtoLens.Encoding.Wire.buildFieldSet
+             (Lens.Family2.view Data.ProtoLens.unknownFields _x)
+instance Control.DeepSeq.NFData SettleInvoiceResp where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_SettleInvoiceResp'_unknownFields x__) ()
+{- | Fields :
+     
+         * 'Proto.InvoiceGrpc_Fields.rHash' @:: Lens' SubscribeSingleInvoiceRequest Data.ByteString.ByteString@ -}
+data SubscribeSingleInvoiceRequest
+  = SubscribeSingleInvoiceRequest'_constructor {_SubscribeSingleInvoiceRequest'rHash :: !Data.ByteString.ByteString,
+                                                _SubscribeSingleInvoiceRequest'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show SubscribeSingleInvoiceRequest where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Field.HasField SubscribeSingleInvoiceRequest "rHash" Data.ByteString.ByteString where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _SubscribeSingleInvoiceRequest'rHash
+           (\ x__ y__ -> x__ {_SubscribeSingleInvoiceRequest'rHash = y__}))
+        Prelude.id
+instance Data.ProtoLens.Message SubscribeSingleInvoiceRequest where
+  messageName _
+    = Data.Text.pack "invoicesrpc.SubscribeSingleInvoiceRequest"
+  packedMessageDescriptor _
+    = "\n\
+      \\GSSubscribeSingleInvoiceRequest\DC2\NAK\n\
+      \\ACKr_hash\CAN\STX \SOH(\fR\ENQrHashJ\EOT\b\SOH\DLE\STX"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag
+    = let
+        rHash__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "r_hash"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional (Data.ProtoLens.Field.field @"rHash")) ::
+              Data.ProtoLens.FieldDescriptor SubscribeSingleInvoiceRequest
+      in
+        Data.Map.fromList [(Data.ProtoLens.Tag 2, rHash__field_descriptor)]
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _SubscribeSingleInvoiceRequest'_unknownFields
+        (\ x__ y__
+           -> x__ {_SubscribeSingleInvoiceRequest'_unknownFields = y__})
+  defMessage
+    = SubscribeSingleInvoiceRequest'_constructor
+        {_SubscribeSingleInvoiceRequest'rHash = Data.ProtoLens.fieldDefault,
+         _SubscribeSingleInvoiceRequest'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          SubscribeSingleInvoiceRequest
+          -> Data.ProtoLens.Encoding.Bytes.Parser SubscribeSingleInvoiceRequest
+        loop x
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of
+                        18
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.getBytes
+                                             (Prelude.fromIntegral len))
+                                       "r_hash"
+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"rHash") y x)
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do loop Data.ProtoLens.defMessage) "SubscribeSingleInvoiceRequest"
+  buildMessage
+    = \ _x
+        -> (Data.Monoid.<>)
+             (let
+                _v = Lens.Family2.view (Data.ProtoLens.Field.field @"rHash") _x
+              in
+                if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                    Data.Monoid.mempty
+                else
+                    (Data.Monoid.<>)
+                      (Data.ProtoLens.Encoding.Bytes.putVarInt 18)
+                      ((\ bs
+                          -> (Data.Monoid.<>)
+                               (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                  (Prelude.fromIntegral (Data.ByteString.length bs)))
+                               (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                         _v))
+             (Data.ProtoLens.Encoding.Wire.buildFieldSet
+                (Lens.Family2.view Data.ProtoLens.unknownFields _x))
+instance Control.DeepSeq.NFData SubscribeSingleInvoiceRequest where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_SubscribeSingleInvoiceRequest'_unknownFields x__)
+             (Control.DeepSeq.deepseq
+                (_SubscribeSingleInvoiceRequest'rHash x__) ())
+data Invoices = Invoices {}
+instance Data.ProtoLens.Service.Types.Service Invoices where
+  type ServiceName Invoices = "Invoices"
+  type ServicePackage Invoices = "invoicesrpc"
+  type ServiceMethods Invoices = '["addHoldInvoice",
+                                   "cancelInvoice",
+                                   "settleInvoice",
+                                   "subscribeSingleInvoice"]
+instance Data.ProtoLens.Service.Types.HasMethodImpl Invoices "subscribeSingleInvoice" where
+  type MethodName Invoices "subscribeSingleInvoice" = "SubscribeSingleInvoice"
+  type MethodInput Invoices "subscribeSingleInvoice" = SubscribeSingleInvoiceRequest
+  type MethodOutput Invoices "subscribeSingleInvoice" = Proto.LndGrpc.Invoice
+  type MethodStreamingType Invoices "subscribeSingleInvoice" =  'Data.ProtoLens.Service.Types.ServerStreaming
+instance Data.ProtoLens.Service.Types.HasMethodImpl Invoices "cancelInvoice" where
+  type MethodName Invoices "cancelInvoice" = "CancelInvoice"
+  type MethodInput Invoices "cancelInvoice" = CancelInvoiceMsg
+  type MethodOutput Invoices "cancelInvoice" = CancelInvoiceResp
+  type MethodStreamingType Invoices "cancelInvoice" =  'Data.ProtoLens.Service.Types.NonStreaming
+instance Data.ProtoLens.Service.Types.HasMethodImpl Invoices "addHoldInvoice" where
+  type MethodName Invoices "addHoldInvoice" = "AddHoldInvoice"
+  type MethodInput Invoices "addHoldInvoice" = AddHoldInvoiceRequest
+  type MethodOutput Invoices "addHoldInvoice" = AddHoldInvoiceResp
+  type MethodStreamingType Invoices "addHoldInvoice" =  'Data.ProtoLens.Service.Types.NonStreaming
+instance Data.ProtoLens.Service.Types.HasMethodImpl Invoices "settleInvoice" where
+  type MethodName Invoices "settleInvoice" = "SettleInvoice"
+  type MethodInput Invoices "settleInvoice" = SettleInvoiceMsg
+  type MethodOutput Invoices "settleInvoice" = SettleInvoiceResp
+  type MethodStreamingType Invoices "settleInvoice" =  'Data.ProtoLens.Service.Types.NonStreaming
+packedFileDescriptor :: Data.ByteString.ByteString
+packedFileDescriptor
+  = "\n\
+    \\DC2invoice_grpc.proto\DC2\vinvoicesrpc\SUB\SOlnd_grpc.proto\"5\n\
+    \\DLECancelInvoiceMsg\DC2!\n\
+    \\fpayment_hash\CAN\SOH \SOH(\fR\vpaymentHash\"\DC3\n\
+    \\DC1CancelInvoiceResp\"\202\STX\n\
+    \\NAKAddHoldInvoiceRequest\DC2\DC2\n\
+    \\EOTmemo\CAN\SOH \SOH(\tR\EOTmemo\DC2\DC2\n\
+    \\EOThash\CAN\STX \SOH(\fR\EOThash\DC2\DC4\n\
+    \\ENQvalue\CAN\ETX \SOH(\ETXR\ENQvalue\DC2\GS\n\
+    \\n\
+    \value_msat\CAN\n\
+    \ \SOH(\ETXR\tvalueMsat\DC2)\n\
+    \\DLEdescription_hash\CAN\EOT \SOH(\fR\SIdescriptionHash\DC2\SYN\n\
+    \\ACKexpiry\CAN\ENQ \SOH(\ETXR\ACKexpiry\DC2#\n\
+    \\rfallback_addr\CAN\ACK \SOH(\tR\ffallbackAddr\DC2\US\n\
+    \\vcltv_expiry\CAN\a \SOH(\EOTR\n\
+    \cltvExpiry\DC21\n\
+    \\vroute_hints\CAN\b \ETX(\v2\DLE.lnrpc.RouteHintR\n\
+    \routeHints\DC2\CAN\n\
+    \\aprivate\CAN\t \SOH(\bR\aprivate\"=\n\
+    \\DC2AddHoldInvoiceResp\DC2'\n\
+    \\SIpayment_request\CAN\SOH \SOH(\tR\SOpaymentRequest\".\n\
+    \\DLESettleInvoiceMsg\DC2\SUB\n\
+    \\bpreimage\CAN\SOH \SOH(\fR\bpreimage\"\DC3\n\
+    \\DC1SettleInvoiceResp\"<\n\
+    \\GSSubscribeSingleInvoiceRequest\DC2\NAK\n\
+    \\ACKr_hash\CAN\STX \SOH(\fR\ENQrHashJ\EOT\b\SOH\DLE\STX2\217\STX\n\
+    \\bInvoices\DC2V\n\
+    \\SYNSubscribeSingleInvoice\DC2*.invoicesrpc.SubscribeSingleInvoiceRequest\SUB\SO.lnrpc.Invoice0\SOH\DC2N\n\
+    \\rCancelInvoice\DC2\GS.invoicesrpc.CancelInvoiceMsg\SUB\RS.invoicesrpc.CancelInvoiceResp\DC2U\n\
+    \\SOAddHoldInvoice\DC2\".invoicesrpc.AddHoldInvoiceRequest\SUB\US.invoicesrpc.AddHoldInvoiceResp\DC2N\n\
+    \\rSettleInvoice\DC2\GS.invoicesrpc.SettleInvoiceMsg\SUB\RS.invoicesrpc.SettleInvoiceRespB3Z1github.com/lightningnetwork/lnd/lnrpc/invoicesrpcJ\242\FS\n\
+    \\ACK\DC2\EOT\STX\NUL{\SOH\n\
+    \\147\SOH\n\
+    \\SOH\f\DC2\ETX\STX\NUL\DC22\136\SOHsource https://raw.githubusercontent.com/lightningnetwork/lnd/c733c139e95a6ef4e5f9ac88b43328ac96c333ef/lnrpc/invoicesrpc/invoices.proto\n\
+    \\n\
+    \\t\n\
+    \\STX\ETX\NUL\DC2\ETX\EOT\NUL\CAN\n\
+    \\b\n\
+    \\SOH\STX\DC2\ETX\ACK\NUL\DC4\n\
+    \\b\n\
+    \\SOH\b\DC2\ETX\b\NULH\n\
+    \\t\n\
+    \\STX\b\v\DC2\ETX\b\NULH\n\
+    \d\n\
+    \\STX\ACK\NUL\DC2\EOT\f\NUL'\SOH\SUBX Invoices is a service that can be used to create, accept, settle and cancel\n\
+    \ invoices.\n\
+    \\n\
+    \\n\
+    \\n\
+    \\ETX\ACK\NUL\SOH\DC2\ETX\f\b\DLE\n\
+    \\215\SOH\n\
+    \\EOT\ACK\NUL\STX\NUL\DC2\EOT\DC2\EOT\DC3'\SUB\200\SOH\n\
+    \SubscribeSingleInvoice returns a uni-directional stream (server -> client)\n\
+    \to notify the client of state transitions of the specified invoice.\n\
+    \Initially the current invoice state is always sent out.\n\
+    \\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\NUL\SOH\DC2\ETX\DC2\b\RS\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\NUL\STX\DC2\ETX\DC2 =\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\NUL\ACK\DC2\ETX\DC3\DC1\ETB\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\NUL\ETX\DC2\ETX\DC3\CAN%\n\
+    \\172\SOH\n\
+    \\EOT\ACK\NUL\STX\SOH\DC2\ETX\SUB\EOTE\SUB\158\SOH\n\
+    \CancelInvoice cancels a currently open invoice. If the invoice is already\n\
+    \canceled, this call will succeed. If the invoice is already settled, it will\n\
+    \fail.\n\
+    \\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\SOH\SOH\DC2\ETX\SUB\b\NAK\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\SOH\STX\DC2\ETX\SUB\ETB'\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\SOH\ETX\DC2\ETX\SUB2C\n\
+    \n\n\
+    \\EOT\ACK\NUL\STX\STX\DC2\ETX \EOTL\SUBa\n\
+    \AddHoldInvoice creates a hold invoice. It ties the invoice to the hash\n\
+    \supplied in the request.\n\
+    \\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\STX\SOH\DC2\ETX \b\SYN\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\STX\STX\DC2\ETX \CAN-\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\STX\ETX\DC2\ETX 8J\n\
+    \t\n\
+    \\EOT\ACK\NUL\STX\ETX\DC2\ETX&\EOTE\SUBg\n\
+    \SettleInvoice settles an accepted invoice. If the invoice is already\n\
+    \settled, this call will succeed.\n\
+    \\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\ETX\SOH\DC2\ETX&\b\NAK\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\ETX\STX\DC2\ETX&\ETB'\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\ETX\ETX\DC2\ETX&2C\n\
+    \\n\
+    \\n\
+    \\STX\EOT\NUL\DC2\EOT)\NUL,\SOH\n\
+    \\n\
+    \\n\
+    \\ETX\EOT\NUL\SOH\DC2\ETX)\b\CAN\n\
+    \B\n\
+    \\EOT\EOT\NUL\STX\NUL\DC2\ETX+\EOT\ESC\SUB5 Hash corresponding to the (hold) invoice to cancel.\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\NUL\EOT\DC2\EOT+\EOT)\SUB\n\
+    \\f\n\
+    \\ENQ\EOT\NUL\STX\NUL\ENQ\DC2\ETX+\EOT\t\n\
+    \\f\n\
+    \\ENQ\EOT\NUL\STX\NUL\SOH\DC2\ETX+\n\
+    \\SYN\n\
+    \\f\n\
+    \\ENQ\EOT\NUL\STX\NUL\ETX\DC2\ETX+\EM\SUB\n\
+    \\n\
+    \\n\
+    \\STX\EOT\SOH\DC2\EOT-\NUL.\SOH\n\
+    \\n\
+    \\n\
+    \\ETX\EOT\SOH\SOH\DC2\ETX-\b\EM\n\
+    \\n\
+    \\n\
+    \\STX\EOT\STX\DC2\EOT0\NULb\SOH\n\
+    \\n\
+    \\n\
+    \\ETX\EOT\STX\SOH\DC2\ETX0\b\GS\n\
+    \\252\SOH\n\
+    \\EOT\EOT\STX\STX\NUL\DC2\ETX7\EOT\DC4\SUB\238\SOH\n\
+    \An optional memo to attach along with the invoice. Used for record keeping\n\
+    \purposes for the invoice's creator, and will also be set in the description\n\
+    \field of the encoded payment request if the description_hash field is not\n\
+    \being used.\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT\STX\STX\NUL\EOT\DC2\EOT7\EOT0\US\n\
+    \\f\n\
+    \\ENQ\EOT\STX\STX\NUL\ENQ\DC2\ETX7\EOT\n\
+    \\n\
+    \\f\n\
+    \\ENQ\EOT\STX\STX\NUL\SOH\DC2\ETX7\v\SI\n\
+    \\f\n\
+    \\ENQ\EOT\STX\STX\NUL\ETX\DC2\ETX7\DC2\DC3\n\
+    \'\n\
+    \\EOT\EOT\STX\STX\SOH\DC2\ETX:\EOT\DC3\SUB\SUB The hash of the preimage\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT\STX\STX\SOH\EOT\DC2\EOT:\EOT7\DC4\n\
+    \\f\n\
+    \\ENQ\EOT\STX\STX\SOH\ENQ\DC2\ETX:\EOT\t\n\
+    \\f\n\
+    \\ENQ\EOT\STX\STX\SOH\SOH\DC2\ETX:\n\
+    \\SO\n\
+    \\f\n\
+    \\ENQ\EOT\STX\STX\SOH\ETX\DC2\ETX:\DC1\DC2\n\
+    \m\n\
+    \\EOT\EOT\STX\STX\STX\DC2\ETXA\EOT\DC4\SUB`\n\
+    \The value of this invoice in satoshis\n\
+    \\n\
+    \The fields value and value_msat are mutually exclusive.\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT\STX\STX\STX\EOT\DC2\EOTA\EOT:\DC3\n\
+    \\f\n\
+    \\ENQ\EOT\STX\STX\STX\ENQ\DC2\ETXA\EOT\t\n\
+    \\f\n\
+    \\ENQ\EOT\STX\STX\STX\SOH\DC2\ETXA\n\
+    \\SI\n\
+    \\f\n\
+    \\ENQ\EOT\STX\STX\STX\ETX\DC2\ETXA\DC2\DC3\n\
+    \r\n\
+    \\EOT\EOT\STX\STX\ETX\DC2\ETXH\EOT\SUB\SUBe\n\
+    \The value of this invoice in millisatoshis\n\
+    \\n\
+    \The fields value and value_msat are mutually exclusive.\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT\STX\STX\ETX\EOT\DC2\EOTH\EOTA\DC4\n\
+    \\f\n\
+    \\ENQ\EOT\STX\STX\ETX\ENQ\DC2\ETXH\EOT\t\n\
+    \\f\n\
+    \\ENQ\EOT\STX\STX\ETX\SOH\DC2\ETXH\n\
+    \\DC4\n\
+    \\f\n\
+    \\ENQ\EOT\STX\STX\ETX\ETX\DC2\ETXH\ETB\EM\n\
+    \\194\SOH\n\
+    \\EOT\EOT\STX\STX\EOT\DC2\ETXO\EOT\US\SUB\180\SOH\n\
+    \Hash (SHA-256) of a description of the payment. Used if the description of\n\
+    \payment (memo) is too long to naturally fit within the description field\n\
+    \of an encoded payment request.\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT\STX\STX\EOT\EOT\DC2\EOTO\EOTH\SUB\n\
+    \\f\n\
+    \\ENQ\EOT\STX\STX\EOT\ENQ\DC2\ETXO\EOT\t\n\
+    \\f\n\
+    \\ENQ\EOT\STX\STX\EOT\SOH\DC2\ETXO\n\
+    \\SUB\n\
+    \\f\n\
+    \\ENQ\EOT\STX\STX\EOT\ETX\DC2\ETXO\GS\RS\n\
+    \P\n\
+    \\EOT\EOT\STX\STX\ENQ\DC2\ETXR\EOT\NAK\SUBC Payment request expiry time in seconds. Default is 3600 (1 hour).\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT\STX\STX\ENQ\EOT\DC2\EOTR\EOTO\US\n\
+    \\f\n\
+    \\ENQ\EOT\STX\STX\ENQ\ENQ\DC2\ETXR\EOT\t\n\
+    \\f\n\
+    \\ENQ\EOT\STX\STX\ENQ\SOH\DC2\ETXR\n\
+    \\DLE\n\
+    \\f\n\
+    \\ENQ\EOT\STX\STX\ENQ\ETX\DC2\ETXR\DC3\DC4\n\
+    \)\n\
+    \\EOT\EOT\STX\STX\ACK\DC2\ETXU\EOT\GS\SUB\FS Fallback on-chain address.\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT\STX\STX\ACK\EOT\DC2\EOTU\EOTR\NAK\n\
+    \\f\n\
+    \\ENQ\EOT\STX\STX\ACK\ENQ\DC2\ETXU\EOT\n\
+    \\n\
+    \\f\n\
+    \\ENQ\EOT\STX\STX\ACK\SOH\DC2\ETXU\v\CAN\n\
+    \\f\n\
+    \\ENQ\EOT\STX\STX\ACK\ETX\DC2\ETXU\ESC\FS\n\
+    \T\n\
+    \\EOT\EOT\STX\STX\a\DC2\ETXX\EOT\ESC\SUBG Delta to use for the time-lock of the CLTV extended to the final hop.\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT\STX\STX\a\EOT\DC2\EOTX\EOTU\GS\n\
+    \\f\n\
+    \\ENQ\EOT\STX\STX\a\ENQ\DC2\ETXX\EOT\n\
+    \\n\
+    \\f\n\
+    \\ENQ\EOT\STX\STX\a\SOH\DC2\ETXX\v\SYN\n\
+    \\f\n\
+    \\ENQ\EOT\STX\STX\a\ETX\DC2\ETXX\EM\SUB\n\
+    \n\n\
+    \\EOT\EOT\STX\STX\b\DC2\ETX^\EOT-\SUBa\n\
+    \Route hints that can each be individually used to assist in reaching the\n\
+    \invoice's destination.\n\
+    \\n\
+    \\f\n\
+    \\ENQ\EOT\STX\STX\b\EOT\DC2\ETX^\EOT\f\n\
+    \\f\n\
+    \\ENQ\EOT\STX\STX\b\ACK\DC2\ETX^\r\FS\n\
+    \\f\n\
+    \\ENQ\EOT\STX\STX\b\SOH\DC2\ETX^\GS(\n\
+    \\f\n\
+    \\ENQ\EOT\STX\STX\b\ETX\DC2\ETX^+,\n\
+    \V\n\
+    \\EOT\EOT\STX\STX\t\DC2\ETXa\EOT\NAK\SUBI Whether this invoice should include routing hints for private channels.\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT\STX\STX\t\EOT\DC2\EOTa\EOT^-\n\
+    \\f\n\
+    \\ENQ\EOT\STX\STX\t\ENQ\DC2\ETXa\EOT\b\n\
+    \\f\n\
+    \\ENQ\EOT\STX\STX\t\SOH\DC2\ETXa\t\DLE\n\
+    \\f\n\
+    \\ENQ\EOT\STX\STX\t\ETX\DC2\ETXa\DC3\DC4\n\
+    \\n\
+    \\n\
+    \\STX\EOT\ETX\DC2\EOTd\NULk\SOH\n\
+    \\n\
+    \\n\
+    \\ETX\EOT\ETX\SOH\DC2\ETXd\b\SUB\n\
+    \\188\SOH\n\
+    \\EOT\EOT\ETX\STX\NUL\DC2\ETXj\EOT\US\SUB\174\SOH\n\
+    \A bare-bones invoice for a payment within the Lightning Network.  With the\n\
+    \details of the invoice, the sender has all the data necessary to send a\n\
+    \payment to the recipient.\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT\ETX\STX\NUL\EOT\DC2\EOTj\EOTd\FS\n\
+    \\f\n\
+    \\ENQ\EOT\ETX\STX\NUL\ENQ\DC2\ETXj\EOT\n\
+    \\n\
+    \\f\n\
+    \\ENQ\EOT\ETX\STX\NUL\SOH\DC2\ETXj\v\SUB\n\
+    \\f\n\
+    \\ENQ\EOT\ETX\STX\NUL\ETX\DC2\ETXj\GS\RS\n\
+    \\n\
+    \\n\
+    \\STX\EOT\EOT\DC2\EOTm\NULq\SOH\n\
+    \\n\
+    \\n\
+    \\ETX\EOT\EOT\SOH\DC2\ETXm\b\CAN\n\
+    \_\n\
+    \\EOT\EOT\EOT\STX\NUL\DC2\ETXp\EOT\ETB\SUBR Externally discovered pre-image that should be used to settle the hold\n\
+    \ invoice.\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT\EOT\STX\NUL\EOT\DC2\EOTp\EOTm\SUB\n\
+    \\f\n\
+    \\ENQ\EOT\EOT\STX\NUL\ENQ\DC2\ETXp\EOT\t\n\
+    \\f\n\
+    \\ENQ\EOT\EOT\STX\NUL\SOH\DC2\ETXp\n\
+    \\DC2\n\
+    \\f\n\
+    \\ENQ\EOT\EOT\STX\NUL\ETX\DC2\ETXp\NAK\SYN\n\
+    \\n\
+    \\n\
+    \\STX\EOT\ENQ\DC2\EOTs\NULt\SOH\n\
+    \\n\
+    \\n\
+    \\ETX\EOT\ENQ\SOH\DC2\ETXs\b\EM\n\
+    \\n\
+    \\n\
+    \\STX\EOT\ACK\DC2\EOTv\NUL{\SOH\n\
+    \\n\
+    \\n\
+    \\ETX\EOT\ACK\SOH\DC2\ETXv\b%\n\
+    \\n\
+    \\n\
+    \\ETX\EOT\ACK\t\DC2\ETXw\EOT\SI\n\
+    \\v\n\
+    \\EOT\EOT\ACK\t\NUL\DC2\ETXw\r\SO\n\
+    \\f\n\
+    \\ENQ\EOT\ACK\t\NUL\SOH\DC2\ETXw\r\SO\n\
+    \\f\n\
+    \\ENQ\EOT\ACK\t\NUL\STX\DC2\ETXw\r\SO\n\
+    \H\n\
+    \\EOT\EOT\ACK\STX\NUL\DC2\ETXz\EOT\NAK\SUB; Hash corresponding to the (hold) invoice to subscribe to.\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT\ACK\STX\NUL\EOT\DC2\EOTz\EOTw\SI\n\
+    \\f\n\
+    \\ENQ\EOT\ACK\STX\NUL\ENQ\DC2\ETXz\EOT\t\n\
+    \\f\n\
+    \\ENQ\EOT\ACK\STX\NUL\SOH\DC2\ETXz\n\
+    \\DLE\n\
+    \\f\n\
+    \\ENQ\EOT\ACK\STX\NUL\ETX\DC2\ETXz\DC3\DC4b\ACKproto3"
diff --git a/src/Proto/InvoiceGrpc_Fields.hs b/src/Proto/InvoiceGrpc_Fields.hs
new file mode 100644
--- /dev/null
+++ b/src/Proto/InvoiceGrpc_Fields.hs
@@ -0,0 +1,114 @@
+{- This file was auto-generated from invoice_grpc.proto by the proto-lens-protoc program. -}
+{-# LANGUAGE ScopedTypeVariables, DataKinds, TypeFamilies, UndecidableInstances, GeneralizedNewtypeDeriving, MultiParamTypeClasses, FlexibleContexts, FlexibleInstances, PatternSynonyms, MagicHash, NoImplicitPrelude, DataKinds, BangPatterns, TypeApplications, OverloadedStrings, DerivingStrategies#-}
+{-# OPTIONS_GHC -Wno-unused-imports#-}
+{-# OPTIONS_GHC -Wno-duplicate-exports#-}
+{-# OPTIONS_GHC -Wno-dodgy-exports#-}
+module Proto.InvoiceGrpc_Fields where
+import qualified Data.ProtoLens.Runtime.Prelude as Prelude
+import qualified Data.ProtoLens.Runtime.Data.Int as Data.Int
+import qualified Data.ProtoLens.Runtime.Data.Monoid as Data.Monoid
+import qualified Data.ProtoLens.Runtime.Data.Word as Data.Word
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens as Data.ProtoLens
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Bytes as Data.ProtoLens.Encoding.Bytes
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Growing as Data.ProtoLens.Encoding.Growing
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Parser.Unsafe as Data.ProtoLens.Encoding.Parser.Unsafe
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Wire as Data.ProtoLens.Encoding.Wire
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Field as Data.ProtoLens.Field
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Message.Enum as Data.ProtoLens.Message.Enum
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Service.Types as Data.ProtoLens.Service.Types
+import qualified Data.ProtoLens.Runtime.Lens.Family2 as Lens.Family2
+import qualified Data.ProtoLens.Runtime.Lens.Family2.Unchecked as Lens.Family2.Unchecked
+import qualified Data.ProtoLens.Runtime.Data.Text as Data.Text
+import qualified Data.ProtoLens.Runtime.Data.Map as Data.Map
+import qualified Data.ProtoLens.Runtime.Data.ByteString as Data.ByteString
+import qualified Data.ProtoLens.Runtime.Data.ByteString.Char8 as Data.ByteString.Char8
+import qualified Data.ProtoLens.Runtime.Data.Text.Encoding as Data.Text.Encoding
+import qualified Data.ProtoLens.Runtime.Data.Vector as Data.Vector
+import qualified Data.ProtoLens.Runtime.Data.Vector.Generic as Data.Vector.Generic
+import qualified Data.ProtoLens.Runtime.Data.Vector.Unboxed as Data.Vector.Unboxed
+import qualified Data.ProtoLens.Runtime.Text.Read as Text.Read
+import qualified Proto.LndGrpc
+cltvExpiry ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "cltvExpiry" a) =>
+  Lens.Family2.LensLike' f s a
+cltvExpiry = Data.ProtoLens.Field.field @"cltvExpiry"
+descriptionHash ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "descriptionHash" a) =>
+  Lens.Family2.LensLike' f s a
+descriptionHash = Data.ProtoLens.Field.field @"descriptionHash"
+expiry ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "expiry" a) =>
+  Lens.Family2.LensLike' f s a
+expiry = Data.ProtoLens.Field.field @"expiry"
+fallbackAddr ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "fallbackAddr" a) =>
+  Lens.Family2.LensLike' f s a
+fallbackAddr = Data.ProtoLens.Field.field @"fallbackAddr"
+hash ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "hash" a) =>
+  Lens.Family2.LensLike' f s a
+hash = Data.ProtoLens.Field.field @"hash"
+memo ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "memo" a) =>
+  Lens.Family2.LensLike' f s a
+memo = Data.ProtoLens.Field.field @"memo"
+paymentHash ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "paymentHash" a) =>
+  Lens.Family2.LensLike' f s a
+paymentHash = Data.ProtoLens.Field.field @"paymentHash"
+paymentRequest ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "paymentRequest" a) =>
+  Lens.Family2.LensLike' f s a
+paymentRequest = Data.ProtoLens.Field.field @"paymentRequest"
+preimage ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "preimage" a) =>
+  Lens.Family2.LensLike' f s a
+preimage = Data.ProtoLens.Field.field @"preimage"
+private ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "private" a) =>
+  Lens.Family2.LensLike' f s a
+private = Data.ProtoLens.Field.field @"private"
+rHash ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "rHash" a) =>
+  Lens.Family2.LensLike' f s a
+rHash = Data.ProtoLens.Field.field @"rHash"
+routeHints ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "routeHints" a) =>
+  Lens.Family2.LensLike' f s a
+routeHints = Data.ProtoLens.Field.field @"routeHints"
+value ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "value" a) =>
+  Lens.Family2.LensLike' f s a
+value = Data.ProtoLens.Field.field @"value"
+valueMsat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "valueMsat" a) =>
+  Lens.Family2.LensLike' f s a
+valueMsat = Data.ProtoLens.Field.field @"valueMsat"
+vec'routeHints ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'routeHints" a) =>
+  Lens.Family2.LensLike' f s a
+vec'routeHints = Data.ProtoLens.Field.field @"vec'routeHints"
diff --git a/src/Proto/LndGrpc.hs b/src/Proto/LndGrpc.hs
new file mode 100644
# file too large to diff: src/Proto/LndGrpc.hs
diff --git a/src/Proto/LndGrpc_Fields.hs b/src/Proto/LndGrpc_Fields.hs
new file mode 100644
--- /dev/null
+++ b/src/Proto/LndGrpc_Fields.hs
@@ -0,0 +1,3320 @@
+{- This file was auto-generated from lnd_grpc.proto by the proto-lens-protoc program. -}
+{-# LANGUAGE ScopedTypeVariables, DataKinds, TypeFamilies, UndecidableInstances, GeneralizedNewtypeDeriving, MultiParamTypeClasses, FlexibleContexts, FlexibleInstances, PatternSynonyms, MagicHash, NoImplicitPrelude, DataKinds, BangPatterns, TypeApplications, OverloadedStrings, DerivingStrategies#-}
+{-# OPTIONS_GHC -Wno-unused-imports#-}
+{-# OPTIONS_GHC -Wno-duplicate-exports#-}
+{-# OPTIONS_GHC -Wno-dodgy-exports#-}
+module Proto.LndGrpc_Fields where
+import qualified Data.ProtoLens.Runtime.Prelude as Prelude
+import qualified Data.ProtoLens.Runtime.Data.Int as Data.Int
+import qualified Data.ProtoLens.Runtime.Data.Monoid as Data.Monoid
+import qualified Data.ProtoLens.Runtime.Data.Word as Data.Word
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens as Data.ProtoLens
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Bytes as Data.ProtoLens.Encoding.Bytes
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Growing as Data.ProtoLens.Encoding.Growing
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Parser.Unsafe as Data.ProtoLens.Encoding.Parser.Unsafe
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Wire as Data.ProtoLens.Encoding.Wire
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Field as Data.ProtoLens.Field
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Message.Enum as Data.ProtoLens.Message.Enum
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Service.Types as Data.ProtoLens.Service.Types
+import qualified Data.ProtoLens.Runtime.Lens.Family2 as Lens.Family2
+import qualified Data.ProtoLens.Runtime.Lens.Family2.Unchecked as Lens.Family2.Unchecked
+import qualified Data.ProtoLens.Runtime.Data.Text as Data.Text
+import qualified Data.ProtoLens.Runtime.Data.Map as Data.Map
+import qualified Data.ProtoLens.Runtime.Data.ByteString as Data.ByteString
+import qualified Data.ProtoLens.Runtime.Data.ByteString.Char8 as Data.ByteString.Char8
+import qualified Data.ProtoLens.Runtime.Data.Text.Encoding as Data.Text.Encoding
+import qualified Data.ProtoLens.Runtime.Data.Vector as Data.Vector
+import qualified Data.ProtoLens.Runtime.Data.Vector.Generic as Data.Vector.Generic
+import qualified Data.ProtoLens.Runtime.Data.Vector.Unboxed as Data.Vector.Unboxed
+import qualified Data.ProtoLens.Runtime.Text.Read as Text.Read
+abandoned ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "abandoned" a) =>
+  Lens.Family2.LensLike' f s a
+abandoned = Data.ProtoLens.Field.field @"abandoned"
+accept ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "accept" a) =>
+  Lens.Family2.LensLike' f s a
+accept = Data.ProtoLens.Field.field @"accept"
+acceptHeight ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "acceptHeight" a) =>
+  Lens.Family2.LensLike' f s a
+acceptHeight = Data.ProtoLens.Field.field @"acceptHeight"
+acceptTime ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "acceptTime" a) =>
+  Lens.Family2.LensLike' f s a
+acceptTime = Data.ProtoLens.Field.field @"acceptTime"
+account ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "account" a) =>
+  Lens.Family2.LensLike' f s a
+account = Data.ProtoLens.Field.field @"account"
+accountBalance ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "accountBalance" a) =>
+  Lens.Family2.LensLike' f s a
+accountBalance = Data.ProtoLens.Field.field @"accountBalance"
+action ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "action" a) =>
+  Lens.Family2.LensLike' f s a
+action = Data.ProtoLens.Field.field @"action"
+actions ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "actions" a) =>
+  Lens.Family2.LensLike' f s a
+actions = Data.ProtoLens.Field.field @"actions"
+active ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "active" a) =>
+  Lens.Family2.LensLike' f s a
+active = Data.ProtoLens.Field.field @"active"
+activeChannel ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "activeChannel" a) =>
+  Lens.Family2.LensLike' f s a
+activeChannel = Data.ProtoLens.Field.field @"activeChannel"
+activeOnly ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "activeOnly" a) =>
+  Lens.Family2.LensLike' f s a
+activeOnly = Data.ProtoLens.Field.field @"activeOnly"
+addIndex ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "addIndex" a) =>
+  Lens.Family2.LensLike' f s a
+addIndex = Data.ProtoLens.Field.field @"addIndex"
+addr ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "addr" a) =>
+  Lens.Family2.LensLike' f s a
+addr = Data.ProtoLens.Field.field @"addr"
+addrToAmount ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "addrToAmount" a) =>
+  Lens.Family2.LensLike' f s a
+addrToAmount = Data.ProtoLens.Field.field @"addrToAmount"
+address ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "address" a) =>
+  Lens.Family2.LensLike' f s a
+address = Data.ProtoLens.Field.field @"address"
+addressType ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "addressType" a) =>
+  Lens.Family2.LensLike' f s a
+addressType = Data.ProtoLens.Field.field @"addressType"
+addresses ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "addresses" a) =>
+  Lens.Family2.LensLike' f s a
+addresses = Data.ProtoLens.Field.field @"addresses"
+advertisingNode ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "advertisingNode" a) =>
+  Lens.Family2.LensLike' f s a
+advertisingNode = Data.ProtoLens.Field.field @"advertisingNode"
+alias ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "alias" a) =>
+  Lens.Family2.LensLike' f s a
+alias = Data.ProtoLens.Field.field @"alias"
+allowSelfPayment ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "allowSelfPayment" a) =>
+  Lens.Family2.LensLike' f s a
+allowSelfPayment = Data.ProtoLens.Field.field @"allowSelfPayment"
+amount ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "amount" a) =>
+  Lens.Family2.LensLike' f s a
+amount = Data.ProtoLens.Field.field @"amount"
+amountSat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "amountSat" a) =>
+  Lens.Family2.LensLike' f s a
+amountSat = Data.ProtoLens.Field.field @"amountSat"
+amp ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "amp" a) =>
+  Lens.Family2.LensLike' f s a
+amp = Data.ProtoLens.Field.field @"amp"
+ampRecord ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "ampRecord" a) =>
+  Lens.Family2.LensLike' f s a
+ampRecord = Data.ProtoLens.Field.field @"ampRecord"
+amt ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "amt" a) =>
+  Lens.Family2.LensLike' f s a
+amt = Data.ProtoLens.Field.field @"amt"
+amtIn ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "amtIn" a) =>
+  Lens.Family2.LensLike' f s a
+amtIn = Data.ProtoLens.Field.field @"amtIn"
+amtInMsat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "amtInMsat" a) =>
+  Lens.Family2.LensLike' f s a
+amtInMsat = Data.ProtoLens.Field.field @"amtInMsat"
+amtMsat ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "amtMsat" a) =>
+  Lens.Family2.LensLike' f s a
+amtMsat = Data.ProtoLens.Field.field @"amtMsat"
+amtOut ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "amtOut" a) =>
+  Lens.Family2.LensLike' f s a
+amtOut = Data.ProtoLens.Field.field @"amtOut"
+amtOutMsat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "amtOutMsat" a) =>
+  Lens.Family2.LensLike' f s a
+amtOutMsat = Data.ProtoLens.Field.field @"amtOutMsat"
+amtPaid ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "amtPaid" a) =>
+  Lens.Family2.LensLike' f s a
+amtPaid = Data.ProtoLens.Field.field @"amtPaid"
+amtPaidMsat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "amtPaidMsat" a) =>
+  Lens.Family2.LensLike' f s a
+amtPaidMsat = Data.ProtoLens.Field.field @"amtPaidMsat"
+amtPaidSat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "amtPaidSat" a) =>
+  Lens.Family2.LensLike' f s a
+amtPaidSat = Data.ProtoLens.Field.field @"amtPaidSat"
+amtToForward ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "amtToForward" a) =>
+  Lens.Family2.LensLike' f s a
+amtToForward = Data.ProtoLens.Field.field @"amtToForward"
+amtToForwardMsat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "amtToForwardMsat" a) =>
+  Lens.Family2.LensLike' f s a
+amtToForwardMsat = Data.ProtoLens.Field.field @"amtToForwardMsat"
+anchor ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "anchor" a) =>
+  Lens.Family2.LensLike' f s a
+anchor = Data.ProtoLens.Field.field @"anchor"
+attemptId ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "attemptId" a) =>
+  Lens.Family2.LensLike' f s a
+attemptId = Data.ProtoLens.Field.field @"attemptId"
+attemptTimeNs ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "attemptTimeNs" a) =>
+  Lens.Family2.LensLike' f s a
+attemptTimeNs = Data.ProtoLens.Field.field @"attemptTimeNs"
+avgChannelSize ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "avgChannelSize" a) =>
+  Lens.Family2.LensLike' f s a
+avgChannelSize = Data.ProtoLens.Field.field @"avgChannelSize"
+avgOutDegree ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "avgOutDegree" a) =>
+  Lens.Family2.LensLike' f s a
+avgOutDegree = Data.ProtoLens.Field.field @"avgOutDegree"
+balance ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "balance" a) =>
+  Lens.Family2.LensLike' f s a
+balance = Data.ProtoLens.Field.field @"balance"
+baseFee ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "baseFee" a) =>
+  Lens.Family2.LensLike' f s a
+baseFee = Data.ProtoLens.Field.field @"baseFee"
+baseFeeMsat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "baseFeeMsat" a) =>
+  Lens.Family2.LensLike' f s a
+baseFeeMsat = Data.ProtoLens.Field.field @"baseFeeMsat"
+basePsbt ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "basePsbt" a) =>
+  Lens.Family2.LensLike' f s a
+basePsbt = Data.ProtoLens.Field.field @"basePsbt"
+bestHeaderTimestamp ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "bestHeaderTimestamp" a) =>
+  Lens.Family2.LensLike' f s a
+bestHeaderTimestamp
+  = Data.ProtoLens.Field.field @"bestHeaderTimestamp"
+betweennessCentrality ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "betweennessCentrality" a) =>
+  Lens.Family2.LensLike' f s a
+betweennessCentrality
+  = Data.ProtoLens.Field.field @"betweennessCentrality"
+blockHash ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "blockHash" a) =>
+  Lens.Family2.LensLike' f s a
+blockHash = Data.ProtoLens.Field.field @"blockHash"
+blockHeight ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "blockHeight" a) =>
+  Lens.Family2.LensLike' f s a
+blockHeight = Data.ProtoLens.Field.field @"blockHeight"
+blockSha ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "blockSha" a) =>
+  Lens.Family2.LensLike' f s a
+blockSha = Data.ProtoLens.Field.field @"blockSha"
+blocksTilMaturity ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "blocksTilMaturity" a) =>
+  Lens.Family2.LensLike' f s a
+blocksTilMaturity = Data.ProtoLens.Field.field @"blocksTilMaturity"
+breach ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "breach" a) =>
+  Lens.Family2.LensLike' f s a
+breach = Data.ProtoLens.Field.field @"breach"
+bytesRecv ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "bytesRecv" a) =>
+  Lens.Family2.LensLike' f s a
+bytesRecv = Data.ProtoLens.Field.field @"bytesRecv"
+bytesSent ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "bytesSent" a) =>
+  Lens.Family2.LensLike' f s a
+bytesSent = Data.ProtoLens.Field.field @"bytesSent"
+capacity ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "capacity" a) =>
+  Lens.Family2.LensLike' f s a
+capacity = Data.ProtoLens.Field.field @"capacity"
+chain ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "chain" a) =>
+  Lens.Family2.LensLike' f s a
+chain = Data.ProtoLens.Field.field @"chain"
+chainHash ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "chainHash" a) =>
+  Lens.Family2.LensLike' f s a
+chainHash = Data.ProtoLens.Field.field @"chainHash"
+chains ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "chains" a) =>
+  Lens.Family2.LensLike' f s a
+chains = Data.ProtoLens.Field.field @"chains"
+chanBackup ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "chanBackup" a) =>
+  Lens.Family2.LensLike' f s a
+chanBackup = Data.ProtoLens.Field.field @"chanBackup"
+chanBackups ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "chanBackups" a) =>
+  Lens.Family2.LensLike' f s a
+chanBackups = Data.ProtoLens.Field.field @"chanBackups"
+chanCapacity ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "chanCapacity" a) =>
+  Lens.Family2.LensLike' f s a
+chanCapacity = Data.ProtoLens.Field.field @"chanCapacity"
+chanClose ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "chanClose" a) =>
+  Lens.Family2.LensLike' f s a
+chanClose = Data.ProtoLens.Field.field @"chanClose"
+chanId ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "chanId" a) =>
+  Lens.Family2.LensLike' f s a
+chanId = Data.ProtoLens.Field.field @"chanId"
+chanIdIn ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "chanIdIn" a) =>
+  Lens.Family2.LensLike' f s a
+chanIdIn = Data.ProtoLens.Field.field @"chanIdIn"
+chanIdOut ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "chanIdOut" a) =>
+  Lens.Family2.LensLike' f s a
+chanIdOut = Data.ProtoLens.Field.field @"chanIdOut"
+chanOpen ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "chanOpen" a) =>
+  Lens.Family2.LensLike' f s a
+chanOpen = Data.ProtoLens.Field.field @"chanOpen"
+chanPending ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "chanPending" a) =>
+  Lens.Family2.LensLike' f s a
+chanPending = Data.ProtoLens.Field.field @"chanPending"
+chanPoint ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "chanPoint" a) =>
+  Lens.Family2.LensLike' f s a
+chanPoint = Data.ProtoLens.Field.field @"chanPoint"
+chanPointShim ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "chanPointShim" a) =>
+  Lens.Family2.LensLike' f s a
+chanPointShim = Data.ProtoLens.Field.field @"chanPointShim"
+chanPoints ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "chanPoints" a) =>
+  Lens.Family2.LensLike' f s a
+chanPoints = Data.ProtoLens.Field.field @"chanPoints"
+chanReserveSat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "chanReserveSat" a) =>
+  Lens.Family2.LensLike' f s a
+chanReserveSat = Data.ProtoLens.Field.field @"chanReserveSat"
+chanStatusFlags ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "chanStatusFlags" a) =>
+  Lens.Family2.LensLike' f s a
+chanStatusFlags = Data.ProtoLens.Field.field @"chanStatusFlags"
+channel ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "channel" a) =>
+  Lens.Family2.LensLike' f s a
+channel = Data.ProtoLens.Field.field @"channel"
+channelFees ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "channelFees" a) =>
+  Lens.Family2.LensLike' f s a
+channelFees = Data.ProtoLens.Field.field @"channelFees"
+channelFlags ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "channelFlags" a) =>
+  Lens.Family2.LensLike' f s a
+channelFlags = Data.ProtoLens.Field.field @"channelFlags"
+channelId ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "channelId" a) =>
+  Lens.Family2.LensLike' f s a
+channelId = Data.ProtoLens.Field.field @"channelId"
+channelPoint ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "channelPoint" a) =>
+  Lens.Family2.LensLike' f s a
+channelPoint = Data.ProtoLens.Field.field @"channelPoint"
+channelReserve ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "channelReserve" a) =>
+  Lens.Family2.LensLike' f s a
+channelReserve = Data.ProtoLens.Field.field @"channelReserve"
+channelUpdate ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "channelUpdate" a) =>
+  Lens.Family2.LensLike' f s a
+channelUpdate = Data.ProtoLens.Field.field @"channelUpdate"
+channelUpdates ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "channelUpdates" a) =>
+  Lens.Family2.LensLike' f s a
+channelUpdates = Data.ProtoLens.Field.field @"channelUpdates"
+channels ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "channels" a) =>
+  Lens.Family2.LensLike' f s a
+channels = Data.ProtoLens.Field.field @"channels"
+childIndex ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "childIndex" a) =>
+  Lens.Family2.LensLike' f s a
+childIndex = Data.ProtoLens.Field.field @"childIndex"
+closeAddress ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "closeAddress" a) =>
+  Lens.Family2.LensLike' f s a
+closeAddress = Data.ProtoLens.Field.field @"closeAddress"
+closeHeight ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "closeHeight" a) =>
+  Lens.Family2.LensLike' f s a
+closeHeight = Data.ProtoLens.Field.field @"closeHeight"
+closeInitiator ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "closeInitiator" a) =>
+  Lens.Family2.LensLike' f s a
+closeInitiator = Data.ProtoLens.Field.field @"closeInitiator"
+closePending ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "closePending" a) =>
+  Lens.Family2.LensLike' f s a
+closePending = Data.ProtoLens.Field.field @"closePending"
+closeType ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "closeType" a) =>
+  Lens.Family2.LensLike' f s a
+closeType = Data.ProtoLens.Field.field @"closeType"
+closedChannel ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "closedChannel" a) =>
+  Lens.Family2.LensLike' f s a
+closedChannel = Data.ProtoLens.Field.field @"closedChannel"
+closedChans ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "closedChans" a) =>
+  Lens.Family2.LensLike' f s a
+closedChans = Data.ProtoLens.Field.field @"closedChans"
+closedHeight ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "closedHeight" a) =>
+  Lens.Family2.LensLike' f s a
+closedHeight = Data.ProtoLens.Field.field @"closedHeight"
+closingTxHash ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "closingTxHash" a) =>
+  Lens.Family2.LensLike' f s a
+closingTxHash = Data.ProtoLens.Field.field @"closingTxHash"
+closingTxid ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "closingTxid" a) =>
+  Lens.Family2.LensLike' f s a
+closingTxid = Data.ProtoLens.Field.field @"closingTxid"
+cltvExpiry ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "cltvExpiry" a) =>
+  Lens.Family2.LensLike' f s a
+cltvExpiry = Data.ProtoLens.Field.field @"cltvExpiry"
+cltvExpiryDelta ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "cltvExpiryDelta" a) =>
+  Lens.Family2.LensLike' f s a
+cltvExpiryDelta = Data.ProtoLens.Field.field @"cltvExpiryDelta"
+cltvLimit ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "cltvLimit" a) =>
+  Lens.Family2.LensLike' f s a
+cltvLimit = Data.ProtoLens.Field.field @"cltvLimit"
+code ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "code" a) =>
+  Lens.Family2.LensLike' f s a
+code = Data.ProtoLens.Field.field @"code"
+color ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "color" a) =>
+  Lens.Family2.LensLike' f s a
+color = Data.ProtoLens.Field.field @"color"
+commitFee ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "commitFee" a) =>
+  Lens.Family2.LensLike' f s a
+commitFee = Data.ProtoLens.Field.field @"commitFee"
+commitHash ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "commitHash" a) =>
+  Lens.Family2.LensLike' f s a
+commitHash = Data.ProtoLens.Field.field @"commitHash"
+commitWeight ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "commitWeight" a) =>
+  Lens.Family2.LensLike' f s a
+commitWeight = Data.ProtoLens.Field.field @"commitWeight"
+commitmentType ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "commitmentType" a) =>
+  Lens.Family2.LensLike' f s a
+commitmentType = Data.ProtoLens.Field.field @"commitmentType"
+commitments ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "commitments" a) =>
+  Lens.Family2.LensLike' f s a
+commitments = Data.ProtoLens.Field.field @"commitments"
+confirmationHeight ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "confirmationHeight" a) =>
+  Lens.Family2.LensLike' f s a
+confirmationHeight
+  = Data.ProtoLens.Field.field @"confirmationHeight"
+confirmations ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "confirmations" a) =>
+  Lens.Family2.LensLike' f s a
+confirmations = Data.ProtoLens.Field.field @"confirmations"
+confirmedBalance ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "confirmedBalance" a) =>
+  Lens.Family2.LensLike' f s a
+confirmedBalance = Data.ProtoLens.Field.field @"confirmedBalance"
+connectingNode ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "connectingNode" a) =>
+  Lens.Family2.LensLike' f s a
+connectingNode = Data.ProtoLens.Field.field @"connectingNode"
+cooperative ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "cooperative" a) =>
+  Lens.Family2.LensLike' f s a
+cooperative = Data.ProtoLens.Field.field @"cooperative"
+creationDate ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "creationDate" a) =>
+  Lens.Family2.LensLike' f s a
+creationDate = Data.ProtoLens.Field.field @"creationDate"
+creationTimeNs ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "creationTimeNs" a) =>
+  Lens.Family2.LensLike' f s a
+creationTimeNs = Data.ProtoLens.Field.field @"creationTimeNs"
+csvDelay ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "csvDelay" a) =>
+  Lens.Family2.LensLike' f s a
+csvDelay = Data.ProtoLens.Field.field @"csvDelay"
+customRecords ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "customRecords" a) =>
+  Lens.Family2.LensLike' f s a
+customRecords = Data.ProtoLens.Field.field @"customRecords"
+dayFeeSum ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "dayFeeSum" a) =>
+  Lens.Family2.LensLike' f s a
+dayFeeSum = Data.ProtoLens.Field.field @"dayFeeSum"
+deleted ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "deleted" a) =>
+  Lens.Family2.LensLike' f s a
+deleted = Data.ProtoLens.Field.field @"deleted"
+deliveryAddress ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "deliveryAddress" a) =>
+  Lens.Family2.LensLike' f s a
+deliveryAddress = Data.ProtoLens.Field.field @"deliveryAddress"
+description ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "description" a) =>
+  Lens.Family2.LensLike' f s a
+description = Data.ProtoLens.Field.field @"description"
+descriptionHash ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "descriptionHash" a) =>
+  Lens.Family2.LensLike' f s a
+descriptionHash = Data.ProtoLens.Field.field @"descriptionHash"
+dest ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "dest" a) =>
+  Lens.Family2.LensLike' f s a
+dest = Data.ProtoLens.Field.field @"dest"
+destAddresses ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "destAddresses" a) =>
+  Lens.Family2.LensLike' f s a
+destAddresses = Data.ProtoLens.Field.field @"destAddresses"
+destCustomRecords ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "destCustomRecords" a) =>
+  Lens.Family2.LensLike' f s a
+destCustomRecords = Data.ProtoLens.Field.field @"destCustomRecords"
+destFeatures ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "destFeatures" a) =>
+  Lens.Family2.LensLike' f s a
+destFeatures = Data.ProtoLens.Field.field @"destFeatures"
+destString ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "destString" a) =>
+  Lens.Family2.LensLike' f s a
+destString = Data.ProtoLens.Field.field @"destString"
+destination ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "destination" a) =>
+  Lens.Family2.LensLike' f s a
+destination = Data.ProtoLens.Field.field @"destination"
+directionReverse ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "directionReverse" a) =>
+  Lens.Family2.LensLike' f s a
+directionReverse = Data.ProtoLens.Field.field @"directionReverse"
+disabled ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "disabled" a) =>
+  Lens.Family2.LensLike' f s a
+disabled = Data.ProtoLens.Field.field @"disabled"
+dustLimit ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "dustLimit" a) =>
+  Lens.Family2.LensLike' f s a
+dustLimit = Data.ProtoLens.Field.field @"dustLimit"
+dustLimitSat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "dustLimitSat" a) =>
+  Lens.Family2.LensLike' f s a
+dustLimitSat = Data.ProtoLens.Field.field @"dustLimitSat"
+edges ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "edges" a) =>
+  Lens.Family2.LensLike' f s a
+edges = Data.ProtoLens.Field.field @"edges"
+endHeight ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "endHeight" a) =>
+  Lens.Family2.LensLike' f s a
+endHeight = Data.ProtoLens.Field.field @"endHeight"
+endTime ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "endTime" a) =>
+  Lens.Family2.LensLike' f s a
+endTime = Data.ProtoLens.Field.field @"endTime"
+entity ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "entity" a) =>
+  Lens.Family2.LensLike' f s a
+entity = Data.ProtoLens.Field.field @"entity"
+error ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "error" a) =>
+  Lens.Family2.LensLike' f s a
+error = Data.ProtoLens.Field.field @"error"
+errors ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "errors" a) =>
+  Lens.Family2.LensLike' f s a
+errors = Data.ProtoLens.Field.field @"errors"
+expirationHeight ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "expirationHeight" a) =>
+  Lens.Family2.LensLike' f s a
+expirationHeight = Data.ProtoLens.Field.field @"expirationHeight"
+expiry ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "expiry" a) =>
+  Lens.Family2.LensLike' f s a
+expiry = Data.ProtoLens.Field.field @"expiry"
+expiryHeight ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "expiryHeight" a) =>
+  Lens.Family2.LensLike' f s a
+expiryHeight = Data.ProtoLens.Field.field @"expiryHeight"
+extraOpaqueData ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "extraOpaqueData" a) =>
+  Lens.Family2.LensLike' f s a
+extraOpaqueData = Data.ProtoLens.Field.field @"extraOpaqueData"
+failedHtlcsOnly ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "failedHtlcsOnly" a) =>
+  Lens.Family2.LensLike' f s a
+failedHtlcsOnly = Data.ProtoLens.Field.field @"failedHtlcsOnly"
+failedPaymentsOnly ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "failedPaymentsOnly" a) =>
+  Lens.Family2.LensLike' f s a
+failedPaymentsOnly
+  = Data.ProtoLens.Field.field @"failedPaymentsOnly"
+failure ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "failure" a) =>
+  Lens.Family2.LensLike' f s a
+failure = Data.ProtoLens.Field.field @"failure"
+failureReason ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "failureReason" a) =>
+  Lens.Family2.LensLike' f s a
+failureReason = Data.ProtoLens.Field.field @"failureReason"
+failureSourceIndex ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "failureSourceIndex" a) =>
+  Lens.Family2.LensLike' f s a
+failureSourceIndex
+  = Data.ProtoLens.Field.field @"failureSourceIndex"
+fallbackAddr ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "fallbackAddr" a) =>
+  Lens.Family2.LensLike' f s a
+fallbackAddr = Data.ProtoLens.Field.field @"fallbackAddr"
+features ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "features" a) =>
+  Lens.Family2.LensLike' f s a
+features = Data.ProtoLens.Field.field @"features"
+fee ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "fee" a) =>
+  Lens.Family2.LensLike' f s a
+fee = Data.ProtoLens.Field.field @"fee"
+feeBaseMsat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "feeBaseMsat" a) =>
+  Lens.Family2.LensLike' f s a
+feeBaseMsat = Data.ProtoLens.Field.field @"feeBaseMsat"
+feeLimit ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "feeLimit" a) =>
+  Lens.Family2.LensLike' f s a
+feeLimit = Data.ProtoLens.Field.field @"feeLimit"
+feeMsat ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "feeMsat" a) =>
+  Lens.Family2.LensLike' f s a
+feeMsat = Data.ProtoLens.Field.field @"feeMsat"
+feePerKw ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "feePerKw" a) =>
+  Lens.Family2.LensLike' f s a
+feePerKw = Data.ProtoLens.Field.field @"feePerKw"
+feePerMil ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "feePerMil" a) =>
+  Lens.Family2.LensLike' f s a
+feePerMil = Data.ProtoLens.Field.field @"feePerMil"
+feeProportionalMillionths ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "feeProportionalMillionths" a) =>
+  Lens.Family2.LensLike' f s a
+feeProportionalMillionths
+  = Data.ProtoLens.Field.field @"feeProportionalMillionths"
+feeRate ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "feeRate" a) =>
+  Lens.Family2.LensLike' f s a
+feeRate = Data.ProtoLens.Field.field @"feeRate"
+feeRateMilliMsat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "feeRateMilliMsat" a) =>
+  Lens.Family2.LensLike' f s a
+feeRateMilliMsat = Data.ProtoLens.Field.field @"feeRateMilliMsat"
+feeSat ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "feeSat" a) =>
+  Lens.Family2.LensLike' f s a
+feeSat = Data.ProtoLens.Field.field @"feeSat"
+feerateSatPerByte ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "feerateSatPerByte" a) =>
+  Lens.Family2.LensLike' f s a
+feerateSatPerByte = Data.ProtoLens.Field.field @"feerateSatPerByte"
+finalCltvDelta ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "finalCltvDelta" a) =>
+  Lens.Family2.LensLike' f s a
+finalCltvDelta = Data.ProtoLens.Field.field @"finalCltvDelta"
+finalRawTx ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "finalRawTx" a) =>
+  Lens.Family2.LensLike' f s a
+finalRawTx = Data.ProtoLens.Field.field @"finalRawTx"
+firstIndexOffset ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "firstIndexOffset" a) =>
+  Lens.Family2.LensLike' f s a
+firstIndexOffset = Data.ProtoLens.Field.field @"firstIndexOffset"
+fixed ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "fixed" a) =>
+  Lens.Family2.LensLike' f s a
+fixed = Data.ProtoLens.Field.field @"fixed"
+fixedMsat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "fixedMsat" a) =>
+  Lens.Family2.LensLike' f s a
+fixedMsat = Data.ProtoLens.Field.field @"fixedMsat"
+flags ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "flags" a) =>
+  Lens.Family2.LensLike' f s a
+flags = Data.ProtoLens.Field.field @"flags"
+flapCount ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "flapCount" a) =>
+  Lens.Family2.LensLike' f s a
+flapCount = Data.ProtoLens.Field.field @"flapCount"
+force ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "force" a) =>
+  Lens.Family2.LensLike' f s a
+force = Data.ProtoLens.Field.field @"force"
+forwardingChannel ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "forwardingChannel" a) =>
+  Lens.Family2.LensLike' f s a
+forwardingChannel = Data.ProtoLens.Field.field @"forwardingChannel"
+forwardingEvents ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "forwardingEvents" a) =>
+  Lens.Family2.LensLike' f s a
+forwardingEvents = Data.ProtoLens.Field.field @"forwardingEvents"
+forwardingHtlcIndex ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "forwardingHtlcIndex" a) =>
+  Lens.Family2.LensLike' f s a
+forwardingHtlcIndex
+  = Data.ProtoLens.Field.field @"forwardingHtlcIndex"
+from ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "from" a) =>
+  Lens.Family2.LensLike' f s a
+from = Data.ProtoLens.Field.field @"from"
+fundedPsbt ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "fundedPsbt" a) =>
+  Lens.Family2.LensLike' f s a
+fundedPsbt = Data.ProtoLens.Field.field @"fundedPsbt"
+fundingAddress ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "fundingAddress" a) =>
+  Lens.Family2.LensLike' f s a
+fundingAddress = Data.ProtoLens.Field.field @"fundingAddress"
+fundingAmount ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "fundingAmount" a) =>
+  Lens.Family2.LensLike' f s a
+fundingAmount = Data.ProtoLens.Field.field @"fundingAmount"
+fundingAmt ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "fundingAmt" a) =>
+  Lens.Family2.LensLike' f s a
+fundingAmt = Data.ProtoLens.Field.field @"fundingAmt"
+fundingCanceled ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "fundingCanceled" a) =>
+  Lens.Family2.LensLike' f s a
+fundingCanceled = Data.ProtoLens.Field.field @"fundingCanceled"
+fundingShim ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "fundingShim" a) =>
+  Lens.Family2.LensLike' f s a
+fundingShim = Data.ProtoLens.Field.field @"fundingShim"
+fundingTxidBytes ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "fundingTxidBytes" a) =>
+  Lens.Family2.LensLike' f s a
+fundingTxidBytes = Data.ProtoLens.Field.field @"fundingTxidBytes"
+fundingTxidStr ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "fundingTxidStr" a) =>
+  Lens.Family2.LensLike' f s a
+fundingTxidStr = Data.ProtoLens.Field.field @"fundingTxidStr"
+global ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "global" a) =>
+  Lens.Family2.LensLike' f s a
+global = Data.ProtoLens.Field.field @"global"
+globalFeatures ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "globalFeatures" a) =>
+  Lens.Family2.LensLike' f s a
+globalFeatures = Data.ProtoLens.Field.field @"globalFeatures"
+graphDiameter ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "graphDiameter" a) =>
+  Lens.Family2.LensLike' f s a
+graphDiameter = Data.ProtoLens.Field.field @"graphDiameter"
+hash ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "hash" a) =>
+  Lens.Family2.LensLike' f s a
+hash = Data.ProtoLens.Field.field @"hash"
+hashLock ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "hashLock" a) =>
+  Lens.Family2.LensLike' f s a
+hashLock = Data.ProtoLens.Field.field @"hashLock"
+height ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "height" a) =>
+  Lens.Family2.LensLike' f s a
+height = Data.ProtoLens.Field.field @"height"
+hopHints ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "hopHints" a) =>
+  Lens.Family2.LensLike' f s a
+hopHints = Data.ProtoLens.Field.field @"hopHints"
+hops ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "hops" a) =>
+  Lens.Family2.LensLike' f s a
+hops = Data.ProtoLens.Field.field @"hops"
+host ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "host" a) =>
+  Lens.Family2.LensLike' f s a
+host = Data.ProtoLens.Field.field @"host"
+htlcIndex ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "htlcIndex" a) =>
+  Lens.Family2.LensLike' f s a
+htlcIndex = Data.ProtoLens.Field.field @"htlcIndex"
+htlcMaximumMsat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "htlcMaximumMsat" a) =>
+  Lens.Family2.LensLike' f s a
+htlcMaximumMsat = Data.ProtoLens.Field.field @"htlcMaximumMsat"
+htlcMinimumMsat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "htlcMinimumMsat" a) =>
+  Lens.Family2.LensLike' f s a
+htlcMinimumMsat = Data.ProtoLens.Field.field @"htlcMinimumMsat"
+htlcMsat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "htlcMsat" a) =>
+  Lens.Family2.LensLike' f s a
+htlcMsat = Data.ProtoLens.Field.field @"htlcMsat"
+htlcs ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "htlcs" a) =>
+  Lens.Family2.LensLike' f s a
+htlcs = Data.ProtoLens.Field.field @"htlcs"
+iKnowWhatIAmDoing ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "iKnowWhatIAmDoing" a) =>
+  Lens.Family2.LensLike' f s a
+iKnowWhatIAmDoing = Data.ProtoLens.Field.field @"iKnowWhatIAmDoing"
+identityKey ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "identityKey" a) =>
+  Lens.Family2.LensLike' f s a
+identityKey = Data.ProtoLens.Field.field @"identityKey"
+identityPubkey ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "identityPubkey" a) =>
+  Lens.Family2.LensLike' f s a
+identityPubkey = Data.ProtoLens.Field.field @"identityPubkey"
+ignoredEdges ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "ignoredEdges" a) =>
+  Lens.Family2.LensLike' f s a
+ignoredEdges = Data.ProtoLens.Field.field @"ignoredEdges"
+ignoredNodes ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "ignoredNodes" a) =>
+  Lens.Family2.LensLike' f s a
+ignoredNodes = Data.ProtoLens.Field.field @"ignoredNodes"
+ignoredPairs ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "ignoredPairs" a) =>
+  Lens.Family2.LensLike' f s a
+ignoredPairs = Data.ProtoLens.Field.field @"ignoredPairs"
+inFlightMaxMsat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "inFlightMaxMsat" a) =>
+  Lens.Family2.LensLike' f s a
+inFlightMaxMsat = Data.ProtoLens.Field.field @"inFlightMaxMsat"
+inactiveChannel ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "inactiveChannel" a) =>
+  Lens.Family2.LensLike' f s a
+inactiveChannel = Data.ProtoLens.Field.field @"inactiveChannel"
+inactiveOnly ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "inactiveOnly" a) =>
+  Lens.Family2.LensLike' f s a
+inactiveOnly = Data.ProtoLens.Field.field @"inactiveOnly"
+inbound ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "inbound" a) =>
+  Lens.Family2.LensLike' f s a
+inbound = Data.ProtoLens.Field.field @"inbound"
+includeChannels ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "includeChannels" a) =>
+  Lens.Family2.LensLike' f s a
+includeChannels = Data.ProtoLens.Field.field @"includeChannels"
+includeIncomplete ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "includeIncomplete" a) =>
+  Lens.Family2.LensLike' f s a
+includeIncomplete = Data.ProtoLens.Field.field @"includeIncomplete"
+includeUnannounced ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "includeUnannounced" a) =>
+  Lens.Family2.LensLike' f s a
+includeUnannounced
+  = Data.ProtoLens.Field.field @"includeUnannounced"
+incoming ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "incoming" a) =>
+  Lens.Family2.LensLike' f s a
+incoming = Data.ProtoLens.Field.field @"incoming"
+indexOffset ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "indexOffset" a) =>
+  Lens.Family2.LensLike' f s a
+indexOffset = Data.ProtoLens.Field.field @"indexOffset"
+initiator ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "initiator" a) =>
+  Lens.Family2.LensLike' f s a
+initiator = Data.ProtoLens.Field.field @"initiator"
+invoices ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "invoices" a) =>
+  Lens.Family2.LensLike' f s a
+invoices = Data.ProtoLens.Field.field @"invoices"
+isAmp ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "isAmp" a) =>
+  Lens.Family2.LensLike' f s a
+isAmp = Data.ProtoLens.Field.field @"isAmp"
+isKeysend ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "isKeysend" a) =>
+  Lens.Family2.LensLike' f s a
+isKeysend = Data.ProtoLens.Field.field @"isKeysend"
+isKnown ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "isKnown" a) =>
+  Lens.Family2.LensLike' f s a
+isKnown = Data.ProtoLens.Field.field @"isKnown"
+isRequired ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "isRequired" a) =>
+  Lens.Family2.LensLike' f s a
+isRequired = Data.ProtoLens.Field.field @"isRequired"
+key ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "key" a) =>
+  Lens.Family2.LensLike' f s a
+key = Data.ProtoLens.Field.field @"key"
+keyFamily ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "keyFamily" a) =>
+  Lens.Family2.LensLike' f s a
+keyFamily = Data.ProtoLens.Field.field @"keyFamily"
+keyIndex ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "keyIndex" a) =>
+  Lens.Family2.LensLike' f s a
+keyIndex = Data.ProtoLens.Field.field @"keyIndex"
+keyLoc ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "keyLoc" a) =>
+  Lens.Family2.LensLike' f s a
+keyLoc = Data.ProtoLens.Field.field @"keyLoc"
+label ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "label" a) =>
+  Lens.Family2.LensLike' f s a
+label = Data.ProtoLens.Field.field @"label"
+lastFlapNs ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "lastFlapNs" a) =>
+  Lens.Family2.LensLike' f s a
+lastFlapNs = Data.ProtoLens.Field.field @"lastFlapNs"
+lastHopPubkey ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "lastHopPubkey" a) =>
+  Lens.Family2.LensLike' f s a
+lastHopPubkey = Data.ProtoLens.Field.field @"lastHopPubkey"
+lastIndexOffset ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "lastIndexOffset" a) =>
+  Lens.Family2.LensLike' f s a
+lastIndexOffset = Data.ProtoLens.Field.field @"lastIndexOffset"
+lastOffsetIndex ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "lastOffsetIndex" a) =>
+  Lens.Family2.LensLike' f s a
+lastOffsetIndex = Data.ProtoLens.Field.field @"lastOffsetIndex"
+lastUpdate ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "lastUpdate" a) =>
+  Lens.Family2.LensLike' f s a
+lastUpdate = Data.ProtoLens.Field.field @"lastUpdate"
+latestError ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "latestError" a) =>
+  Lens.Family2.LensLike' f s a
+latestError = Data.ProtoLens.Field.field @"latestError"
+levelSpec ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "levelSpec" a) =>
+  Lens.Family2.LensLike' f s a
+levelSpec = Data.ProtoLens.Field.field @"levelSpec"
+lifetime ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "lifetime" a) =>
+  Lens.Family2.LensLike' f s a
+lifetime = Data.ProtoLens.Field.field @"lifetime"
+limboBalance ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "limboBalance" a) =>
+  Lens.Family2.LensLike' f s a
+limboBalance = Data.ProtoLens.Field.field @"limboBalance"
+localBalance ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "localBalance" a) =>
+  Lens.Family2.LensLike' f s a
+localBalance = Data.ProtoLens.Field.field @"localBalance"
+localChanReserveSat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "localChanReserveSat" a) =>
+  Lens.Family2.LensLike' f s a
+localChanReserveSat
+  = Data.ProtoLens.Field.field @"localChanReserveSat"
+localCommitFeeSat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "localCommitFeeSat" a) =>
+  Lens.Family2.LensLike' f s a
+localCommitFeeSat = Data.ProtoLens.Field.field @"localCommitFeeSat"
+localConstraints ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "localConstraints" a) =>
+  Lens.Family2.LensLike' f s a
+localConstraints = Data.ProtoLens.Field.field @"localConstraints"
+localForce ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "localForce" a) =>
+  Lens.Family2.LensLike' f s a
+localForce = Data.ProtoLens.Field.field @"localForce"
+localFundingAmount ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "localFundingAmount" a) =>
+  Lens.Family2.LensLike' f s a
+localFundingAmount
+  = Data.ProtoLens.Field.field @"localFundingAmount"
+localKey ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "localKey" a) =>
+  Lens.Family2.LensLike' f s a
+localKey = Data.ProtoLens.Field.field @"localKey"
+localTxid ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "localTxid" a) =>
+  Lens.Family2.LensLike' f s a
+localTxid = Data.ProtoLens.Field.field @"localTxid"
+macaroon ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "macaroon" a) =>
+  Lens.Family2.LensLike' f s a
+macaroon = Data.ProtoLens.Field.field @"macaroon"
+maturityHeight ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maturityHeight" a) =>
+  Lens.Family2.LensLike' f s a
+maturityHeight = Data.ProtoLens.Field.field @"maturityHeight"
+maxAcceptedHtlcs ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maxAcceptedHtlcs" a) =>
+  Lens.Family2.LensLike' f s a
+maxAcceptedHtlcs = Data.ProtoLens.Field.field @"maxAcceptedHtlcs"
+maxChannelSize ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maxChannelSize" a) =>
+  Lens.Family2.LensLike' f s a
+maxChannelSize = Data.ProtoLens.Field.field @"maxChannelSize"
+maxConfs ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maxConfs" a) =>
+  Lens.Family2.LensLike' f s a
+maxConfs = Data.ProtoLens.Field.field @"maxConfs"
+maxHtlcCount ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maxHtlcCount" a) =>
+  Lens.Family2.LensLike' f s a
+maxHtlcCount = Data.ProtoLens.Field.field @"maxHtlcCount"
+maxHtlcMsat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maxHtlcMsat" a) =>
+  Lens.Family2.LensLike' f s a
+maxHtlcMsat = Data.ProtoLens.Field.field @"maxHtlcMsat"
+maxLocalCsv ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maxLocalCsv" a) =>
+  Lens.Family2.LensLike' f s a
+maxLocalCsv = Data.ProtoLens.Field.field @"maxLocalCsv"
+maxOutDegree ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maxOutDegree" a) =>
+  Lens.Family2.LensLike' f s a
+maxOutDegree = Data.ProtoLens.Field.field @"maxOutDegree"
+maxPayments ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maxPayments" a) =>
+  Lens.Family2.LensLike' f s a
+maxPayments = Data.ProtoLens.Field.field @"maxPayments"
+maxPendingAmtMsat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maxPendingAmtMsat" a) =>
+  Lens.Family2.LensLike' f s a
+maxPendingAmtMsat = Data.ProtoLens.Field.field @"maxPendingAmtMsat"
+maxValueInFlight ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maxValueInFlight" a) =>
+  Lens.Family2.LensLike' f s a
+maxValueInFlight = Data.ProtoLens.Field.field @"maxValueInFlight"
+maybe'activeChannel ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'activeChannel" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'activeChannel
+  = Data.ProtoLens.Field.field @"maybe'activeChannel"
+maybe'addr ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'addr" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'addr = Data.ProtoLens.Field.field @"maybe'addr"
+maybe'amp ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'amp" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'amp = Data.ProtoLens.Field.field @"maybe'amp"
+maybe'ampRecord ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'ampRecord" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'ampRecord = Data.ProtoLens.Field.field @"maybe'ampRecord"
+maybe'backup ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'backup" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'backup = Data.ProtoLens.Field.field @"maybe'backup"
+maybe'chanBackups ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'chanBackups" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'chanBackups = Data.ProtoLens.Field.field @"maybe'chanBackups"
+maybe'chanClose ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'chanClose" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'chanClose = Data.ProtoLens.Field.field @"maybe'chanClose"
+maybe'chanOpen ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'chanOpen" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'chanOpen = Data.ProtoLens.Field.field @"maybe'chanOpen"
+maybe'chanPending ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'chanPending" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'chanPending = Data.ProtoLens.Field.field @"maybe'chanPending"
+maybe'chanPoint ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'chanPoint" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'chanPoint = Data.ProtoLens.Field.field @"maybe'chanPoint"
+maybe'chanPointShim ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'chanPointShim" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'chanPointShim
+  = Data.ProtoLens.Field.field @"maybe'chanPointShim"
+maybe'channel ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'channel" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'channel = Data.ProtoLens.Field.field @"maybe'channel"
+maybe'channelPoint ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'channelPoint" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'channelPoint
+  = Data.ProtoLens.Field.field @"maybe'channelPoint"
+maybe'channelUpdate ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'channelUpdate" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'channelUpdate
+  = Data.ProtoLens.Field.field @"maybe'channelUpdate"
+maybe'closePending ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'closePending" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'closePending
+  = Data.ProtoLens.Field.field @"maybe'closePending"
+maybe'closedChannel ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'closedChannel" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'closedChannel
+  = Data.ProtoLens.Field.field @"maybe'closedChannel"
+maybe'commitments ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'commitments" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'commitments = Data.ProtoLens.Field.field @"maybe'commitments"
+maybe'failure ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'failure" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'failure = Data.ProtoLens.Field.field @"maybe'failure"
+maybe'feeLimit ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'feeLimit" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'feeLimit = Data.ProtoLens.Field.field @"maybe'feeLimit"
+maybe'fixed ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'fixed" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'fixed = Data.ProtoLens.Field.field @"maybe'fixed"
+maybe'fixedMsat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'fixedMsat" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'fixedMsat = Data.ProtoLens.Field.field @"maybe'fixedMsat"
+maybe'fundingShim ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'fundingShim" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'fundingShim = Data.ProtoLens.Field.field @"maybe'fundingShim"
+maybe'fundingTxid ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'fundingTxid" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'fundingTxid = Data.ProtoLens.Field.field @"maybe'fundingTxid"
+maybe'fundingTxidBytes ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'fundingTxidBytes" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'fundingTxidBytes
+  = Data.ProtoLens.Field.field @"maybe'fundingTxidBytes"
+maybe'fundingTxidStr ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'fundingTxidStr" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'fundingTxidStr
+  = Data.ProtoLens.Field.field @"maybe'fundingTxidStr"
+maybe'global ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'global" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'global = Data.ProtoLens.Field.field @"maybe'global"
+maybe'inactiveChannel ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'inactiveChannel" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'inactiveChannel
+  = Data.ProtoLens.Field.field @"maybe'inactiveChannel"
+maybe'keyLoc ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'keyLoc" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'keyLoc = Data.ProtoLens.Field.field @"maybe'keyLoc"
+maybe'limit ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'limit" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'limit = Data.ProtoLens.Field.field @"maybe'limit"
+maybe'localBalance ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'localBalance" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'localBalance
+  = Data.ProtoLens.Field.field @"maybe'localBalance"
+maybe'localConstraints ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'localConstraints" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'localConstraints
+  = Data.ProtoLens.Field.field @"maybe'localConstraints"
+maybe'localKey ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'localKey" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'localKey = Data.ProtoLens.Field.field @"maybe'localKey"
+maybe'mppRecord ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'mppRecord" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'mppRecord = Data.ProtoLens.Field.field @"maybe'mppRecord"
+maybe'multiChanBackup ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'multiChanBackup" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'multiChanBackup
+  = Data.ProtoLens.Field.field @"maybe'multiChanBackup"
+maybe'node ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'node" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'node = Data.ProtoLens.Field.field @"maybe'node"
+maybe'node1Policy ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'node1Policy" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'node1Policy = Data.ProtoLens.Field.field @"maybe'node1Policy"
+maybe'node2Policy ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'node2Policy" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'node2Policy = Data.ProtoLens.Field.field @"maybe'node2Policy"
+maybe'openChannel ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'openChannel" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'openChannel = Data.ProtoLens.Field.field @"maybe'openChannel"
+maybe'outpoint ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'outpoint" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'outpoint = Data.ProtoLens.Field.field @"maybe'outpoint"
+maybe'paymentRoute ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'paymentRoute" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'paymentRoute
+  = Data.ProtoLens.Field.field @"maybe'paymentRoute"
+maybe'pendingOpenChannel ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'pendingOpenChannel" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'pendingOpenChannel
+  = Data.ProtoLens.Field.field @"maybe'pendingOpenChannel"
+maybe'pendingOpenLocalBalance ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'pendingOpenLocalBalance" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'pendingOpenLocalBalance
+  = Data.ProtoLens.Field.field @"maybe'pendingOpenLocalBalance"
+maybe'pendingOpenRemoteBalance ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'pendingOpenRemoteBalance" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'pendingOpenRemoteBalance
+  = Data.ProtoLens.Field.field @"maybe'pendingOpenRemoteBalance"
+maybe'percent ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'percent" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'percent = Data.ProtoLens.Field.field @"maybe'percent"
+maybe'psbtFinalize ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'psbtFinalize" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'psbtFinalize
+  = Data.ProtoLens.Field.field @"maybe'psbtFinalize"
+maybe'psbtFund ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'psbtFund" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'psbtFund = Data.ProtoLens.Field.field @"maybe'psbtFund"
+maybe'psbtShim ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'psbtShim" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'psbtShim = Data.ProtoLens.Field.field @"maybe'psbtShim"
+maybe'psbtVerify ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'psbtVerify" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'psbtVerify = Data.ProtoLens.Field.field @"maybe'psbtVerify"
+maybe'remoteBalance ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'remoteBalance" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'remoteBalance
+  = Data.ProtoLens.Field.field @"maybe'remoteBalance"
+maybe'remoteConstraints ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'remoteConstraints" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'remoteConstraints
+  = Data.ProtoLens.Field.field @"maybe'remoteConstraints"
+maybe'route ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'route" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'route = Data.ProtoLens.Field.field @"maybe'route"
+maybe'routingPolicy ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'routingPolicy" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'routingPolicy
+  = Data.ProtoLens.Field.field @"maybe'routingPolicy"
+maybe'scope ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'scope" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'scope = Data.ProtoLens.Field.field @"maybe'scope"
+maybe'shim ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'shim" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'shim = Data.ProtoLens.Field.field @"maybe'shim"
+maybe'shimCancel ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'shimCancel" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'shimCancel = Data.ProtoLens.Field.field @"maybe'shimCancel"
+maybe'shimRegister ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'shimRegister" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'shimRegister
+  = Data.ProtoLens.Field.field @"maybe'shimRegister"
+maybe'singleChanBackups ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'singleChanBackups" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'singleChanBackups
+  = Data.ProtoLens.Field.field @"maybe'singleChanBackups"
+maybe'trigger ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'trigger" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'trigger = Data.ProtoLens.Field.field @"maybe'trigger"
+maybe'unsettledLocalBalance ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'unsettledLocalBalance" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'unsettledLocalBalance
+  = Data.ProtoLens.Field.field @"maybe'unsettledLocalBalance"
+maybe'unsettledRemoteBalance ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'unsettledRemoteBalance" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'unsettledRemoteBalance
+  = Data.ProtoLens.Field.field @"maybe'unsettledRemoteBalance"
+maybe'update ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'update" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'update = Data.ProtoLens.Field.field @"maybe'update"
+maybe'value ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'value" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'value = Data.ProtoLens.Field.field @"maybe'value"
+medianChannelSizeSat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "medianChannelSizeSat" a) =>
+  Lens.Family2.LensLike' f s a
+medianChannelSizeSat
+  = Data.ProtoLens.Field.field @"medianChannelSizeSat"
+memo ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "memo" a) =>
+  Lens.Family2.LensLike' f s a
+memo = Data.ProtoLens.Field.field @"memo"
+messageFlags ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "messageFlags" a) =>
+  Lens.Family2.LensLike' f s a
+messageFlags = Data.ProtoLens.Field.field @"messageFlags"
+methodPermissions ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "methodPermissions" a) =>
+  Lens.Family2.LensLike' f s a
+methodPermissions = Data.ProtoLens.Field.field @"methodPermissions"
+minAcceptDepth ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "minAcceptDepth" a) =>
+  Lens.Family2.LensLike' f s a
+minAcceptDepth = Data.ProtoLens.Field.field @"minAcceptDepth"
+minChannelSize ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "minChannelSize" a) =>
+  Lens.Family2.LensLike' f s a
+minChannelSize = Data.ProtoLens.Field.field @"minChannelSize"
+minConfs ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "minConfs" a) =>
+  Lens.Family2.LensLike' f s a
+minConfs = Data.ProtoLens.Field.field @"minConfs"
+minHtlc ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "minHtlc" a) =>
+  Lens.Family2.LensLike' f s a
+minHtlc = Data.ProtoLens.Field.field @"minHtlc"
+minHtlcIn ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "minHtlcIn" a) =>
+  Lens.Family2.LensLike' f s a
+minHtlcIn = Data.ProtoLens.Field.field @"minHtlcIn"
+minHtlcMsat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "minHtlcMsat" a) =>
+  Lens.Family2.LensLike' f s a
+minHtlcMsat = Data.ProtoLens.Field.field @"minHtlcMsat"
+minHtlcMsatSpecified ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "minHtlcMsatSpecified" a) =>
+  Lens.Family2.LensLike' f s a
+minHtlcMsatSpecified
+  = Data.ProtoLens.Field.field @"minHtlcMsatSpecified"
+monthFeeSum ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "monthFeeSum" a) =>
+  Lens.Family2.LensLike' f s a
+monthFeeSum = Data.ProtoLens.Field.field @"monthFeeSum"
+mppRecord ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "mppRecord" a) =>
+  Lens.Family2.LensLike' f s a
+mppRecord = Data.ProtoLens.Field.field @"mppRecord"
+mppTotalAmtMsat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "mppTotalAmtMsat" a) =>
+  Lens.Family2.LensLike' f s a
+mppTotalAmtMsat = Data.ProtoLens.Field.field @"mppTotalAmtMsat"
+msat ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "msat" a) =>
+  Lens.Family2.LensLike' f s a
+msat = Data.ProtoLens.Field.field @"msat"
+msg ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "msg" a) =>
+  Lens.Family2.LensLike' f s a
+msg = Data.ProtoLens.Field.field @"msg"
+multiChanBackup ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "multiChanBackup" a) =>
+  Lens.Family2.LensLike' f s a
+multiChanBackup = Data.ProtoLens.Field.field @"multiChanBackup"
+name ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "name" a) =>
+  Lens.Family2.LensLike' f s a
+name = Data.ProtoLens.Field.field @"name"
+network ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "network" a) =>
+  Lens.Family2.LensLike' f s a
+network = Data.ProtoLens.Field.field @"network"
+noPublish ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "noPublish" a) =>
+  Lens.Family2.LensLike' f s a
+noPublish = Data.ProtoLens.Field.field @"noPublish"
+node ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "node" a) =>
+  Lens.Family2.LensLike' f s a
+node = Data.ProtoLens.Field.field @"node"
+node1Policy ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "node1Policy" a) =>
+  Lens.Family2.LensLike' f s a
+node1Policy = Data.ProtoLens.Field.field @"node1Policy"
+node1Pub ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "node1Pub" a) =>
+  Lens.Family2.LensLike' f s a
+node1Pub = Data.ProtoLens.Field.field @"node1Pub"
+node2Policy ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "node2Policy" a) =>
+  Lens.Family2.LensLike' f s a
+node2Policy = Data.ProtoLens.Field.field @"node2Policy"
+node2Pub ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "node2Pub" a) =>
+  Lens.Family2.LensLike' f s a
+node2Pub = Data.ProtoLens.Field.field @"node2Pub"
+nodeAddresses ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "nodeAddresses" a) =>
+  Lens.Family2.LensLike' f s a
+nodeAddresses = Data.ProtoLens.Field.field @"nodeAddresses"
+nodeId ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "nodeId" a) =>
+  Lens.Family2.LensLike' f s a
+nodeId = Data.ProtoLens.Field.field @"nodeId"
+nodePubkey ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "nodePubkey" a) =>
+  Lens.Family2.LensLike' f s a
+nodePubkey = Data.ProtoLens.Field.field @"nodePubkey"
+nodePubkeyString ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "nodePubkeyString" a) =>
+  Lens.Family2.LensLike' f s a
+nodePubkeyString = Data.ProtoLens.Field.field @"nodePubkeyString"
+nodeUpdates ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "nodeUpdates" a) =>
+  Lens.Family2.LensLike' f s a
+nodeUpdates = Data.ProtoLens.Field.field @"nodeUpdates"
+nodes ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "nodes" a) =>
+  Lens.Family2.LensLike' f s a
+nodes = Data.ProtoLens.Field.field @"nodes"
+nonce ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "nonce" a) =>
+  Lens.Family2.LensLike' f s a
+nonce = Data.ProtoLens.Field.field @"nonce"
+normalizedValue ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "normalizedValue" a) =>
+  Lens.Family2.LensLike' f s a
+normalizedValue = Data.ProtoLens.Field.field @"normalizedValue"
+numActiveChannels ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "numActiveChannels" a) =>
+  Lens.Family2.LensLike' f s a
+numActiveChannels = Data.ProtoLens.Field.field @"numActiveChannels"
+numChannels ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "numChannels" a) =>
+  Lens.Family2.LensLike' f s a
+numChannels = Data.ProtoLens.Field.field @"numChannels"
+numConfirmations ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "numConfirmations" a) =>
+  Lens.Family2.LensLike' f s a
+numConfirmations = Data.ProtoLens.Field.field @"numConfirmations"
+numConfsLeft ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "numConfsLeft" a) =>
+  Lens.Family2.LensLike' f s a
+numConfsLeft = Data.ProtoLens.Field.field @"numConfsLeft"
+numInactiveChannels ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "numInactiveChannels" a) =>
+  Lens.Family2.LensLike' f s a
+numInactiveChannels
+  = Data.ProtoLens.Field.field @"numInactiveChannels"
+numMaxEvents ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "numMaxEvents" a) =>
+  Lens.Family2.LensLike' f s a
+numMaxEvents = Data.ProtoLens.Field.field @"numMaxEvents"
+numMaxInvoices ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "numMaxInvoices" a) =>
+  Lens.Family2.LensLike' f s a
+numMaxInvoices = Data.ProtoLens.Field.field @"numMaxInvoices"
+numMsat ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "numMsat" a) =>
+  Lens.Family2.LensLike' f s a
+numMsat = Data.ProtoLens.Field.field @"numMsat"
+numNodes ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "numNodes" a) =>
+  Lens.Family2.LensLike' f s a
+numNodes = Data.ProtoLens.Field.field @"numNodes"
+numPeers ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "numPeers" a) =>
+  Lens.Family2.LensLike' f s a
+numPeers = Data.ProtoLens.Field.field @"numPeers"
+numPendingChannels ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "numPendingChannels" a) =>
+  Lens.Family2.LensLike' f s a
+numPendingChannels
+  = Data.ProtoLens.Field.field @"numPendingChannels"
+numSatoshis ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "numSatoshis" a) =>
+  Lens.Family2.LensLike' f s a
+numSatoshis = Data.ProtoLens.Field.field @"numSatoshis"
+numUpdates ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "numUpdates" a) =>
+  Lens.Family2.LensLike' f s a
+numUpdates = Data.ProtoLens.Field.field @"numUpdates"
+numZombieChans ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "numZombieChans" a) =>
+  Lens.Family2.LensLike' f s a
+numZombieChans = Data.ProtoLens.Field.field @"numZombieChans"
+onionSha256 ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "onionSha256" a) =>
+  Lens.Family2.LensLike' f s a
+onionSha256 = Data.ProtoLens.Field.field @"onionSha256"
+openChannel ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "openChannel" a) =>
+  Lens.Family2.LensLike' f s a
+openChannel = Data.ProtoLens.Field.field @"openChannel"
+openInitiator ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "openInitiator" a) =>
+  Lens.Family2.LensLike' f s a
+openInitiator = Data.ProtoLens.Field.field @"openInitiator"
+ops ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "ops" a) =>
+  Lens.Family2.LensLike' f s a
+ops = Data.ProtoLens.Field.field @"ops"
+outcome ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "outcome" a) =>
+  Lens.Family2.LensLike' f s a
+outcome = Data.ProtoLens.Field.field @"outcome"
+outgoingChanId ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "outgoingChanId" a) =>
+  Lens.Family2.LensLike' f s a
+outgoingChanId = Data.ProtoLens.Field.field @"outgoingChanId"
+outpoint ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "outpoint" a) =>
+  Lens.Family2.LensLike' f s a
+outpoint = Data.ProtoLens.Field.field @"outpoint"
+outputIndex ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "outputIndex" a) =>
+  Lens.Family2.LensLike' f s a
+outputIndex = Data.ProtoLens.Field.field @"outputIndex"
+payReq ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "payReq" a) =>
+  Lens.Family2.LensLike' f s a
+payReq = Data.ProtoLens.Field.field @"payReq"
+paymentAddr ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "paymentAddr" a) =>
+  Lens.Family2.LensLike' f s a
+paymentAddr = Data.ProtoLens.Field.field @"paymentAddr"
+paymentError ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "paymentError" a) =>
+  Lens.Family2.LensLike' f s a
+paymentError = Data.ProtoLens.Field.field @"paymentError"
+paymentHash ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "paymentHash" a) =>
+  Lens.Family2.LensLike' f s a
+paymentHash = Data.ProtoLens.Field.field @"paymentHash"
+paymentHashString ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "paymentHashString" a) =>
+  Lens.Family2.LensLike' f s a
+paymentHashString = Data.ProtoLens.Field.field @"paymentHashString"
+paymentIndex ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "paymentIndex" a) =>
+  Lens.Family2.LensLike' f s a
+paymentIndex = Data.ProtoLens.Field.field @"paymentIndex"
+paymentPreimage ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "paymentPreimage" a) =>
+  Lens.Family2.LensLike' f s a
+paymentPreimage = Data.ProtoLens.Field.field @"paymentPreimage"
+paymentRequest ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "paymentRequest" a) =>
+  Lens.Family2.LensLike' f s a
+paymentRequest = Data.ProtoLens.Field.field @"paymentRequest"
+paymentRoute ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "paymentRoute" a) =>
+  Lens.Family2.LensLike' f s a
+paymentRoute = Data.ProtoLens.Field.field @"paymentRoute"
+payments ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "payments" a) =>
+  Lens.Family2.LensLike' f s a
+payments = Data.ProtoLens.Field.field @"payments"
+peer ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "peer" a) =>
+  Lens.Family2.LensLike' f s a
+peer = Data.ProtoLens.Field.field @"peer"
+peers ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "peers" a) =>
+  Lens.Family2.LensLike' f s a
+peers = Data.ProtoLens.Field.field @"peers"
+pendingChanId ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "pendingChanId" a) =>
+  Lens.Family2.LensLike' f s a
+pendingChanId = Data.ProtoLens.Field.field @"pendingChanId"
+pendingClosingChannels ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "pendingClosingChannels" a) =>
+  Lens.Family2.LensLike' f s a
+pendingClosingChannels
+  = Data.ProtoLens.Field.field @"pendingClosingChannels"
+pendingForceClosingChannels ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "pendingForceClosingChannels" a) =>
+  Lens.Family2.LensLike' f s a
+pendingForceClosingChannels
+  = Data.ProtoLens.Field.field @"pendingForceClosingChannels"
+pendingFundingShimOnly ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "pendingFundingShimOnly" a) =>
+  Lens.Family2.LensLike' f s a
+pendingFundingShimOnly
+  = Data.ProtoLens.Field.field @"pendingFundingShimOnly"
+pendingHtlcs ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "pendingHtlcs" a) =>
+  Lens.Family2.LensLike' f s a
+pendingHtlcs = Data.ProtoLens.Field.field @"pendingHtlcs"
+pendingOnly ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "pendingOnly" a) =>
+  Lens.Family2.LensLike' f s a
+pendingOnly = Data.ProtoLens.Field.field @"pendingOnly"
+pendingOpenBalance ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "pendingOpenBalance" a) =>
+  Lens.Family2.LensLike' f s a
+pendingOpenBalance
+  = Data.ProtoLens.Field.field @"pendingOpenBalance"
+pendingOpenChannel ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "pendingOpenChannel" a) =>
+  Lens.Family2.LensLike' f s a
+pendingOpenChannel
+  = Data.ProtoLens.Field.field @"pendingOpenChannel"
+pendingOpenChannels ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "pendingOpenChannels" a) =>
+  Lens.Family2.LensLike' f s a
+pendingOpenChannels
+  = Data.ProtoLens.Field.field @"pendingOpenChannels"
+pendingOpenLocalBalance ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "pendingOpenLocalBalance" a) =>
+  Lens.Family2.LensLike' f s a
+pendingOpenLocalBalance
+  = Data.ProtoLens.Field.field @"pendingOpenLocalBalance"
+pendingOpenRemoteBalance ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "pendingOpenRemoteBalance" a) =>
+  Lens.Family2.LensLike' f s a
+pendingOpenRemoteBalance
+  = Data.ProtoLens.Field.field @"pendingOpenRemoteBalance"
+percent ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "percent" a) =>
+  Lens.Family2.LensLike' f s a
+percent = Data.ProtoLens.Field.field @"percent"
+perm ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "perm" a) =>
+  Lens.Family2.LensLike' f s a
+perm = Data.ProtoLens.Field.field @"perm"
+permissions ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "permissions" a) =>
+  Lens.Family2.LensLike' f s a
+permissions = Data.ProtoLens.Field.field @"permissions"
+pingTime ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "pingTime" a) =>
+  Lens.Family2.LensLike' f s a
+pingTime = Data.ProtoLens.Field.field @"pingTime"
+pkScript ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "pkScript" a) =>
+  Lens.Family2.LensLike' f s a
+pkScript = Data.ProtoLens.Field.field @"pkScript"
+preimage ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "preimage" a) =>
+  Lens.Family2.LensLike' f s a
+preimage = Data.ProtoLens.Field.field @"preimage"
+private ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "private" a) =>
+  Lens.Family2.LensLike' f s a
+private = Data.ProtoLens.Field.field @"private"
+privateOnly ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "privateOnly" a) =>
+  Lens.Family2.LensLike' f s a
+privateOnly = Data.ProtoLens.Field.field @"privateOnly"
+progress ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "progress" a) =>
+  Lens.Family2.LensLike' f s a
+progress = Data.ProtoLens.Field.field @"progress"
+psbt ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "psbt" a) =>
+  Lens.Family2.LensLike' f s a
+psbt = Data.ProtoLens.Field.field @"psbt"
+psbtFinalize ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "psbtFinalize" a) =>
+  Lens.Family2.LensLike' f s a
+psbtFinalize = Data.ProtoLens.Field.field @"psbtFinalize"
+psbtFund ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "psbtFund" a) =>
+  Lens.Family2.LensLike' f s a
+psbtFund = Data.ProtoLens.Field.field @"psbtFund"
+psbtShim ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "psbtShim" a) =>
+  Lens.Family2.LensLike' f s a
+psbtShim = Data.ProtoLens.Field.field @"psbtShim"
+psbtVerify ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "psbtVerify" a) =>
+  Lens.Family2.LensLike' f s a
+psbtVerify = Data.ProtoLens.Field.field @"psbtVerify"
+pubKey ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "pubKey" a) =>
+  Lens.Family2.LensLike' f s a
+pubKey = Data.ProtoLens.Field.field @"pubKey"
+pubkey ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "pubkey" a) =>
+  Lens.Family2.LensLike' f s a
+pubkey = Data.ProtoLens.Field.field @"pubkey"
+publicOnly ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "publicOnly" a) =>
+  Lens.Family2.LensLike' f s a
+publicOnly = Data.ProtoLens.Field.field @"publicOnly"
+pushAmountSat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "pushAmountSat" a) =>
+  Lens.Family2.LensLike' f s a
+pushAmountSat = Data.ProtoLens.Field.field @"pushAmountSat"
+pushAmt ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "pushAmt" a) =>
+  Lens.Family2.LensLike' f s a
+pushAmt = Data.ProtoLens.Field.field @"pushAmt"
+pushSat ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "pushSat" a) =>
+  Lens.Family2.LensLike' f s a
+pushSat = Data.ProtoLens.Field.field @"pushSat"
+rHash ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "rHash" a) =>
+  Lens.Family2.LensLike' f s a
+rHash = Data.ProtoLens.Field.field @"rHash"
+rHashStr ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "rHashStr" a) =>
+  Lens.Family2.LensLike' f s a
+rHashStr = Data.ProtoLens.Field.field @"rHashStr"
+rPreimage ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "rPreimage" a) =>
+  Lens.Family2.LensLike' f s a
+rPreimage = Data.ProtoLens.Field.field @"rPreimage"
+rawKeyBytes ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "rawKeyBytes" a) =>
+  Lens.Family2.LensLike' f s a
+rawKeyBytes = Data.ProtoLens.Field.field @"rawKeyBytes"
+rawTxHex ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "rawTxHex" a) =>
+  Lens.Family2.LensLike' f s a
+rawTxHex = Data.ProtoLens.Field.field @"rawTxHex"
+recoveredBalance ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "recoveredBalance" a) =>
+  Lens.Family2.LensLike' f s a
+recoveredBalance = Data.ProtoLens.Field.field @"recoveredBalance"
+recoveryFinished ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "recoveryFinished" a) =>
+  Lens.Family2.LensLike' f s a
+recoveryFinished = Data.ProtoLens.Field.field @"recoveryFinished"
+recoveryMode ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "recoveryMode" a) =>
+  Lens.Family2.LensLike' f s a
+recoveryMode = Data.ProtoLens.Field.field @"recoveryMode"
+remoteBalance ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "remoteBalance" a) =>
+  Lens.Family2.LensLike' f s a
+remoteBalance = Data.ProtoLens.Field.field @"remoteBalance"
+remoteChanReserveSat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "remoteChanReserveSat" a) =>
+  Lens.Family2.LensLike' f s a
+remoteChanReserveSat
+  = Data.ProtoLens.Field.field @"remoteChanReserveSat"
+remoteCommitFeeSat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "remoteCommitFeeSat" a) =>
+  Lens.Family2.LensLike' f s a
+remoteCommitFeeSat
+  = Data.ProtoLens.Field.field @"remoteCommitFeeSat"
+remoteConstraints ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "remoteConstraints" a) =>
+  Lens.Family2.LensLike' f s a
+remoteConstraints = Data.ProtoLens.Field.field @"remoteConstraints"
+remoteCsvDelay ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "remoteCsvDelay" a) =>
+  Lens.Family2.LensLike' f s a
+remoteCsvDelay = Data.ProtoLens.Field.field @"remoteCsvDelay"
+remoteForce ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "remoteForce" a) =>
+  Lens.Family2.LensLike' f s a
+remoteForce = Data.ProtoLens.Field.field @"remoteForce"
+remoteKey ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "remoteKey" a) =>
+  Lens.Family2.LensLike' f s a
+remoteKey = Data.ProtoLens.Field.field @"remoteKey"
+remoteMaxHtlcs ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "remoteMaxHtlcs" a) =>
+  Lens.Family2.LensLike' f s a
+remoteMaxHtlcs = Data.ProtoLens.Field.field @"remoteMaxHtlcs"
+remoteMaxValueInFlightMsat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "remoteMaxValueInFlightMsat" a) =>
+  Lens.Family2.LensLike' f s a
+remoteMaxValueInFlightMsat
+  = Data.ProtoLens.Field.field @"remoteMaxValueInFlightMsat"
+remoteNodePub ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "remoteNodePub" a) =>
+  Lens.Family2.LensLike' f s a
+remoteNodePub = Data.ProtoLens.Field.field @"remoteNodePub"
+remotePendingCommitFeeSat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "remotePendingCommitFeeSat" a) =>
+  Lens.Family2.LensLike' f s a
+remotePendingCommitFeeSat
+  = Data.ProtoLens.Field.field @"remotePendingCommitFeeSat"
+remotePendingTxid ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "remotePendingTxid" a) =>
+  Lens.Family2.LensLike' f s a
+remotePendingTxid = Data.ProtoLens.Field.field @"remotePendingTxid"
+remotePubkey ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "remotePubkey" a) =>
+  Lens.Family2.LensLike' f s a
+remotePubkey = Data.ProtoLens.Field.field @"remotePubkey"
+remoteTxid ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "remoteTxid" a) =>
+  Lens.Family2.LensLike' f s a
+remoteTxid = Data.ProtoLens.Field.field @"remoteTxid"
+reserveSat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "reserveSat" a) =>
+  Lens.Family2.LensLike' f s a
+reserveSat = Data.ProtoLens.Field.field @"reserveSat"
+resolutionType ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "resolutionType" a) =>
+  Lens.Family2.LensLike' f s a
+resolutionType = Data.ProtoLens.Field.field @"resolutionType"
+resolutions ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "resolutions" a) =>
+  Lens.Family2.LensLike' f s a
+resolutions = Data.ProtoLens.Field.field @"resolutions"
+resolveTime ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "resolveTime" a) =>
+  Lens.Family2.LensLike' f s a
+resolveTime = Data.ProtoLens.Field.field @"resolveTime"
+resolveTimeNs ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "resolveTimeNs" a) =>
+  Lens.Family2.LensLike' f s a
+resolveTimeNs = Data.ProtoLens.Field.field @"resolveTimeNs"
+reversed ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "reversed" a) =>
+  Lens.Family2.LensLike' f s a
+reversed = Data.ProtoLens.Field.field @"reversed"
+rootKeyId ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "rootKeyId" a) =>
+  Lens.Family2.LensLike' f s a
+rootKeyId = Data.ProtoLens.Field.field @"rootKeyId"
+rootKeyIds ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "rootKeyIds" a) =>
+  Lens.Family2.LensLike' f s a
+rootKeyIds = Data.ProtoLens.Field.field @"rootKeyIds"
+rootShare ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "rootShare" a) =>
+  Lens.Family2.LensLike' f s a
+rootShare = Data.ProtoLens.Field.field @"rootShare"
+route ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "route" a) =>
+  Lens.Family2.LensLike' f s a
+route = Data.ProtoLens.Field.field @"route"
+routeHints ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "routeHints" a) =>
+  Lens.Family2.LensLike' f s a
+routeHints = Data.ProtoLens.Field.field @"routeHints"
+routes ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "routes" a) =>
+  Lens.Family2.LensLike' f s a
+routes = Data.ProtoLens.Field.field @"routes"
+routingPolicy ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "routingPolicy" a) =>
+  Lens.Family2.LensLike' f s a
+routingPolicy = Data.ProtoLens.Field.field @"routingPolicy"
+sat ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "sat" a) =>
+  Lens.Family2.LensLike' f s a
+sat = Data.ProtoLens.Field.field @"sat"
+satPerByte ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "satPerByte" a) =>
+  Lens.Family2.LensLike' f s a
+satPerByte = Data.ProtoLens.Field.field @"satPerByte"
+satPerVbyte ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "satPerVbyte" a) =>
+  Lens.Family2.LensLike' f s a
+satPerVbyte = Data.ProtoLens.Field.field @"satPerVbyte"
+satRecv ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "satRecv" a) =>
+  Lens.Family2.LensLike' f s a
+satRecv = Data.ProtoLens.Field.field @"satRecv"
+satSent ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "satSent" a) =>
+  Lens.Family2.LensLike' f s a
+satSent = Data.ProtoLens.Field.field @"satSent"
+sendAll ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "sendAll" a) =>
+  Lens.Family2.LensLike' f s a
+sendAll = Data.ProtoLens.Field.field @"sendAll"
+setId ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "setId" a) =>
+  Lens.Family2.LensLike' f s a
+setId = Data.ProtoLens.Field.field @"setId"
+settleDate ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "settleDate" a) =>
+  Lens.Family2.LensLike' f s a
+settleDate = Data.ProtoLens.Field.field @"settleDate"
+settleIndex ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "settleIndex" a) =>
+  Lens.Family2.LensLike' f s a
+settleIndex = Data.ProtoLens.Field.field @"settleIndex"
+settled ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "settled" a) =>
+  Lens.Family2.LensLike' f s a
+settled = Data.ProtoLens.Field.field @"settled"
+settledBalance ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "settledBalance" a) =>
+  Lens.Family2.LensLike' f s a
+settledBalance = Data.ProtoLens.Field.field @"settledBalance"
+shimCancel ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "shimCancel" a) =>
+  Lens.Family2.LensLike' f s a
+shimCancel = Data.ProtoLens.Field.field @"shimCancel"
+shimRegister ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "shimRegister" a) =>
+  Lens.Family2.LensLike' f s a
+shimRegister = Data.ProtoLens.Field.field @"shimRegister"
+show ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "show" a) =>
+  Lens.Family2.LensLike' f s a
+show = Data.ProtoLens.Field.field @"show"
+signature ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "signature" a) =>
+  Lens.Family2.LensLike' f s a
+signature = Data.ProtoLens.Field.field @"signature"
+signedPsbt ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "signedPsbt" a) =>
+  Lens.Family2.LensLike' f s a
+signedPsbt = Data.ProtoLens.Field.field @"signedPsbt"
+singleChanBackups ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "singleChanBackups" a) =>
+  Lens.Family2.LensLike' f s a
+singleChanBackups = Data.ProtoLens.Field.field @"singleChanBackups"
+sourcePubKey ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "sourcePubKey" a) =>
+  Lens.Family2.LensLike' f s a
+sourcePubKey = Data.ProtoLens.Field.field @"sourcePubKey"
+spendUnconfirmed ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "spendUnconfirmed" a) =>
+  Lens.Family2.LensLike' f s a
+spendUnconfirmed = Data.ProtoLens.Field.field @"spendUnconfirmed"
+stage ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "stage" a) =>
+  Lens.Family2.LensLike' f s a
+stage = Data.ProtoLens.Field.field @"stage"
+startHeight ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "startHeight" a) =>
+  Lens.Family2.LensLike' f s a
+startHeight = Data.ProtoLens.Field.field @"startHeight"
+startTime ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "startTime" a) =>
+  Lens.Family2.LensLike' f s a
+startTime = Data.ProtoLens.Field.field @"startTime"
+state ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "state" a) =>
+  Lens.Family2.LensLike' f s a
+state = Data.ProtoLens.Field.field @"state"
+staticRemoteKey ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "staticRemoteKey" a) =>
+  Lens.Family2.LensLike' f s a
+staticRemoteKey = Data.ProtoLens.Field.field @"staticRemoteKey"
+status ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "status" a) =>
+  Lens.Family2.LensLike' f s a
+status = Data.ProtoLens.Field.field @"status"
+storageId ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "storageId" a) =>
+  Lens.Family2.LensLike' f s a
+storageId = Data.ProtoLens.Field.field @"storageId"
+subSystems ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "subSystems" a) =>
+  Lens.Family2.LensLike' f s a
+subSystems = Data.ProtoLens.Field.field @"subSystems"
+success ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "success" a) =>
+  Lens.Family2.LensLike' f s a
+success = Data.ProtoLens.Field.field @"success"
+successProb ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "successProb" a) =>
+  Lens.Family2.LensLike' f s a
+successProb = Data.ProtoLens.Field.field @"successProb"
+sweepTxid ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "sweepTxid" a) =>
+  Lens.Family2.LensLike' f s a
+sweepTxid = Data.ProtoLens.Field.field @"sweepTxid"
+syncType ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "syncType" a) =>
+  Lens.Family2.LensLike' f s a
+syncType = Data.ProtoLens.Field.field @"syncType"
+syncedToChain ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "syncedToChain" a) =>
+  Lens.Family2.LensLike' f s a
+syncedToChain = Data.ProtoLens.Field.field @"syncedToChain"
+syncedToGraph ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "syncedToGraph" a) =>
+  Lens.Family2.LensLike' f s a
+syncedToGraph = Data.ProtoLens.Field.field @"syncedToGraph"
+targetConf ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "targetConf" a) =>
+  Lens.Family2.LensLike' f s a
+targetConf = Data.ProtoLens.Field.field @"targetConf"
+testnet ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "testnet" a) =>
+  Lens.Family2.LensLike' f s a
+testnet = Data.ProtoLens.Field.field @"testnet"
+thawHeight ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "thawHeight" a) =>
+  Lens.Family2.LensLike' f s a
+thawHeight = Data.ProtoLens.Field.field @"thawHeight"
+timeLockDelta ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "timeLockDelta" a) =>
+  Lens.Family2.LensLike' f s a
+timeLockDelta = Data.ProtoLens.Field.field @"timeLockDelta"
+timeLockedBalance ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "timeLockedBalance" a) =>
+  Lens.Family2.LensLike' f s a
+timeLockedBalance = Data.ProtoLens.Field.field @"timeLockedBalance"
+timeStamp ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "timeStamp" a) =>
+  Lens.Family2.LensLike' f s a
+timeStamp = Data.ProtoLens.Field.field @"timeStamp"
+timeout ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "timeout" a) =>
+  Lens.Family2.LensLike' f s a
+timeout = Data.ProtoLens.Field.field @"timeout"
+timestamp ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "timestamp" a) =>
+  Lens.Family2.LensLike' f s a
+timestamp = Data.ProtoLens.Field.field @"timestamp"
+timestampNs ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "timestampNs" a) =>
+  Lens.Family2.LensLike' f s a
+timestampNs = Data.ProtoLens.Field.field @"timestampNs"
+tlvPayload ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "tlvPayload" a) =>
+  Lens.Family2.LensLike' f s a
+tlvPayload = Data.ProtoLens.Field.field @"tlvPayload"
+to ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "to" a) =>
+  Lens.Family2.LensLike' f s a
+to = Data.ProtoLens.Field.field @"to"
+totalAmt ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "totalAmt" a) =>
+  Lens.Family2.LensLike' f s a
+totalAmt = Data.ProtoLens.Field.field @"totalAmt"
+totalAmtMsat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "totalAmtMsat" a) =>
+  Lens.Family2.LensLike' f s a
+totalAmtMsat = Data.ProtoLens.Field.field @"totalAmtMsat"
+totalBalance ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "totalBalance" a) =>
+  Lens.Family2.LensLike' f s a
+totalBalance = Data.ProtoLens.Field.field @"totalBalance"
+totalCapacity ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "totalCapacity" a) =>
+  Lens.Family2.LensLike' f s a
+totalCapacity = Data.ProtoLens.Field.field @"totalCapacity"
+totalFees ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "totalFees" a) =>
+  Lens.Family2.LensLike' f s a
+totalFees = Data.ProtoLens.Field.field @"totalFees"
+totalFeesMsat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "totalFeesMsat" a) =>
+  Lens.Family2.LensLike' f s a
+totalFeesMsat = Data.ProtoLens.Field.field @"totalFeesMsat"
+totalLimboBalance ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "totalLimboBalance" a) =>
+  Lens.Family2.LensLike' f s a
+totalLimboBalance = Data.ProtoLens.Field.field @"totalLimboBalance"
+totalNetworkCapacity ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "totalNetworkCapacity" a) =>
+  Lens.Family2.LensLike' f s a
+totalNetworkCapacity
+  = Data.ProtoLens.Field.field @"totalNetworkCapacity"
+totalSatoshisReceived ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "totalSatoshisReceived" a) =>
+  Lens.Family2.LensLike' f s a
+totalSatoshisReceived
+  = Data.ProtoLens.Field.field @"totalSatoshisReceived"
+totalSatoshisSent ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "totalSatoshisSent" a) =>
+  Lens.Family2.LensLike' f s a
+totalSatoshisSent = Data.ProtoLens.Field.field @"totalSatoshisSent"
+totalTimeLock ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "totalTimeLock" a) =>
+  Lens.Family2.LensLike' f s a
+totalTimeLock = Data.ProtoLens.Field.field @"totalTimeLock"
+transactions ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "transactions" a) =>
+  Lens.Family2.LensLike' f s a
+transactions = Data.ProtoLens.Field.field @"transactions"
+txHash ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "txHash" a) =>
+  Lens.Family2.LensLike' f s a
+txHash = Data.ProtoLens.Field.field @"txHash"
+txid ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "txid" a) =>
+  Lens.Family2.LensLike' f s a
+txid = Data.ProtoLens.Field.field @"txid"
+txidBytes ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "txidBytes" a) =>
+  Lens.Family2.LensLike' f s a
+txidBytes = Data.ProtoLens.Field.field @"txidBytes"
+txidStr ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "txidStr" a) =>
+  Lens.Family2.LensLike' f s a
+txidStr = Data.ProtoLens.Field.field @"txidStr"
+type' ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "type'" a) =>
+  Lens.Family2.LensLike' f s a
+type' = Data.ProtoLens.Field.field @"type'"
+types ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "types" a) =>
+  Lens.Family2.LensLike' f s a
+types = Data.ProtoLens.Field.field @"types"
+unconfirmedBalance ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "unconfirmedBalance" a) =>
+  Lens.Family2.LensLike' f s a
+unconfirmedBalance
+  = Data.ProtoLens.Field.field @"unconfirmedBalance"
+unsettledBalance ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "unsettledBalance" a) =>
+  Lens.Family2.LensLike' f s a
+unsettledBalance = Data.ProtoLens.Field.field @"unsettledBalance"
+unsettledLocalBalance ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "unsettledLocalBalance" a) =>
+  Lens.Family2.LensLike' f s a
+unsettledLocalBalance
+  = Data.ProtoLens.Field.field @"unsettledLocalBalance"
+unsettledRemoteBalance ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "unsettledRemoteBalance" a) =>
+  Lens.Family2.LensLike' f s a
+unsettledRemoteBalance
+  = Data.ProtoLens.Field.field @"unsettledRemoteBalance"
+upfrontShutdown ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "upfrontShutdown" a) =>
+  Lens.Family2.LensLike' f s a
+upfrontShutdown = Data.ProtoLens.Field.field @"upfrontShutdown"
+uptime ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "uptime" a) =>
+  Lens.Family2.LensLike' f s a
+uptime = Data.ProtoLens.Field.field @"uptime"
+uris ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "uris" a) =>
+  Lens.Family2.LensLike' f s a
+uris = Data.ProtoLens.Field.field @"uris"
+useMissionControl ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "useMissionControl" a) =>
+  Lens.Family2.LensLike' f s a
+useMissionControl = Data.ProtoLens.Field.field @"useMissionControl"
+utxos ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "utxos" a) =>
+  Lens.Family2.LensLike' f s a
+utxos = Data.ProtoLens.Field.field @"utxos"
+valid ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "valid" a) =>
+  Lens.Family2.LensLike' f s a
+valid = Data.ProtoLens.Field.field @"valid"
+value ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "value" a) =>
+  Lens.Family2.LensLike' f s a
+value = Data.ProtoLens.Field.field @"value"
+valueMsat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "valueMsat" a) =>
+  Lens.Family2.LensLike' f s a
+valueMsat = Data.ProtoLens.Field.field @"valueMsat"
+valueSat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "valueSat" a) =>
+  Lens.Family2.LensLike' f s a
+valueSat = Data.ProtoLens.Field.field @"valueSat"
+vec'actions ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'actions" a) =>
+  Lens.Family2.LensLike' f s a
+vec'actions = Data.ProtoLens.Field.field @"vec'actions"
+vec'addresses ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'addresses" a) =>
+  Lens.Family2.LensLike' f s a
+vec'addresses = Data.ProtoLens.Field.field @"vec'addresses"
+vec'chains ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'chains" a) =>
+  Lens.Family2.LensLike' f s a
+vec'chains = Data.ProtoLens.Field.field @"vec'chains"
+vec'chanBackups ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'chanBackups" a) =>
+  Lens.Family2.LensLike' f s a
+vec'chanBackups = Data.ProtoLens.Field.field @"vec'chanBackups"
+vec'chanPoints ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'chanPoints" a) =>
+  Lens.Family2.LensLike' f s a
+vec'chanPoints = Data.ProtoLens.Field.field @"vec'chanPoints"
+vec'channelFees ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'channelFees" a) =>
+  Lens.Family2.LensLike' f s a
+vec'channelFees = Data.ProtoLens.Field.field @"vec'channelFees"
+vec'channelUpdates ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'channelUpdates" a) =>
+  Lens.Family2.LensLike' f s a
+vec'channelUpdates
+  = Data.ProtoLens.Field.field @"vec'channelUpdates"
+vec'channels ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'channels" a) =>
+  Lens.Family2.LensLike' f s a
+vec'channels = Data.ProtoLens.Field.field @"vec'channels"
+vec'closedChans ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'closedChans" a) =>
+  Lens.Family2.LensLike' f s a
+vec'closedChans = Data.ProtoLens.Field.field @"vec'closedChans"
+vec'destAddresses ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'destAddresses" a) =>
+  Lens.Family2.LensLike' f s a
+vec'destAddresses = Data.ProtoLens.Field.field @"vec'destAddresses"
+vec'destFeatures ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'destFeatures" a) =>
+  Lens.Family2.LensLike' f s a
+vec'destFeatures = Data.ProtoLens.Field.field @"vec'destFeatures"
+vec'edges ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'edges" a) =>
+  Lens.Family2.LensLike' f s a
+vec'edges = Data.ProtoLens.Field.field @"vec'edges"
+vec'errors ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'errors" a) =>
+  Lens.Family2.LensLike' f s a
+vec'errors = Data.ProtoLens.Field.field @"vec'errors"
+vec'forwardingEvents ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'forwardingEvents" a) =>
+  Lens.Family2.LensLike' f s a
+vec'forwardingEvents
+  = Data.ProtoLens.Field.field @"vec'forwardingEvents"
+vec'hopHints ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'hopHints" a) =>
+  Lens.Family2.LensLike' f s a
+vec'hopHints = Data.ProtoLens.Field.field @"vec'hopHints"
+vec'hops ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'hops" a) =>
+  Lens.Family2.LensLike' f s a
+vec'hops = Data.ProtoLens.Field.field @"vec'hops"
+vec'htlcs ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'htlcs" a) =>
+  Lens.Family2.LensLike' f s a
+vec'htlcs = Data.ProtoLens.Field.field @"vec'htlcs"
+vec'ignoredEdges ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'ignoredEdges" a) =>
+  Lens.Family2.LensLike' f s a
+vec'ignoredEdges = Data.ProtoLens.Field.field @"vec'ignoredEdges"
+vec'ignoredNodes ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'ignoredNodes" a) =>
+  Lens.Family2.LensLike' f s a
+vec'ignoredNodes = Data.ProtoLens.Field.field @"vec'ignoredNodes"
+vec'ignoredPairs ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'ignoredPairs" a) =>
+  Lens.Family2.LensLike' f s a
+vec'ignoredPairs = Data.ProtoLens.Field.field @"vec'ignoredPairs"
+vec'invoices ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'invoices" a) =>
+  Lens.Family2.LensLike' f s a
+vec'invoices = Data.ProtoLens.Field.field @"vec'invoices"
+vec'nodeAddresses ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'nodeAddresses" a) =>
+  Lens.Family2.LensLike' f s a
+vec'nodeAddresses = Data.ProtoLens.Field.field @"vec'nodeAddresses"
+vec'nodeUpdates ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'nodeUpdates" a) =>
+  Lens.Family2.LensLike' f s a
+vec'nodeUpdates = Data.ProtoLens.Field.field @"vec'nodeUpdates"
+vec'nodes ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'nodes" a) =>
+  Lens.Family2.LensLike' f s a
+vec'nodes = Data.ProtoLens.Field.field @"vec'nodes"
+vec'ops ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "vec'ops" a) =>
+  Lens.Family2.LensLike' f s a
+vec'ops = Data.ProtoLens.Field.field @"vec'ops"
+vec'payments ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'payments" a) =>
+  Lens.Family2.LensLike' f s a
+vec'payments = Data.ProtoLens.Field.field @"vec'payments"
+vec'peers ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'peers" a) =>
+  Lens.Family2.LensLike' f s a
+vec'peers = Data.ProtoLens.Field.field @"vec'peers"
+vec'pendingClosingChannels ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'pendingClosingChannels" a) =>
+  Lens.Family2.LensLike' f s a
+vec'pendingClosingChannels
+  = Data.ProtoLens.Field.field @"vec'pendingClosingChannels"
+vec'pendingForceClosingChannels ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'pendingForceClosingChannels" a) =>
+  Lens.Family2.LensLike' f s a
+vec'pendingForceClosingChannels
+  = Data.ProtoLens.Field.field @"vec'pendingForceClosingChannels"
+vec'pendingHtlcs ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'pendingHtlcs" a) =>
+  Lens.Family2.LensLike' f s a
+vec'pendingHtlcs = Data.ProtoLens.Field.field @"vec'pendingHtlcs"
+vec'pendingOpenChannels ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'pendingOpenChannels" a) =>
+  Lens.Family2.LensLike' f s a
+vec'pendingOpenChannels
+  = Data.ProtoLens.Field.field @"vec'pendingOpenChannels"
+vec'permissions ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'permissions" a) =>
+  Lens.Family2.LensLike' f s a
+vec'permissions = Data.ProtoLens.Field.field @"vec'permissions"
+vec'resolutions ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'resolutions" a) =>
+  Lens.Family2.LensLike' f s a
+vec'resolutions = Data.ProtoLens.Field.field @"vec'resolutions"
+vec'rootKeyIds ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'rootKeyIds" a) =>
+  Lens.Family2.LensLike' f s a
+vec'rootKeyIds = Data.ProtoLens.Field.field @"vec'rootKeyIds"
+vec'routeHints ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'routeHints" a) =>
+  Lens.Family2.LensLike' f s a
+vec'routeHints = Data.ProtoLens.Field.field @"vec'routeHints"
+vec'routes ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'routes" a) =>
+  Lens.Family2.LensLike' f s a
+vec'routes = Data.ProtoLens.Field.field @"vec'routes"
+vec'transactions ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'transactions" a) =>
+  Lens.Family2.LensLike' f s a
+vec'transactions = Data.ProtoLens.Field.field @"vec'transactions"
+vec'types ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'types" a) =>
+  Lens.Family2.LensLike' f s a
+vec'types = Data.ProtoLens.Field.field @"vec'types"
+vec'uris ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'uris" a) =>
+  Lens.Family2.LensLike' f s a
+vec'uris = Data.ProtoLens.Field.field @"vec'uris"
+vec'utxos ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'utxos" a) =>
+  Lens.Family2.LensLike' f s a
+vec'utxos = Data.ProtoLens.Field.field @"vec'utxos"
+vec'waitingCloseChannels ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'waitingCloseChannels" a) =>
+  Lens.Family2.LensLike' f s a
+vec'waitingCloseChannels
+  = Data.ProtoLens.Field.field @"vec'waitingCloseChannels"
+version ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "version" a) =>
+  Lens.Family2.LensLike' f s a
+version = Data.ProtoLens.Field.field @"version"
+waitingCloseChannels ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "waitingCloseChannels" a) =>
+  Lens.Family2.LensLike' f s a
+waitingCloseChannels
+  = Data.ProtoLens.Field.field @"waitingCloseChannels"
+weekFeeSum ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "weekFeeSum" a) =>
+  Lens.Family2.LensLike' f s a
+weekFeeSum = Data.ProtoLens.Field.field @"weekFeeSum"
diff --git a/src/Proto/RouterGrpc.hs b/src/Proto/RouterGrpc.hs
new file mode 100644
--- /dev/null
+++ b/src/Proto/RouterGrpc.hs
@@ -0,0 +1,10865 @@
+{- This file was auto-generated from router_grpc.proto by the proto-lens-protoc program. -}
+{-# LANGUAGE ScopedTypeVariables, DataKinds, TypeFamilies, UndecidableInstances, GeneralizedNewtypeDeriving, MultiParamTypeClasses, FlexibleContexts, FlexibleInstances, PatternSynonyms, MagicHash, NoImplicitPrelude, DataKinds, BangPatterns, TypeApplications, OverloadedStrings, DerivingStrategies#-}
+{-# OPTIONS_GHC -Wno-unused-imports#-}
+{-# OPTIONS_GHC -Wno-duplicate-exports#-}
+{-# OPTIONS_GHC -Wno-dodgy-exports#-}
+module Proto.RouterGrpc (
+        Router(..), BuildRouteRequest(), BuildRouteResponse(),
+        ChanStatusAction(..), ChanStatusAction(),
+        ChanStatusAction'UnrecognizedValue, CircuitKey(),
+        FailureDetail(..), FailureDetail(),
+        FailureDetail'UnrecognizedValue, ForwardEvent(),
+        ForwardFailEvent(), ForwardHtlcInterceptRequest(),
+        ForwardHtlcInterceptRequest'CustomRecordsEntry(),
+        ForwardHtlcInterceptResponse(), GetMissionControlConfigRequest(),
+        GetMissionControlConfigResponse(), HtlcEvent(),
+        HtlcEvent'Event(..), _HtlcEvent'ForwardEvent,
+        _HtlcEvent'ForwardFailEvent, _HtlcEvent'SettleEvent,
+        _HtlcEvent'LinkFailEvent, HtlcEvent'EventType(..),
+        HtlcEvent'EventType(), HtlcEvent'EventType'UnrecognizedValue,
+        HtlcInfo(), LinkFailEvent(), MissionControlConfig(), PairData(),
+        PairHistory(), PaymentState(..), PaymentState(),
+        PaymentState'UnrecognizedValue, PaymentStatus(),
+        QueryMissionControlRequest(), QueryMissionControlResponse(),
+        QueryProbabilityRequest(), QueryProbabilityResponse(),
+        ResetMissionControlRequest(), ResetMissionControlResponse(),
+        ResolveHoldForwardAction(..), ResolveHoldForwardAction(),
+        ResolveHoldForwardAction'UnrecognizedValue, RouteFeeRequest(),
+        RouteFeeResponse(), SendPaymentRequest(),
+        SendPaymentRequest'DestCustomRecordsEntry(), SendToRouteRequest(),
+        SendToRouteResponse(), SetMissionControlConfigRequest(),
+        SetMissionControlConfigResponse(), SettleEvent(),
+        SubscribeHtlcEventsRequest(), TrackPaymentRequest(),
+        UpdateChanStatusRequest(), UpdateChanStatusResponse(),
+        XImportMissionControlRequest(), XImportMissionControlResponse()
+    ) where
+import qualified Data.ProtoLens.Runtime.Control.DeepSeq as Control.DeepSeq
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Prism as Data.ProtoLens.Prism
+import qualified Data.ProtoLens.Runtime.Prelude as Prelude
+import qualified Data.ProtoLens.Runtime.Data.Int as Data.Int
+import qualified Data.ProtoLens.Runtime.Data.Monoid as Data.Monoid
+import qualified Data.ProtoLens.Runtime.Data.Word as Data.Word
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens as Data.ProtoLens
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Bytes as Data.ProtoLens.Encoding.Bytes
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Growing as Data.ProtoLens.Encoding.Growing
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Parser.Unsafe as Data.ProtoLens.Encoding.Parser.Unsafe
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Wire as Data.ProtoLens.Encoding.Wire
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Field as Data.ProtoLens.Field
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Message.Enum as Data.ProtoLens.Message.Enum
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Service.Types as Data.ProtoLens.Service.Types
+import qualified Data.ProtoLens.Runtime.Lens.Family2 as Lens.Family2
+import qualified Data.ProtoLens.Runtime.Lens.Family2.Unchecked as Lens.Family2.Unchecked
+import qualified Data.ProtoLens.Runtime.Data.Text as Data.Text
+import qualified Data.ProtoLens.Runtime.Data.Map as Data.Map
+import qualified Data.ProtoLens.Runtime.Data.ByteString as Data.ByteString
+import qualified Data.ProtoLens.Runtime.Data.ByteString.Char8 as Data.ByteString.Char8
+import qualified Data.ProtoLens.Runtime.Data.Text.Encoding as Data.Text.Encoding
+import qualified Data.ProtoLens.Runtime.Data.Vector as Data.Vector
+import qualified Data.ProtoLens.Runtime.Data.Vector.Generic as Data.Vector.Generic
+import qualified Data.ProtoLens.Runtime.Data.Vector.Unboxed as Data.Vector.Unboxed
+import qualified Data.ProtoLens.Runtime.Text.Read as Text.Read
+import qualified Proto.LndGrpc
+{- | Fields :
+     
+         * 'Proto.RouterGrpc_Fields.amtMsat' @:: Lens' BuildRouteRequest Data.Int.Int64@
+         * 'Proto.RouterGrpc_Fields.finalCltvDelta' @:: Lens' BuildRouteRequest Data.Int.Int32@
+         * 'Proto.RouterGrpc_Fields.outgoingChanId' @:: Lens' BuildRouteRequest Data.Word.Word64@
+         * 'Proto.RouterGrpc_Fields.hopPubkeys' @:: Lens' BuildRouteRequest [Data.ByteString.ByteString]@
+         * 'Proto.RouterGrpc_Fields.vec'hopPubkeys' @:: Lens' BuildRouteRequest (Data.Vector.Vector Data.ByteString.ByteString)@
+         * 'Proto.RouterGrpc_Fields.paymentAddr' @:: Lens' BuildRouteRequest Data.ByteString.ByteString@ -}
+data BuildRouteRequest
+  = BuildRouteRequest'_constructor {_BuildRouteRequest'amtMsat :: !Data.Int.Int64,
+                                    _BuildRouteRequest'finalCltvDelta :: !Data.Int.Int32,
+                                    _BuildRouteRequest'outgoingChanId :: !Data.Word.Word64,
+                                    _BuildRouteRequest'hopPubkeys :: !(Data.Vector.Vector Data.ByteString.ByteString),
+                                    _BuildRouteRequest'paymentAddr :: !Data.ByteString.ByteString,
+                                    _BuildRouteRequest'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show BuildRouteRequest where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Field.HasField BuildRouteRequest "amtMsat" Data.Int.Int64 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _BuildRouteRequest'amtMsat
+           (\ x__ y__ -> x__ {_BuildRouteRequest'amtMsat = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField BuildRouteRequest "finalCltvDelta" Data.Int.Int32 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _BuildRouteRequest'finalCltvDelta
+           (\ x__ y__ -> x__ {_BuildRouteRequest'finalCltvDelta = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField BuildRouteRequest "outgoingChanId" Data.Word.Word64 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _BuildRouteRequest'outgoingChanId
+           (\ x__ y__ -> x__ {_BuildRouteRequest'outgoingChanId = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField BuildRouteRequest "hopPubkeys" [Data.ByteString.ByteString] where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _BuildRouteRequest'hopPubkeys
+           (\ x__ y__ -> x__ {_BuildRouteRequest'hopPubkeys = y__}))
+        (Lens.Family2.Unchecked.lens
+           Data.Vector.Generic.toList
+           (\ _ y__ -> Data.Vector.Generic.fromList y__))
+instance Data.ProtoLens.Field.HasField BuildRouteRequest "vec'hopPubkeys" (Data.Vector.Vector Data.ByteString.ByteString) where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _BuildRouteRequest'hopPubkeys
+           (\ x__ y__ -> x__ {_BuildRouteRequest'hopPubkeys = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField BuildRouteRequest "paymentAddr" Data.ByteString.ByteString where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _BuildRouteRequest'paymentAddr
+           (\ x__ y__ -> x__ {_BuildRouteRequest'paymentAddr = y__}))
+        Prelude.id
+instance Data.ProtoLens.Message BuildRouteRequest where
+  messageName _ = Data.Text.pack "routerrpc.BuildRouteRequest"
+  packedMessageDescriptor _
+    = "\n\
+      \\DC1BuildRouteRequest\DC2\EM\n\
+      \\bamt_msat\CAN\SOH \SOH(\ETXR\aamtMsat\DC2(\n\
+      \\DLEfinal_cltv_delta\CAN\STX \SOH(\ENQR\SOfinalCltvDelta\DC2,\n\
+      \\DLEoutgoing_chan_id\CAN\ETX \SOH(\EOTR\SOoutgoingChanIdB\STX0\SOH\DC2\US\n\
+      \\vhop_pubkeys\CAN\EOT \ETX(\fR\n\
+      \hopPubkeys\DC2!\n\
+      \\fpayment_addr\CAN\ENQ \SOH(\fR\vpaymentAddr"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag
+    = let
+        amtMsat__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "amt_msat"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.Int64Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional (Data.ProtoLens.Field.field @"amtMsat")) ::
+              Data.ProtoLens.FieldDescriptor BuildRouteRequest
+        finalCltvDelta__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "final_cltv_delta"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"finalCltvDelta")) ::
+              Data.ProtoLens.FieldDescriptor BuildRouteRequest
+        outgoingChanId__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "outgoing_chan_id"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.UInt64Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Word.Word64)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"outgoingChanId")) ::
+              Data.ProtoLens.FieldDescriptor BuildRouteRequest
+        hopPubkeys__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "hop_pubkeys"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
+              (Data.ProtoLens.RepeatedField
+                 Data.ProtoLens.Unpacked
+                 (Data.ProtoLens.Field.field @"hopPubkeys")) ::
+              Data.ProtoLens.FieldDescriptor BuildRouteRequest
+        paymentAddr__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "payment_addr"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"paymentAddr")) ::
+              Data.ProtoLens.FieldDescriptor BuildRouteRequest
+      in
+        Data.Map.fromList
+          [(Data.ProtoLens.Tag 1, amtMsat__field_descriptor),
+           (Data.ProtoLens.Tag 2, finalCltvDelta__field_descriptor),
+           (Data.ProtoLens.Tag 3, outgoingChanId__field_descriptor),
+           (Data.ProtoLens.Tag 4, hopPubkeys__field_descriptor),
+           (Data.ProtoLens.Tag 5, paymentAddr__field_descriptor)]
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _BuildRouteRequest'_unknownFields
+        (\ x__ y__ -> x__ {_BuildRouteRequest'_unknownFields = y__})
+  defMessage
+    = BuildRouteRequest'_constructor
+        {_BuildRouteRequest'amtMsat = Data.ProtoLens.fieldDefault,
+         _BuildRouteRequest'finalCltvDelta = Data.ProtoLens.fieldDefault,
+         _BuildRouteRequest'outgoingChanId = Data.ProtoLens.fieldDefault,
+         _BuildRouteRequest'hopPubkeys = Data.Vector.Generic.empty,
+         _BuildRouteRequest'paymentAddr = Data.ProtoLens.fieldDefault,
+         _BuildRouteRequest'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          BuildRouteRequest
+          -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld Data.ByteString.ByteString
+             -> Data.ProtoLens.Encoding.Bytes.Parser BuildRouteRequest
+        loop x mutable'hopPubkeys
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do frozen'hopPubkeys <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
+                                             (Data.ProtoLens.Encoding.Growing.unsafeFreeze
+                                                mutable'hopPubkeys)
+                      (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields
+                           (\ !t -> Prelude.reverse t)
+                           (Lens.Family2.set
+                              (Data.ProtoLens.Field.field @"vec'hopPubkeys")
+                              frozen'hopPubkeys
+                              x))
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of
+                        8 -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          Prelude.fromIntegral
+                                          Data.ProtoLens.Encoding.Bytes.getVarInt)
+                                       "amt_msat"
+                                loop
+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"amtMsat") y x)
+                                  mutable'hopPubkeys
+                        16
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          Prelude.fromIntegral
+                                          Data.ProtoLens.Encoding.Bytes.getVarInt)
+                                       "final_cltv_delta"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"finalCltvDelta") y x)
+                                  mutable'hopPubkeys
+                        24
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       Data.ProtoLens.Encoding.Bytes.getVarInt "outgoing_chan_id"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"outgoingChanId") y x)
+                                  mutable'hopPubkeys
+                        34
+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                        (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                            Data.ProtoLens.Encoding.Bytes.getBytes
+                                              (Prelude.fromIntegral len))
+                                        "hop_pubkeys"
+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
+                                       (Data.ProtoLens.Encoding.Growing.append mutable'hopPubkeys y)
+                                loop x v
+                        42
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.getBytes
+                                             (Prelude.fromIntegral len))
+                                       "payment_addr"
+                                loop
+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"paymentAddr") y x)
+                                  mutable'hopPubkeys
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)
+                                  mutable'hopPubkeys
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do mutable'hopPubkeys <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
+                                      Data.ProtoLens.Encoding.Growing.new
+              loop Data.ProtoLens.defMessage mutable'hopPubkeys)
+          "BuildRouteRequest"
+  buildMessage
+    = \ _x
+        -> (Data.Monoid.<>)
+             (let
+                _v = Lens.Family2.view (Data.ProtoLens.Field.field @"amtMsat") _x
+              in
+                if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                    Data.Monoid.mempty
+                else
+                    (Data.Monoid.<>)
+                      (Data.ProtoLens.Encoding.Bytes.putVarInt 8)
+                      ((Prelude..)
+                         Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v))
+             ((Data.Monoid.<>)
+                (let
+                   _v
+                     = Lens.Family2.view
+                         (Data.ProtoLens.Field.field @"finalCltvDelta") _x
+                 in
+                   if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                       Data.Monoid.mempty
+                   else
+                       (Data.Monoid.<>)
+                         (Data.ProtoLens.Encoding.Bytes.putVarInt 16)
+                         ((Prelude..)
+                            Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v))
+                ((Data.Monoid.<>)
+                   (let
+                      _v
+                        = Lens.Family2.view
+                            (Data.ProtoLens.Field.field @"outgoingChanId") _x
+                    in
+                      if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                          Data.Monoid.mempty
+                      else
+                          (Data.Monoid.<>)
+                            (Data.ProtoLens.Encoding.Bytes.putVarInt 24)
+                            (Data.ProtoLens.Encoding.Bytes.putVarInt _v))
+                   ((Data.Monoid.<>)
+                      (Data.ProtoLens.Encoding.Bytes.foldMapBuilder
+                         (\ _v
+                            -> (Data.Monoid.<>)
+                                 (Data.ProtoLens.Encoding.Bytes.putVarInt 34)
+                                 ((\ bs
+                                     -> (Data.Monoid.<>)
+                                          (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                             (Prelude.fromIntegral (Data.ByteString.length bs)))
+                                          (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                                    _v))
+                         (Lens.Family2.view
+                            (Data.ProtoLens.Field.field @"vec'hopPubkeys") _x))
+                      ((Data.Monoid.<>)
+                         (let
+                            _v
+                              = Lens.Family2.view (Data.ProtoLens.Field.field @"paymentAddr") _x
+                          in
+                            if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                                Data.Monoid.mempty
+                            else
+                                (Data.Monoid.<>)
+                                  (Data.ProtoLens.Encoding.Bytes.putVarInt 42)
+                                  ((\ bs
+                                      -> (Data.Monoid.<>)
+                                           (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                              (Prelude.fromIntegral (Data.ByteString.length bs)))
+                                           (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                                     _v))
+                         (Data.ProtoLens.Encoding.Wire.buildFieldSet
+                            (Lens.Family2.view Data.ProtoLens.unknownFields _x))))))
+instance Control.DeepSeq.NFData BuildRouteRequest where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_BuildRouteRequest'_unknownFields x__)
+             (Control.DeepSeq.deepseq
+                (_BuildRouteRequest'amtMsat x__)
+                (Control.DeepSeq.deepseq
+                   (_BuildRouteRequest'finalCltvDelta x__)
+                   (Control.DeepSeq.deepseq
+                      (_BuildRouteRequest'outgoingChanId x__)
+                      (Control.DeepSeq.deepseq
+                         (_BuildRouteRequest'hopPubkeys x__)
+                         (Control.DeepSeq.deepseq
+                            (_BuildRouteRequest'paymentAddr x__) ())))))
+{- | Fields :
+     
+         * 'Proto.RouterGrpc_Fields.route' @:: Lens' BuildRouteResponse Proto.LndGrpc.Route@
+         * 'Proto.RouterGrpc_Fields.maybe'route' @:: Lens' BuildRouteResponse (Prelude.Maybe Proto.LndGrpc.Route)@ -}
+data BuildRouteResponse
+  = BuildRouteResponse'_constructor {_BuildRouteResponse'route :: !(Prelude.Maybe Proto.LndGrpc.Route),
+                                     _BuildRouteResponse'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show BuildRouteResponse where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Field.HasField BuildRouteResponse "route" Proto.LndGrpc.Route where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _BuildRouteResponse'route
+           (\ x__ y__ -> x__ {_BuildRouteResponse'route = y__}))
+        (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage)
+instance Data.ProtoLens.Field.HasField BuildRouteResponse "maybe'route" (Prelude.Maybe Proto.LndGrpc.Route) where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _BuildRouteResponse'route
+           (\ x__ y__ -> x__ {_BuildRouteResponse'route = y__}))
+        Prelude.id
+instance Data.ProtoLens.Message BuildRouteResponse where
+  messageName _ = Data.Text.pack "routerrpc.BuildRouteResponse"
+  packedMessageDescriptor _
+    = "\n\
+      \\DC2BuildRouteResponse\DC2\"\n\
+      \\ENQroute\CAN\SOH \SOH(\v2\f.lnrpc.RouteR\ENQroute"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag
+    = let
+        route__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "route"
+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
+                 Data.ProtoLens.FieldTypeDescriptor Proto.LndGrpc.Route)
+              (Data.ProtoLens.OptionalField
+                 (Data.ProtoLens.Field.field @"maybe'route")) ::
+              Data.ProtoLens.FieldDescriptor BuildRouteResponse
+      in
+        Data.Map.fromList [(Data.ProtoLens.Tag 1, route__field_descriptor)]
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _BuildRouteResponse'_unknownFields
+        (\ x__ y__ -> x__ {_BuildRouteResponse'_unknownFields = y__})
+  defMessage
+    = BuildRouteResponse'_constructor
+        {_BuildRouteResponse'route = Prelude.Nothing,
+         _BuildRouteResponse'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          BuildRouteResponse
+          -> Data.ProtoLens.Encoding.Bytes.Parser BuildRouteResponse
+        loop x
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of
+                        10
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.isolate
+                                             (Prelude.fromIntegral len) Data.ProtoLens.parseMessage)
+                                       "route"
+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"route") y x)
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do loop Data.ProtoLens.defMessage) "BuildRouteResponse"
+  buildMessage
+    = \ _x
+        -> (Data.Monoid.<>)
+             (case
+                  Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'route") _x
+              of
+                Prelude.Nothing -> Data.Monoid.mempty
+                (Prelude.Just _v)
+                  -> (Data.Monoid.<>)
+                       (Data.ProtoLens.Encoding.Bytes.putVarInt 10)
+                       ((Prelude..)
+                          (\ bs
+                             -> (Data.Monoid.<>)
+                                  (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                     (Prelude.fromIntegral (Data.ByteString.length bs)))
+                                  (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                          Data.ProtoLens.encodeMessage
+                          _v))
+             (Data.ProtoLens.Encoding.Wire.buildFieldSet
+                (Lens.Family2.view Data.ProtoLens.unknownFields _x))
+instance Control.DeepSeq.NFData BuildRouteResponse where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_BuildRouteResponse'_unknownFields x__)
+             (Control.DeepSeq.deepseq (_BuildRouteResponse'route x__) ())
+newtype ChanStatusAction'UnrecognizedValue
+  = ChanStatusAction'UnrecognizedValue Data.Int.Int32
+  deriving stock (Prelude.Eq, Prelude.Ord, Prelude.Show)
+data ChanStatusAction
+  = ENABLE |
+    DISABLE |
+    AUTO |
+    ChanStatusAction'Unrecognized !ChanStatusAction'UnrecognizedValue
+  deriving stock (Prelude.Show, Prelude.Eq, Prelude.Ord)
+instance Data.ProtoLens.MessageEnum ChanStatusAction where
+  maybeToEnum 0 = Prelude.Just ENABLE
+  maybeToEnum 1 = Prelude.Just DISABLE
+  maybeToEnum 2 = Prelude.Just AUTO
+  maybeToEnum k
+    = Prelude.Just
+        (ChanStatusAction'Unrecognized
+           (ChanStatusAction'UnrecognizedValue (Prelude.fromIntegral k)))
+  showEnum ENABLE = "ENABLE"
+  showEnum DISABLE = "DISABLE"
+  showEnum AUTO = "AUTO"
+  showEnum
+    (ChanStatusAction'Unrecognized (ChanStatusAction'UnrecognizedValue k))
+    = Prelude.show k
+  readEnum k
+    | (Prelude.==) k "ENABLE" = Prelude.Just ENABLE
+    | (Prelude.==) k "DISABLE" = Prelude.Just DISABLE
+    | (Prelude.==) k "AUTO" = Prelude.Just AUTO
+    | Prelude.otherwise
+    = (Prelude.>>=) (Text.Read.readMaybe k) Data.ProtoLens.maybeToEnum
+instance Prelude.Bounded ChanStatusAction where
+  minBound = ENABLE
+  maxBound = AUTO
+instance Prelude.Enum ChanStatusAction where
+  toEnum k__
+    = Prelude.maybe
+        (Prelude.error
+           ((Prelude.++)
+              "toEnum: unknown value for enum ChanStatusAction: "
+              (Prelude.show k__)))
+        Prelude.id
+        (Data.ProtoLens.maybeToEnum k__)
+  fromEnum ENABLE = 0
+  fromEnum DISABLE = 1
+  fromEnum AUTO = 2
+  fromEnum
+    (ChanStatusAction'Unrecognized (ChanStatusAction'UnrecognizedValue k))
+    = Prelude.fromIntegral k
+  succ AUTO
+    = Prelude.error
+        "ChanStatusAction.succ: bad argument AUTO. This value would be out of bounds."
+  succ ENABLE = DISABLE
+  succ DISABLE = AUTO
+  succ (ChanStatusAction'Unrecognized _)
+    = Prelude.error
+        "ChanStatusAction.succ: bad argument: unrecognized value"
+  pred ENABLE
+    = Prelude.error
+        "ChanStatusAction.pred: bad argument ENABLE. This value would be out of bounds."
+  pred DISABLE = ENABLE
+  pred AUTO = DISABLE
+  pred (ChanStatusAction'Unrecognized _)
+    = Prelude.error
+        "ChanStatusAction.pred: bad argument: unrecognized value"
+  enumFrom = Data.ProtoLens.Message.Enum.messageEnumFrom
+  enumFromTo = Data.ProtoLens.Message.Enum.messageEnumFromTo
+  enumFromThen = Data.ProtoLens.Message.Enum.messageEnumFromThen
+  enumFromThenTo = Data.ProtoLens.Message.Enum.messageEnumFromThenTo
+instance Data.ProtoLens.FieldDefault ChanStatusAction where
+  fieldDefault = ENABLE
+instance Control.DeepSeq.NFData ChanStatusAction where
+  rnf x__ = Prelude.seq x__ ()
+{- | Fields :
+     
+         * 'Proto.RouterGrpc_Fields.chanId' @:: Lens' CircuitKey Data.Word.Word64@
+         * 'Proto.RouterGrpc_Fields.htlcId' @:: Lens' CircuitKey Data.Word.Word64@ -}
+data CircuitKey
+  = CircuitKey'_constructor {_CircuitKey'chanId :: !Data.Word.Word64,
+                             _CircuitKey'htlcId :: !Data.Word.Word64,
+                             _CircuitKey'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show CircuitKey where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Field.HasField CircuitKey "chanId" Data.Word.Word64 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _CircuitKey'chanId (\ x__ y__ -> x__ {_CircuitKey'chanId = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField CircuitKey "htlcId" Data.Word.Word64 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _CircuitKey'htlcId (\ x__ y__ -> x__ {_CircuitKey'htlcId = y__}))
+        Prelude.id
+instance Data.ProtoLens.Message CircuitKey where
+  messageName _ = Data.Text.pack "routerrpc.CircuitKey"
+  packedMessageDescriptor _
+    = "\n\
+      \\n\
+      \CircuitKey\DC2\ETB\n\
+      \\achan_id\CAN\SOH \SOH(\EOTR\ACKchanId\DC2\ETB\n\
+      \\ahtlc_id\CAN\STX \SOH(\EOTR\ACKhtlcId"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag
+    = let
+        chanId__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "chan_id"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.UInt64Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Word.Word64)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional (Data.ProtoLens.Field.field @"chanId")) ::
+              Data.ProtoLens.FieldDescriptor CircuitKey
+        htlcId__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "htlc_id"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.UInt64Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Word.Word64)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional (Data.ProtoLens.Field.field @"htlcId")) ::
+              Data.ProtoLens.FieldDescriptor CircuitKey
+      in
+        Data.Map.fromList
+          [(Data.ProtoLens.Tag 1, chanId__field_descriptor),
+           (Data.ProtoLens.Tag 2, htlcId__field_descriptor)]
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _CircuitKey'_unknownFields
+        (\ x__ y__ -> x__ {_CircuitKey'_unknownFields = y__})
+  defMessage
+    = CircuitKey'_constructor
+        {_CircuitKey'chanId = Data.ProtoLens.fieldDefault,
+         _CircuitKey'htlcId = Data.ProtoLens.fieldDefault,
+         _CircuitKey'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          CircuitKey -> Data.ProtoLens.Encoding.Bytes.Parser CircuitKey
+        loop x
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of
+                        8 -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       Data.ProtoLens.Encoding.Bytes.getVarInt "chan_id"
+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"chanId") y x)
+                        16
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       Data.ProtoLens.Encoding.Bytes.getVarInt "htlc_id"
+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"htlcId") y x)
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do loop Data.ProtoLens.defMessage) "CircuitKey"
+  buildMessage
+    = \ _x
+        -> (Data.Monoid.<>)
+             (let
+                _v = Lens.Family2.view (Data.ProtoLens.Field.field @"chanId") _x
+              in
+                if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                    Data.Monoid.mempty
+                else
+                    (Data.Monoid.<>)
+                      (Data.ProtoLens.Encoding.Bytes.putVarInt 8)
+                      (Data.ProtoLens.Encoding.Bytes.putVarInt _v))
+             ((Data.Monoid.<>)
+                (let
+                   _v = Lens.Family2.view (Data.ProtoLens.Field.field @"htlcId") _x
+                 in
+                   if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                       Data.Monoid.mempty
+                   else
+                       (Data.Monoid.<>)
+                         (Data.ProtoLens.Encoding.Bytes.putVarInt 16)
+                         (Data.ProtoLens.Encoding.Bytes.putVarInt _v))
+                (Data.ProtoLens.Encoding.Wire.buildFieldSet
+                   (Lens.Family2.view Data.ProtoLens.unknownFields _x)))
+instance Control.DeepSeq.NFData CircuitKey where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_CircuitKey'_unknownFields x__)
+             (Control.DeepSeq.deepseq
+                (_CircuitKey'chanId x__)
+                (Control.DeepSeq.deepseq (_CircuitKey'htlcId x__) ()))
+newtype FailureDetail'UnrecognizedValue
+  = FailureDetail'UnrecognizedValue Data.Int.Int32
+  deriving stock (Prelude.Eq, Prelude.Ord, Prelude.Show)
+data FailureDetail
+  = UNKNOWN |
+    NO_DETAIL |
+    ONION_DECODE |
+    LINK_NOT_ELIGIBLE |
+    ON_CHAIN_TIMEOUT |
+    HTLC_EXCEEDS_MAX |
+    INSUFFICIENT_BALANCE |
+    INCOMPLETE_FORWARD |
+    HTLC_ADD_FAILED |
+    FORWARDS_DISABLED |
+    INVOICE_CANCELED |
+    INVOICE_UNDERPAID |
+    INVOICE_EXPIRY_TOO_SOON |
+    INVOICE_NOT_OPEN |
+    MPP_INVOICE_TIMEOUT |
+    ADDRESS_MISMATCH |
+    SET_TOTAL_MISMATCH |
+    SET_TOTAL_TOO_LOW |
+    SET_OVERPAID |
+    UNKNOWN_INVOICE |
+    INVALID_KEYSEND |
+    MPP_IN_PROGRESS |
+    CIRCULAR_ROUTE |
+    FailureDetail'Unrecognized !FailureDetail'UnrecognizedValue
+  deriving stock (Prelude.Show, Prelude.Eq, Prelude.Ord)
+instance Data.ProtoLens.MessageEnum FailureDetail where
+  maybeToEnum 0 = Prelude.Just UNKNOWN
+  maybeToEnum 1 = Prelude.Just NO_DETAIL
+  maybeToEnum 2 = Prelude.Just ONION_DECODE
+  maybeToEnum 3 = Prelude.Just LINK_NOT_ELIGIBLE
+  maybeToEnum 4 = Prelude.Just ON_CHAIN_TIMEOUT
+  maybeToEnum 5 = Prelude.Just HTLC_EXCEEDS_MAX
+  maybeToEnum 6 = Prelude.Just INSUFFICIENT_BALANCE
+  maybeToEnum 7 = Prelude.Just INCOMPLETE_FORWARD
+  maybeToEnum 8 = Prelude.Just HTLC_ADD_FAILED
+  maybeToEnum 9 = Prelude.Just FORWARDS_DISABLED
+  maybeToEnum 10 = Prelude.Just INVOICE_CANCELED
+  maybeToEnum 11 = Prelude.Just INVOICE_UNDERPAID
+  maybeToEnum 12 = Prelude.Just INVOICE_EXPIRY_TOO_SOON
+  maybeToEnum 13 = Prelude.Just INVOICE_NOT_OPEN
+  maybeToEnum 14 = Prelude.Just MPP_INVOICE_TIMEOUT
+  maybeToEnum 15 = Prelude.Just ADDRESS_MISMATCH
+  maybeToEnum 16 = Prelude.Just SET_TOTAL_MISMATCH
+  maybeToEnum 17 = Prelude.Just SET_TOTAL_TOO_LOW
+  maybeToEnum 18 = Prelude.Just SET_OVERPAID
+  maybeToEnum 19 = Prelude.Just UNKNOWN_INVOICE
+  maybeToEnum 20 = Prelude.Just INVALID_KEYSEND
+  maybeToEnum 21 = Prelude.Just MPP_IN_PROGRESS
+  maybeToEnum 22 = Prelude.Just CIRCULAR_ROUTE
+  maybeToEnum k
+    = Prelude.Just
+        (FailureDetail'Unrecognized
+           (FailureDetail'UnrecognizedValue (Prelude.fromIntegral k)))
+  showEnum UNKNOWN = "UNKNOWN"
+  showEnum NO_DETAIL = "NO_DETAIL"
+  showEnum ONION_DECODE = "ONION_DECODE"
+  showEnum LINK_NOT_ELIGIBLE = "LINK_NOT_ELIGIBLE"
+  showEnum ON_CHAIN_TIMEOUT = "ON_CHAIN_TIMEOUT"
+  showEnum HTLC_EXCEEDS_MAX = "HTLC_EXCEEDS_MAX"
+  showEnum INSUFFICIENT_BALANCE = "INSUFFICIENT_BALANCE"
+  showEnum INCOMPLETE_FORWARD = "INCOMPLETE_FORWARD"
+  showEnum HTLC_ADD_FAILED = "HTLC_ADD_FAILED"
+  showEnum FORWARDS_DISABLED = "FORWARDS_DISABLED"
+  showEnum INVOICE_CANCELED = "INVOICE_CANCELED"
+  showEnum INVOICE_UNDERPAID = "INVOICE_UNDERPAID"
+  showEnum INVOICE_EXPIRY_TOO_SOON = "INVOICE_EXPIRY_TOO_SOON"
+  showEnum INVOICE_NOT_OPEN = "INVOICE_NOT_OPEN"
+  showEnum MPP_INVOICE_TIMEOUT = "MPP_INVOICE_TIMEOUT"
+  showEnum ADDRESS_MISMATCH = "ADDRESS_MISMATCH"
+  showEnum SET_TOTAL_MISMATCH = "SET_TOTAL_MISMATCH"
+  showEnum SET_TOTAL_TOO_LOW = "SET_TOTAL_TOO_LOW"
+  showEnum SET_OVERPAID = "SET_OVERPAID"
+  showEnum UNKNOWN_INVOICE = "UNKNOWN_INVOICE"
+  showEnum INVALID_KEYSEND = "INVALID_KEYSEND"
+  showEnum MPP_IN_PROGRESS = "MPP_IN_PROGRESS"
+  showEnum CIRCULAR_ROUTE = "CIRCULAR_ROUTE"
+  showEnum
+    (FailureDetail'Unrecognized (FailureDetail'UnrecognizedValue k))
+    = Prelude.show k
+  readEnum k
+    | (Prelude.==) k "UNKNOWN" = Prelude.Just UNKNOWN
+    | (Prelude.==) k "NO_DETAIL" = Prelude.Just NO_DETAIL
+    | (Prelude.==) k "ONION_DECODE" = Prelude.Just ONION_DECODE
+    | (Prelude.==) k "LINK_NOT_ELIGIBLE"
+    = Prelude.Just LINK_NOT_ELIGIBLE
+    | (Prelude.==) k "ON_CHAIN_TIMEOUT" = Prelude.Just ON_CHAIN_TIMEOUT
+    | (Prelude.==) k "HTLC_EXCEEDS_MAX" = Prelude.Just HTLC_EXCEEDS_MAX
+    | (Prelude.==) k "INSUFFICIENT_BALANCE"
+    = Prelude.Just INSUFFICIENT_BALANCE
+    | (Prelude.==) k "INCOMPLETE_FORWARD"
+    = Prelude.Just INCOMPLETE_FORWARD
+    | (Prelude.==) k "HTLC_ADD_FAILED" = Prelude.Just HTLC_ADD_FAILED
+    | (Prelude.==) k "FORWARDS_DISABLED"
+    = Prelude.Just FORWARDS_DISABLED
+    | (Prelude.==) k "INVOICE_CANCELED" = Prelude.Just INVOICE_CANCELED
+    | (Prelude.==) k "INVOICE_UNDERPAID"
+    = Prelude.Just INVOICE_UNDERPAID
+    | (Prelude.==) k "INVOICE_EXPIRY_TOO_SOON"
+    = Prelude.Just INVOICE_EXPIRY_TOO_SOON
+    | (Prelude.==) k "INVOICE_NOT_OPEN" = Prelude.Just INVOICE_NOT_OPEN
+    | (Prelude.==) k "MPP_INVOICE_TIMEOUT"
+    = Prelude.Just MPP_INVOICE_TIMEOUT
+    | (Prelude.==) k "ADDRESS_MISMATCH" = Prelude.Just ADDRESS_MISMATCH
+    | (Prelude.==) k "SET_TOTAL_MISMATCH"
+    = Prelude.Just SET_TOTAL_MISMATCH
+    | (Prelude.==) k "SET_TOTAL_TOO_LOW"
+    = Prelude.Just SET_TOTAL_TOO_LOW
+    | (Prelude.==) k "SET_OVERPAID" = Prelude.Just SET_OVERPAID
+    | (Prelude.==) k "UNKNOWN_INVOICE" = Prelude.Just UNKNOWN_INVOICE
+    | (Prelude.==) k "INVALID_KEYSEND" = Prelude.Just INVALID_KEYSEND
+    | (Prelude.==) k "MPP_IN_PROGRESS" = Prelude.Just MPP_IN_PROGRESS
+    | (Prelude.==) k "CIRCULAR_ROUTE" = Prelude.Just CIRCULAR_ROUTE
+    | Prelude.otherwise
+    = (Prelude.>>=) (Text.Read.readMaybe k) Data.ProtoLens.maybeToEnum
+instance Prelude.Bounded FailureDetail where
+  minBound = UNKNOWN
+  maxBound = CIRCULAR_ROUTE
+instance Prelude.Enum FailureDetail where
+  toEnum k__
+    = Prelude.maybe
+        (Prelude.error
+           ((Prelude.++)
+              "toEnum: unknown value for enum FailureDetail: "
+              (Prelude.show k__)))
+        Prelude.id
+        (Data.ProtoLens.maybeToEnum k__)
+  fromEnum UNKNOWN = 0
+  fromEnum NO_DETAIL = 1
+  fromEnum ONION_DECODE = 2
+  fromEnum LINK_NOT_ELIGIBLE = 3
+  fromEnum ON_CHAIN_TIMEOUT = 4
+  fromEnum HTLC_EXCEEDS_MAX = 5
+  fromEnum INSUFFICIENT_BALANCE = 6
+  fromEnum INCOMPLETE_FORWARD = 7
+  fromEnum HTLC_ADD_FAILED = 8
+  fromEnum FORWARDS_DISABLED = 9
+  fromEnum INVOICE_CANCELED = 10
+  fromEnum INVOICE_UNDERPAID = 11
+  fromEnum INVOICE_EXPIRY_TOO_SOON = 12
+  fromEnum INVOICE_NOT_OPEN = 13
+  fromEnum MPP_INVOICE_TIMEOUT = 14
+  fromEnum ADDRESS_MISMATCH = 15
+  fromEnum SET_TOTAL_MISMATCH = 16
+  fromEnum SET_TOTAL_TOO_LOW = 17
+  fromEnum SET_OVERPAID = 18
+  fromEnum UNKNOWN_INVOICE = 19
+  fromEnum INVALID_KEYSEND = 20
+  fromEnum MPP_IN_PROGRESS = 21
+  fromEnum CIRCULAR_ROUTE = 22
+  fromEnum
+    (FailureDetail'Unrecognized (FailureDetail'UnrecognizedValue k))
+    = Prelude.fromIntegral k
+  succ CIRCULAR_ROUTE
+    = Prelude.error
+        "FailureDetail.succ: bad argument CIRCULAR_ROUTE. This value would be out of bounds."
+  succ UNKNOWN = NO_DETAIL
+  succ NO_DETAIL = ONION_DECODE
+  succ ONION_DECODE = LINK_NOT_ELIGIBLE
+  succ LINK_NOT_ELIGIBLE = ON_CHAIN_TIMEOUT
+  succ ON_CHAIN_TIMEOUT = HTLC_EXCEEDS_MAX
+  succ HTLC_EXCEEDS_MAX = INSUFFICIENT_BALANCE
+  succ INSUFFICIENT_BALANCE = INCOMPLETE_FORWARD
+  succ INCOMPLETE_FORWARD = HTLC_ADD_FAILED
+  succ HTLC_ADD_FAILED = FORWARDS_DISABLED
+  succ FORWARDS_DISABLED = INVOICE_CANCELED
+  succ INVOICE_CANCELED = INVOICE_UNDERPAID
+  succ INVOICE_UNDERPAID = INVOICE_EXPIRY_TOO_SOON
+  succ INVOICE_EXPIRY_TOO_SOON = INVOICE_NOT_OPEN
+  succ INVOICE_NOT_OPEN = MPP_INVOICE_TIMEOUT
+  succ MPP_INVOICE_TIMEOUT = ADDRESS_MISMATCH
+  succ ADDRESS_MISMATCH = SET_TOTAL_MISMATCH
+  succ SET_TOTAL_MISMATCH = SET_TOTAL_TOO_LOW
+  succ SET_TOTAL_TOO_LOW = SET_OVERPAID
+  succ SET_OVERPAID = UNKNOWN_INVOICE
+  succ UNKNOWN_INVOICE = INVALID_KEYSEND
+  succ INVALID_KEYSEND = MPP_IN_PROGRESS
+  succ MPP_IN_PROGRESS = CIRCULAR_ROUTE
+  succ (FailureDetail'Unrecognized _)
+    = Prelude.error
+        "FailureDetail.succ: bad argument: unrecognized value"
+  pred UNKNOWN
+    = Prelude.error
+        "FailureDetail.pred: bad argument UNKNOWN. This value would be out of bounds."
+  pred NO_DETAIL = UNKNOWN
+  pred ONION_DECODE = NO_DETAIL
+  pred LINK_NOT_ELIGIBLE = ONION_DECODE
+  pred ON_CHAIN_TIMEOUT = LINK_NOT_ELIGIBLE
+  pred HTLC_EXCEEDS_MAX = ON_CHAIN_TIMEOUT
+  pred INSUFFICIENT_BALANCE = HTLC_EXCEEDS_MAX
+  pred INCOMPLETE_FORWARD = INSUFFICIENT_BALANCE
+  pred HTLC_ADD_FAILED = INCOMPLETE_FORWARD
+  pred FORWARDS_DISABLED = HTLC_ADD_FAILED
+  pred INVOICE_CANCELED = FORWARDS_DISABLED
+  pred INVOICE_UNDERPAID = INVOICE_CANCELED
+  pred INVOICE_EXPIRY_TOO_SOON = INVOICE_UNDERPAID
+  pred INVOICE_NOT_OPEN = INVOICE_EXPIRY_TOO_SOON
+  pred MPP_INVOICE_TIMEOUT = INVOICE_NOT_OPEN
+  pred ADDRESS_MISMATCH = MPP_INVOICE_TIMEOUT
+  pred SET_TOTAL_MISMATCH = ADDRESS_MISMATCH
+  pred SET_TOTAL_TOO_LOW = SET_TOTAL_MISMATCH
+  pred SET_OVERPAID = SET_TOTAL_TOO_LOW
+  pred UNKNOWN_INVOICE = SET_OVERPAID
+  pred INVALID_KEYSEND = UNKNOWN_INVOICE
+  pred MPP_IN_PROGRESS = INVALID_KEYSEND
+  pred CIRCULAR_ROUTE = MPP_IN_PROGRESS
+  pred (FailureDetail'Unrecognized _)
+    = Prelude.error
+        "FailureDetail.pred: bad argument: unrecognized value"
+  enumFrom = Data.ProtoLens.Message.Enum.messageEnumFrom
+  enumFromTo = Data.ProtoLens.Message.Enum.messageEnumFromTo
+  enumFromThen = Data.ProtoLens.Message.Enum.messageEnumFromThen
+  enumFromThenTo = Data.ProtoLens.Message.Enum.messageEnumFromThenTo
+instance Data.ProtoLens.FieldDefault FailureDetail where
+  fieldDefault = UNKNOWN
+instance Control.DeepSeq.NFData FailureDetail where
+  rnf x__ = Prelude.seq x__ ()
+{- | Fields :
+     
+         * 'Proto.RouterGrpc_Fields.info' @:: Lens' ForwardEvent HtlcInfo@
+         * 'Proto.RouterGrpc_Fields.maybe'info' @:: Lens' ForwardEvent (Prelude.Maybe HtlcInfo)@ -}
+data ForwardEvent
+  = ForwardEvent'_constructor {_ForwardEvent'info :: !(Prelude.Maybe HtlcInfo),
+                               _ForwardEvent'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show ForwardEvent where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Field.HasField ForwardEvent "info" HtlcInfo where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _ForwardEvent'info (\ x__ y__ -> x__ {_ForwardEvent'info = y__}))
+        (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage)
+instance Data.ProtoLens.Field.HasField ForwardEvent "maybe'info" (Prelude.Maybe HtlcInfo) where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _ForwardEvent'info (\ x__ y__ -> x__ {_ForwardEvent'info = y__}))
+        Prelude.id
+instance Data.ProtoLens.Message ForwardEvent where
+  messageName _ = Data.Text.pack "routerrpc.ForwardEvent"
+  packedMessageDescriptor _
+    = "\n\
+      \\fForwardEvent\DC2'\n\
+      \\EOTinfo\CAN\SOH \SOH(\v2\DC3.routerrpc.HtlcInfoR\EOTinfo"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag
+    = let
+        info__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "info"
+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
+                 Data.ProtoLens.FieldTypeDescriptor HtlcInfo)
+              (Data.ProtoLens.OptionalField
+                 (Data.ProtoLens.Field.field @"maybe'info")) ::
+              Data.ProtoLens.FieldDescriptor ForwardEvent
+      in
+        Data.Map.fromList [(Data.ProtoLens.Tag 1, info__field_descriptor)]
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _ForwardEvent'_unknownFields
+        (\ x__ y__ -> x__ {_ForwardEvent'_unknownFields = y__})
+  defMessage
+    = ForwardEvent'_constructor
+        {_ForwardEvent'info = Prelude.Nothing,
+         _ForwardEvent'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          ForwardEvent -> Data.ProtoLens.Encoding.Bytes.Parser ForwardEvent
+        loop x
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of
+                        10
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.isolate
+                                             (Prelude.fromIntegral len) Data.ProtoLens.parseMessage)
+                                       "info"
+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"info") y x)
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do loop Data.ProtoLens.defMessage) "ForwardEvent"
+  buildMessage
+    = \ _x
+        -> (Data.Monoid.<>)
+             (case
+                  Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'info") _x
+              of
+                Prelude.Nothing -> Data.Monoid.mempty
+                (Prelude.Just _v)
+                  -> (Data.Monoid.<>)
+                       (Data.ProtoLens.Encoding.Bytes.putVarInt 10)
+                       ((Prelude..)
+                          (\ bs
+                             -> (Data.Monoid.<>)
+                                  (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                     (Prelude.fromIntegral (Data.ByteString.length bs)))
+                                  (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                          Data.ProtoLens.encodeMessage
+                          _v))
+             (Data.ProtoLens.Encoding.Wire.buildFieldSet
+                (Lens.Family2.view Data.ProtoLens.unknownFields _x))
+instance Control.DeepSeq.NFData ForwardEvent where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_ForwardEvent'_unknownFields x__)
+             (Control.DeepSeq.deepseq (_ForwardEvent'info x__) ())
+{- | Fields :
+      -}
+data ForwardFailEvent
+  = ForwardFailEvent'_constructor {_ForwardFailEvent'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show ForwardFailEvent where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Message ForwardFailEvent where
+  messageName _ = Data.Text.pack "routerrpc.ForwardFailEvent"
+  packedMessageDescriptor _
+    = "\n\
+      \\DLEForwardFailEvent"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag = let in Data.Map.fromList []
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _ForwardFailEvent'_unknownFields
+        (\ x__ y__ -> x__ {_ForwardFailEvent'_unknownFields = y__})
+  defMessage
+    = ForwardFailEvent'_constructor
+        {_ForwardFailEvent'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          ForwardFailEvent
+          -> Data.ProtoLens.Encoding.Bytes.Parser ForwardFailEvent
+        loop x
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of {
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) }
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do loop Data.ProtoLens.defMessage) "ForwardFailEvent"
+  buildMessage
+    = \ _x
+        -> Data.ProtoLens.Encoding.Wire.buildFieldSet
+             (Lens.Family2.view Data.ProtoLens.unknownFields _x)
+instance Control.DeepSeq.NFData ForwardFailEvent where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_ForwardFailEvent'_unknownFields x__) ()
+{- | Fields :
+     
+         * 'Proto.RouterGrpc_Fields.incomingCircuitKey' @:: Lens' ForwardHtlcInterceptRequest CircuitKey@
+         * 'Proto.RouterGrpc_Fields.maybe'incomingCircuitKey' @:: Lens' ForwardHtlcInterceptRequest (Prelude.Maybe CircuitKey)@
+         * 'Proto.RouterGrpc_Fields.incomingAmountMsat' @:: Lens' ForwardHtlcInterceptRequest Data.Word.Word64@
+         * 'Proto.RouterGrpc_Fields.incomingExpiry' @:: Lens' ForwardHtlcInterceptRequest Data.Word.Word32@
+         * 'Proto.RouterGrpc_Fields.paymentHash' @:: Lens' ForwardHtlcInterceptRequest Data.ByteString.ByteString@
+         * 'Proto.RouterGrpc_Fields.outgoingRequestedChanId' @:: Lens' ForwardHtlcInterceptRequest Data.Word.Word64@
+         * 'Proto.RouterGrpc_Fields.outgoingAmountMsat' @:: Lens' ForwardHtlcInterceptRequest Data.Word.Word64@
+         * 'Proto.RouterGrpc_Fields.outgoingExpiry' @:: Lens' ForwardHtlcInterceptRequest Data.Word.Word32@
+         * 'Proto.RouterGrpc_Fields.customRecords' @:: Lens' ForwardHtlcInterceptRequest (Data.Map.Map Data.Word.Word64 Data.ByteString.ByteString)@
+         * 'Proto.RouterGrpc_Fields.onionBlob' @:: Lens' ForwardHtlcInterceptRequest Data.ByteString.ByteString@ -}
+data ForwardHtlcInterceptRequest
+  = ForwardHtlcInterceptRequest'_constructor {_ForwardHtlcInterceptRequest'incomingCircuitKey :: !(Prelude.Maybe CircuitKey),
+                                              _ForwardHtlcInterceptRequest'incomingAmountMsat :: !Data.Word.Word64,
+                                              _ForwardHtlcInterceptRequest'incomingExpiry :: !Data.Word.Word32,
+                                              _ForwardHtlcInterceptRequest'paymentHash :: !Data.ByteString.ByteString,
+                                              _ForwardHtlcInterceptRequest'outgoingRequestedChanId :: !Data.Word.Word64,
+                                              _ForwardHtlcInterceptRequest'outgoingAmountMsat :: !Data.Word.Word64,
+                                              _ForwardHtlcInterceptRequest'outgoingExpiry :: !Data.Word.Word32,
+                                              _ForwardHtlcInterceptRequest'customRecords :: !(Data.Map.Map Data.Word.Word64 Data.ByteString.ByteString),
+                                              _ForwardHtlcInterceptRequest'onionBlob :: !Data.ByteString.ByteString,
+                                              _ForwardHtlcInterceptRequest'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show ForwardHtlcInterceptRequest where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Field.HasField ForwardHtlcInterceptRequest "incomingCircuitKey" CircuitKey where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _ForwardHtlcInterceptRequest'incomingCircuitKey
+           (\ x__ y__
+              -> x__ {_ForwardHtlcInterceptRequest'incomingCircuitKey = y__}))
+        (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage)
+instance Data.ProtoLens.Field.HasField ForwardHtlcInterceptRequest "maybe'incomingCircuitKey" (Prelude.Maybe CircuitKey) where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _ForwardHtlcInterceptRequest'incomingCircuitKey
+           (\ x__ y__
+              -> x__ {_ForwardHtlcInterceptRequest'incomingCircuitKey = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField ForwardHtlcInterceptRequest "incomingAmountMsat" Data.Word.Word64 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _ForwardHtlcInterceptRequest'incomingAmountMsat
+           (\ x__ y__
+              -> x__ {_ForwardHtlcInterceptRequest'incomingAmountMsat = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField ForwardHtlcInterceptRequest "incomingExpiry" Data.Word.Word32 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _ForwardHtlcInterceptRequest'incomingExpiry
+           (\ x__ y__
+              -> x__ {_ForwardHtlcInterceptRequest'incomingExpiry = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField ForwardHtlcInterceptRequest "paymentHash" Data.ByteString.ByteString where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _ForwardHtlcInterceptRequest'paymentHash
+           (\ x__ y__
+              -> x__ {_ForwardHtlcInterceptRequest'paymentHash = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField ForwardHtlcInterceptRequest "outgoingRequestedChanId" Data.Word.Word64 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _ForwardHtlcInterceptRequest'outgoingRequestedChanId
+           (\ x__ y__
+              -> x__
+                   {_ForwardHtlcInterceptRequest'outgoingRequestedChanId = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField ForwardHtlcInterceptRequest "outgoingAmountMsat" Data.Word.Word64 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _ForwardHtlcInterceptRequest'outgoingAmountMsat
+           (\ x__ y__
+              -> x__ {_ForwardHtlcInterceptRequest'outgoingAmountMsat = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField ForwardHtlcInterceptRequest "outgoingExpiry" Data.Word.Word32 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _ForwardHtlcInterceptRequest'outgoingExpiry
+           (\ x__ y__
+              -> x__ {_ForwardHtlcInterceptRequest'outgoingExpiry = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField ForwardHtlcInterceptRequest "customRecords" (Data.Map.Map Data.Word.Word64 Data.ByteString.ByteString) where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _ForwardHtlcInterceptRequest'customRecords
+           (\ x__ y__
+              -> x__ {_ForwardHtlcInterceptRequest'customRecords = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField ForwardHtlcInterceptRequest "onionBlob" Data.ByteString.ByteString where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _ForwardHtlcInterceptRequest'onionBlob
+           (\ x__ y__ -> x__ {_ForwardHtlcInterceptRequest'onionBlob = y__}))
+        Prelude.id
+instance Data.ProtoLens.Message ForwardHtlcInterceptRequest where
+  messageName _
+    = Data.Text.pack "routerrpc.ForwardHtlcInterceptRequest"
+  packedMessageDescriptor _
+    = "\n\
+      \\ESCForwardHtlcInterceptRequest\DC2G\n\
+      \\DC4incoming_circuit_key\CAN\SOH \SOH(\v2\NAK.routerrpc.CircuitKeyR\DC2incomingCircuitKey\DC20\n\
+      \\DC4incoming_amount_msat\CAN\ENQ \SOH(\EOTR\DC2incomingAmountMsat\DC2'\n\
+      \\SIincoming_expiry\CAN\ACK \SOH(\rR\SOincomingExpiry\DC2!\n\
+      \\fpayment_hash\CAN\STX \SOH(\fR\vpaymentHash\DC2;\n\
+      \\SUBoutgoing_requested_chan_id\CAN\a \SOH(\EOTR\ETBoutgoingRequestedChanId\DC20\n\
+      \\DC4outgoing_amount_msat\CAN\ETX \SOH(\EOTR\DC2outgoingAmountMsat\DC2'\n\
+      \\SIoutgoing_expiry\CAN\EOT \SOH(\rR\SOoutgoingExpiry\DC2`\n\
+      \\SOcustom_records\CAN\b \ETX(\v29.routerrpc.ForwardHtlcInterceptRequest.CustomRecordsEntryR\rcustomRecords\DC2\GS\n\
+      \\n\
+      \onion_blob\CAN\t \SOH(\fR\tonionBlob\SUB@\n\
+      \\DC2CustomRecordsEntry\DC2\DLE\n\
+      \\ETXkey\CAN\SOH \SOH(\EOTR\ETXkey\DC2\DC4\n\
+      \\ENQvalue\CAN\STX \SOH(\fR\ENQvalue:\STX8\SOH"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag
+    = let
+        incomingCircuitKey__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "incoming_circuit_key"
+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
+                 Data.ProtoLens.FieldTypeDescriptor CircuitKey)
+              (Data.ProtoLens.OptionalField
+                 (Data.ProtoLens.Field.field @"maybe'incomingCircuitKey")) ::
+              Data.ProtoLens.FieldDescriptor ForwardHtlcInterceptRequest
+        incomingAmountMsat__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "incoming_amount_msat"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.UInt64Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Word.Word64)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"incomingAmountMsat")) ::
+              Data.ProtoLens.FieldDescriptor ForwardHtlcInterceptRequest
+        incomingExpiry__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "incoming_expiry"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.UInt32Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Word.Word32)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"incomingExpiry")) ::
+              Data.ProtoLens.FieldDescriptor ForwardHtlcInterceptRequest
+        paymentHash__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "payment_hash"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"paymentHash")) ::
+              Data.ProtoLens.FieldDescriptor ForwardHtlcInterceptRequest
+        outgoingRequestedChanId__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "outgoing_requested_chan_id"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.UInt64Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Word.Word64)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"outgoingRequestedChanId")) ::
+              Data.ProtoLens.FieldDescriptor ForwardHtlcInterceptRequest
+        outgoingAmountMsat__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "outgoing_amount_msat"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.UInt64Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Word.Word64)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"outgoingAmountMsat")) ::
+              Data.ProtoLens.FieldDescriptor ForwardHtlcInterceptRequest
+        outgoingExpiry__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "outgoing_expiry"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.UInt32Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Word.Word32)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"outgoingExpiry")) ::
+              Data.ProtoLens.FieldDescriptor ForwardHtlcInterceptRequest
+        customRecords__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "custom_records"
+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
+                 Data.ProtoLens.FieldTypeDescriptor ForwardHtlcInterceptRequest'CustomRecordsEntry)
+              (Data.ProtoLens.MapField
+                 (Data.ProtoLens.Field.field @"key")
+                 (Data.ProtoLens.Field.field @"value")
+                 (Data.ProtoLens.Field.field @"customRecords")) ::
+              Data.ProtoLens.FieldDescriptor ForwardHtlcInterceptRequest
+        onionBlob__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "onion_blob"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"onionBlob")) ::
+              Data.ProtoLens.FieldDescriptor ForwardHtlcInterceptRequest
+      in
+        Data.Map.fromList
+          [(Data.ProtoLens.Tag 1, incomingCircuitKey__field_descriptor),
+           (Data.ProtoLens.Tag 5, incomingAmountMsat__field_descriptor),
+           (Data.ProtoLens.Tag 6, incomingExpiry__field_descriptor),
+           (Data.ProtoLens.Tag 2, paymentHash__field_descriptor),
+           (Data.ProtoLens.Tag 7, outgoingRequestedChanId__field_descriptor),
+           (Data.ProtoLens.Tag 3, outgoingAmountMsat__field_descriptor),
+           (Data.ProtoLens.Tag 4, outgoingExpiry__field_descriptor),
+           (Data.ProtoLens.Tag 8, customRecords__field_descriptor),
+           (Data.ProtoLens.Tag 9, onionBlob__field_descriptor)]
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _ForwardHtlcInterceptRequest'_unknownFields
+        (\ x__ y__
+           -> x__ {_ForwardHtlcInterceptRequest'_unknownFields = y__})
+  defMessage
+    = ForwardHtlcInterceptRequest'_constructor
+        {_ForwardHtlcInterceptRequest'incomingCircuitKey = Prelude.Nothing,
+         _ForwardHtlcInterceptRequest'incomingAmountMsat = Data.ProtoLens.fieldDefault,
+         _ForwardHtlcInterceptRequest'incomingExpiry = Data.ProtoLens.fieldDefault,
+         _ForwardHtlcInterceptRequest'paymentHash = Data.ProtoLens.fieldDefault,
+         _ForwardHtlcInterceptRequest'outgoingRequestedChanId = Data.ProtoLens.fieldDefault,
+         _ForwardHtlcInterceptRequest'outgoingAmountMsat = Data.ProtoLens.fieldDefault,
+         _ForwardHtlcInterceptRequest'outgoingExpiry = Data.ProtoLens.fieldDefault,
+         _ForwardHtlcInterceptRequest'customRecords = Data.Map.empty,
+         _ForwardHtlcInterceptRequest'onionBlob = Data.ProtoLens.fieldDefault,
+         _ForwardHtlcInterceptRequest'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          ForwardHtlcInterceptRequest
+          -> Data.ProtoLens.Encoding.Bytes.Parser ForwardHtlcInterceptRequest
+        loop x
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of
+                        10
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.isolate
+                                             (Prelude.fromIntegral len) Data.ProtoLens.parseMessage)
+                                       "incoming_circuit_key"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"incomingCircuitKey") y x)
+                        40
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       Data.ProtoLens.Encoding.Bytes.getVarInt
+                                       "incoming_amount_msat"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"incomingAmountMsat") y x)
+                        48
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          Prelude.fromIntegral
+                                          Data.ProtoLens.Encoding.Bytes.getVarInt)
+                                       "incoming_expiry"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"incomingExpiry") y x)
+                        18
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.getBytes
+                                             (Prelude.fromIntegral len))
+                                       "payment_hash"
+                                loop
+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"paymentHash") y x)
+                        56
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       Data.ProtoLens.Encoding.Bytes.getVarInt
+                                       "outgoing_requested_chan_id"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"outgoingRequestedChanId") y x)
+                        24
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       Data.ProtoLens.Encoding.Bytes.getVarInt
+                                       "outgoing_amount_msat"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"outgoingAmountMsat") y x)
+                        32
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          Prelude.fromIntegral
+                                          Data.ProtoLens.Encoding.Bytes.getVarInt)
+                                       "outgoing_expiry"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"outgoingExpiry") y x)
+                        66
+                          -> do !(entry :: ForwardHtlcInterceptRequest'CustomRecordsEntry) <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                                                                                (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                                                                                    Data.ProtoLens.Encoding.Bytes.isolate
+                                                                                                      (Prelude.fromIntegral
+                                                                                                         len)
+                                                                                                      Data.ProtoLens.parseMessage)
+                                                                                                "custom_records"
+                                (let
+                                   key = Lens.Family2.view (Data.ProtoLens.Field.field @"key") entry
+                                   value
+                                     = Lens.Family2.view (Data.ProtoLens.Field.field @"value") entry
+                                 in
+                                   loop
+                                     (Lens.Family2.over
+                                        (Data.ProtoLens.Field.field @"customRecords")
+                                        (\ !t -> Data.Map.insert key value t)
+                                        x))
+                        74
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.getBytes
+                                             (Prelude.fromIntegral len))
+                                       "onion_blob"
+                                loop
+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"onionBlob") y x)
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do loop Data.ProtoLens.defMessage) "ForwardHtlcInterceptRequest"
+  buildMessage
+    = \ _x
+        -> (Data.Monoid.<>)
+             (case
+                  Lens.Family2.view
+                    (Data.ProtoLens.Field.field @"maybe'incomingCircuitKey") _x
+              of
+                Prelude.Nothing -> Data.Monoid.mempty
+                (Prelude.Just _v)
+                  -> (Data.Monoid.<>)
+                       (Data.ProtoLens.Encoding.Bytes.putVarInt 10)
+                       ((Prelude..)
+                          (\ bs
+                             -> (Data.Monoid.<>)
+                                  (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                     (Prelude.fromIntegral (Data.ByteString.length bs)))
+                                  (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                          Data.ProtoLens.encodeMessage
+                          _v))
+             ((Data.Monoid.<>)
+                (let
+                   _v
+                     = Lens.Family2.view
+                         (Data.ProtoLens.Field.field @"incomingAmountMsat") _x
+                 in
+                   if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                       Data.Monoid.mempty
+                   else
+                       (Data.Monoid.<>)
+                         (Data.ProtoLens.Encoding.Bytes.putVarInt 40)
+                         (Data.ProtoLens.Encoding.Bytes.putVarInt _v))
+                ((Data.Monoid.<>)
+                   (let
+                      _v
+                        = Lens.Family2.view
+                            (Data.ProtoLens.Field.field @"incomingExpiry") _x
+                    in
+                      if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                          Data.Monoid.mempty
+                      else
+                          (Data.Monoid.<>)
+                            (Data.ProtoLens.Encoding.Bytes.putVarInt 48)
+                            ((Prelude..)
+                               Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v))
+                   ((Data.Monoid.<>)
+                      (let
+                         _v
+                           = Lens.Family2.view (Data.ProtoLens.Field.field @"paymentHash") _x
+                       in
+                         if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                             Data.Monoid.mempty
+                         else
+                             (Data.Monoid.<>)
+                               (Data.ProtoLens.Encoding.Bytes.putVarInt 18)
+                               ((\ bs
+                                   -> (Data.Monoid.<>)
+                                        (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                           (Prelude.fromIntegral (Data.ByteString.length bs)))
+                                        (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                                  _v))
+                      ((Data.Monoid.<>)
+                         (let
+                            _v
+                              = Lens.Family2.view
+                                  (Data.ProtoLens.Field.field @"outgoingRequestedChanId") _x
+                          in
+                            if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                                Data.Monoid.mempty
+                            else
+                                (Data.Monoid.<>)
+                                  (Data.ProtoLens.Encoding.Bytes.putVarInt 56)
+                                  (Data.ProtoLens.Encoding.Bytes.putVarInt _v))
+                         ((Data.Monoid.<>)
+                            (let
+                               _v
+                                 = Lens.Family2.view
+                                     (Data.ProtoLens.Field.field @"outgoingAmountMsat") _x
+                             in
+                               if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                                   Data.Monoid.mempty
+                               else
+                                   (Data.Monoid.<>)
+                                     (Data.ProtoLens.Encoding.Bytes.putVarInt 24)
+                                     (Data.ProtoLens.Encoding.Bytes.putVarInt _v))
+                            ((Data.Monoid.<>)
+                               (let
+                                  _v
+                                    = Lens.Family2.view
+                                        (Data.ProtoLens.Field.field @"outgoingExpiry") _x
+                                in
+                                  if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                                      Data.Monoid.mempty
+                                  else
+                                      (Data.Monoid.<>)
+                                        (Data.ProtoLens.Encoding.Bytes.putVarInt 32)
+                                        ((Prelude..)
+                                           Data.ProtoLens.Encoding.Bytes.putVarInt
+                                           Prelude.fromIntegral
+                                           _v))
+                               ((Data.Monoid.<>)
+                                  (Data.Monoid.mconcat
+                                     (Prelude.map
+                                        (\ _v
+                                           -> (Data.Monoid.<>)
+                                                (Data.ProtoLens.Encoding.Bytes.putVarInt 66)
+                                                ((Prelude..)
+                                                   (\ bs
+                                                      -> (Data.Monoid.<>)
+                                                           (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                                              (Prelude.fromIntegral
+                                                                 (Data.ByteString.length bs)))
+                                                           (Data.ProtoLens.Encoding.Bytes.putBytes
+                                                              bs))
+                                                   Data.ProtoLens.encodeMessage
+                                                   (Lens.Family2.set
+                                                      (Data.ProtoLens.Field.field @"key")
+                                                      (Prelude.fst _v)
+                                                      (Lens.Family2.set
+                                                         (Data.ProtoLens.Field.field @"value")
+                                                         (Prelude.snd _v)
+                                                         (Data.ProtoLens.defMessage ::
+                                                            ForwardHtlcInterceptRequest'CustomRecordsEntry)))))
+                                        (Data.Map.toList
+                                           (Lens.Family2.view
+                                              (Data.ProtoLens.Field.field @"customRecords") _x))))
+                                  ((Data.Monoid.<>)
+                                     (let
+                                        _v
+                                          = Lens.Family2.view
+                                              (Data.ProtoLens.Field.field @"onionBlob") _x
+                                      in
+                                        if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                                            Data.Monoid.mempty
+                                        else
+                                            (Data.Monoid.<>)
+                                              (Data.ProtoLens.Encoding.Bytes.putVarInt 74)
+                                              ((\ bs
+                                                  -> (Data.Monoid.<>)
+                                                       (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                                          (Prelude.fromIntegral
+                                                             (Data.ByteString.length bs)))
+                                                       (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                                                 _v))
+                                     (Data.ProtoLens.Encoding.Wire.buildFieldSet
+                                        (Lens.Family2.view Data.ProtoLens.unknownFields _x))))))))))
+instance Control.DeepSeq.NFData ForwardHtlcInterceptRequest where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_ForwardHtlcInterceptRequest'_unknownFields x__)
+             (Control.DeepSeq.deepseq
+                (_ForwardHtlcInterceptRequest'incomingCircuitKey x__)
+                (Control.DeepSeq.deepseq
+                   (_ForwardHtlcInterceptRequest'incomingAmountMsat x__)
+                   (Control.DeepSeq.deepseq
+                      (_ForwardHtlcInterceptRequest'incomingExpiry x__)
+                      (Control.DeepSeq.deepseq
+                         (_ForwardHtlcInterceptRequest'paymentHash x__)
+                         (Control.DeepSeq.deepseq
+                            (_ForwardHtlcInterceptRequest'outgoingRequestedChanId x__)
+                            (Control.DeepSeq.deepseq
+                               (_ForwardHtlcInterceptRequest'outgoingAmountMsat x__)
+                               (Control.DeepSeq.deepseq
+                                  (_ForwardHtlcInterceptRequest'outgoingExpiry x__)
+                                  (Control.DeepSeq.deepseq
+                                     (_ForwardHtlcInterceptRequest'customRecords x__)
+                                     (Control.DeepSeq.deepseq
+                                        (_ForwardHtlcInterceptRequest'onionBlob x__) ())))))))))
+{- | Fields :
+     
+         * 'Proto.RouterGrpc_Fields.key' @:: Lens' ForwardHtlcInterceptRequest'CustomRecordsEntry Data.Word.Word64@
+         * 'Proto.RouterGrpc_Fields.value' @:: Lens' ForwardHtlcInterceptRequest'CustomRecordsEntry Data.ByteString.ByteString@ -}
+data ForwardHtlcInterceptRequest'CustomRecordsEntry
+  = ForwardHtlcInterceptRequest'CustomRecordsEntry'_constructor {_ForwardHtlcInterceptRequest'CustomRecordsEntry'key :: !Data.Word.Word64,
+                                                                 _ForwardHtlcInterceptRequest'CustomRecordsEntry'value :: !Data.ByteString.ByteString,
+                                                                 _ForwardHtlcInterceptRequest'CustomRecordsEntry'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show ForwardHtlcInterceptRequest'CustomRecordsEntry where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Field.HasField ForwardHtlcInterceptRequest'CustomRecordsEntry "key" Data.Word.Word64 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _ForwardHtlcInterceptRequest'CustomRecordsEntry'key
+           (\ x__ y__
+              -> x__
+                   {_ForwardHtlcInterceptRequest'CustomRecordsEntry'key = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField ForwardHtlcInterceptRequest'CustomRecordsEntry "value" Data.ByteString.ByteString where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _ForwardHtlcInterceptRequest'CustomRecordsEntry'value
+           (\ x__ y__
+              -> x__
+                   {_ForwardHtlcInterceptRequest'CustomRecordsEntry'value = y__}))
+        Prelude.id
+instance Data.ProtoLens.Message ForwardHtlcInterceptRequest'CustomRecordsEntry where
+  messageName _
+    = Data.Text.pack
+        "routerrpc.ForwardHtlcInterceptRequest.CustomRecordsEntry"
+  packedMessageDescriptor _
+    = "\n\
+      \\DC2CustomRecordsEntry\DC2\DLE\n\
+      \\ETXkey\CAN\SOH \SOH(\EOTR\ETXkey\DC2\DC4\n\
+      \\ENQvalue\CAN\STX \SOH(\fR\ENQvalue:\STX8\SOH"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag
+    = let
+        key__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "key"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.UInt64Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Word.Word64)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional (Data.ProtoLens.Field.field @"key")) ::
+              Data.ProtoLens.FieldDescriptor ForwardHtlcInterceptRequest'CustomRecordsEntry
+        value__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "value"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional (Data.ProtoLens.Field.field @"value")) ::
+              Data.ProtoLens.FieldDescriptor ForwardHtlcInterceptRequest'CustomRecordsEntry
+      in
+        Data.Map.fromList
+          [(Data.ProtoLens.Tag 1, key__field_descriptor),
+           (Data.ProtoLens.Tag 2, value__field_descriptor)]
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _ForwardHtlcInterceptRequest'CustomRecordsEntry'_unknownFields
+        (\ x__ y__
+           -> x__
+                {_ForwardHtlcInterceptRequest'CustomRecordsEntry'_unknownFields = y__})
+  defMessage
+    = ForwardHtlcInterceptRequest'CustomRecordsEntry'_constructor
+        {_ForwardHtlcInterceptRequest'CustomRecordsEntry'key = Data.ProtoLens.fieldDefault,
+         _ForwardHtlcInterceptRequest'CustomRecordsEntry'value = Data.ProtoLens.fieldDefault,
+         _ForwardHtlcInterceptRequest'CustomRecordsEntry'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          ForwardHtlcInterceptRequest'CustomRecordsEntry
+          -> Data.ProtoLens.Encoding.Bytes.Parser ForwardHtlcInterceptRequest'CustomRecordsEntry
+        loop x
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of
+                        8 -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       Data.ProtoLens.Encoding.Bytes.getVarInt "key"
+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"key") y x)
+                        18
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.getBytes
+                                             (Prelude.fromIntegral len))
+                                       "value"
+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"value") y x)
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do loop Data.ProtoLens.defMessage) "CustomRecordsEntry"
+  buildMessage
+    = \ _x
+        -> (Data.Monoid.<>)
+             (let _v = Lens.Family2.view (Data.ProtoLens.Field.field @"key") _x
+              in
+                if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                    Data.Monoid.mempty
+                else
+                    (Data.Monoid.<>)
+                      (Data.ProtoLens.Encoding.Bytes.putVarInt 8)
+                      (Data.ProtoLens.Encoding.Bytes.putVarInt _v))
+             ((Data.Monoid.<>)
+                (let
+                   _v = Lens.Family2.view (Data.ProtoLens.Field.field @"value") _x
+                 in
+                   if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                       Data.Monoid.mempty
+                   else
+                       (Data.Monoid.<>)
+                         (Data.ProtoLens.Encoding.Bytes.putVarInt 18)
+                         ((\ bs
+                             -> (Data.Monoid.<>)
+                                  (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                     (Prelude.fromIntegral (Data.ByteString.length bs)))
+                                  (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                            _v))
+                (Data.ProtoLens.Encoding.Wire.buildFieldSet
+                   (Lens.Family2.view Data.ProtoLens.unknownFields _x)))
+instance Control.DeepSeq.NFData ForwardHtlcInterceptRequest'CustomRecordsEntry where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_ForwardHtlcInterceptRequest'CustomRecordsEntry'_unknownFields
+                x__)
+             (Control.DeepSeq.deepseq
+                (_ForwardHtlcInterceptRequest'CustomRecordsEntry'key x__)
+                (Control.DeepSeq.deepseq
+                   (_ForwardHtlcInterceptRequest'CustomRecordsEntry'value x__) ()))
+{- | Fields :
+     
+         * 'Proto.RouterGrpc_Fields.incomingCircuitKey' @:: Lens' ForwardHtlcInterceptResponse CircuitKey@
+         * 'Proto.RouterGrpc_Fields.maybe'incomingCircuitKey' @:: Lens' ForwardHtlcInterceptResponse (Prelude.Maybe CircuitKey)@
+         * 'Proto.RouterGrpc_Fields.action' @:: Lens' ForwardHtlcInterceptResponse ResolveHoldForwardAction@
+         * 'Proto.RouterGrpc_Fields.preimage' @:: Lens' ForwardHtlcInterceptResponse Data.ByteString.ByteString@ -}
+data ForwardHtlcInterceptResponse
+  = ForwardHtlcInterceptResponse'_constructor {_ForwardHtlcInterceptResponse'incomingCircuitKey :: !(Prelude.Maybe CircuitKey),
+                                               _ForwardHtlcInterceptResponse'action :: !ResolveHoldForwardAction,
+                                               _ForwardHtlcInterceptResponse'preimage :: !Data.ByteString.ByteString,
+                                               _ForwardHtlcInterceptResponse'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show ForwardHtlcInterceptResponse where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Field.HasField ForwardHtlcInterceptResponse "incomingCircuitKey" CircuitKey where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _ForwardHtlcInterceptResponse'incomingCircuitKey
+           (\ x__ y__
+              -> x__ {_ForwardHtlcInterceptResponse'incomingCircuitKey = y__}))
+        (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage)
+instance Data.ProtoLens.Field.HasField ForwardHtlcInterceptResponse "maybe'incomingCircuitKey" (Prelude.Maybe CircuitKey) where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _ForwardHtlcInterceptResponse'incomingCircuitKey
+           (\ x__ y__
+              -> x__ {_ForwardHtlcInterceptResponse'incomingCircuitKey = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField ForwardHtlcInterceptResponse "action" ResolveHoldForwardAction where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _ForwardHtlcInterceptResponse'action
+           (\ x__ y__ -> x__ {_ForwardHtlcInterceptResponse'action = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField ForwardHtlcInterceptResponse "preimage" Data.ByteString.ByteString where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _ForwardHtlcInterceptResponse'preimage
+           (\ x__ y__ -> x__ {_ForwardHtlcInterceptResponse'preimage = y__}))
+        Prelude.id
+instance Data.ProtoLens.Message ForwardHtlcInterceptResponse where
+  messageName _
+    = Data.Text.pack "routerrpc.ForwardHtlcInterceptResponse"
+  packedMessageDescriptor _
+    = "\n\
+      \\FSForwardHtlcInterceptResponse\DC2G\n\
+      \\DC4incoming_circuit_key\CAN\SOH \SOH(\v2\NAK.routerrpc.CircuitKeyR\DC2incomingCircuitKey\DC2;\n\
+      \\ACKaction\CAN\STX \SOH(\SO2#.routerrpc.ResolveHoldForwardActionR\ACKaction\DC2\SUB\n\
+      \\bpreimage\CAN\ETX \SOH(\fR\bpreimage"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag
+    = let
+        incomingCircuitKey__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "incoming_circuit_key"
+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
+                 Data.ProtoLens.FieldTypeDescriptor CircuitKey)
+              (Data.ProtoLens.OptionalField
+                 (Data.ProtoLens.Field.field @"maybe'incomingCircuitKey")) ::
+              Data.ProtoLens.FieldDescriptor ForwardHtlcInterceptResponse
+        action__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "action"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField ::
+                 Data.ProtoLens.FieldTypeDescriptor ResolveHoldForwardAction)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional (Data.ProtoLens.Field.field @"action")) ::
+              Data.ProtoLens.FieldDescriptor ForwardHtlcInterceptResponse
+        preimage__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "preimage"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"preimage")) ::
+              Data.ProtoLens.FieldDescriptor ForwardHtlcInterceptResponse
+      in
+        Data.Map.fromList
+          [(Data.ProtoLens.Tag 1, incomingCircuitKey__field_descriptor),
+           (Data.ProtoLens.Tag 2, action__field_descriptor),
+           (Data.ProtoLens.Tag 3, preimage__field_descriptor)]
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _ForwardHtlcInterceptResponse'_unknownFields
+        (\ x__ y__
+           -> x__ {_ForwardHtlcInterceptResponse'_unknownFields = y__})
+  defMessage
+    = ForwardHtlcInterceptResponse'_constructor
+        {_ForwardHtlcInterceptResponse'incomingCircuitKey = Prelude.Nothing,
+         _ForwardHtlcInterceptResponse'action = Data.ProtoLens.fieldDefault,
+         _ForwardHtlcInterceptResponse'preimage = Data.ProtoLens.fieldDefault,
+         _ForwardHtlcInterceptResponse'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          ForwardHtlcInterceptResponse
+          -> Data.ProtoLens.Encoding.Bytes.Parser ForwardHtlcInterceptResponse
+        loop x
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of
+                        10
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.isolate
+                                             (Prelude.fromIntegral len) Data.ProtoLens.parseMessage)
+                                       "incoming_circuit_key"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"incomingCircuitKey") y x)
+                        16
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          Prelude.toEnum
+                                          (Prelude.fmap
+                                             Prelude.fromIntegral
+                                             Data.ProtoLens.Encoding.Bytes.getVarInt))
+                                       "action"
+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"action") y x)
+                        26
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.getBytes
+                                             (Prelude.fromIntegral len))
+                                       "preimage"
+                                loop
+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"preimage") y x)
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do loop Data.ProtoLens.defMessage) "ForwardHtlcInterceptResponse"
+  buildMessage
+    = \ _x
+        -> (Data.Monoid.<>)
+             (case
+                  Lens.Family2.view
+                    (Data.ProtoLens.Field.field @"maybe'incomingCircuitKey") _x
+              of
+                Prelude.Nothing -> Data.Monoid.mempty
+                (Prelude.Just _v)
+                  -> (Data.Monoid.<>)
+                       (Data.ProtoLens.Encoding.Bytes.putVarInt 10)
+                       ((Prelude..)
+                          (\ bs
+                             -> (Data.Monoid.<>)
+                                  (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                     (Prelude.fromIntegral (Data.ByteString.length bs)))
+                                  (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                          Data.ProtoLens.encodeMessage
+                          _v))
+             ((Data.Monoid.<>)
+                (let
+                   _v = Lens.Family2.view (Data.ProtoLens.Field.field @"action") _x
+                 in
+                   if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                       Data.Monoid.mempty
+                   else
+                       (Data.Monoid.<>)
+                         (Data.ProtoLens.Encoding.Bytes.putVarInt 16)
+                         ((Prelude..)
+                            ((Prelude..)
+                               Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral)
+                            Prelude.fromEnum
+                            _v))
+                ((Data.Monoid.<>)
+                   (let
+                      _v = Lens.Family2.view (Data.ProtoLens.Field.field @"preimage") _x
+                    in
+                      if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                          Data.Monoid.mempty
+                      else
+                          (Data.Monoid.<>)
+                            (Data.ProtoLens.Encoding.Bytes.putVarInt 26)
+                            ((\ bs
+                                -> (Data.Monoid.<>)
+                                     (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                        (Prelude.fromIntegral (Data.ByteString.length bs)))
+                                     (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                               _v))
+                   (Data.ProtoLens.Encoding.Wire.buildFieldSet
+                      (Lens.Family2.view Data.ProtoLens.unknownFields _x))))
+instance Control.DeepSeq.NFData ForwardHtlcInterceptResponse where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_ForwardHtlcInterceptResponse'_unknownFields x__)
+             (Control.DeepSeq.deepseq
+                (_ForwardHtlcInterceptResponse'incomingCircuitKey x__)
+                (Control.DeepSeq.deepseq
+                   (_ForwardHtlcInterceptResponse'action x__)
+                   (Control.DeepSeq.deepseq
+                      (_ForwardHtlcInterceptResponse'preimage x__) ())))
+{- | Fields :
+      -}
+data GetMissionControlConfigRequest
+  = GetMissionControlConfigRequest'_constructor {_GetMissionControlConfigRequest'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show GetMissionControlConfigRequest where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Message GetMissionControlConfigRequest where
+  messageName _
+    = Data.Text.pack "routerrpc.GetMissionControlConfigRequest"
+  packedMessageDescriptor _
+    = "\n\
+      \\RSGetMissionControlConfigRequest"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag = let in Data.Map.fromList []
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _GetMissionControlConfigRequest'_unknownFields
+        (\ x__ y__
+           -> x__ {_GetMissionControlConfigRequest'_unknownFields = y__})
+  defMessage
+    = GetMissionControlConfigRequest'_constructor
+        {_GetMissionControlConfigRequest'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          GetMissionControlConfigRequest
+          -> Data.ProtoLens.Encoding.Bytes.Parser GetMissionControlConfigRequest
+        loop x
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of {
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) }
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do loop Data.ProtoLens.defMessage)
+          "GetMissionControlConfigRequest"
+  buildMessage
+    = \ _x
+        -> Data.ProtoLens.Encoding.Wire.buildFieldSet
+             (Lens.Family2.view Data.ProtoLens.unknownFields _x)
+instance Control.DeepSeq.NFData GetMissionControlConfigRequest where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_GetMissionControlConfigRequest'_unknownFields x__) ()
+{- | Fields :
+     
+         * 'Proto.RouterGrpc_Fields.config' @:: Lens' GetMissionControlConfigResponse MissionControlConfig@
+         * 'Proto.RouterGrpc_Fields.maybe'config' @:: Lens' GetMissionControlConfigResponse (Prelude.Maybe MissionControlConfig)@ -}
+data GetMissionControlConfigResponse
+  = GetMissionControlConfigResponse'_constructor {_GetMissionControlConfigResponse'config :: !(Prelude.Maybe MissionControlConfig),
+                                                  _GetMissionControlConfigResponse'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show GetMissionControlConfigResponse where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Field.HasField GetMissionControlConfigResponse "config" MissionControlConfig where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _GetMissionControlConfigResponse'config
+           (\ x__ y__ -> x__ {_GetMissionControlConfigResponse'config = y__}))
+        (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage)
+instance Data.ProtoLens.Field.HasField GetMissionControlConfigResponse "maybe'config" (Prelude.Maybe MissionControlConfig) where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _GetMissionControlConfigResponse'config
+           (\ x__ y__ -> x__ {_GetMissionControlConfigResponse'config = y__}))
+        Prelude.id
+instance Data.ProtoLens.Message GetMissionControlConfigResponse where
+  messageName _
+    = Data.Text.pack "routerrpc.GetMissionControlConfigResponse"
+  packedMessageDescriptor _
+    = "\n\
+      \\USGetMissionControlConfigResponse\DC27\n\
+      \\ACKconfig\CAN\SOH \SOH(\v2\US.routerrpc.MissionControlConfigR\ACKconfig"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag
+    = let
+        config__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "config"
+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
+                 Data.ProtoLens.FieldTypeDescriptor MissionControlConfig)
+              (Data.ProtoLens.OptionalField
+                 (Data.ProtoLens.Field.field @"maybe'config")) ::
+              Data.ProtoLens.FieldDescriptor GetMissionControlConfigResponse
+      in
+        Data.Map.fromList
+          [(Data.ProtoLens.Tag 1, config__field_descriptor)]
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _GetMissionControlConfigResponse'_unknownFields
+        (\ x__ y__
+           -> x__ {_GetMissionControlConfigResponse'_unknownFields = y__})
+  defMessage
+    = GetMissionControlConfigResponse'_constructor
+        {_GetMissionControlConfigResponse'config = Prelude.Nothing,
+         _GetMissionControlConfigResponse'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          GetMissionControlConfigResponse
+          -> Data.ProtoLens.Encoding.Bytes.Parser GetMissionControlConfigResponse
+        loop x
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of
+                        10
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.isolate
+                                             (Prelude.fromIntegral len) Data.ProtoLens.parseMessage)
+                                       "config"
+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"config") y x)
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do loop Data.ProtoLens.defMessage)
+          "GetMissionControlConfigResponse"
+  buildMessage
+    = \ _x
+        -> (Data.Monoid.<>)
+             (case
+                  Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'config") _x
+              of
+                Prelude.Nothing -> Data.Monoid.mempty
+                (Prelude.Just _v)
+                  -> (Data.Monoid.<>)
+                       (Data.ProtoLens.Encoding.Bytes.putVarInt 10)
+                       ((Prelude..)
+                          (\ bs
+                             -> (Data.Monoid.<>)
+                                  (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                     (Prelude.fromIntegral (Data.ByteString.length bs)))
+                                  (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                          Data.ProtoLens.encodeMessage
+                          _v))
+             (Data.ProtoLens.Encoding.Wire.buildFieldSet
+                (Lens.Family2.view Data.ProtoLens.unknownFields _x))
+instance Control.DeepSeq.NFData GetMissionControlConfigResponse where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_GetMissionControlConfigResponse'_unknownFields x__)
+             (Control.DeepSeq.deepseq
+                (_GetMissionControlConfigResponse'config x__) ())
+{- | Fields :
+     
+         * 'Proto.RouterGrpc_Fields.incomingChannelId' @:: Lens' HtlcEvent Data.Word.Word64@
+         * 'Proto.RouterGrpc_Fields.outgoingChannelId' @:: Lens' HtlcEvent Data.Word.Word64@
+         * 'Proto.RouterGrpc_Fields.incomingHtlcId' @:: Lens' HtlcEvent Data.Word.Word64@
+         * 'Proto.RouterGrpc_Fields.outgoingHtlcId' @:: Lens' HtlcEvent Data.Word.Word64@
+         * 'Proto.RouterGrpc_Fields.timestampNs' @:: Lens' HtlcEvent Data.Word.Word64@
+         * 'Proto.RouterGrpc_Fields.eventType' @:: Lens' HtlcEvent HtlcEvent'EventType@
+         * 'Proto.RouterGrpc_Fields.maybe'event' @:: Lens' HtlcEvent (Prelude.Maybe HtlcEvent'Event)@
+         * 'Proto.RouterGrpc_Fields.maybe'forwardEvent' @:: Lens' HtlcEvent (Prelude.Maybe ForwardEvent)@
+         * 'Proto.RouterGrpc_Fields.forwardEvent' @:: Lens' HtlcEvent ForwardEvent@
+         * 'Proto.RouterGrpc_Fields.maybe'forwardFailEvent' @:: Lens' HtlcEvent (Prelude.Maybe ForwardFailEvent)@
+         * 'Proto.RouterGrpc_Fields.forwardFailEvent' @:: Lens' HtlcEvent ForwardFailEvent@
+         * 'Proto.RouterGrpc_Fields.maybe'settleEvent' @:: Lens' HtlcEvent (Prelude.Maybe SettleEvent)@
+         * 'Proto.RouterGrpc_Fields.settleEvent' @:: Lens' HtlcEvent SettleEvent@
+         * 'Proto.RouterGrpc_Fields.maybe'linkFailEvent' @:: Lens' HtlcEvent (Prelude.Maybe LinkFailEvent)@
+         * 'Proto.RouterGrpc_Fields.linkFailEvent' @:: Lens' HtlcEvent LinkFailEvent@ -}
+data HtlcEvent
+  = HtlcEvent'_constructor {_HtlcEvent'incomingChannelId :: !Data.Word.Word64,
+                            _HtlcEvent'outgoingChannelId :: !Data.Word.Word64,
+                            _HtlcEvent'incomingHtlcId :: !Data.Word.Word64,
+                            _HtlcEvent'outgoingHtlcId :: !Data.Word.Word64,
+                            _HtlcEvent'timestampNs :: !Data.Word.Word64,
+                            _HtlcEvent'eventType :: !HtlcEvent'EventType,
+                            _HtlcEvent'event :: !(Prelude.Maybe HtlcEvent'Event),
+                            _HtlcEvent'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show HtlcEvent where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+data HtlcEvent'Event
+  = HtlcEvent'ForwardEvent !ForwardEvent |
+    HtlcEvent'ForwardFailEvent !ForwardFailEvent |
+    HtlcEvent'SettleEvent !SettleEvent |
+    HtlcEvent'LinkFailEvent !LinkFailEvent
+  deriving stock (Prelude.Show, Prelude.Eq, Prelude.Ord)
+instance Data.ProtoLens.Field.HasField HtlcEvent "incomingChannelId" Data.Word.Word64 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _HtlcEvent'incomingChannelId
+           (\ x__ y__ -> x__ {_HtlcEvent'incomingChannelId = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField HtlcEvent "outgoingChannelId" Data.Word.Word64 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _HtlcEvent'outgoingChannelId
+           (\ x__ y__ -> x__ {_HtlcEvent'outgoingChannelId = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField HtlcEvent "incomingHtlcId" Data.Word.Word64 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _HtlcEvent'incomingHtlcId
+           (\ x__ y__ -> x__ {_HtlcEvent'incomingHtlcId = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField HtlcEvent "outgoingHtlcId" Data.Word.Word64 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _HtlcEvent'outgoingHtlcId
+           (\ x__ y__ -> x__ {_HtlcEvent'outgoingHtlcId = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField HtlcEvent "timestampNs" Data.Word.Word64 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _HtlcEvent'timestampNs
+           (\ x__ y__ -> x__ {_HtlcEvent'timestampNs = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField HtlcEvent "eventType" HtlcEvent'EventType where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _HtlcEvent'eventType
+           (\ x__ y__ -> x__ {_HtlcEvent'eventType = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField HtlcEvent "maybe'event" (Prelude.Maybe HtlcEvent'Event) where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _HtlcEvent'event (\ x__ y__ -> x__ {_HtlcEvent'event = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField HtlcEvent "maybe'forwardEvent" (Prelude.Maybe ForwardEvent) where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _HtlcEvent'event (\ x__ y__ -> x__ {_HtlcEvent'event = y__}))
+        (Lens.Family2.Unchecked.lens
+           (\ x__
+              -> case x__ of
+                   (Prelude.Just (HtlcEvent'ForwardEvent x__val))
+                     -> Prelude.Just x__val
+                   _otherwise -> Prelude.Nothing)
+           (\ _ y__ -> Prelude.fmap HtlcEvent'ForwardEvent y__))
+instance Data.ProtoLens.Field.HasField HtlcEvent "forwardEvent" ForwardEvent where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _HtlcEvent'event (\ x__ y__ -> x__ {_HtlcEvent'event = y__}))
+        ((Prelude..)
+           (Lens.Family2.Unchecked.lens
+              (\ x__
+                 -> case x__ of
+                      (Prelude.Just (HtlcEvent'ForwardEvent x__val))
+                        -> Prelude.Just x__val
+                      _otherwise -> Prelude.Nothing)
+              (\ _ y__ -> Prelude.fmap HtlcEvent'ForwardEvent y__))
+           (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage))
+instance Data.ProtoLens.Field.HasField HtlcEvent "maybe'forwardFailEvent" (Prelude.Maybe ForwardFailEvent) where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _HtlcEvent'event (\ x__ y__ -> x__ {_HtlcEvent'event = y__}))
+        (Lens.Family2.Unchecked.lens
+           (\ x__
+              -> case x__ of
+                   (Prelude.Just (HtlcEvent'ForwardFailEvent x__val))
+                     -> Prelude.Just x__val
+                   _otherwise -> Prelude.Nothing)
+           (\ _ y__ -> Prelude.fmap HtlcEvent'ForwardFailEvent y__))
+instance Data.ProtoLens.Field.HasField HtlcEvent "forwardFailEvent" ForwardFailEvent where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _HtlcEvent'event (\ x__ y__ -> x__ {_HtlcEvent'event = y__}))
+        ((Prelude..)
+           (Lens.Family2.Unchecked.lens
+              (\ x__
+                 -> case x__ of
+                      (Prelude.Just (HtlcEvent'ForwardFailEvent x__val))
+                        -> Prelude.Just x__val
+                      _otherwise -> Prelude.Nothing)
+              (\ _ y__ -> Prelude.fmap HtlcEvent'ForwardFailEvent y__))
+           (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage))
+instance Data.ProtoLens.Field.HasField HtlcEvent "maybe'settleEvent" (Prelude.Maybe SettleEvent) where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _HtlcEvent'event (\ x__ y__ -> x__ {_HtlcEvent'event = y__}))
+        (Lens.Family2.Unchecked.lens
+           (\ x__
+              -> case x__ of
+                   (Prelude.Just (HtlcEvent'SettleEvent x__val))
+                     -> Prelude.Just x__val
+                   _otherwise -> Prelude.Nothing)
+           (\ _ y__ -> Prelude.fmap HtlcEvent'SettleEvent y__))
+instance Data.ProtoLens.Field.HasField HtlcEvent "settleEvent" SettleEvent where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _HtlcEvent'event (\ x__ y__ -> x__ {_HtlcEvent'event = y__}))
+        ((Prelude..)
+           (Lens.Family2.Unchecked.lens
+              (\ x__
+                 -> case x__ of
+                      (Prelude.Just (HtlcEvent'SettleEvent x__val))
+                        -> Prelude.Just x__val
+                      _otherwise -> Prelude.Nothing)
+              (\ _ y__ -> Prelude.fmap HtlcEvent'SettleEvent y__))
+           (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage))
+instance Data.ProtoLens.Field.HasField HtlcEvent "maybe'linkFailEvent" (Prelude.Maybe LinkFailEvent) where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _HtlcEvent'event (\ x__ y__ -> x__ {_HtlcEvent'event = y__}))
+        (Lens.Family2.Unchecked.lens
+           (\ x__
+              -> case x__ of
+                   (Prelude.Just (HtlcEvent'LinkFailEvent x__val))
+                     -> Prelude.Just x__val
+                   _otherwise -> Prelude.Nothing)
+           (\ _ y__ -> Prelude.fmap HtlcEvent'LinkFailEvent y__))
+instance Data.ProtoLens.Field.HasField HtlcEvent "linkFailEvent" LinkFailEvent where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _HtlcEvent'event (\ x__ y__ -> x__ {_HtlcEvent'event = y__}))
+        ((Prelude..)
+           (Lens.Family2.Unchecked.lens
+              (\ x__
+                 -> case x__ of
+                      (Prelude.Just (HtlcEvent'LinkFailEvent x__val))
+                        -> Prelude.Just x__val
+                      _otherwise -> Prelude.Nothing)
+              (\ _ y__ -> Prelude.fmap HtlcEvent'LinkFailEvent y__))
+           (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage))
+instance Data.ProtoLens.Message HtlcEvent where
+  messageName _ = Data.Text.pack "routerrpc.HtlcEvent"
+  packedMessageDescriptor _
+    = "\n\
+      \\tHtlcEvent\DC2.\n\
+      \\DC3incoming_channel_id\CAN\SOH \SOH(\EOTR\DC1incomingChannelId\DC2.\n\
+      \\DC3outgoing_channel_id\CAN\STX \SOH(\EOTR\DC1outgoingChannelId\DC2(\n\
+      \\DLEincoming_htlc_id\CAN\ETX \SOH(\EOTR\SOincomingHtlcId\DC2(\n\
+      \\DLEoutgoing_htlc_id\CAN\EOT \SOH(\EOTR\SOoutgoingHtlcId\DC2!\n\
+      \\ftimestamp_ns\CAN\ENQ \SOH(\EOTR\vtimestampNs\DC2=\n\
+      \\n\
+      \event_type\CAN\ACK \SOH(\SO2\RS.routerrpc.HtlcEvent.EventTypeR\teventType\DC2>\n\
+      \\rforward_event\CAN\a \SOH(\v2\ETB.routerrpc.ForwardEventH\NULR\fforwardEvent\DC2K\n\
+      \\DC2forward_fail_event\CAN\b \SOH(\v2\ESC.routerrpc.ForwardFailEventH\NULR\DLEforwardFailEvent\DC2;\n\
+      \\fsettle_event\CAN\t \SOH(\v2\SYN.routerrpc.SettleEventH\NULR\vsettleEvent\DC2B\n\
+      \\SIlink_fail_event\CAN\n\
+      \ \SOH(\v2\CAN.routerrpc.LinkFailEventH\NULR\rlinkFailEvent\"<\n\
+      \\tEventType\DC2\v\n\
+      \\aUNKNOWN\DLE\NUL\DC2\b\n\
+      \\EOTSEND\DLE\SOH\DC2\v\n\
+      \\aRECEIVE\DLE\STX\DC2\v\n\
+      \\aFORWARD\DLE\ETXB\a\n\
+      \\ENQevent"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag
+    = let
+        incomingChannelId__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "incoming_channel_id"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.UInt64Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Word.Word64)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"incomingChannelId")) ::
+              Data.ProtoLens.FieldDescriptor HtlcEvent
+        outgoingChannelId__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "outgoing_channel_id"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.UInt64Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Word.Word64)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"outgoingChannelId")) ::
+              Data.ProtoLens.FieldDescriptor HtlcEvent
+        incomingHtlcId__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "incoming_htlc_id"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.UInt64Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Word.Word64)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"incomingHtlcId")) ::
+              Data.ProtoLens.FieldDescriptor HtlcEvent
+        outgoingHtlcId__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "outgoing_htlc_id"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.UInt64Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Word.Word64)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"outgoingHtlcId")) ::
+              Data.ProtoLens.FieldDescriptor HtlcEvent
+        timestampNs__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "timestamp_ns"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.UInt64Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Word.Word64)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"timestampNs")) ::
+              Data.ProtoLens.FieldDescriptor HtlcEvent
+        eventType__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "event_type"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField ::
+                 Data.ProtoLens.FieldTypeDescriptor HtlcEvent'EventType)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"eventType")) ::
+              Data.ProtoLens.FieldDescriptor HtlcEvent
+        forwardEvent__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "forward_event"
+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
+                 Data.ProtoLens.FieldTypeDescriptor ForwardEvent)
+              (Data.ProtoLens.OptionalField
+                 (Data.ProtoLens.Field.field @"maybe'forwardEvent")) ::
+              Data.ProtoLens.FieldDescriptor HtlcEvent
+        forwardFailEvent__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "forward_fail_event"
+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
+                 Data.ProtoLens.FieldTypeDescriptor ForwardFailEvent)
+              (Data.ProtoLens.OptionalField
+                 (Data.ProtoLens.Field.field @"maybe'forwardFailEvent")) ::
+              Data.ProtoLens.FieldDescriptor HtlcEvent
+        settleEvent__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "settle_event"
+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
+                 Data.ProtoLens.FieldTypeDescriptor SettleEvent)
+              (Data.ProtoLens.OptionalField
+                 (Data.ProtoLens.Field.field @"maybe'settleEvent")) ::
+              Data.ProtoLens.FieldDescriptor HtlcEvent
+        linkFailEvent__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "link_fail_event"
+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
+                 Data.ProtoLens.FieldTypeDescriptor LinkFailEvent)
+              (Data.ProtoLens.OptionalField
+                 (Data.ProtoLens.Field.field @"maybe'linkFailEvent")) ::
+              Data.ProtoLens.FieldDescriptor HtlcEvent
+      in
+        Data.Map.fromList
+          [(Data.ProtoLens.Tag 1, incomingChannelId__field_descriptor),
+           (Data.ProtoLens.Tag 2, outgoingChannelId__field_descriptor),
+           (Data.ProtoLens.Tag 3, incomingHtlcId__field_descriptor),
+           (Data.ProtoLens.Tag 4, outgoingHtlcId__field_descriptor),
+           (Data.ProtoLens.Tag 5, timestampNs__field_descriptor),
+           (Data.ProtoLens.Tag 6, eventType__field_descriptor),
+           (Data.ProtoLens.Tag 7, forwardEvent__field_descriptor),
+           (Data.ProtoLens.Tag 8, forwardFailEvent__field_descriptor),
+           (Data.ProtoLens.Tag 9, settleEvent__field_descriptor),
+           (Data.ProtoLens.Tag 10, linkFailEvent__field_descriptor)]
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _HtlcEvent'_unknownFields
+        (\ x__ y__ -> x__ {_HtlcEvent'_unknownFields = y__})
+  defMessage
+    = HtlcEvent'_constructor
+        {_HtlcEvent'incomingChannelId = Data.ProtoLens.fieldDefault,
+         _HtlcEvent'outgoingChannelId = Data.ProtoLens.fieldDefault,
+         _HtlcEvent'incomingHtlcId = Data.ProtoLens.fieldDefault,
+         _HtlcEvent'outgoingHtlcId = Data.ProtoLens.fieldDefault,
+         _HtlcEvent'timestampNs = Data.ProtoLens.fieldDefault,
+         _HtlcEvent'eventType = Data.ProtoLens.fieldDefault,
+         _HtlcEvent'event = Prelude.Nothing, _HtlcEvent'_unknownFields = []}
+  parseMessage
+    = let
+        loop :: HtlcEvent -> Data.ProtoLens.Encoding.Bytes.Parser HtlcEvent
+        loop x
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of
+                        8 -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       Data.ProtoLens.Encoding.Bytes.getVarInt "incoming_channel_id"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"incomingChannelId") y x)
+                        16
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       Data.ProtoLens.Encoding.Bytes.getVarInt "outgoing_channel_id"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"outgoingChannelId") y x)
+                        24
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       Data.ProtoLens.Encoding.Bytes.getVarInt "incoming_htlc_id"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"incomingHtlcId") y x)
+                        32
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       Data.ProtoLens.Encoding.Bytes.getVarInt "outgoing_htlc_id"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"outgoingHtlcId") y x)
+                        40
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       Data.ProtoLens.Encoding.Bytes.getVarInt "timestamp_ns"
+                                loop
+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"timestampNs") y x)
+                        48
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          Prelude.toEnum
+                                          (Prelude.fmap
+                                             Prelude.fromIntegral
+                                             Data.ProtoLens.Encoding.Bytes.getVarInt))
+                                       "event_type"
+                                loop
+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"eventType") y x)
+                        58
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.isolate
+                                             (Prelude.fromIntegral len) Data.ProtoLens.parseMessage)
+                                       "forward_event"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"forwardEvent") y x)
+                        66
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.isolate
+                                             (Prelude.fromIntegral len) Data.ProtoLens.parseMessage)
+                                       "forward_fail_event"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"forwardFailEvent") y x)
+                        74
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.isolate
+                                             (Prelude.fromIntegral len) Data.ProtoLens.parseMessage)
+                                       "settle_event"
+                                loop
+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"settleEvent") y x)
+                        82
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.isolate
+                                             (Prelude.fromIntegral len) Data.ProtoLens.parseMessage)
+                                       "link_fail_event"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"linkFailEvent") y x)
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do loop Data.ProtoLens.defMessage) "HtlcEvent"
+  buildMessage
+    = \ _x
+        -> (Data.Monoid.<>)
+             (let
+                _v
+                  = Lens.Family2.view
+                      (Data.ProtoLens.Field.field @"incomingChannelId") _x
+              in
+                if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                    Data.Monoid.mempty
+                else
+                    (Data.Monoid.<>)
+                      (Data.ProtoLens.Encoding.Bytes.putVarInt 8)
+                      (Data.ProtoLens.Encoding.Bytes.putVarInt _v))
+             ((Data.Monoid.<>)
+                (let
+                   _v
+                     = Lens.Family2.view
+                         (Data.ProtoLens.Field.field @"outgoingChannelId") _x
+                 in
+                   if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                       Data.Monoid.mempty
+                   else
+                       (Data.Monoid.<>)
+                         (Data.ProtoLens.Encoding.Bytes.putVarInt 16)
+                         (Data.ProtoLens.Encoding.Bytes.putVarInt _v))
+                ((Data.Monoid.<>)
+                   (let
+                      _v
+                        = Lens.Family2.view
+                            (Data.ProtoLens.Field.field @"incomingHtlcId") _x
+                    in
+                      if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                          Data.Monoid.mempty
+                      else
+                          (Data.Monoid.<>)
+                            (Data.ProtoLens.Encoding.Bytes.putVarInt 24)
+                            (Data.ProtoLens.Encoding.Bytes.putVarInt _v))
+                   ((Data.Monoid.<>)
+                      (let
+                         _v
+                           = Lens.Family2.view
+                               (Data.ProtoLens.Field.field @"outgoingHtlcId") _x
+                       in
+                         if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                             Data.Monoid.mempty
+                         else
+                             (Data.Monoid.<>)
+                               (Data.ProtoLens.Encoding.Bytes.putVarInt 32)
+                               (Data.ProtoLens.Encoding.Bytes.putVarInt _v))
+                      ((Data.Monoid.<>)
+                         (let
+                            _v
+                              = Lens.Family2.view (Data.ProtoLens.Field.field @"timestampNs") _x
+                          in
+                            if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                                Data.Monoid.mempty
+                            else
+                                (Data.Monoid.<>)
+                                  (Data.ProtoLens.Encoding.Bytes.putVarInt 40)
+                                  (Data.ProtoLens.Encoding.Bytes.putVarInt _v))
+                         ((Data.Monoid.<>)
+                            (let
+                               _v = Lens.Family2.view (Data.ProtoLens.Field.field @"eventType") _x
+                             in
+                               if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                                   Data.Monoid.mempty
+                               else
+                                   (Data.Monoid.<>)
+                                     (Data.ProtoLens.Encoding.Bytes.putVarInt 48)
+                                     ((Prelude..)
+                                        ((Prelude..)
+                                           Data.ProtoLens.Encoding.Bytes.putVarInt
+                                           Prelude.fromIntegral)
+                                        Prelude.fromEnum
+                                        _v))
+                            ((Data.Monoid.<>)
+                               (case
+                                    Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'event") _x
+                                of
+                                  Prelude.Nothing -> Data.Monoid.mempty
+                                  (Prelude.Just (HtlcEvent'ForwardEvent v))
+                                    -> (Data.Monoid.<>)
+                                         (Data.ProtoLens.Encoding.Bytes.putVarInt 58)
+                                         ((Prelude..)
+                                            (\ bs
+                                               -> (Data.Monoid.<>)
+                                                    (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                                       (Prelude.fromIntegral
+                                                          (Data.ByteString.length bs)))
+                                                    (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                                            Data.ProtoLens.encodeMessage
+                                            v)
+                                  (Prelude.Just (HtlcEvent'ForwardFailEvent v))
+                                    -> (Data.Monoid.<>)
+                                         (Data.ProtoLens.Encoding.Bytes.putVarInt 66)
+                                         ((Prelude..)
+                                            (\ bs
+                                               -> (Data.Monoid.<>)
+                                                    (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                                       (Prelude.fromIntegral
+                                                          (Data.ByteString.length bs)))
+                                                    (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                                            Data.ProtoLens.encodeMessage
+                                            v)
+                                  (Prelude.Just (HtlcEvent'SettleEvent v))
+                                    -> (Data.Monoid.<>)
+                                         (Data.ProtoLens.Encoding.Bytes.putVarInt 74)
+                                         ((Prelude..)
+                                            (\ bs
+                                               -> (Data.Monoid.<>)
+                                                    (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                                       (Prelude.fromIntegral
+                                                          (Data.ByteString.length bs)))
+                                                    (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                                            Data.ProtoLens.encodeMessage
+                                            v)
+                                  (Prelude.Just (HtlcEvent'LinkFailEvent v))
+                                    -> (Data.Monoid.<>)
+                                         (Data.ProtoLens.Encoding.Bytes.putVarInt 82)
+                                         ((Prelude..)
+                                            (\ bs
+                                               -> (Data.Monoid.<>)
+                                                    (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                                       (Prelude.fromIntegral
+                                                          (Data.ByteString.length bs)))
+                                                    (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                                            Data.ProtoLens.encodeMessage
+                                            v))
+                               (Data.ProtoLens.Encoding.Wire.buildFieldSet
+                                  (Lens.Family2.view Data.ProtoLens.unknownFields _x))))))))
+instance Control.DeepSeq.NFData HtlcEvent where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_HtlcEvent'_unknownFields x__)
+             (Control.DeepSeq.deepseq
+                (_HtlcEvent'incomingChannelId x__)
+                (Control.DeepSeq.deepseq
+                   (_HtlcEvent'outgoingChannelId x__)
+                   (Control.DeepSeq.deepseq
+                      (_HtlcEvent'incomingHtlcId x__)
+                      (Control.DeepSeq.deepseq
+                         (_HtlcEvent'outgoingHtlcId x__)
+                         (Control.DeepSeq.deepseq
+                            (_HtlcEvent'timestampNs x__)
+                            (Control.DeepSeq.deepseq
+                               (_HtlcEvent'eventType x__)
+                               (Control.DeepSeq.deepseq (_HtlcEvent'event x__) ())))))))
+instance Control.DeepSeq.NFData HtlcEvent'Event where
+  rnf (HtlcEvent'ForwardEvent x__) = Control.DeepSeq.rnf x__
+  rnf (HtlcEvent'ForwardFailEvent x__) = Control.DeepSeq.rnf x__
+  rnf (HtlcEvent'SettleEvent x__) = Control.DeepSeq.rnf x__
+  rnf (HtlcEvent'LinkFailEvent x__) = Control.DeepSeq.rnf x__
+_HtlcEvent'ForwardEvent ::
+  Data.ProtoLens.Prism.Prism' HtlcEvent'Event ForwardEvent
+_HtlcEvent'ForwardEvent
+  = Data.ProtoLens.Prism.prism'
+      HtlcEvent'ForwardEvent
+      (\ p__
+         -> case p__ of
+              (HtlcEvent'ForwardEvent p__val) -> Prelude.Just p__val
+              _otherwise -> Prelude.Nothing)
+_HtlcEvent'ForwardFailEvent ::
+  Data.ProtoLens.Prism.Prism' HtlcEvent'Event ForwardFailEvent
+_HtlcEvent'ForwardFailEvent
+  = Data.ProtoLens.Prism.prism'
+      HtlcEvent'ForwardFailEvent
+      (\ p__
+         -> case p__ of
+              (HtlcEvent'ForwardFailEvent p__val) -> Prelude.Just p__val
+              _otherwise -> Prelude.Nothing)
+_HtlcEvent'SettleEvent ::
+  Data.ProtoLens.Prism.Prism' HtlcEvent'Event SettleEvent
+_HtlcEvent'SettleEvent
+  = Data.ProtoLens.Prism.prism'
+      HtlcEvent'SettleEvent
+      (\ p__
+         -> case p__ of
+              (HtlcEvent'SettleEvent p__val) -> Prelude.Just p__val
+              _otherwise -> Prelude.Nothing)
+_HtlcEvent'LinkFailEvent ::
+  Data.ProtoLens.Prism.Prism' HtlcEvent'Event LinkFailEvent
+_HtlcEvent'LinkFailEvent
+  = Data.ProtoLens.Prism.prism'
+      HtlcEvent'LinkFailEvent
+      (\ p__
+         -> case p__ of
+              (HtlcEvent'LinkFailEvent p__val) -> Prelude.Just p__val
+              _otherwise -> Prelude.Nothing)
+newtype HtlcEvent'EventType'UnrecognizedValue
+  = HtlcEvent'EventType'UnrecognizedValue Data.Int.Int32
+  deriving stock (Prelude.Eq, Prelude.Ord, Prelude.Show)
+data HtlcEvent'EventType
+  = HtlcEvent'UNKNOWN |
+    HtlcEvent'SEND |
+    HtlcEvent'RECEIVE |
+    HtlcEvent'FORWARD |
+    HtlcEvent'EventType'Unrecognized !HtlcEvent'EventType'UnrecognizedValue
+  deriving stock (Prelude.Show, Prelude.Eq, Prelude.Ord)
+instance Data.ProtoLens.MessageEnum HtlcEvent'EventType where
+  maybeToEnum 0 = Prelude.Just HtlcEvent'UNKNOWN
+  maybeToEnum 1 = Prelude.Just HtlcEvent'SEND
+  maybeToEnum 2 = Prelude.Just HtlcEvent'RECEIVE
+  maybeToEnum 3 = Prelude.Just HtlcEvent'FORWARD
+  maybeToEnum k
+    = Prelude.Just
+        (HtlcEvent'EventType'Unrecognized
+           (HtlcEvent'EventType'UnrecognizedValue (Prelude.fromIntegral k)))
+  showEnum HtlcEvent'UNKNOWN = "UNKNOWN"
+  showEnum HtlcEvent'SEND = "SEND"
+  showEnum HtlcEvent'RECEIVE = "RECEIVE"
+  showEnum HtlcEvent'FORWARD = "FORWARD"
+  showEnum
+    (HtlcEvent'EventType'Unrecognized (HtlcEvent'EventType'UnrecognizedValue k))
+    = Prelude.show k
+  readEnum k
+    | (Prelude.==) k "UNKNOWN" = Prelude.Just HtlcEvent'UNKNOWN
+    | (Prelude.==) k "SEND" = Prelude.Just HtlcEvent'SEND
+    | (Prelude.==) k "RECEIVE" = Prelude.Just HtlcEvent'RECEIVE
+    | (Prelude.==) k "FORWARD" = Prelude.Just HtlcEvent'FORWARD
+    | Prelude.otherwise
+    = (Prelude.>>=) (Text.Read.readMaybe k) Data.ProtoLens.maybeToEnum
+instance Prelude.Bounded HtlcEvent'EventType where
+  minBound = HtlcEvent'UNKNOWN
+  maxBound = HtlcEvent'FORWARD
+instance Prelude.Enum HtlcEvent'EventType where
+  toEnum k__
+    = Prelude.maybe
+        (Prelude.error
+           ((Prelude.++)
+              "toEnum: unknown value for enum EventType: " (Prelude.show k__)))
+        Prelude.id
+        (Data.ProtoLens.maybeToEnum k__)
+  fromEnum HtlcEvent'UNKNOWN = 0
+  fromEnum HtlcEvent'SEND = 1
+  fromEnum HtlcEvent'RECEIVE = 2
+  fromEnum HtlcEvent'FORWARD = 3
+  fromEnum
+    (HtlcEvent'EventType'Unrecognized (HtlcEvent'EventType'UnrecognizedValue k))
+    = Prelude.fromIntegral k
+  succ HtlcEvent'FORWARD
+    = Prelude.error
+        "HtlcEvent'EventType.succ: bad argument HtlcEvent'FORWARD. This value would be out of bounds."
+  succ HtlcEvent'UNKNOWN = HtlcEvent'SEND
+  succ HtlcEvent'SEND = HtlcEvent'RECEIVE
+  succ HtlcEvent'RECEIVE = HtlcEvent'FORWARD
+  succ (HtlcEvent'EventType'Unrecognized _)
+    = Prelude.error
+        "HtlcEvent'EventType.succ: bad argument: unrecognized value"
+  pred HtlcEvent'UNKNOWN
+    = Prelude.error
+        "HtlcEvent'EventType.pred: bad argument HtlcEvent'UNKNOWN. This value would be out of bounds."
+  pred HtlcEvent'SEND = HtlcEvent'UNKNOWN
+  pred HtlcEvent'RECEIVE = HtlcEvent'SEND
+  pred HtlcEvent'FORWARD = HtlcEvent'RECEIVE
+  pred (HtlcEvent'EventType'Unrecognized _)
+    = Prelude.error
+        "HtlcEvent'EventType.pred: bad argument: unrecognized value"
+  enumFrom = Data.ProtoLens.Message.Enum.messageEnumFrom
+  enumFromTo = Data.ProtoLens.Message.Enum.messageEnumFromTo
+  enumFromThen = Data.ProtoLens.Message.Enum.messageEnumFromThen
+  enumFromThenTo = Data.ProtoLens.Message.Enum.messageEnumFromThenTo
+instance Data.ProtoLens.FieldDefault HtlcEvent'EventType where
+  fieldDefault = HtlcEvent'UNKNOWN
+instance Control.DeepSeq.NFData HtlcEvent'EventType where
+  rnf x__ = Prelude.seq x__ ()
+{- | Fields :
+     
+         * 'Proto.RouterGrpc_Fields.incomingTimelock' @:: Lens' HtlcInfo Data.Word.Word32@
+         * 'Proto.RouterGrpc_Fields.outgoingTimelock' @:: Lens' HtlcInfo Data.Word.Word32@
+         * 'Proto.RouterGrpc_Fields.incomingAmtMsat' @:: Lens' HtlcInfo Data.Word.Word64@
+         * 'Proto.RouterGrpc_Fields.outgoingAmtMsat' @:: Lens' HtlcInfo Data.Word.Word64@ -}
+data HtlcInfo
+  = HtlcInfo'_constructor {_HtlcInfo'incomingTimelock :: !Data.Word.Word32,
+                           _HtlcInfo'outgoingTimelock :: !Data.Word.Word32,
+                           _HtlcInfo'incomingAmtMsat :: !Data.Word.Word64,
+                           _HtlcInfo'outgoingAmtMsat :: !Data.Word.Word64,
+                           _HtlcInfo'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show HtlcInfo where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Field.HasField HtlcInfo "incomingTimelock" Data.Word.Word32 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _HtlcInfo'incomingTimelock
+           (\ x__ y__ -> x__ {_HtlcInfo'incomingTimelock = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField HtlcInfo "outgoingTimelock" Data.Word.Word32 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _HtlcInfo'outgoingTimelock
+           (\ x__ y__ -> x__ {_HtlcInfo'outgoingTimelock = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField HtlcInfo "incomingAmtMsat" Data.Word.Word64 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _HtlcInfo'incomingAmtMsat
+           (\ x__ y__ -> x__ {_HtlcInfo'incomingAmtMsat = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField HtlcInfo "outgoingAmtMsat" Data.Word.Word64 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _HtlcInfo'outgoingAmtMsat
+           (\ x__ y__ -> x__ {_HtlcInfo'outgoingAmtMsat = y__}))
+        Prelude.id
+instance Data.ProtoLens.Message HtlcInfo where
+  messageName _ = Data.Text.pack "routerrpc.HtlcInfo"
+  packedMessageDescriptor _
+    = "\n\
+      \\bHtlcInfo\DC2+\n\
+      \\DC1incoming_timelock\CAN\SOH \SOH(\rR\DLEincomingTimelock\DC2+\n\
+      \\DC1outgoing_timelock\CAN\STX \SOH(\rR\DLEoutgoingTimelock\DC2*\n\
+      \\DC1incoming_amt_msat\CAN\ETX \SOH(\EOTR\SIincomingAmtMsat\DC2*\n\
+      \\DC1outgoing_amt_msat\CAN\EOT \SOH(\EOTR\SIoutgoingAmtMsat"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag
+    = let
+        incomingTimelock__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "incoming_timelock"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.UInt32Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Word.Word32)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"incomingTimelock")) ::
+              Data.ProtoLens.FieldDescriptor HtlcInfo
+        outgoingTimelock__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "outgoing_timelock"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.UInt32Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Word.Word32)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"outgoingTimelock")) ::
+              Data.ProtoLens.FieldDescriptor HtlcInfo
+        incomingAmtMsat__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "incoming_amt_msat"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.UInt64Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Word.Word64)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"incomingAmtMsat")) ::
+              Data.ProtoLens.FieldDescriptor HtlcInfo
+        outgoingAmtMsat__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "outgoing_amt_msat"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.UInt64Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Word.Word64)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"outgoingAmtMsat")) ::
+              Data.ProtoLens.FieldDescriptor HtlcInfo
+      in
+        Data.Map.fromList
+          [(Data.ProtoLens.Tag 1, incomingTimelock__field_descriptor),
+           (Data.ProtoLens.Tag 2, outgoingTimelock__field_descriptor),
+           (Data.ProtoLens.Tag 3, incomingAmtMsat__field_descriptor),
+           (Data.ProtoLens.Tag 4, outgoingAmtMsat__field_descriptor)]
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _HtlcInfo'_unknownFields
+        (\ x__ y__ -> x__ {_HtlcInfo'_unknownFields = y__})
+  defMessage
+    = HtlcInfo'_constructor
+        {_HtlcInfo'incomingTimelock = Data.ProtoLens.fieldDefault,
+         _HtlcInfo'outgoingTimelock = Data.ProtoLens.fieldDefault,
+         _HtlcInfo'incomingAmtMsat = Data.ProtoLens.fieldDefault,
+         _HtlcInfo'outgoingAmtMsat = Data.ProtoLens.fieldDefault,
+         _HtlcInfo'_unknownFields = []}
+  parseMessage
+    = let
+        loop :: HtlcInfo -> Data.ProtoLens.Encoding.Bytes.Parser HtlcInfo
+        loop x
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of
+                        8 -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          Prelude.fromIntegral
+                                          Data.ProtoLens.Encoding.Bytes.getVarInt)
+                                       "incoming_timelock"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"incomingTimelock") y x)
+                        16
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          Prelude.fromIntegral
+                                          Data.ProtoLens.Encoding.Bytes.getVarInt)
+                                       "outgoing_timelock"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"outgoingTimelock") y x)
+                        24
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       Data.ProtoLens.Encoding.Bytes.getVarInt "incoming_amt_msat"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"incomingAmtMsat") y x)
+                        32
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       Data.ProtoLens.Encoding.Bytes.getVarInt "outgoing_amt_msat"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"outgoingAmtMsat") y x)
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do loop Data.ProtoLens.defMessage) "HtlcInfo"
+  buildMessage
+    = \ _x
+        -> (Data.Monoid.<>)
+             (let
+                _v
+                  = Lens.Family2.view
+                      (Data.ProtoLens.Field.field @"incomingTimelock") _x
+              in
+                if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                    Data.Monoid.mempty
+                else
+                    (Data.Monoid.<>)
+                      (Data.ProtoLens.Encoding.Bytes.putVarInt 8)
+                      ((Prelude..)
+                         Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v))
+             ((Data.Monoid.<>)
+                (let
+                   _v
+                     = Lens.Family2.view
+                         (Data.ProtoLens.Field.field @"outgoingTimelock") _x
+                 in
+                   if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                       Data.Monoid.mempty
+                   else
+                       (Data.Monoid.<>)
+                         (Data.ProtoLens.Encoding.Bytes.putVarInt 16)
+                         ((Prelude..)
+                            Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v))
+                ((Data.Monoid.<>)
+                   (let
+                      _v
+                        = Lens.Family2.view
+                            (Data.ProtoLens.Field.field @"incomingAmtMsat") _x
+                    in
+                      if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                          Data.Monoid.mempty
+                      else
+                          (Data.Monoid.<>)
+                            (Data.ProtoLens.Encoding.Bytes.putVarInt 24)
+                            (Data.ProtoLens.Encoding.Bytes.putVarInt _v))
+                   ((Data.Monoid.<>)
+                      (let
+                         _v
+                           = Lens.Family2.view
+                               (Data.ProtoLens.Field.field @"outgoingAmtMsat") _x
+                       in
+                         if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                             Data.Monoid.mempty
+                         else
+                             (Data.Monoid.<>)
+                               (Data.ProtoLens.Encoding.Bytes.putVarInt 32)
+                               (Data.ProtoLens.Encoding.Bytes.putVarInt _v))
+                      (Data.ProtoLens.Encoding.Wire.buildFieldSet
+                         (Lens.Family2.view Data.ProtoLens.unknownFields _x)))))
+instance Control.DeepSeq.NFData HtlcInfo where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_HtlcInfo'_unknownFields x__)
+             (Control.DeepSeq.deepseq
+                (_HtlcInfo'incomingTimelock x__)
+                (Control.DeepSeq.deepseq
+                   (_HtlcInfo'outgoingTimelock x__)
+                   (Control.DeepSeq.deepseq
+                      (_HtlcInfo'incomingAmtMsat x__)
+                      (Control.DeepSeq.deepseq (_HtlcInfo'outgoingAmtMsat x__) ()))))
+{- | Fields :
+     
+         * 'Proto.RouterGrpc_Fields.info' @:: Lens' LinkFailEvent HtlcInfo@
+         * 'Proto.RouterGrpc_Fields.maybe'info' @:: Lens' LinkFailEvent (Prelude.Maybe HtlcInfo)@
+         * 'Proto.RouterGrpc_Fields.wireFailure' @:: Lens' LinkFailEvent Proto.LndGrpc.Failure'FailureCode@
+         * 'Proto.RouterGrpc_Fields.failureDetail' @:: Lens' LinkFailEvent FailureDetail@
+         * 'Proto.RouterGrpc_Fields.failureString' @:: Lens' LinkFailEvent Data.Text.Text@ -}
+data LinkFailEvent
+  = LinkFailEvent'_constructor {_LinkFailEvent'info :: !(Prelude.Maybe HtlcInfo),
+                                _LinkFailEvent'wireFailure :: !Proto.LndGrpc.Failure'FailureCode,
+                                _LinkFailEvent'failureDetail :: !FailureDetail,
+                                _LinkFailEvent'failureString :: !Data.Text.Text,
+                                _LinkFailEvent'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show LinkFailEvent where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Field.HasField LinkFailEvent "info" HtlcInfo where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _LinkFailEvent'info (\ x__ y__ -> x__ {_LinkFailEvent'info = y__}))
+        (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage)
+instance Data.ProtoLens.Field.HasField LinkFailEvent "maybe'info" (Prelude.Maybe HtlcInfo) where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _LinkFailEvent'info (\ x__ y__ -> x__ {_LinkFailEvent'info = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField LinkFailEvent "wireFailure" Proto.LndGrpc.Failure'FailureCode where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _LinkFailEvent'wireFailure
+           (\ x__ y__ -> x__ {_LinkFailEvent'wireFailure = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField LinkFailEvent "failureDetail" FailureDetail where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _LinkFailEvent'failureDetail
+           (\ x__ y__ -> x__ {_LinkFailEvent'failureDetail = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField LinkFailEvent "failureString" Data.Text.Text where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _LinkFailEvent'failureString
+           (\ x__ y__ -> x__ {_LinkFailEvent'failureString = y__}))
+        Prelude.id
+instance Data.ProtoLens.Message LinkFailEvent where
+  messageName _ = Data.Text.pack "routerrpc.LinkFailEvent"
+  packedMessageDescriptor _
+    = "\n\
+      \\rLinkFailEvent\DC2'\n\
+      \\EOTinfo\CAN\SOH \SOH(\v2\DC3.routerrpc.HtlcInfoR\EOTinfo\DC2=\n\
+      \\fwire_failure\CAN\STX \SOH(\SO2\SUB.lnrpc.Failure.FailureCodeR\vwireFailure\DC2?\n\
+      \\SOfailure_detail\CAN\ETX \SOH(\SO2\CAN.routerrpc.FailureDetailR\rfailureDetail\DC2%\n\
+      \\SOfailure_string\CAN\EOT \SOH(\tR\rfailureString"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag
+    = let
+        info__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "info"
+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
+                 Data.ProtoLens.FieldTypeDescriptor HtlcInfo)
+              (Data.ProtoLens.OptionalField
+                 (Data.ProtoLens.Field.field @"maybe'info")) ::
+              Data.ProtoLens.FieldDescriptor LinkFailEvent
+        wireFailure__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "wire_failure"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField ::
+                 Data.ProtoLens.FieldTypeDescriptor Proto.LndGrpc.Failure'FailureCode)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"wireFailure")) ::
+              Data.ProtoLens.FieldDescriptor LinkFailEvent
+        failureDetail__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "failure_detail"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField ::
+                 Data.ProtoLens.FieldTypeDescriptor FailureDetail)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"failureDetail")) ::
+              Data.ProtoLens.FieldDescriptor LinkFailEvent
+        failureString__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "failure_string"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"failureString")) ::
+              Data.ProtoLens.FieldDescriptor LinkFailEvent
+      in
+        Data.Map.fromList
+          [(Data.ProtoLens.Tag 1, info__field_descriptor),
+           (Data.ProtoLens.Tag 2, wireFailure__field_descriptor),
+           (Data.ProtoLens.Tag 3, failureDetail__field_descriptor),
+           (Data.ProtoLens.Tag 4, failureString__field_descriptor)]
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _LinkFailEvent'_unknownFields
+        (\ x__ y__ -> x__ {_LinkFailEvent'_unknownFields = y__})
+  defMessage
+    = LinkFailEvent'_constructor
+        {_LinkFailEvent'info = Prelude.Nothing,
+         _LinkFailEvent'wireFailure = Data.ProtoLens.fieldDefault,
+         _LinkFailEvent'failureDetail = Data.ProtoLens.fieldDefault,
+         _LinkFailEvent'failureString = Data.ProtoLens.fieldDefault,
+         _LinkFailEvent'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          LinkFailEvent -> Data.ProtoLens.Encoding.Bytes.Parser LinkFailEvent
+        loop x
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of
+                        10
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.isolate
+                                             (Prelude.fromIntegral len) Data.ProtoLens.parseMessage)
+                                       "info"
+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"info") y x)
+                        16
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          Prelude.toEnum
+                                          (Prelude.fmap
+                                             Prelude.fromIntegral
+                                             Data.ProtoLens.Encoding.Bytes.getVarInt))
+                                       "wire_failure"
+                                loop
+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"wireFailure") y x)
+                        24
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          Prelude.toEnum
+                                          (Prelude.fmap
+                                             Prelude.fromIntegral
+                                             Data.ProtoLens.Encoding.Bytes.getVarInt))
+                                       "failure_detail"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"failureDetail") y x)
+                        34
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                                       Data.ProtoLens.Encoding.Bytes.getBytes
+                                                         (Prelude.fromIntegral len)
+                                           Data.ProtoLens.Encoding.Bytes.runEither
+                                             (case Data.Text.Encoding.decodeUtf8' value of
+                                                (Prelude.Left err)
+                                                  -> Prelude.Left (Prelude.show err)
+                                                (Prelude.Right r) -> Prelude.Right r))
+                                       "failure_string"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"failureString") y x)
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do loop Data.ProtoLens.defMessage) "LinkFailEvent"
+  buildMessage
+    = \ _x
+        -> (Data.Monoid.<>)
+             (case
+                  Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'info") _x
+              of
+                Prelude.Nothing -> Data.Monoid.mempty
+                (Prelude.Just _v)
+                  -> (Data.Monoid.<>)
+                       (Data.ProtoLens.Encoding.Bytes.putVarInt 10)
+                       ((Prelude..)
+                          (\ bs
+                             -> (Data.Monoid.<>)
+                                  (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                     (Prelude.fromIntegral (Data.ByteString.length bs)))
+                                  (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                          Data.ProtoLens.encodeMessage
+                          _v))
+             ((Data.Monoid.<>)
+                (let
+                   _v
+                     = Lens.Family2.view (Data.ProtoLens.Field.field @"wireFailure") _x
+                 in
+                   if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                       Data.Monoid.mempty
+                   else
+                       (Data.Monoid.<>)
+                         (Data.ProtoLens.Encoding.Bytes.putVarInt 16)
+                         ((Prelude..)
+                            ((Prelude..)
+                               Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral)
+                            Prelude.fromEnum
+                            _v))
+                ((Data.Monoid.<>)
+                   (let
+                      _v
+                        = Lens.Family2.view
+                            (Data.ProtoLens.Field.field @"failureDetail") _x
+                    in
+                      if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                          Data.Monoid.mempty
+                      else
+                          (Data.Monoid.<>)
+                            (Data.ProtoLens.Encoding.Bytes.putVarInt 24)
+                            ((Prelude..)
+                               ((Prelude..)
+                                  Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral)
+                               Prelude.fromEnum
+                               _v))
+                   ((Data.Monoid.<>)
+                      (let
+                         _v
+                           = Lens.Family2.view
+                               (Data.ProtoLens.Field.field @"failureString") _x
+                       in
+                         if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                             Data.Monoid.mempty
+                         else
+                             (Data.Monoid.<>)
+                               (Data.ProtoLens.Encoding.Bytes.putVarInt 34)
+                               ((Prelude..)
+                                  (\ bs
+                                     -> (Data.Monoid.<>)
+                                          (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                             (Prelude.fromIntegral (Data.ByteString.length bs)))
+                                          (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                                  Data.Text.Encoding.encodeUtf8
+                                  _v))
+                      (Data.ProtoLens.Encoding.Wire.buildFieldSet
+                         (Lens.Family2.view Data.ProtoLens.unknownFields _x)))))
+instance Control.DeepSeq.NFData LinkFailEvent where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_LinkFailEvent'_unknownFields x__)
+             (Control.DeepSeq.deepseq
+                (_LinkFailEvent'info x__)
+                (Control.DeepSeq.deepseq
+                   (_LinkFailEvent'wireFailure x__)
+                   (Control.DeepSeq.deepseq
+                      (_LinkFailEvent'failureDetail x__)
+                      (Control.DeepSeq.deepseq (_LinkFailEvent'failureString x__) ()))))
+{- | Fields :
+     
+         * 'Proto.RouterGrpc_Fields.halfLifeSeconds' @:: Lens' MissionControlConfig Data.Word.Word64@
+         * 'Proto.RouterGrpc_Fields.hopProbability' @:: Lens' MissionControlConfig Prelude.Float@
+         * 'Proto.RouterGrpc_Fields.weight' @:: Lens' MissionControlConfig Prelude.Float@
+         * 'Proto.RouterGrpc_Fields.maximumPaymentResults' @:: Lens' MissionControlConfig Data.Word.Word32@
+         * 'Proto.RouterGrpc_Fields.minimumFailureRelaxInterval' @:: Lens' MissionControlConfig Data.Word.Word64@ -}
+data MissionControlConfig
+  = MissionControlConfig'_constructor {_MissionControlConfig'halfLifeSeconds :: !Data.Word.Word64,
+                                       _MissionControlConfig'hopProbability :: !Prelude.Float,
+                                       _MissionControlConfig'weight :: !Prelude.Float,
+                                       _MissionControlConfig'maximumPaymentResults :: !Data.Word.Word32,
+                                       _MissionControlConfig'minimumFailureRelaxInterval :: !Data.Word.Word64,
+                                       _MissionControlConfig'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show MissionControlConfig where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Field.HasField MissionControlConfig "halfLifeSeconds" Data.Word.Word64 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _MissionControlConfig'halfLifeSeconds
+           (\ x__ y__ -> x__ {_MissionControlConfig'halfLifeSeconds = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField MissionControlConfig "hopProbability" Prelude.Float where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _MissionControlConfig'hopProbability
+           (\ x__ y__ -> x__ {_MissionControlConfig'hopProbability = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField MissionControlConfig "weight" Prelude.Float where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _MissionControlConfig'weight
+           (\ x__ y__ -> x__ {_MissionControlConfig'weight = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField MissionControlConfig "maximumPaymentResults" Data.Word.Word32 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _MissionControlConfig'maximumPaymentResults
+           (\ x__ y__
+              -> x__ {_MissionControlConfig'maximumPaymentResults = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField MissionControlConfig "minimumFailureRelaxInterval" Data.Word.Word64 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _MissionControlConfig'minimumFailureRelaxInterval
+           (\ x__ y__
+              -> x__ {_MissionControlConfig'minimumFailureRelaxInterval = y__}))
+        Prelude.id
+instance Data.ProtoLens.Message MissionControlConfig where
+  messageName _ = Data.Text.pack "routerrpc.MissionControlConfig"
+  packedMessageDescriptor _
+    = "\n\
+      \\DC4MissionControlConfig\DC2*\n\
+      \\DC1half_life_seconds\CAN\SOH \SOH(\EOTR\SIhalfLifeSeconds\DC2'\n\
+      \\SIhop_probability\CAN\STX \SOH(\STXR\SOhopProbability\DC2\SYN\n\
+      \\ACKweight\CAN\ETX \SOH(\STXR\ACKweight\DC26\n\
+      \\ETBmaximum_payment_results\CAN\EOT \SOH(\rR\NAKmaximumPaymentResults\DC2C\n\
+      \\RSminimum_failure_relax_interval\CAN\ENQ \SOH(\EOTR\ESCminimumFailureRelaxInterval"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag
+    = let
+        halfLifeSeconds__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "half_life_seconds"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.UInt64Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Word.Word64)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"halfLifeSeconds")) ::
+              Data.ProtoLens.FieldDescriptor MissionControlConfig
+        hopProbability__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "hop_probability"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.FloatField ::
+                 Data.ProtoLens.FieldTypeDescriptor Prelude.Float)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"hopProbability")) ::
+              Data.ProtoLens.FieldDescriptor MissionControlConfig
+        weight__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "weight"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.FloatField ::
+                 Data.ProtoLens.FieldTypeDescriptor Prelude.Float)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional (Data.ProtoLens.Field.field @"weight")) ::
+              Data.ProtoLens.FieldDescriptor MissionControlConfig
+        maximumPaymentResults__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "maximum_payment_results"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.UInt32Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Word.Word32)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"maximumPaymentResults")) ::
+              Data.ProtoLens.FieldDescriptor MissionControlConfig
+        minimumFailureRelaxInterval__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "minimum_failure_relax_interval"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.UInt64Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Word.Word64)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"minimumFailureRelaxInterval")) ::
+              Data.ProtoLens.FieldDescriptor MissionControlConfig
+      in
+        Data.Map.fromList
+          [(Data.ProtoLens.Tag 1, halfLifeSeconds__field_descriptor),
+           (Data.ProtoLens.Tag 2, hopProbability__field_descriptor),
+           (Data.ProtoLens.Tag 3, weight__field_descriptor),
+           (Data.ProtoLens.Tag 4, maximumPaymentResults__field_descriptor),
+           (Data.ProtoLens.Tag 5, 
+            minimumFailureRelaxInterval__field_descriptor)]
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _MissionControlConfig'_unknownFields
+        (\ x__ y__ -> x__ {_MissionControlConfig'_unknownFields = y__})
+  defMessage
+    = MissionControlConfig'_constructor
+        {_MissionControlConfig'halfLifeSeconds = Data.ProtoLens.fieldDefault,
+         _MissionControlConfig'hopProbability = Data.ProtoLens.fieldDefault,
+         _MissionControlConfig'weight = Data.ProtoLens.fieldDefault,
+         _MissionControlConfig'maximumPaymentResults = Data.ProtoLens.fieldDefault,
+         _MissionControlConfig'minimumFailureRelaxInterval = Data.ProtoLens.fieldDefault,
+         _MissionControlConfig'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          MissionControlConfig
+          -> Data.ProtoLens.Encoding.Bytes.Parser MissionControlConfig
+        loop x
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of
+                        8 -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       Data.ProtoLens.Encoding.Bytes.getVarInt "half_life_seconds"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"halfLifeSeconds") y x)
+                        21
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          Data.ProtoLens.Encoding.Bytes.wordToFloat
+                                          Data.ProtoLens.Encoding.Bytes.getFixed32)
+                                       "hop_probability"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"hopProbability") y x)
+                        29
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          Data.ProtoLens.Encoding.Bytes.wordToFloat
+                                          Data.ProtoLens.Encoding.Bytes.getFixed32)
+                                       "weight"
+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"weight") y x)
+                        32
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          Prelude.fromIntegral
+                                          Data.ProtoLens.Encoding.Bytes.getVarInt)
+                                       "maximum_payment_results"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"maximumPaymentResults") y x)
+                        40
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       Data.ProtoLens.Encoding.Bytes.getVarInt
+                                       "minimum_failure_relax_interval"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"minimumFailureRelaxInterval")
+                                     y
+                                     x)
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do loop Data.ProtoLens.defMessage) "MissionControlConfig"
+  buildMessage
+    = \ _x
+        -> (Data.Monoid.<>)
+             (let
+                _v
+                  = Lens.Family2.view
+                      (Data.ProtoLens.Field.field @"halfLifeSeconds") _x
+              in
+                if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                    Data.Monoid.mempty
+                else
+                    (Data.Monoid.<>)
+                      (Data.ProtoLens.Encoding.Bytes.putVarInt 8)
+                      (Data.ProtoLens.Encoding.Bytes.putVarInt _v))
+             ((Data.Monoid.<>)
+                (let
+                   _v
+                     = Lens.Family2.view
+                         (Data.ProtoLens.Field.field @"hopProbability") _x
+                 in
+                   if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                       Data.Monoid.mempty
+                   else
+                       (Data.Monoid.<>)
+                         (Data.ProtoLens.Encoding.Bytes.putVarInt 21)
+                         ((Prelude..)
+                            Data.ProtoLens.Encoding.Bytes.putFixed32
+                            Data.ProtoLens.Encoding.Bytes.floatToWord
+                            _v))
+                ((Data.Monoid.<>)
+                   (let
+                      _v = Lens.Family2.view (Data.ProtoLens.Field.field @"weight") _x
+                    in
+                      if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                          Data.Monoid.mempty
+                      else
+                          (Data.Monoid.<>)
+                            (Data.ProtoLens.Encoding.Bytes.putVarInt 29)
+                            ((Prelude..)
+                               Data.ProtoLens.Encoding.Bytes.putFixed32
+                               Data.ProtoLens.Encoding.Bytes.floatToWord
+                               _v))
+                   ((Data.Monoid.<>)
+                      (let
+                         _v
+                           = Lens.Family2.view
+                               (Data.ProtoLens.Field.field @"maximumPaymentResults") _x
+                       in
+                         if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                             Data.Monoid.mempty
+                         else
+                             (Data.Monoid.<>)
+                               (Data.ProtoLens.Encoding.Bytes.putVarInt 32)
+                               ((Prelude..)
+                                  Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v))
+                      ((Data.Monoid.<>)
+                         (let
+                            _v
+                              = Lens.Family2.view
+                                  (Data.ProtoLens.Field.field @"minimumFailureRelaxInterval") _x
+                          in
+                            if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                                Data.Monoid.mempty
+                            else
+                                (Data.Monoid.<>)
+                                  (Data.ProtoLens.Encoding.Bytes.putVarInt 40)
+                                  (Data.ProtoLens.Encoding.Bytes.putVarInt _v))
+                         (Data.ProtoLens.Encoding.Wire.buildFieldSet
+                            (Lens.Family2.view Data.ProtoLens.unknownFields _x))))))
+instance Control.DeepSeq.NFData MissionControlConfig where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_MissionControlConfig'_unknownFields x__)
+             (Control.DeepSeq.deepseq
+                (_MissionControlConfig'halfLifeSeconds x__)
+                (Control.DeepSeq.deepseq
+                   (_MissionControlConfig'hopProbability x__)
+                   (Control.DeepSeq.deepseq
+                      (_MissionControlConfig'weight x__)
+                      (Control.DeepSeq.deepseq
+                         (_MissionControlConfig'maximumPaymentResults x__)
+                         (Control.DeepSeq.deepseq
+                            (_MissionControlConfig'minimumFailureRelaxInterval x__) ())))))
+{- | Fields :
+     
+         * 'Proto.RouterGrpc_Fields.failTime' @:: Lens' PairData Data.Int.Int64@
+         * 'Proto.RouterGrpc_Fields.failAmtSat' @:: Lens' PairData Data.Int.Int64@
+         * 'Proto.RouterGrpc_Fields.failAmtMsat' @:: Lens' PairData Data.Int.Int64@
+         * 'Proto.RouterGrpc_Fields.successTime' @:: Lens' PairData Data.Int.Int64@
+         * 'Proto.RouterGrpc_Fields.successAmtSat' @:: Lens' PairData Data.Int.Int64@
+         * 'Proto.RouterGrpc_Fields.successAmtMsat' @:: Lens' PairData Data.Int.Int64@ -}
+data PairData
+  = PairData'_constructor {_PairData'failTime :: !Data.Int.Int64,
+                           _PairData'failAmtSat :: !Data.Int.Int64,
+                           _PairData'failAmtMsat :: !Data.Int.Int64,
+                           _PairData'successTime :: !Data.Int.Int64,
+                           _PairData'successAmtSat :: !Data.Int.Int64,
+                           _PairData'successAmtMsat :: !Data.Int.Int64,
+                           _PairData'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show PairData where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Field.HasField PairData "failTime" Data.Int.Int64 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _PairData'failTime (\ x__ y__ -> x__ {_PairData'failTime = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField PairData "failAmtSat" Data.Int.Int64 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _PairData'failAmtSat
+           (\ x__ y__ -> x__ {_PairData'failAmtSat = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField PairData "failAmtMsat" Data.Int.Int64 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _PairData'failAmtMsat
+           (\ x__ y__ -> x__ {_PairData'failAmtMsat = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField PairData "successTime" Data.Int.Int64 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _PairData'successTime
+           (\ x__ y__ -> x__ {_PairData'successTime = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField PairData "successAmtSat" Data.Int.Int64 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _PairData'successAmtSat
+           (\ x__ y__ -> x__ {_PairData'successAmtSat = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField PairData "successAmtMsat" Data.Int.Int64 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _PairData'successAmtMsat
+           (\ x__ y__ -> x__ {_PairData'successAmtMsat = y__}))
+        Prelude.id
+instance Data.ProtoLens.Message PairData where
+  messageName _ = Data.Text.pack "routerrpc.PairData"
+  packedMessageDescriptor _
+    = "\n\
+      \\bPairData\DC2\ESC\n\
+      \\tfail_time\CAN\SOH \SOH(\ETXR\bfailTime\DC2 \n\
+      \\ffail_amt_sat\CAN\STX \SOH(\ETXR\n\
+      \failAmtSat\DC2\"\n\
+      \\rfail_amt_msat\CAN\EOT \SOH(\ETXR\vfailAmtMsat\DC2!\n\
+      \\fsuccess_time\CAN\ENQ \SOH(\ETXR\vsuccessTime\DC2&\n\
+      \\SIsuccess_amt_sat\CAN\ACK \SOH(\ETXR\rsuccessAmtSat\DC2(\n\
+      \\DLEsuccess_amt_msat\CAN\a \SOH(\ETXR\SOsuccessAmtMsatJ\EOT\b\ETX\DLE\EOT"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag
+    = let
+        failTime__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "fail_time"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.Int64Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"failTime")) ::
+              Data.ProtoLens.FieldDescriptor PairData
+        failAmtSat__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "fail_amt_sat"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.Int64Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"failAmtSat")) ::
+              Data.ProtoLens.FieldDescriptor PairData
+        failAmtMsat__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "fail_amt_msat"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.Int64Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"failAmtMsat")) ::
+              Data.ProtoLens.FieldDescriptor PairData
+        successTime__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "success_time"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.Int64Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"successTime")) ::
+              Data.ProtoLens.FieldDescriptor PairData
+        successAmtSat__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "success_amt_sat"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.Int64Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"successAmtSat")) ::
+              Data.ProtoLens.FieldDescriptor PairData
+        successAmtMsat__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "success_amt_msat"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.Int64Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"successAmtMsat")) ::
+              Data.ProtoLens.FieldDescriptor PairData
+      in
+        Data.Map.fromList
+          [(Data.ProtoLens.Tag 1, failTime__field_descriptor),
+           (Data.ProtoLens.Tag 2, failAmtSat__field_descriptor),
+           (Data.ProtoLens.Tag 4, failAmtMsat__field_descriptor),
+           (Data.ProtoLens.Tag 5, successTime__field_descriptor),
+           (Data.ProtoLens.Tag 6, successAmtSat__field_descriptor),
+           (Data.ProtoLens.Tag 7, successAmtMsat__field_descriptor)]
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _PairData'_unknownFields
+        (\ x__ y__ -> x__ {_PairData'_unknownFields = y__})
+  defMessage
+    = PairData'_constructor
+        {_PairData'failTime = Data.ProtoLens.fieldDefault,
+         _PairData'failAmtSat = Data.ProtoLens.fieldDefault,
+         _PairData'failAmtMsat = Data.ProtoLens.fieldDefault,
+         _PairData'successTime = Data.ProtoLens.fieldDefault,
+         _PairData'successAmtSat = Data.ProtoLens.fieldDefault,
+         _PairData'successAmtMsat = Data.ProtoLens.fieldDefault,
+         _PairData'_unknownFields = []}
+  parseMessage
+    = let
+        loop :: PairData -> Data.ProtoLens.Encoding.Bytes.Parser PairData
+        loop x
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of
+                        8 -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          Prelude.fromIntegral
+                                          Data.ProtoLens.Encoding.Bytes.getVarInt)
+                                       "fail_time"
+                                loop
+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"failTime") y x)
+                        16
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          Prelude.fromIntegral
+                                          Data.ProtoLens.Encoding.Bytes.getVarInt)
+                                       "fail_amt_sat"
+                                loop
+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"failAmtSat") y x)
+                        32
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          Prelude.fromIntegral
+                                          Data.ProtoLens.Encoding.Bytes.getVarInt)
+                                       "fail_amt_msat"
+                                loop
+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"failAmtMsat") y x)
+                        40
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          Prelude.fromIntegral
+                                          Data.ProtoLens.Encoding.Bytes.getVarInt)
+                                       "success_time"
+                                loop
+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"successTime") y x)
+                        48
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          Prelude.fromIntegral
+                                          Data.ProtoLens.Encoding.Bytes.getVarInt)
+                                       "success_amt_sat"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"successAmtSat") y x)
+                        56
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          Prelude.fromIntegral
+                                          Data.ProtoLens.Encoding.Bytes.getVarInt)
+                                       "success_amt_msat"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"successAmtMsat") y x)
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do loop Data.ProtoLens.defMessage) "PairData"
+  buildMessage
+    = \ _x
+        -> (Data.Monoid.<>)
+             (let
+                _v = Lens.Family2.view (Data.ProtoLens.Field.field @"failTime") _x
+              in
+                if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                    Data.Monoid.mempty
+                else
+                    (Data.Monoid.<>)
+                      (Data.ProtoLens.Encoding.Bytes.putVarInt 8)
+                      ((Prelude..)
+                         Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v))
+             ((Data.Monoid.<>)
+                (let
+                   _v
+                     = Lens.Family2.view (Data.ProtoLens.Field.field @"failAmtSat") _x
+                 in
+                   if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                       Data.Monoid.mempty
+                   else
+                       (Data.Monoid.<>)
+                         (Data.ProtoLens.Encoding.Bytes.putVarInt 16)
+                         ((Prelude..)
+                            Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v))
+                ((Data.Monoid.<>)
+                   (let
+                      _v
+                        = Lens.Family2.view (Data.ProtoLens.Field.field @"failAmtMsat") _x
+                    in
+                      if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                          Data.Monoid.mempty
+                      else
+                          (Data.Monoid.<>)
+                            (Data.ProtoLens.Encoding.Bytes.putVarInt 32)
+                            ((Prelude..)
+                               Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v))
+                   ((Data.Monoid.<>)
+                      (let
+                         _v
+                           = Lens.Family2.view (Data.ProtoLens.Field.field @"successTime") _x
+                       in
+                         if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                             Data.Monoid.mempty
+                         else
+                             (Data.Monoid.<>)
+                               (Data.ProtoLens.Encoding.Bytes.putVarInt 40)
+                               ((Prelude..)
+                                  Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v))
+                      ((Data.Monoid.<>)
+                         (let
+                            _v
+                              = Lens.Family2.view
+                                  (Data.ProtoLens.Field.field @"successAmtSat") _x
+                          in
+                            if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                                Data.Monoid.mempty
+                            else
+                                (Data.Monoid.<>)
+                                  (Data.ProtoLens.Encoding.Bytes.putVarInt 48)
+                                  ((Prelude..)
+                                     Data.ProtoLens.Encoding.Bytes.putVarInt
+                                     Prelude.fromIntegral
+                                     _v))
+                         ((Data.Monoid.<>)
+                            (let
+                               _v
+                                 = Lens.Family2.view
+                                     (Data.ProtoLens.Field.field @"successAmtMsat") _x
+                             in
+                               if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                                   Data.Monoid.mempty
+                               else
+                                   (Data.Monoid.<>)
+                                     (Data.ProtoLens.Encoding.Bytes.putVarInt 56)
+                                     ((Prelude..)
+                                        Data.ProtoLens.Encoding.Bytes.putVarInt
+                                        Prelude.fromIntegral
+                                        _v))
+                            (Data.ProtoLens.Encoding.Wire.buildFieldSet
+                               (Lens.Family2.view Data.ProtoLens.unknownFields _x)))))))
+instance Control.DeepSeq.NFData PairData where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_PairData'_unknownFields x__)
+             (Control.DeepSeq.deepseq
+                (_PairData'failTime x__)
+                (Control.DeepSeq.deepseq
+                   (_PairData'failAmtSat x__)
+                   (Control.DeepSeq.deepseq
+                      (_PairData'failAmtMsat x__)
+                      (Control.DeepSeq.deepseq
+                         (_PairData'successTime x__)
+                         (Control.DeepSeq.deepseq
+                            (_PairData'successAmtSat x__)
+                            (Control.DeepSeq.deepseq (_PairData'successAmtMsat x__) ()))))))
+{- | Fields :
+     
+         * 'Proto.RouterGrpc_Fields.nodeFrom' @:: Lens' PairHistory Data.ByteString.ByteString@
+         * 'Proto.RouterGrpc_Fields.nodeTo' @:: Lens' PairHistory Data.ByteString.ByteString@
+         * 'Proto.RouterGrpc_Fields.history' @:: Lens' PairHistory PairData@
+         * 'Proto.RouterGrpc_Fields.maybe'history' @:: Lens' PairHistory (Prelude.Maybe PairData)@ -}
+data PairHistory
+  = PairHistory'_constructor {_PairHistory'nodeFrom :: !Data.ByteString.ByteString,
+                              _PairHistory'nodeTo :: !Data.ByteString.ByteString,
+                              _PairHistory'history :: !(Prelude.Maybe PairData),
+                              _PairHistory'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show PairHistory where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Field.HasField PairHistory "nodeFrom" Data.ByteString.ByteString where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _PairHistory'nodeFrom
+           (\ x__ y__ -> x__ {_PairHistory'nodeFrom = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField PairHistory "nodeTo" Data.ByteString.ByteString where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _PairHistory'nodeTo (\ x__ y__ -> x__ {_PairHistory'nodeTo = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField PairHistory "history" PairData where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _PairHistory'history
+           (\ x__ y__ -> x__ {_PairHistory'history = y__}))
+        (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage)
+instance Data.ProtoLens.Field.HasField PairHistory "maybe'history" (Prelude.Maybe PairData) where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _PairHistory'history
+           (\ x__ y__ -> x__ {_PairHistory'history = y__}))
+        Prelude.id
+instance Data.ProtoLens.Message PairHistory where
+  messageName _ = Data.Text.pack "routerrpc.PairHistory"
+  packedMessageDescriptor _
+    = "\n\
+      \\vPairHistory\DC2\ESC\n\
+      \\tnode_from\CAN\SOH \SOH(\fR\bnodeFrom\DC2\ETB\n\
+      \\anode_to\CAN\STX \SOH(\fR\ACKnodeTo\DC2-\n\
+      \\ahistory\CAN\a \SOH(\v2\DC3.routerrpc.PairDataR\ahistoryJ\EOT\b\ETX\DLE\EOTJ\EOT\b\EOT\DLE\ENQJ\EOT\b\ENQ\DLE\ACKJ\EOT\b\ACK\DLE\a"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag
+    = let
+        nodeFrom__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "node_from"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"nodeFrom")) ::
+              Data.ProtoLens.FieldDescriptor PairHistory
+        nodeTo__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "node_to"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional (Data.ProtoLens.Field.field @"nodeTo")) ::
+              Data.ProtoLens.FieldDescriptor PairHistory
+        history__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "history"
+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
+                 Data.ProtoLens.FieldTypeDescriptor PairData)
+              (Data.ProtoLens.OptionalField
+                 (Data.ProtoLens.Field.field @"maybe'history")) ::
+              Data.ProtoLens.FieldDescriptor PairHistory
+      in
+        Data.Map.fromList
+          [(Data.ProtoLens.Tag 1, nodeFrom__field_descriptor),
+           (Data.ProtoLens.Tag 2, nodeTo__field_descriptor),
+           (Data.ProtoLens.Tag 7, history__field_descriptor)]
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _PairHistory'_unknownFields
+        (\ x__ y__ -> x__ {_PairHistory'_unknownFields = y__})
+  defMessage
+    = PairHistory'_constructor
+        {_PairHistory'nodeFrom = Data.ProtoLens.fieldDefault,
+         _PairHistory'nodeTo = Data.ProtoLens.fieldDefault,
+         _PairHistory'history = Prelude.Nothing,
+         _PairHistory'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          PairHistory -> Data.ProtoLens.Encoding.Bytes.Parser PairHistory
+        loop x
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of
+                        10
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.getBytes
+                                             (Prelude.fromIntegral len))
+                                       "node_from"
+                                loop
+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"nodeFrom") y x)
+                        18
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.getBytes
+                                             (Prelude.fromIntegral len))
+                                       "node_to"
+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"nodeTo") y x)
+                        58
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.isolate
+                                             (Prelude.fromIntegral len) Data.ProtoLens.parseMessage)
+                                       "history"
+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"history") y x)
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do loop Data.ProtoLens.defMessage) "PairHistory"
+  buildMessage
+    = \ _x
+        -> (Data.Monoid.<>)
+             (let
+                _v = Lens.Family2.view (Data.ProtoLens.Field.field @"nodeFrom") _x
+              in
+                if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                    Data.Monoid.mempty
+                else
+                    (Data.Monoid.<>)
+                      (Data.ProtoLens.Encoding.Bytes.putVarInt 10)
+                      ((\ bs
+                          -> (Data.Monoid.<>)
+                               (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                  (Prelude.fromIntegral (Data.ByteString.length bs)))
+                               (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                         _v))
+             ((Data.Monoid.<>)
+                (let
+                   _v = Lens.Family2.view (Data.ProtoLens.Field.field @"nodeTo") _x
+                 in
+                   if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                       Data.Monoid.mempty
+                   else
+                       (Data.Monoid.<>)
+                         (Data.ProtoLens.Encoding.Bytes.putVarInt 18)
+                         ((\ bs
+                             -> (Data.Monoid.<>)
+                                  (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                     (Prelude.fromIntegral (Data.ByteString.length bs)))
+                                  (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                            _v))
+                ((Data.Monoid.<>)
+                   (case
+                        Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'history") _x
+                    of
+                      Prelude.Nothing -> Data.Monoid.mempty
+                      (Prelude.Just _v)
+                        -> (Data.Monoid.<>)
+                             (Data.ProtoLens.Encoding.Bytes.putVarInt 58)
+                             ((Prelude..)
+                                (\ bs
+                                   -> (Data.Monoid.<>)
+                                        (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                           (Prelude.fromIntegral (Data.ByteString.length bs)))
+                                        (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                                Data.ProtoLens.encodeMessage
+                                _v))
+                   (Data.ProtoLens.Encoding.Wire.buildFieldSet
+                      (Lens.Family2.view Data.ProtoLens.unknownFields _x))))
+instance Control.DeepSeq.NFData PairHistory where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_PairHistory'_unknownFields x__)
+             (Control.DeepSeq.deepseq
+                (_PairHistory'nodeFrom x__)
+                (Control.DeepSeq.deepseq
+                   (_PairHistory'nodeTo x__)
+                   (Control.DeepSeq.deepseq (_PairHistory'history x__) ())))
+newtype PaymentState'UnrecognizedValue
+  = PaymentState'UnrecognizedValue Data.Int.Int32
+  deriving stock (Prelude.Eq, Prelude.Ord, Prelude.Show)
+data PaymentState
+  = IN_FLIGHT |
+    SUCCEEDED |
+    FAILED_TIMEOUT |
+    FAILED_NO_ROUTE |
+    FAILED_ERROR |
+    FAILED_INCORRECT_PAYMENT_DETAILS |
+    FAILED_INSUFFICIENT_BALANCE |
+    PaymentState'Unrecognized !PaymentState'UnrecognizedValue
+  deriving stock (Prelude.Show, Prelude.Eq, Prelude.Ord)
+instance Data.ProtoLens.MessageEnum PaymentState where
+  maybeToEnum 0 = Prelude.Just IN_FLIGHT
+  maybeToEnum 1 = Prelude.Just SUCCEEDED
+  maybeToEnum 2 = Prelude.Just FAILED_TIMEOUT
+  maybeToEnum 3 = Prelude.Just FAILED_NO_ROUTE
+  maybeToEnum 4 = Prelude.Just FAILED_ERROR
+  maybeToEnum 5 = Prelude.Just FAILED_INCORRECT_PAYMENT_DETAILS
+  maybeToEnum 6 = Prelude.Just FAILED_INSUFFICIENT_BALANCE
+  maybeToEnum k
+    = Prelude.Just
+        (PaymentState'Unrecognized
+           (PaymentState'UnrecognizedValue (Prelude.fromIntegral k)))
+  showEnum IN_FLIGHT = "IN_FLIGHT"
+  showEnum SUCCEEDED = "SUCCEEDED"
+  showEnum FAILED_TIMEOUT = "FAILED_TIMEOUT"
+  showEnum FAILED_NO_ROUTE = "FAILED_NO_ROUTE"
+  showEnum FAILED_ERROR = "FAILED_ERROR"
+  showEnum FAILED_INCORRECT_PAYMENT_DETAILS
+    = "FAILED_INCORRECT_PAYMENT_DETAILS"
+  showEnum FAILED_INSUFFICIENT_BALANCE
+    = "FAILED_INSUFFICIENT_BALANCE"
+  showEnum
+    (PaymentState'Unrecognized (PaymentState'UnrecognizedValue k))
+    = Prelude.show k
+  readEnum k
+    | (Prelude.==) k "IN_FLIGHT" = Prelude.Just IN_FLIGHT
+    | (Prelude.==) k "SUCCEEDED" = Prelude.Just SUCCEEDED
+    | (Prelude.==) k "FAILED_TIMEOUT" = Prelude.Just FAILED_TIMEOUT
+    | (Prelude.==) k "FAILED_NO_ROUTE" = Prelude.Just FAILED_NO_ROUTE
+    | (Prelude.==) k "FAILED_ERROR" = Prelude.Just FAILED_ERROR
+    | (Prelude.==) k "FAILED_INCORRECT_PAYMENT_DETAILS"
+    = Prelude.Just FAILED_INCORRECT_PAYMENT_DETAILS
+    | (Prelude.==) k "FAILED_INSUFFICIENT_BALANCE"
+    = Prelude.Just FAILED_INSUFFICIENT_BALANCE
+    | Prelude.otherwise
+    = (Prelude.>>=) (Text.Read.readMaybe k) Data.ProtoLens.maybeToEnum
+instance Prelude.Bounded PaymentState where
+  minBound = IN_FLIGHT
+  maxBound = FAILED_INSUFFICIENT_BALANCE
+instance Prelude.Enum PaymentState where
+  toEnum k__
+    = Prelude.maybe
+        (Prelude.error
+           ((Prelude.++)
+              "toEnum: unknown value for enum PaymentState: "
+              (Prelude.show k__)))
+        Prelude.id
+        (Data.ProtoLens.maybeToEnum k__)
+  fromEnum IN_FLIGHT = 0
+  fromEnum SUCCEEDED = 1
+  fromEnum FAILED_TIMEOUT = 2
+  fromEnum FAILED_NO_ROUTE = 3
+  fromEnum FAILED_ERROR = 4
+  fromEnum FAILED_INCORRECT_PAYMENT_DETAILS = 5
+  fromEnum FAILED_INSUFFICIENT_BALANCE = 6
+  fromEnum
+    (PaymentState'Unrecognized (PaymentState'UnrecognizedValue k))
+    = Prelude.fromIntegral k
+  succ FAILED_INSUFFICIENT_BALANCE
+    = Prelude.error
+        "PaymentState.succ: bad argument FAILED_INSUFFICIENT_BALANCE. This value would be out of bounds."
+  succ IN_FLIGHT = SUCCEEDED
+  succ SUCCEEDED = FAILED_TIMEOUT
+  succ FAILED_TIMEOUT = FAILED_NO_ROUTE
+  succ FAILED_NO_ROUTE = FAILED_ERROR
+  succ FAILED_ERROR = FAILED_INCORRECT_PAYMENT_DETAILS
+  succ FAILED_INCORRECT_PAYMENT_DETAILS = FAILED_INSUFFICIENT_BALANCE
+  succ (PaymentState'Unrecognized _)
+    = Prelude.error
+        "PaymentState.succ: bad argument: unrecognized value"
+  pred IN_FLIGHT
+    = Prelude.error
+        "PaymentState.pred: bad argument IN_FLIGHT. This value would be out of bounds."
+  pred SUCCEEDED = IN_FLIGHT
+  pred FAILED_TIMEOUT = SUCCEEDED
+  pred FAILED_NO_ROUTE = FAILED_TIMEOUT
+  pred FAILED_ERROR = FAILED_NO_ROUTE
+  pred FAILED_INCORRECT_PAYMENT_DETAILS = FAILED_ERROR
+  pred FAILED_INSUFFICIENT_BALANCE = FAILED_INCORRECT_PAYMENT_DETAILS
+  pred (PaymentState'Unrecognized _)
+    = Prelude.error
+        "PaymentState.pred: bad argument: unrecognized value"
+  enumFrom = Data.ProtoLens.Message.Enum.messageEnumFrom
+  enumFromTo = Data.ProtoLens.Message.Enum.messageEnumFromTo
+  enumFromThen = Data.ProtoLens.Message.Enum.messageEnumFromThen
+  enumFromThenTo = Data.ProtoLens.Message.Enum.messageEnumFromThenTo
+instance Data.ProtoLens.FieldDefault PaymentState where
+  fieldDefault = IN_FLIGHT
+instance Control.DeepSeq.NFData PaymentState where
+  rnf x__ = Prelude.seq x__ ()
+{- | Fields :
+     
+         * 'Proto.RouterGrpc_Fields.state' @:: Lens' PaymentStatus PaymentState@
+         * 'Proto.RouterGrpc_Fields.preimage' @:: Lens' PaymentStatus Data.ByteString.ByteString@
+         * 'Proto.RouterGrpc_Fields.htlcs' @:: Lens' PaymentStatus [Proto.LndGrpc.HTLCAttempt]@
+         * 'Proto.RouterGrpc_Fields.vec'htlcs' @:: Lens' PaymentStatus (Data.Vector.Vector Proto.LndGrpc.HTLCAttempt)@ -}
+data PaymentStatus
+  = PaymentStatus'_constructor {_PaymentStatus'state :: !PaymentState,
+                                _PaymentStatus'preimage :: !Data.ByteString.ByteString,
+                                _PaymentStatus'htlcs :: !(Data.Vector.Vector Proto.LndGrpc.HTLCAttempt),
+                                _PaymentStatus'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show PaymentStatus where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Field.HasField PaymentStatus "state" PaymentState where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _PaymentStatus'state
+           (\ x__ y__ -> x__ {_PaymentStatus'state = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField PaymentStatus "preimage" Data.ByteString.ByteString where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _PaymentStatus'preimage
+           (\ x__ y__ -> x__ {_PaymentStatus'preimage = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField PaymentStatus "htlcs" [Proto.LndGrpc.HTLCAttempt] where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _PaymentStatus'htlcs
+           (\ x__ y__ -> x__ {_PaymentStatus'htlcs = y__}))
+        (Lens.Family2.Unchecked.lens
+           Data.Vector.Generic.toList
+           (\ _ y__ -> Data.Vector.Generic.fromList y__))
+instance Data.ProtoLens.Field.HasField PaymentStatus "vec'htlcs" (Data.Vector.Vector Proto.LndGrpc.HTLCAttempt) where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _PaymentStatus'htlcs
+           (\ x__ y__ -> x__ {_PaymentStatus'htlcs = y__}))
+        Prelude.id
+instance Data.ProtoLens.Message PaymentStatus where
+  messageName _ = Data.Text.pack "routerrpc.PaymentStatus"
+  packedMessageDescriptor _
+    = "\n\
+      \\rPaymentStatus\DC2-\n\
+      \\ENQstate\CAN\SOH \SOH(\SO2\ETB.routerrpc.PaymentStateR\ENQstate\DC2\SUB\n\
+      \\bpreimage\CAN\STX \SOH(\fR\bpreimage\DC2(\n\
+      \\ENQhtlcs\CAN\EOT \ETX(\v2\DC2.lnrpc.HTLCAttemptR\ENQhtlcsJ\EOT\b\ETX\DLE\EOT"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag
+    = let
+        state__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "state"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField ::
+                 Data.ProtoLens.FieldTypeDescriptor PaymentState)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional (Data.ProtoLens.Field.field @"state")) ::
+              Data.ProtoLens.FieldDescriptor PaymentStatus
+        preimage__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "preimage"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"preimage")) ::
+              Data.ProtoLens.FieldDescriptor PaymentStatus
+        htlcs__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "htlcs"
+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
+                 Data.ProtoLens.FieldTypeDescriptor Proto.LndGrpc.HTLCAttempt)
+              (Data.ProtoLens.RepeatedField
+                 Data.ProtoLens.Unpacked (Data.ProtoLens.Field.field @"htlcs")) ::
+              Data.ProtoLens.FieldDescriptor PaymentStatus
+      in
+        Data.Map.fromList
+          [(Data.ProtoLens.Tag 1, state__field_descriptor),
+           (Data.ProtoLens.Tag 2, preimage__field_descriptor),
+           (Data.ProtoLens.Tag 4, htlcs__field_descriptor)]
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _PaymentStatus'_unknownFields
+        (\ x__ y__ -> x__ {_PaymentStatus'_unknownFields = y__})
+  defMessage
+    = PaymentStatus'_constructor
+        {_PaymentStatus'state = Data.ProtoLens.fieldDefault,
+         _PaymentStatus'preimage = Data.ProtoLens.fieldDefault,
+         _PaymentStatus'htlcs = Data.Vector.Generic.empty,
+         _PaymentStatus'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          PaymentStatus
+          -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld Proto.LndGrpc.HTLCAttempt
+             -> Data.ProtoLens.Encoding.Bytes.Parser PaymentStatus
+        loop x mutable'htlcs
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do frozen'htlcs <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
+                                        (Data.ProtoLens.Encoding.Growing.unsafeFreeze mutable'htlcs)
+                      (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields
+                           (\ !t -> Prelude.reverse t)
+                           (Lens.Family2.set
+                              (Data.ProtoLens.Field.field @"vec'htlcs") frozen'htlcs x))
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of
+                        8 -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          Prelude.toEnum
+                                          (Prelude.fmap
+                                             Prelude.fromIntegral
+                                             Data.ProtoLens.Encoding.Bytes.getVarInt))
+                                       "state"
+                                loop
+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"state") y x)
+                                  mutable'htlcs
+                        18
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.getBytes
+                                             (Prelude.fromIntegral len))
+                                       "preimage"
+                                loop
+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"preimage") y x)
+                                  mutable'htlcs
+                        34
+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                        (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                            Data.ProtoLens.Encoding.Bytes.isolate
+                                              (Prelude.fromIntegral len)
+                                              Data.ProtoLens.parseMessage)
+                                        "htlcs"
+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
+                                       (Data.ProtoLens.Encoding.Growing.append mutable'htlcs y)
+                                loop x v
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)
+                                  mutable'htlcs
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do mutable'htlcs <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
+                                 Data.ProtoLens.Encoding.Growing.new
+              loop Data.ProtoLens.defMessage mutable'htlcs)
+          "PaymentStatus"
+  buildMessage
+    = \ _x
+        -> (Data.Monoid.<>)
+             (let
+                _v = Lens.Family2.view (Data.ProtoLens.Field.field @"state") _x
+              in
+                if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                    Data.Monoid.mempty
+                else
+                    (Data.Monoid.<>)
+                      (Data.ProtoLens.Encoding.Bytes.putVarInt 8)
+                      ((Prelude..)
+                         ((Prelude..)
+                            Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral)
+                         Prelude.fromEnum
+                         _v))
+             ((Data.Monoid.<>)
+                (let
+                   _v = Lens.Family2.view (Data.ProtoLens.Field.field @"preimage") _x
+                 in
+                   if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                       Data.Monoid.mempty
+                   else
+                       (Data.Monoid.<>)
+                         (Data.ProtoLens.Encoding.Bytes.putVarInt 18)
+                         ((\ bs
+                             -> (Data.Monoid.<>)
+                                  (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                     (Prelude.fromIntegral (Data.ByteString.length bs)))
+                                  (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                            _v))
+                ((Data.Monoid.<>)
+                   (Data.ProtoLens.Encoding.Bytes.foldMapBuilder
+                      (\ _v
+                         -> (Data.Monoid.<>)
+                              (Data.ProtoLens.Encoding.Bytes.putVarInt 34)
+                              ((Prelude..)
+                                 (\ bs
+                                    -> (Data.Monoid.<>)
+                                         (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                            (Prelude.fromIntegral (Data.ByteString.length bs)))
+                                         (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                                 Data.ProtoLens.encodeMessage
+                                 _v))
+                      (Lens.Family2.view (Data.ProtoLens.Field.field @"vec'htlcs") _x))
+                   (Data.ProtoLens.Encoding.Wire.buildFieldSet
+                      (Lens.Family2.view Data.ProtoLens.unknownFields _x))))
+instance Control.DeepSeq.NFData PaymentStatus where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_PaymentStatus'_unknownFields x__)
+             (Control.DeepSeq.deepseq
+                (_PaymentStatus'state x__)
+                (Control.DeepSeq.deepseq
+                   (_PaymentStatus'preimage x__)
+                   (Control.DeepSeq.deepseq (_PaymentStatus'htlcs x__) ())))
+{- | Fields :
+      -}
+data QueryMissionControlRequest
+  = QueryMissionControlRequest'_constructor {_QueryMissionControlRequest'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show QueryMissionControlRequest where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Message QueryMissionControlRequest where
+  messageName _
+    = Data.Text.pack "routerrpc.QueryMissionControlRequest"
+  packedMessageDescriptor _
+    = "\n\
+      \\SUBQueryMissionControlRequest"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag = let in Data.Map.fromList []
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _QueryMissionControlRequest'_unknownFields
+        (\ x__ y__
+           -> x__ {_QueryMissionControlRequest'_unknownFields = y__})
+  defMessage
+    = QueryMissionControlRequest'_constructor
+        {_QueryMissionControlRequest'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          QueryMissionControlRequest
+          -> Data.ProtoLens.Encoding.Bytes.Parser QueryMissionControlRequest
+        loop x
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of {
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) }
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do loop Data.ProtoLens.defMessage) "QueryMissionControlRequest"
+  buildMessage
+    = \ _x
+        -> Data.ProtoLens.Encoding.Wire.buildFieldSet
+             (Lens.Family2.view Data.ProtoLens.unknownFields _x)
+instance Control.DeepSeq.NFData QueryMissionControlRequest where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_QueryMissionControlRequest'_unknownFields x__) ()
+{- | Fields :
+     
+         * 'Proto.RouterGrpc_Fields.pairs' @:: Lens' QueryMissionControlResponse [PairHistory]@
+         * 'Proto.RouterGrpc_Fields.vec'pairs' @:: Lens' QueryMissionControlResponse (Data.Vector.Vector PairHistory)@ -}
+data QueryMissionControlResponse
+  = QueryMissionControlResponse'_constructor {_QueryMissionControlResponse'pairs :: !(Data.Vector.Vector PairHistory),
+                                              _QueryMissionControlResponse'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show QueryMissionControlResponse where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Field.HasField QueryMissionControlResponse "pairs" [PairHistory] where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _QueryMissionControlResponse'pairs
+           (\ x__ y__ -> x__ {_QueryMissionControlResponse'pairs = y__}))
+        (Lens.Family2.Unchecked.lens
+           Data.Vector.Generic.toList
+           (\ _ y__ -> Data.Vector.Generic.fromList y__))
+instance Data.ProtoLens.Field.HasField QueryMissionControlResponse "vec'pairs" (Data.Vector.Vector PairHistory) where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _QueryMissionControlResponse'pairs
+           (\ x__ y__ -> x__ {_QueryMissionControlResponse'pairs = y__}))
+        Prelude.id
+instance Data.ProtoLens.Message QueryMissionControlResponse where
+  messageName _
+    = Data.Text.pack "routerrpc.QueryMissionControlResponse"
+  packedMessageDescriptor _
+    = "\n\
+      \\ESCQueryMissionControlResponse\DC2,\n\
+      \\ENQpairs\CAN\STX \ETX(\v2\SYN.routerrpc.PairHistoryR\ENQpairsJ\EOT\b\SOH\DLE\STX"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag
+    = let
+        pairs__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "pairs"
+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
+                 Data.ProtoLens.FieldTypeDescriptor PairHistory)
+              (Data.ProtoLens.RepeatedField
+                 Data.ProtoLens.Unpacked (Data.ProtoLens.Field.field @"pairs")) ::
+              Data.ProtoLens.FieldDescriptor QueryMissionControlResponse
+      in
+        Data.Map.fromList [(Data.ProtoLens.Tag 2, pairs__field_descriptor)]
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _QueryMissionControlResponse'_unknownFields
+        (\ x__ y__
+           -> x__ {_QueryMissionControlResponse'_unknownFields = y__})
+  defMessage
+    = QueryMissionControlResponse'_constructor
+        {_QueryMissionControlResponse'pairs = Data.Vector.Generic.empty,
+         _QueryMissionControlResponse'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          QueryMissionControlResponse
+          -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld PairHistory
+             -> Data.ProtoLens.Encoding.Bytes.Parser QueryMissionControlResponse
+        loop x mutable'pairs
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do frozen'pairs <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
+                                        (Data.ProtoLens.Encoding.Growing.unsafeFreeze mutable'pairs)
+                      (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields
+                           (\ !t -> Prelude.reverse t)
+                           (Lens.Family2.set
+                              (Data.ProtoLens.Field.field @"vec'pairs") frozen'pairs x))
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of
+                        18
+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                        (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                            Data.ProtoLens.Encoding.Bytes.isolate
+                                              (Prelude.fromIntegral len)
+                                              Data.ProtoLens.parseMessage)
+                                        "pairs"
+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
+                                       (Data.ProtoLens.Encoding.Growing.append mutable'pairs y)
+                                loop x v
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)
+                                  mutable'pairs
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do mutable'pairs <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
+                                 Data.ProtoLens.Encoding.Growing.new
+              loop Data.ProtoLens.defMessage mutable'pairs)
+          "QueryMissionControlResponse"
+  buildMessage
+    = \ _x
+        -> (Data.Monoid.<>)
+             (Data.ProtoLens.Encoding.Bytes.foldMapBuilder
+                (\ _v
+                   -> (Data.Monoid.<>)
+                        (Data.ProtoLens.Encoding.Bytes.putVarInt 18)
+                        ((Prelude..)
+                           (\ bs
+                              -> (Data.Monoid.<>)
+                                   (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                      (Prelude.fromIntegral (Data.ByteString.length bs)))
+                                   (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                           Data.ProtoLens.encodeMessage
+                           _v))
+                (Lens.Family2.view (Data.ProtoLens.Field.field @"vec'pairs") _x))
+             (Data.ProtoLens.Encoding.Wire.buildFieldSet
+                (Lens.Family2.view Data.ProtoLens.unknownFields _x))
+instance Control.DeepSeq.NFData QueryMissionControlResponse where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_QueryMissionControlResponse'_unknownFields x__)
+             (Control.DeepSeq.deepseq
+                (_QueryMissionControlResponse'pairs x__) ())
+{- | Fields :
+     
+         * 'Proto.RouterGrpc_Fields.fromNode' @:: Lens' QueryProbabilityRequest Data.ByteString.ByteString@
+         * 'Proto.RouterGrpc_Fields.toNode' @:: Lens' QueryProbabilityRequest Data.ByteString.ByteString@
+         * 'Proto.RouterGrpc_Fields.amtMsat' @:: Lens' QueryProbabilityRequest Data.Int.Int64@ -}
+data QueryProbabilityRequest
+  = QueryProbabilityRequest'_constructor {_QueryProbabilityRequest'fromNode :: !Data.ByteString.ByteString,
+                                          _QueryProbabilityRequest'toNode :: !Data.ByteString.ByteString,
+                                          _QueryProbabilityRequest'amtMsat :: !Data.Int.Int64,
+                                          _QueryProbabilityRequest'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show QueryProbabilityRequest where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Field.HasField QueryProbabilityRequest "fromNode" Data.ByteString.ByteString where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _QueryProbabilityRequest'fromNode
+           (\ x__ y__ -> x__ {_QueryProbabilityRequest'fromNode = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField QueryProbabilityRequest "toNode" Data.ByteString.ByteString where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _QueryProbabilityRequest'toNode
+           (\ x__ y__ -> x__ {_QueryProbabilityRequest'toNode = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField QueryProbabilityRequest "amtMsat" Data.Int.Int64 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _QueryProbabilityRequest'amtMsat
+           (\ x__ y__ -> x__ {_QueryProbabilityRequest'amtMsat = y__}))
+        Prelude.id
+instance Data.ProtoLens.Message QueryProbabilityRequest where
+  messageName _ = Data.Text.pack "routerrpc.QueryProbabilityRequest"
+  packedMessageDescriptor _
+    = "\n\
+      \\ETBQueryProbabilityRequest\DC2\ESC\n\
+      \\tfrom_node\CAN\SOH \SOH(\fR\bfromNode\DC2\ETB\n\
+      \\ato_node\CAN\STX \SOH(\fR\ACKtoNode\DC2\EM\n\
+      \\bamt_msat\CAN\ETX \SOH(\ETXR\aamtMsat"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag
+    = let
+        fromNode__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "from_node"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"fromNode")) ::
+              Data.ProtoLens.FieldDescriptor QueryProbabilityRequest
+        toNode__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "to_node"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional (Data.ProtoLens.Field.field @"toNode")) ::
+              Data.ProtoLens.FieldDescriptor QueryProbabilityRequest
+        amtMsat__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "amt_msat"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.Int64Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional (Data.ProtoLens.Field.field @"amtMsat")) ::
+              Data.ProtoLens.FieldDescriptor QueryProbabilityRequest
+      in
+        Data.Map.fromList
+          [(Data.ProtoLens.Tag 1, fromNode__field_descriptor),
+           (Data.ProtoLens.Tag 2, toNode__field_descriptor),
+           (Data.ProtoLens.Tag 3, amtMsat__field_descriptor)]
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _QueryProbabilityRequest'_unknownFields
+        (\ x__ y__ -> x__ {_QueryProbabilityRequest'_unknownFields = y__})
+  defMessage
+    = QueryProbabilityRequest'_constructor
+        {_QueryProbabilityRequest'fromNode = Data.ProtoLens.fieldDefault,
+         _QueryProbabilityRequest'toNode = Data.ProtoLens.fieldDefault,
+         _QueryProbabilityRequest'amtMsat = Data.ProtoLens.fieldDefault,
+         _QueryProbabilityRequest'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          QueryProbabilityRequest
+          -> Data.ProtoLens.Encoding.Bytes.Parser QueryProbabilityRequest
+        loop x
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of
+                        10
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.getBytes
+                                             (Prelude.fromIntegral len))
+                                       "from_node"
+                                loop
+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"fromNode") y x)
+                        18
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.getBytes
+                                             (Prelude.fromIntegral len))
+                                       "to_node"
+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"toNode") y x)
+                        24
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          Prelude.fromIntegral
+                                          Data.ProtoLens.Encoding.Bytes.getVarInt)
+                                       "amt_msat"
+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"amtMsat") y x)
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do loop Data.ProtoLens.defMessage) "QueryProbabilityRequest"
+  buildMessage
+    = \ _x
+        -> (Data.Monoid.<>)
+             (let
+                _v = Lens.Family2.view (Data.ProtoLens.Field.field @"fromNode") _x
+              in
+                if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                    Data.Monoid.mempty
+                else
+                    (Data.Monoid.<>)
+                      (Data.ProtoLens.Encoding.Bytes.putVarInt 10)
+                      ((\ bs
+                          -> (Data.Monoid.<>)
+                               (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                  (Prelude.fromIntegral (Data.ByteString.length bs)))
+                               (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                         _v))
+             ((Data.Monoid.<>)
+                (let
+                   _v = Lens.Family2.view (Data.ProtoLens.Field.field @"toNode") _x
+                 in
+                   if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                       Data.Monoid.mempty
+                   else
+                       (Data.Monoid.<>)
+                         (Data.ProtoLens.Encoding.Bytes.putVarInt 18)
+                         ((\ bs
+                             -> (Data.Monoid.<>)
+                                  (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                     (Prelude.fromIntegral (Data.ByteString.length bs)))
+                                  (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                            _v))
+                ((Data.Monoid.<>)
+                   (let
+                      _v = Lens.Family2.view (Data.ProtoLens.Field.field @"amtMsat") _x
+                    in
+                      if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                          Data.Monoid.mempty
+                      else
+                          (Data.Monoid.<>)
+                            (Data.ProtoLens.Encoding.Bytes.putVarInt 24)
+                            ((Prelude..)
+                               Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v))
+                   (Data.ProtoLens.Encoding.Wire.buildFieldSet
+                      (Lens.Family2.view Data.ProtoLens.unknownFields _x))))
+instance Control.DeepSeq.NFData QueryProbabilityRequest where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_QueryProbabilityRequest'_unknownFields x__)
+             (Control.DeepSeq.deepseq
+                (_QueryProbabilityRequest'fromNode x__)
+                (Control.DeepSeq.deepseq
+                   (_QueryProbabilityRequest'toNode x__)
+                   (Control.DeepSeq.deepseq
+                      (_QueryProbabilityRequest'amtMsat x__) ())))
+{- | Fields :
+     
+         * 'Proto.RouterGrpc_Fields.probability' @:: Lens' QueryProbabilityResponse Prelude.Double@
+         * 'Proto.RouterGrpc_Fields.history' @:: Lens' QueryProbabilityResponse PairData@
+         * 'Proto.RouterGrpc_Fields.maybe'history' @:: Lens' QueryProbabilityResponse (Prelude.Maybe PairData)@ -}
+data QueryProbabilityResponse
+  = QueryProbabilityResponse'_constructor {_QueryProbabilityResponse'probability :: !Prelude.Double,
+                                           _QueryProbabilityResponse'history :: !(Prelude.Maybe PairData),
+                                           _QueryProbabilityResponse'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show QueryProbabilityResponse where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Field.HasField QueryProbabilityResponse "probability" Prelude.Double where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _QueryProbabilityResponse'probability
+           (\ x__ y__ -> x__ {_QueryProbabilityResponse'probability = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField QueryProbabilityResponse "history" PairData where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _QueryProbabilityResponse'history
+           (\ x__ y__ -> x__ {_QueryProbabilityResponse'history = y__}))
+        (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage)
+instance Data.ProtoLens.Field.HasField QueryProbabilityResponse "maybe'history" (Prelude.Maybe PairData) where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _QueryProbabilityResponse'history
+           (\ x__ y__ -> x__ {_QueryProbabilityResponse'history = y__}))
+        Prelude.id
+instance Data.ProtoLens.Message QueryProbabilityResponse where
+  messageName _ = Data.Text.pack "routerrpc.QueryProbabilityResponse"
+  packedMessageDescriptor _
+    = "\n\
+      \\CANQueryProbabilityResponse\DC2 \n\
+      \\vprobability\CAN\SOH \SOH(\SOHR\vprobability\DC2-\n\
+      \\ahistory\CAN\STX \SOH(\v2\DC3.routerrpc.PairDataR\ahistory"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag
+    = let
+        probability__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "probability"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.DoubleField ::
+                 Data.ProtoLens.FieldTypeDescriptor Prelude.Double)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"probability")) ::
+              Data.ProtoLens.FieldDescriptor QueryProbabilityResponse
+        history__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "history"
+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
+                 Data.ProtoLens.FieldTypeDescriptor PairData)
+              (Data.ProtoLens.OptionalField
+                 (Data.ProtoLens.Field.field @"maybe'history")) ::
+              Data.ProtoLens.FieldDescriptor QueryProbabilityResponse
+      in
+        Data.Map.fromList
+          [(Data.ProtoLens.Tag 1, probability__field_descriptor),
+           (Data.ProtoLens.Tag 2, history__field_descriptor)]
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _QueryProbabilityResponse'_unknownFields
+        (\ x__ y__ -> x__ {_QueryProbabilityResponse'_unknownFields = y__})
+  defMessage
+    = QueryProbabilityResponse'_constructor
+        {_QueryProbabilityResponse'probability = Data.ProtoLens.fieldDefault,
+         _QueryProbabilityResponse'history = Prelude.Nothing,
+         _QueryProbabilityResponse'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          QueryProbabilityResponse
+          -> Data.ProtoLens.Encoding.Bytes.Parser QueryProbabilityResponse
+        loop x
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of
+                        9 -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          Data.ProtoLens.Encoding.Bytes.wordToDouble
+                                          Data.ProtoLens.Encoding.Bytes.getFixed64)
+                                       "probability"
+                                loop
+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"probability") y x)
+                        18
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.isolate
+                                             (Prelude.fromIntegral len) Data.ProtoLens.parseMessage)
+                                       "history"
+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"history") y x)
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do loop Data.ProtoLens.defMessage) "QueryProbabilityResponse"
+  buildMessage
+    = \ _x
+        -> (Data.Monoid.<>)
+             (let
+                _v
+                  = Lens.Family2.view (Data.ProtoLens.Field.field @"probability") _x
+              in
+                if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                    Data.Monoid.mempty
+                else
+                    (Data.Monoid.<>)
+                      (Data.ProtoLens.Encoding.Bytes.putVarInt 9)
+                      ((Prelude..)
+                         Data.ProtoLens.Encoding.Bytes.putFixed64
+                         Data.ProtoLens.Encoding.Bytes.doubleToWord
+                         _v))
+             ((Data.Monoid.<>)
+                (case
+                     Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'history") _x
+                 of
+                   Prelude.Nothing -> Data.Monoid.mempty
+                   (Prelude.Just _v)
+                     -> (Data.Monoid.<>)
+                          (Data.ProtoLens.Encoding.Bytes.putVarInt 18)
+                          ((Prelude..)
+                             (\ bs
+                                -> (Data.Monoid.<>)
+                                     (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                        (Prelude.fromIntegral (Data.ByteString.length bs)))
+                                     (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                             Data.ProtoLens.encodeMessage
+                             _v))
+                (Data.ProtoLens.Encoding.Wire.buildFieldSet
+                   (Lens.Family2.view Data.ProtoLens.unknownFields _x)))
+instance Control.DeepSeq.NFData QueryProbabilityResponse where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_QueryProbabilityResponse'_unknownFields x__)
+             (Control.DeepSeq.deepseq
+                (_QueryProbabilityResponse'probability x__)
+                (Control.DeepSeq.deepseq
+                   (_QueryProbabilityResponse'history x__) ()))
+{- | Fields :
+      -}
+data ResetMissionControlRequest
+  = ResetMissionControlRequest'_constructor {_ResetMissionControlRequest'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show ResetMissionControlRequest where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Message ResetMissionControlRequest where
+  messageName _
+    = Data.Text.pack "routerrpc.ResetMissionControlRequest"
+  packedMessageDescriptor _
+    = "\n\
+      \\SUBResetMissionControlRequest"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag = let in Data.Map.fromList []
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _ResetMissionControlRequest'_unknownFields
+        (\ x__ y__
+           -> x__ {_ResetMissionControlRequest'_unknownFields = y__})
+  defMessage
+    = ResetMissionControlRequest'_constructor
+        {_ResetMissionControlRequest'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          ResetMissionControlRequest
+          -> Data.ProtoLens.Encoding.Bytes.Parser ResetMissionControlRequest
+        loop x
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of {
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) }
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do loop Data.ProtoLens.defMessage) "ResetMissionControlRequest"
+  buildMessage
+    = \ _x
+        -> Data.ProtoLens.Encoding.Wire.buildFieldSet
+             (Lens.Family2.view Data.ProtoLens.unknownFields _x)
+instance Control.DeepSeq.NFData ResetMissionControlRequest where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_ResetMissionControlRequest'_unknownFields x__) ()
+{- | Fields :
+      -}
+data ResetMissionControlResponse
+  = ResetMissionControlResponse'_constructor {_ResetMissionControlResponse'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show ResetMissionControlResponse where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Message ResetMissionControlResponse where
+  messageName _
+    = Data.Text.pack "routerrpc.ResetMissionControlResponse"
+  packedMessageDescriptor _
+    = "\n\
+      \\ESCResetMissionControlResponse"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag = let in Data.Map.fromList []
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _ResetMissionControlResponse'_unknownFields
+        (\ x__ y__
+           -> x__ {_ResetMissionControlResponse'_unknownFields = y__})
+  defMessage
+    = ResetMissionControlResponse'_constructor
+        {_ResetMissionControlResponse'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          ResetMissionControlResponse
+          -> Data.ProtoLens.Encoding.Bytes.Parser ResetMissionControlResponse
+        loop x
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of {
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) }
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do loop Data.ProtoLens.defMessage) "ResetMissionControlResponse"
+  buildMessage
+    = \ _x
+        -> Data.ProtoLens.Encoding.Wire.buildFieldSet
+             (Lens.Family2.view Data.ProtoLens.unknownFields _x)
+instance Control.DeepSeq.NFData ResetMissionControlResponse where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_ResetMissionControlResponse'_unknownFields x__) ()
+newtype ResolveHoldForwardAction'UnrecognizedValue
+  = ResolveHoldForwardAction'UnrecognizedValue Data.Int.Int32
+  deriving stock (Prelude.Eq, Prelude.Ord, Prelude.Show)
+data ResolveHoldForwardAction
+  = SETTLE |
+    FAIL |
+    RESUME |
+    ResolveHoldForwardAction'Unrecognized !ResolveHoldForwardAction'UnrecognizedValue
+  deriving stock (Prelude.Show, Prelude.Eq, Prelude.Ord)
+instance Data.ProtoLens.MessageEnum ResolveHoldForwardAction where
+  maybeToEnum 0 = Prelude.Just SETTLE
+  maybeToEnum 1 = Prelude.Just FAIL
+  maybeToEnum 2 = Prelude.Just RESUME
+  maybeToEnum k
+    = Prelude.Just
+        (ResolveHoldForwardAction'Unrecognized
+           (ResolveHoldForwardAction'UnrecognizedValue
+              (Prelude.fromIntegral k)))
+  showEnum SETTLE = "SETTLE"
+  showEnum FAIL = "FAIL"
+  showEnum RESUME = "RESUME"
+  showEnum
+    (ResolveHoldForwardAction'Unrecognized (ResolveHoldForwardAction'UnrecognizedValue k))
+    = Prelude.show k
+  readEnum k
+    | (Prelude.==) k "SETTLE" = Prelude.Just SETTLE
+    | (Prelude.==) k "FAIL" = Prelude.Just FAIL
+    | (Prelude.==) k "RESUME" = Prelude.Just RESUME
+    | Prelude.otherwise
+    = (Prelude.>>=) (Text.Read.readMaybe k) Data.ProtoLens.maybeToEnum
+instance Prelude.Bounded ResolveHoldForwardAction where
+  minBound = SETTLE
+  maxBound = RESUME
+instance Prelude.Enum ResolveHoldForwardAction where
+  toEnum k__
+    = Prelude.maybe
+        (Prelude.error
+           ((Prelude.++)
+              "toEnum: unknown value for enum ResolveHoldForwardAction: "
+              (Prelude.show k__)))
+        Prelude.id
+        (Data.ProtoLens.maybeToEnum k__)
+  fromEnum SETTLE = 0
+  fromEnum FAIL = 1
+  fromEnum RESUME = 2
+  fromEnum
+    (ResolveHoldForwardAction'Unrecognized (ResolveHoldForwardAction'UnrecognizedValue k))
+    = Prelude.fromIntegral k
+  succ RESUME
+    = Prelude.error
+        "ResolveHoldForwardAction.succ: bad argument RESUME. This value would be out of bounds."
+  succ SETTLE = FAIL
+  succ FAIL = RESUME
+  succ (ResolveHoldForwardAction'Unrecognized _)
+    = Prelude.error
+        "ResolveHoldForwardAction.succ: bad argument: unrecognized value"
+  pred SETTLE
+    = Prelude.error
+        "ResolveHoldForwardAction.pred: bad argument SETTLE. This value would be out of bounds."
+  pred FAIL = SETTLE
+  pred RESUME = FAIL
+  pred (ResolveHoldForwardAction'Unrecognized _)
+    = Prelude.error
+        "ResolveHoldForwardAction.pred: bad argument: unrecognized value"
+  enumFrom = Data.ProtoLens.Message.Enum.messageEnumFrom
+  enumFromTo = Data.ProtoLens.Message.Enum.messageEnumFromTo
+  enumFromThen = Data.ProtoLens.Message.Enum.messageEnumFromThen
+  enumFromThenTo = Data.ProtoLens.Message.Enum.messageEnumFromThenTo
+instance Data.ProtoLens.FieldDefault ResolveHoldForwardAction where
+  fieldDefault = SETTLE
+instance Control.DeepSeq.NFData ResolveHoldForwardAction where
+  rnf x__ = Prelude.seq x__ ()
+{- | Fields :
+     
+         * 'Proto.RouterGrpc_Fields.dest' @:: Lens' RouteFeeRequest Data.ByteString.ByteString@
+         * 'Proto.RouterGrpc_Fields.amtSat' @:: Lens' RouteFeeRequest Data.Int.Int64@ -}
+data RouteFeeRequest
+  = RouteFeeRequest'_constructor {_RouteFeeRequest'dest :: !Data.ByteString.ByteString,
+                                  _RouteFeeRequest'amtSat :: !Data.Int.Int64,
+                                  _RouteFeeRequest'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show RouteFeeRequest where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Field.HasField RouteFeeRequest "dest" Data.ByteString.ByteString where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _RouteFeeRequest'dest
+           (\ x__ y__ -> x__ {_RouteFeeRequest'dest = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField RouteFeeRequest "amtSat" Data.Int.Int64 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _RouteFeeRequest'amtSat
+           (\ x__ y__ -> x__ {_RouteFeeRequest'amtSat = y__}))
+        Prelude.id
+instance Data.ProtoLens.Message RouteFeeRequest where
+  messageName _ = Data.Text.pack "routerrpc.RouteFeeRequest"
+  packedMessageDescriptor _
+    = "\n\
+      \\SIRouteFeeRequest\DC2\DC2\n\
+      \\EOTdest\CAN\SOH \SOH(\fR\EOTdest\DC2\ETB\n\
+      \\aamt_sat\CAN\STX \SOH(\ETXR\ACKamtSat"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag
+    = let
+        dest__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "dest"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional (Data.ProtoLens.Field.field @"dest")) ::
+              Data.ProtoLens.FieldDescriptor RouteFeeRequest
+        amtSat__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "amt_sat"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.Int64Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional (Data.ProtoLens.Field.field @"amtSat")) ::
+              Data.ProtoLens.FieldDescriptor RouteFeeRequest
+      in
+        Data.Map.fromList
+          [(Data.ProtoLens.Tag 1, dest__field_descriptor),
+           (Data.ProtoLens.Tag 2, amtSat__field_descriptor)]
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _RouteFeeRequest'_unknownFields
+        (\ x__ y__ -> x__ {_RouteFeeRequest'_unknownFields = y__})
+  defMessage
+    = RouteFeeRequest'_constructor
+        {_RouteFeeRequest'dest = Data.ProtoLens.fieldDefault,
+         _RouteFeeRequest'amtSat = Data.ProtoLens.fieldDefault,
+         _RouteFeeRequest'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          RouteFeeRequest
+          -> Data.ProtoLens.Encoding.Bytes.Parser RouteFeeRequest
+        loop x
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of
+                        10
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.getBytes
+                                             (Prelude.fromIntegral len))
+                                       "dest"
+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"dest") y x)
+                        16
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          Prelude.fromIntegral
+                                          Data.ProtoLens.Encoding.Bytes.getVarInt)
+                                       "amt_sat"
+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"amtSat") y x)
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do loop Data.ProtoLens.defMessage) "RouteFeeRequest"
+  buildMessage
+    = \ _x
+        -> (Data.Monoid.<>)
+             (let _v = Lens.Family2.view (Data.ProtoLens.Field.field @"dest") _x
+              in
+                if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                    Data.Monoid.mempty
+                else
+                    (Data.Monoid.<>)
+                      (Data.ProtoLens.Encoding.Bytes.putVarInt 10)
+                      ((\ bs
+                          -> (Data.Monoid.<>)
+                               (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                  (Prelude.fromIntegral (Data.ByteString.length bs)))
+                               (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                         _v))
+             ((Data.Monoid.<>)
+                (let
+                   _v = Lens.Family2.view (Data.ProtoLens.Field.field @"amtSat") _x
+                 in
+                   if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                       Data.Monoid.mempty
+                   else
+                       (Data.Monoid.<>)
+                         (Data.ProtoLens.Encoding.Bytes.putVarInt 16)
+                         ((Prelude..)
+                            Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v))
+                (Data.ProtoLens.Encoding.Wire.buildFieldSet
+                   (Lens.Family2.view Data.ProtoLens.unknownFields _x)))
+instance Control.DeepSeq.NFData RouteFeeRequest where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_RouteFeeRequest'_unknownFields x__)
+             (Control.DeepSeq.deepseq
+                (_RouteFeeRequest'dest x__)
+                (Control.DeepSeq.deepseq (_RouteFeeRequest'amtSat x__) ()))
+{- | Fields :
+     
+         * 'Proto.RouterGrpc_Fields.routingFeeMsat' @:: Lens' RouteFeeResponse Data.Int.Int64@
+         * 'Proto.RouterGrpc_Fields.timeLockDelay' @:: Lens' RouteFeeResponse Data.Int.Int64@ -}
+data RouteFeeResponse
+  = RouteFeeResponse'_constructor {_RouteFeeResponse'routingFeeMsat :: !Data.Int.Int64,
+                                   _RouteFeeResponse'timeLockDelay :: !Data.Int.Int64,
+                                   _RouteFeeResponse'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show RouteFeeResponse where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Field.HasField RouteFeeResponse "routingFeeMsat" Data.Int.Int64 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _RouteFeeResponse'routingFeeMsat
+           (\ x__ y__ -> x__ {_RouteFeeResponse'routingFeeMsat = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField RouteFeeResponse "timeLockDelay" Data.Int.Int64 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _RouteFeeResponse'timeLockDelay
+           (\ x__ y__ -> x__ {_RouteFeeResponse'timeLockDelay = y__}))
+        Prelude.id
+instance Data.ProtoLens.Message RouteFeeResponse where
+  messageName _ = Data.Text.pack "routerrpc.RouteFeeResponse"
+  packedMessageDescriptor _
+    = "\n\
+      \\DLERouteFeeResponse\DC2(\n\
+      \\DLErouting_fee_msat\CAN\SOH \SOH(\ETXR\SOroutingFeeMsat\DC2&\n\
+      \\SItime_lock_delay\CAN\STX \SOH(\ETXR\rtimeLockDelay"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag
+    = let
+        routingFeeMsat__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "routing_fee_msat"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.Int64Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"routingFeeMsat")) ::
+              Data.ProtoLens.FieldDescriptor RouteFeeResponse
+        timeLockDelay__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "time_lock_delay"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.Int64Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"timeLockDelay")) ::
+              Data.ProtoLens.FieldDescriptor RouteFeeResponse
+      in
+        Data.Map.fromList
+          [(Data.ProtoLens.Tag 1, routingFeeMsat__field_descriptor),
+           (Data.ProtoLens.Tag 2, timeLockDelay__field_descriptor)]
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _RouteFeeResponse'_unknownFields
+        (\ x__ y__ -> x__ {_RouteFeeResponse'_unknownFields = y__})
+  defMessage
+    = RouteFeeResponse'_constructor
+        {_RouteFeeResponse'routingFeeMsat = Data.ProtoLens.fieldDefault,
+         _RouteFeeResponse'timeLockDelay = Data.ProtoLens.fieldDefault,
+         _RouteFeeResponse'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          RouteFeeResponse
+          -> Data.ProtoLens.Encoding.Bytes.Parser RouteFeeResponse
+        loop x
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of
+                        8 -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          Prelude.fromIntegral
+                                          Data.ProtoLens.Encoding.Bytes.getVarInt)
+                                       "routing_fee_msat"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"routingFeeMsat") y x)
+                        16
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          Prelude.fromIntegral
+                                          Data.ProtoLens.Encoding.Bytes.getVarInt)
+                                       "time_lock_delay"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"timeLockDelay") y x)
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do loop Data.ProtoLens.defMessage) "RouteFeeResponse"
+  buildMessage
+    = \ _x
+        -> (Data.Monoid.<>)
+             (let
+                _v
+                  = Lens.Family2.view
+                      (Data.ProtoLens.Field.field @"routingFeeMsat") _x
+              in
+                if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                    Data.Monoid.mempty
+                else
+                    (Data.Monoid.<>)
+                      (Data.ProtoLens.Encoding.Bytes.putVarInt 8)
+                      ((Prelude..)
+                         Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v))
+             ((Data.Monoid.<>)
+                (let
+                   _v
+                     = Lens.Family2.view
+                         (Data.ProtoLens.Field.field @"timeLockDelay") _x
+                 in
+                   if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                       Data.Monoid.mempty
+                   else
+                       (Data.Monoid.<>)
+                         (Data.ProtoLens.Encoding.Bytes.putVarInt 16)
+                         ((Prelude..)
+                            Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v))
+                (Data.ProtoLens.Encoding.Wire.buildFieldSet
+                   (Lens.Family2.view Data.ProtoLens.unknownFields _x)))
+instance Control.DeepSeq.NFData RouteFeeResponse where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_RouteFeeResponse'_unknownFields x__)
+             (Control.DeepSeq.deepseq
+                (_RouteFeeResponse'routingFeeMsat x__)
+                (Control.DeepSeq.deepseq (_RouteFeeResponse'timeLockDelay x__) ()))
+{- | Fields :
+     
+         * 'Proto.RouterGrpc_Fields.dest' @:: Lens' SendPaymentRequest Data.ByteString.ByteString@
+         * 'Proto.RouterGrpc_Fields.amt' @:: Lens' SendPaymentRequest Data.Int.Int64@
+         * 'Proto.RouterGrpc_Fields.amtMsat' @:: Lens' SendPaymentRequest Data.Int.Int64@
+         * 'Proto.RouterGrpc_Fields.paymentHash' @:: Lens' SendPaymentRequest Data.ByteString.ByteString@
+         * 'Proto.RouterGrpc_Fields.finalCltvDelta' @:: Lens' SendPaymentRequest Data.Int.Int32@
+         * 'Proto.RouterGrpc_Fields.paymentAddr' @:: Lens' SendPaymentRequest Data.ByteString.ByteString@
+         * 'Proto.RouterGrpc_Fields.paymentRequest' @:: Lens' SendPaymentRequest Data.Text.Text@
+         * 'Proto.RouterGrpc_Fields.timeoutSeconds' @:: Lens' SendPaymentRequest Data.Int.Int32@
+         * 'Proto.RouterGrpc_Fields.feeLimitSat' @:: Lens' SendPaymentRequest Data.Int.Int64@
+         * 'Proto.RouterGrpc_Fields.feeLimitMsat' @:: Lens' SendPaymentRequest Data.Int.Int64@
+         * 'Proto.RouterGrpc_Fields.outgoingChanId' @:: Lens' SendPaymentRequest Data.Word.Word64@
+         * 'Proto.RouterGrpc_Fields.outgoingChanIds' @:: Lens' SendPaymentRequest [Data.Word.Word64]@
+         * 'Proto.RouterGrpc_Fields.vec'outgoingChanIds' @:: Lens' SendPaymentRequest (Data.Vector.Unboxed.Vector Data.Word.Word64)@
+         * 'Proto.RouterGrpc_Fields.lastHopPubkey' @:: Lens' SendPaymentRequest Data.ByteString.ByteString@
+         * 'Proto.RouterGrpc_Fields.cltvLimit' @:: Lens' SendPaymentRequest Data.Int.Int32@
+         * 'Proto.RouterGrpc_Fields.routeHints' @:: Lens' SendPaymentRequest [Proto.LndGrpc.RouteHint]@
+         * 'Proto.RouterGrpc_Fields.vec'routeHints' @:: Lens' SendPaymentRequest (Data.Vector.Vector Proto.LndGrpc.RouteHint)@
+         * 'Proto.RouterGrpc_Fields.destCustomRecords' @:: Lens' SendPaymentRequest (Data.Map.Map Data.Word.Word64 Data.ByteString.ByteString)@
+         * 'Proto.RouterGrpc_Fields.allowSelfPayment' @:: Lens' SendPaymentRequest Prelude.Bool@
+         * 'Proto.RouterGrpc_Fields.destFeatures' @:: Lens' SendPaymentRequest [Proto.LndGrpc.FeatureBit]@
+         * 'Proto.RouterGrpc_Fields.vec'destFeatures' @:: Lens' SendPaymentRequest (Data.Vector.Vector Proto.LndGrpc.FeatureBit)@
+         * 'Proto.RouterGrpc_Fields.maxParts' @:: Lens' SendPaymentRequest Data.Word.Word32@
+         * 'Proto.RouterGrpc_Fields.noInflightUpdates' @:: Lens' SendPaymentRequest Prelude.Bool@
+         * 'Proto.RouterGrpc_Fields.maxShardSizeMsat' @:: Lens' SendPaymentRequest Data.Word.Word64@
+         * 'Proto.RouterGrpc_Fields.amp' @:: Lens' SendPaymentRequest Prelude.Bool@ -}
+data SendPaymentRequest
+  = SendPaymentRequest'_constructor {_SendPaymentRequest'dest :: !Data.ByteString.ByteString,
+                                     _SendPaymentRequest'amt :: !Data.Int.Int64,
+                                     _SendPaymentRequest'amtMsat :: !Data.Int.Int64,
+                                     _SendPaymentRequest'paymentHash :: !Data.ByteString.ByteString,
+                                     _SendPaymentRequest'finalCltvDelta :: !Data.Int.Int32,
+                                     _SendPaymentRequest'paymentAddr :: !Data.ByteString.ByteString,
+                                     _SendPaymentRequest'paymentRequest :: !Data.Text.Text,
+                                     _SendPaymentRequest'timeoutSeconds :: !Data.Int.Int32,
+                                     _SendPaymentRequest'feeLimitSat :: !Data.Int.Int64,
+                                     _SendPaymentRequest'feeLimitMsat :: !Data.Int.Int64,
+                                     _SendPaymentRequest'outgoingChanId :: !Data.Word.Word64,
+                                     _SendPaymentRequest'outgoingChanIds :: !(Data.Vector.Unboxed.Vector Data.Word.Word64),
+                                     _SendPaymentRequest'lastHopPubkey :: !Data.ByteString.ByteString,
+                                     _SendPaymentRequest'cltvLimit :: !Data.Int.Int32,
+                                     _SendPaymentRequest'routeHints :: !(Data.Vector.Vector Proto.LndGrpc.RouteHint),
+                                     _SendPaymentRequest'destCustomRecords :: !(Data.Map.Map Data.Word.Word64 Data.ByteString.ByteString),
+                                     _SendPaymentRequest'allowSelfPayment :: !Prelude.Bool,
+                                     _SendPaymentRequest'destFeatures :: !(Data.Vector.Vector Proto.LndGrpc.FeatureBit),
+                                     _SendPaymentRequest'maxParts :: !Data.Word.Word32,
+                                     _SendPaymentRequest'noInflightUpdates :: !Prelude.Bool,
+                                     _SendPaymentRequest'maxShardSizeMsat :: !Data.Word.Word64,
+                                     _SendPaymentRequest'amp :: !Prelude.Bool,
+                                     _SendPaymentRequest'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show SendPaymentRequest where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Field.HasField SendPaymentRequest "dest" Data.ByteString.ByteString where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _SendPaymentRequest'dest
+           (\ x__ y__ -> x__ {_SendPaymentRequest'dest = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField SendPaymentRequest "amt" Data.Int.Int64 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _SendPaymentRequest'amt
+           (\ x__ y__ -> x__ {_SendPaymentRequest'amt = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField SendPaymentRequest "amtMsat" Data.Int.Int64 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _SendPaymentRequest'amtMsat
+           (\ x__ y__ -> x__ {_SendPaymentRequest'amtMsat = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField SendPaymentRequest "paymentHash" Data.ByteString.ByteString where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _SendPaymentRequest'paymentHash
+           (\ x__ y__ -> x__ {_SendPaymentRequest'paymentHash = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField SendPaymentRequest "finalCltvDelta" Data.Int.Int32 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _SendPaymentRequest'finalCltvDelta
+           (\ x__ y__ -> x__ {_SendPaymentRequest'finalCltvDelta = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField SendPaymentRequest "paymentAddr" Data.ByteString.ByteString where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _SendPaymentRequest'paymentAddr
+           (\ x__ y__ -> x__ {_SendPaymentRequest'paymentAddr = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField SendPaymentRequest "paymentRequest" Data.Text.Text where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _SendPaymentRequest'paymentRequest
+           (\ x__ y__ -> x__ {_SendPaymentRequest'paymentRequest = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField SendPaymentRequest "timeoutSeconds" Data.Int.Int32 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _SendPaymentRequest'timeoutSeconds
+           (\ x__ y__ -> x__ {_SendPaymentRequest'timeoutSeconds = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField SendPaymentRequest "feeLimitSat" Data.Int.Int64 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _SendPaymentRequest'feeLimitSat
+           (\ x__ y__ -> x__ {_SendPaymentRequest'feeLimitSat = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField SendPaymentRequest "feeLimitMsat" Data.Int.Int64 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _SendPaymentRequest'feeLimitMsat
+           (\ x__ y__ -> x__ {_SendPaymentRequest'feeLimitMsat = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField SendPaymentRequest "outgoingChanId" Data.Word.Word64 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _SendPaymentRequest'outgoingChanId
+           (\ x__ y__ -> x__ {_SendPaymentRequest'outgoingChanId = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField SendPaymentRequest "outgoingChanIds" [Data.Word.Word64] where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _SendPaymentRequest'outgoingChanIds
+           (\ x__ y__ -> x__ {_SendPaymentRequest'outgoingChanIds = y__}))
+        (Lens.Family2.Unchecked.lens
+           Data.Vector.Generic.toList
+           (\ _ y__ -> Data.Vector.Generic.fromList y__))
+instance Data.ProtoLens.Field.HasField SendPaymentRequest "vec'outgoingChanIds" (Data.Vector.Unboxed.Vector Data.Word.Word64) where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _SendPaymentRequest'outgoingChanIds
+           (\ x__ y__ -> x__ {_SendPaymentRequest'outgoingChanIds = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField SendPaymentRequest "lastHopPubkey" Data.ByteString.ByteString where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _SendPaymentRequest'lastHopPubkey
+           (\ x__ y__ -> x__ {_SendPaymentRequest'lastHopPubkey = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField SendPaymentRequest "cltvLimit" Data.Int.Int32 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _SendPaymentRequest'cltvLimit
+           (\ x__ y__ -> x__ {_SendPaymentRequest'cltvLimit = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField SendPaymentRequest "routeHints" [Proto.LndGrpc.RouteHint] where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _SendPaymentRequest'routeHints
+           (\ x__ y__ -> x__ {_SendPaymentRequest'routeHints = y__}))
+        (Lens.Family2.Unchecked.lens
+           Data.Vector.Generic.toList
+           (\ _ y__ -> Data.Vector.Generic.fromList y__))
+instance Data.ProtoLens.Field.HasField SendPaymentRequest "vec'routeHints" (Data.Vector.Vector Proto.LndGrpc.RouteHint) where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _SendPaymentRequest'routeHints
+           (\ x__ y__ -> x__ {_SendPaymentRequest'routeHints = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField SendPaymentRequest "destCustomRecords" (Data.Map.Map Data.Word.Word64 Data.ByteString.ByteString) where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _SendPaymentRequest'destCustomRecords
+           (\ x__ y__ -> x__ {_SendPaymentRequest'destCustomRecords = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField SendPaymentRequest "allowSelfPayment" Prelude.Bool where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _SendPaymentRequest'allowSelfPayment
+           (\ x__ y__ -> x__ {_SendPaymentRequest'allowSelfPayment = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField SendPaymentRequest "destFeatures" [Proto.LndGrpc.FeatureBit] where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _SendPaymentRequest'destFeatures
+           (\ x__ y__ -> x__ {_SendPaymentRequest'destFeatures = y__}))
+        (Lens.Family2.Unchecked.lens
+           Data.Vector.Generic.toList
+           (\ _ y__ -> Data.Vector.Generic.fromList y__))
+instance Data.ProtoLens.Field.HasField SendPaymentRequest "vec'destFeatures" (Data.Vector.Vector Proto.LndGrpc.FeatureBit) where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _SendPaymentRequest'destFeatures
+           (\ x__ y__ -> x__ {_SendPaymentRequest'destFeatures = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField SendPaymentRequest "maxParts" Data.Word.Word32 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _SendPaymentRequest'maxParts
+           (\ x__ y__ -> x__ {_SendPaymentRequest'maxParts = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField SendPaymentRequest "noInflightUpdates" Prelude.Bool where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _SendPaymentRequest'noInflightUpdates
+           (\ x__ y__ -> x__ {_SendPaymentRequest'noInflightUpdates = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField SendPaymentRequest "maxShardSizeMsat" Data.Word.Word64 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _SendPaymentRequest'maxShardSizeMsat
+           (\ x__ y__ -> x__ {_SendPaymentRequest'maxShardSizeMsat = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField SendPaymentRequest "amp" Prelude.Bool where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _SendPaymentRequest'amp
+           (\ x__ y__ -> x__ {_SendPaymentRequest'amp = y__}))
+        Prelude.id
+instance Data.ProtoLens.Message SendPaymentRequest where
+  messageName _ = Data.Text.pack "routerrpc.SendPaymentRequest"
+  packedMessageDescriptor _
+    = "\n\
+      \\DC2SendPaymentRequest\DC2\DC2\n\
+      \\EOTdest\CAN\SOH \SOH(\fR\EOTdest\DC2\DLE\n\
+      \\ETXamt\CAN\STX \SOH(\ETXR\ETXamt\DC2\EM\n\
+      \\bamt_msat\CAN\f \SOH(\ETXR\aamtMsat\DC2!\n\
+      \\fpayment_hash\CAN\ETX \SOH(\fR\vpaymentHash\DC2(\n\
+      \\DLEfinal_cltv_delta\CAN\EOT \SOH(\ENQR\SOfinalCltvDelta\DC2!\n\
+      \\fpayment_addr\CAN\DC4 \SOH(\fR\vpaymentAddr\DC2'\n\
+      \\SIpayment_request\CAN\ENQ \SOH(\tR\SOpaymentRequest\DC2'\n\
+      \\SItimeout_seconds\CAN\ACK \SOH(\ENQR\SOtimeoutSeconds\DC2\"\n\
+      \\rfee_limit_sat\CAN\a \SOH(\ETXR\vfeeLimitSat\DC2$\n\
+      \\SOfee_limit_msat\CAN\r \SOH(\ETXR\ffeeLimitMsat\DC2.\n\
+      \\DLEoutgoing_chan_id\CAN\b \SOH(\EOTR\SOoutgoingChanIdB\EOT0\SOH\CAN\SOH\DC2*\n\
+      \\DC1outgoing_chan_ids\CAN\DC3 \ETX(\EOTR\SIoutgoingChanIds\DC2&\n\
+      \\SIlast_hop_pubkey\CAN\SO \SOH(\fR\rlastHopPubkey\DC2\GS\n\
+      \\n\
+      \cltv_limit\CAN\t \SOH(\ENQR\tcltvLimit\DC21\n\
+      \\vroute_hints\CAN\n\
+      \ \ETX(\v2\DLE.lnrpc.RouteHintR\n\
+      \routeHints\DC2d\n\
+      \\DC3dest_custom_records\CAN\v \ETX(\v24.routerrpc.SendPaymentRequest.DestCustomRecordsEntryR\DC1destCustomRecords\DC2,\n\
+      \\DC2allow_self_payment\CAN\SI \SOH(\bR\DLEallowSelfPayment\DC26\n\
+      \\rdest_features\CAN\DLE \ETX(\SO2\DC1.lnrpc.FeatureBitR\fdestFeatures\DC2\ESC\n\
+      \\tmax_parts\CAN\DC1 \SOH(\rR\bmaxParts\DC2.\n\
+      \\DC3no_inflight_updates\CAN\DC2 \SOH(\bR\DC1noInflightUpdates\DC2-\n\
+      \\DC3max_shard_size_msat\CAN\NAK \SOH(\EOTR\DLEmaxShardSizeMsat\DC2\DLE\n\
+      \\ETXamp\CAN\SYN \SOH(\bR\ETXamp\SUBD\n\
+      \\SYNDestCustomRecordsEntry\DC2\DLE\n\
+      \\ETXkey\CAN\SOH \SOH(\EOTR\ETXkey\DC2\DC4\n\
+      \\ENQvalue\CAN\STX \SOH(\fR\ENQvalue:\STX8\SOH"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag
+    = let
+        dest__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "dest"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional (Data.ProtoLens.Field.field @"dest")) ::
+              Data.ProtoLens.FieldDescriptor SendPaymentRequest
+        amt__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "amt"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.Int64Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional (Data.ProtoLens.Field.field @"amt")) ::
+              Data.ProtoLens.FieldDescriptor SendPaymentRequest
+        amtMsat__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "amt_msat"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.Int64Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional (Data.ProtoLens.Field.field @"amtMsat")) ::
+              Data.ProtoLens.FieldDescriptor SendPaymentRequest
+        paymentHash__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "payment_hash"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"paymentHash")) ::
+              Data.ProtoLens.FieldDescriptor SendPaymentRequest
+        finalCltvDelta__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "final_cltv_delta"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"finalCltvDelta")) ::
+              Data.ProtoLens.FieldDescriptor SendPaymentRequest
+        paymentAddr__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "payment_addr"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"paymentAddr")) ::
+              Data.ProtoLens.FieldDescriptor SendPaymentRequest
+        paymentRequest__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "payment_request"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"paymentRequest")) ::
+              Data.ProtoLens.FieldDescriptor SendPaymentRequest
+        timeoutSeconds__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "timeout_seconds"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"timeoutSeconds")) ::
+              Data.ProtoLens.FieldDescriptor SendPaymentRequest
+        feeLimitSat__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "fee_limit_sat"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.Int64Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"feeLimitSat")) ::
+              Data.ProtoLens.FieldDescriptor SendPaymentRequest
+        feeLimitMsat__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "fee_limit_msat"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.Int64Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"feeLimitMsat")) ::
+              Data.ProtoLens.FieldDescriptor SendPaymentRequest
+        outgoingChanId__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "outgoing_chan_id"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.UInt64Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Word.Word64)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"outgoingChanId")) ::
+              Data.ProtoLens.FieldDescriptor SendPaymentRequest
+        outgoingChanIds__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "outgoing_chan_ids"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.UInt64Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Word.Word64)
+              (Data.ProtoLens.RepeatedField
+                 Data.ProtoLens.Packed
+                 (Data.ProtoLens.Field.field @"outgoingChanIds")) ::
+              Data.ProtoLens.FieldDescriptor SendPaymentRequest
+        lastHopPubkey__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "last_hop_pubkey"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"lastHopPubkey")) ::
+              Data.ProtoLens.FieldDescriptor SendPaymentRequest
+        cltvLimit__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "cltv_limit"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"cltvLimit")) ::
+              Data.ProtoLens.FieldDescriptor SendPaymentRequest
+        routeHints__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "route_hints"
+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
+                 Data.ProtoLens.FieldTypeDescriptor Proto.LndGrpc.RouteHint)
+              (Data.ProtoLens.RepeatedField
+                 Data.ProtoLens.Unpacked
+                 (Data.ProtoLens.Field.field @"routeHints")) ::
+              Data.ProtoLens.FieldDescriptor SendPaymentRequest
+        destCustomRecords__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "dest_custom_records"
+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
+                 Data.ProtoLens.FieldTypeDescriptor SendPaymentRequest'DestCustomRecordsEntry)
+              (Data.ProtoLens.MapField
+                 (Data.ProtoLens.Field.field @"key")
+                 (Data.ProtoLens.Field.field @"value")
+                 (Data.ProtoLens.Field.field @"destCustomRecords")) ::
+              Data.ProtoLens.FieldDescriptor SendPaymentRequest
+        allowSelfPayment__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "allow_self_payment"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::
+                 Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"allowSelfPayment")) ::
+              Data.ProtoLens.FieldDescriptor SendPaymentRequest
+        destFeatures__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "dest_features"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField ::
+                 Data.ProtoLens.FieldTypeDescriptor Proto.LndGrpc.FeatureBit)
+              (Data.ProtoLens.RepeatedField
+                 Data.ProtoLens.Packed
+                 (Data.ProtoLens.Field.field @"destFeatures")) ::
+              Data.ProtoLens.FieldDescriptor SendPaymentRequest
+        maxParts__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "max_parts"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.UInt32Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Word.Word32)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"maxParts")) ::
+              Data.ProtoLens.FieldDescriptor SendPaymentRequest
+        noInflightUpdates__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "no_inflight_updates"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::
+                 Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"noInflightUpdates")) ::
+              Data.ProtoLens.FieldDescriptor SendPaymentRequest
+        maxShardSizeMsat__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "max_shard_size_msat"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.UInt64Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Word.Word64)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"maxShardSizeMsat")) ::
+              Data.ProtoLens.FieldDescriptor SendPaymentRequest
+        amp__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "amp"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::
+                 Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional (Data.ProtoLens.Field.field @"amp")) ::
+              Data.ProtoLens.FieldDescriptor SendPaymentRequest
+      in
+        Data.Map.fromList
+          [(Data.ProtoLens.Tag 1, dest__field_descriptor),
+           (Data.ProtoLens.Tag 2, amt__field_descriptor),
+           (Data.ProtoLens.Tag 12, amtMsat__field_descriptor),
+           (Data.ProtoLens.Tag 3, paymentHash__field_descriptor),
+           (Data.ProtoLens.Tag 4, finalCltvDelta__field_descriptor),
+           (Data.ProtoLens.Tag 20, paymentAddr__field_descriptor),
+           (Data.ProtoLens.Tag 5, paymentRequest__field_descriptor),
+           (Data.ProtoLens.Tag 6, timeoutSeconds__field_descriptor),
+           (Data.ProtoLens.Tag 7, feeLimitSat__field_descriptor),
+           (Data.ProtoLens.Tag 13, feeLimitMsat__field_descriptor),
+           (Data.ProtoLens.Tag 8, outgoingChanId__field_descriptor),
+           (Data.ProtoLens.Tag 19, outgoingChanIds__field_descriptor),
+           (Data.ProtoLens.Tag 14, lastHopPubkey__field_descriptor),
+           (Data.ProtoLens.Tag 9, cltvLimit__field_descriptor),
+           (Data.ProtoLens.Tag 10, routeHints__field_descriptor),
+           (Data.ProtoLens.Tag 11, destCustomRecords__field_descriptor),
+           (Data.ProtoLens.Tag 15, allowSelfPayment__field_descriptor),
+           (Data.ProtoLens.Tag 16, destFeatures__field_descriptor),
+           (Data.ProtoLens.Tag 17, maxParts__field_descriptor),
+           (Data.ProtoLens.Tag 18, noInflightUpdates__field_descriptor),
+           (Data.ProtoLens.Tag 21, maxShardSizeMsat__field_descriptor),
+           (Data.ProtoLens.Tag 22, amp__field_descriptor)]
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _SendPaymentRequest'_unknownFields
+        (\ x__ y__ -> x__ {_SendPaymentRequest'_unknownFields = y__})
+  defMessage
+    = SendPaymentRequest'_constructor
+        {_SendPaymentRequest'dest = Data.ProtoLens.fieldDefault,
+         _SendPaymentRequest'amt = Data.ProtoLens.fieldDefault,
+         _SendPaymentRequest'amtMsat = Data.ProtoLens.fieldDefault,
+         _SendPaymentRequest'paymentHash = Data.ProtoLens.fieldDefault,
+         _SendPaymentRequest'finalCltvDelta = Data.ProtoLens.fieldDefault,
+         _SendPaymentRequest'paymentAddr = Data.ProtoLens.fieldDefault,
+         _SendPaymentRequest'paymentRequest = Data.ProtoLens.fieldDefault,
+         _SendPaymentRequest'timeoutSeconds = Data.ProtoLens.fieldDefault,
+         _SendPaymentRequest'feeLimitSat = Data.ProtoLens.fieldDefault,
+         _SendPaymentRequest'feeLimitMsat = Data.ProtoLens.fieldDefault,
+         _SendPaymentRequest'outgoingChanId = Data.ProtoLens.fieldDefault,
+         _SendPaymentRequest'outgoingChanIds = Data.Vector.Generic.empty,
+         _SendPaymentRequest'lastHopPubkey = Data.ProtoLens.fieldDefault,
+         _SendPaymentRequest'cltvLimit = Data.ProtoLens.fieldDefault,
+         _SendPaymentRequest'routeHints = Data.Vector.Generic.empty,
+         _SendPaymentRequest'destCustomRecords = Data.Map.empty,
+         _SendPaymentRequest'allowSelfPayment = Data.ProtoLens.fieldDefault,
+         _SendPaymentRequest'destFeatures = Data.Vector.Generic.empty,
+         _SendPaymentRequest'maxParts = Data.ProtoLens.fieldDefault,
+         _SendPaymentRequest'noInflightUpdates = Data.ProtoLens.fieldDefault,
+         _SendPaymentRequest'maxShardSizeMsat = Data.ProtoLens.fieldDefault,
+         _SendPaymentRequest'amp = Data.ProtoLens.fieldDefault,
+         _SendPaymentRequest'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          SendPaymentRequest
+          -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld Proto.LndGrpc.FeatureBit
+             -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Unboxed.Vector Data.ProtoLens.Encoding.Growing.RealWorld Data.Word.Word64
+                -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld Proto.LndGrpc.RouteHint
+                   -> Data.ProtoLens.Encoding.Bytes.Parser SendPaymentRequest
+        loop
+          x
+          mutable'destFeatures
+          mutable'outgoingChanIds
+          mutable'routeHints
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do frozen'destFeatures <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
+                                               (Data.ProtoLens.Encoding.Growing.unsafeFreeze
+                                                  mutable'destFeatures)
+                      frozen'outgoingChanIds <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
+                                                  (Data.ProtoLens.Encoding.Growing.unsafeFreeze
+                                                     mutable'outgoingChanIds)
+                      frozen'routeHints <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
+                                             (Data.ProtoLens.Encoding.Growing.unsafeFreeze
+                                                mutable'routeHints)
+                      (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields
+                           (\ !t -> Prelude.reverse t)
+                           (Lens.Family2.set
+                              (Data.ProtoLens.Field.field @"vec'destFeatures")
+                              frozen'destFeatures
+                              (Lens.Family2.set
+                                 (Data.ProtoLens.Field.field @"vec'outgoingChanIds")
+                                 frozen'outgoingChanIds
+                                 (Lens.Family2.set
+                                    (Data.ProtoLens.Field.field @"vec'routeHints")
+                                    frozen'routeHints
+                                    x))))
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of
+                        10
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.getBytes
+                                             (Prelude.fromIntegral len))
+                                       "dest"
+                                loop
+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"dest") y x)
+                                  mutable'destFeatures
+                                  mutable'outgoingChanIds
+                                  mutable'routeHints
+                        16
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          Prelude.fromIntegral
+                                          Data.ProtoLens.Encoding.Bytes.getVarInt)
+                                       "amt"
+                                loop
+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"amt") y x)
+                                  mutable'destFeatures
+                                  mutable'outgoingChanIds
+                                  mutable'routeHints
+                        96
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          Prelude.fromIntegral
+                                          Data.ProtoLens.Encoding.Bytes.getVarInt)
+                                       "amt_msat"
+                                loop
+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"amtMsat") y x)
+                                  mutable'destFeatures
+                                  mutable'outgoingChanIds
+                                  mutable'routeHints
+                        26
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.getBytes
+                                             (Prelude.fromIntegral len))
+                                       "payment_hash"
+                                loop
+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"paymentHash") y x)
+                                  mutable'destFeatures
+                                  mutable'outgoingChanIds
+                                  mutable'routeHints
+                        32
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          Prelude.fromIntegral
+                                          Data.ProtoLens.Encoding.Bytes.getVarInt)
+                                       "final_cltv_delta"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"finalCltvDelta") y x)
+                                  mutable'destFeatures
+                                  mutable'outgoingChanIds
+                                  mutable'routeHints
+                        162
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.getBytes
+                                             (Prelude.fromIntegral len))
+                                       "payment_addr"
+                                loop
+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"paymentAddr") y x)
+                                  mutable'destFeatures
+                                  mutable'outgoingChanIds
+                                  mutable'routeHints
+                        42
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                                       Data.ProtoLens.Encoding.Bytes.getBytes
+                                                         (Prelude.fromIntegral len)
+                                           Data.ProtoLens.Encoding.Bytes.runEither
+                                             (case Data.Text.Encoding.decodeUtf8' value of
+                                                (Prelude.Left err)
+                                                  -> Prelude.Left (Prelude.show err)
+                                                (Prelude.Right r) -> Prelude.Right r))
+                                       "payment_request"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"paymentRequest") y x)
+                                  mutable'destFeatures
+                                  mutable'outgoingChanIds
+                                  mutable'routeHints
+                        48
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          Prelude.fromIntegral
+                                          Data.ProtoLens.Encoding.Bytes.getVarInt)
+                                       "timeout_seconds"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"timeoutSeconds") y x)
+                                  mutable'destFeatures
+                                  mutable'outgoingChanIds
+                                  mutable'routeHints
+                        56
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          Prelude.fromIntegral
+                                          Data.ProtoLens.Encoding.Bytes.getVarInt)
+                                       "fee_limit_sat"
+                                loop
+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"feeLimitSat") y x)
+                                  mutable'destFeatures
+                                  mutable'outgoingChanIds
+                                  mutable'routeHints
+                        104
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          Prelude.fromIntegral
+                                          Data.ProtoLens.Encoding.Bytes.getVarInt)
+                                       "fee_limit_msat"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"feeLimitMsat") y x)
+                                  mutable'destFeatures
+                                  mutable'outgoingChanIds
+                                  mutable'routeHints
+                        64
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       Data.ProtoLens.Encoding.Bytes.getVarInt "outgoing_chan_id"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"outgoingChanId") y x)
+                                  mutable'destFeatures
+                                  mutable'outgoingChanIds
+                                  mutable'routeHints
+                        152
+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                        Data.ProtoLens.Encoding.Bytes.getVarInt "outgoing_chan_ids"
+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
+                                       (Data.ProtoLens.Encoding.Growing.append
+                                          mutable'outgoingChanIds y)
+                                loop x mutable'destFeatures v mutable'routeHints
+                        154
+                          -> do y <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                        Data.ProtoLens.Encoding.Bytes.isolate
+                                          (Prelude.fromIntegral len)
+                                          ((let
+                                              ploop qs
+                                                = do packedEnd <- Data.ProtoLens.Encoding.Bytes.atEnd
+                                                     if packedEnd then
+                                                         Prelude.return qs
+                                                     else
+                                                         do !q <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                                                    Data.ProtoLens.Encoding.Bytes.getVarInt
+                                                                    "outgoing_chan_ids"
+                                                            qs' <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
+                                                                     (Data.ProtoLens.Encoding.Growing.append
+                                                                        qs q)
+                                                            ploop qs'
+                                            in ploop)
+                                             mutable'outgoingChanIds)
+                                loop x mutable'destFeatures y mutable'routeHints
+                        114
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.getBytes
+                                             (Prelude.fromIntegral len))
+                                       "last_hop_pubkey"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"lastHopPubkey") y x)
+                                  mutable'destFeatures
+                                  mutable'outgoingChanIds
+                                  mutable'routeHints
+                        72
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          Prelude.fromIntegral
+                                          Data.ProtoLens.Encoding.Bytes.getVarInt)
+                                       "cltv_limit"
+                                loop
+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"cltvLimit") y x)
+                                  mutable'destFeatures
+                                  mutable'outgoingChanIds
+                                  mutable'routeHints
+                        82
+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                        (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                            Data.ProtoLens.Encoding.Bytes.isolate
+                                              (Prelude.fromIntegral len)
+                                              Data.ProtoLens.parseMessage)
+                                        "route_hints"
+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
+                                       (Data.ProtoLens.Encoding.Growing.append mutable'routeHints y)
+                                loop x mutable'destFeatures mutable'outgoingChanIds v
+                        90
+                          -> do !(entry :: SendPaymentRequest'DestCustomRecordsEntry) <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                                                                           (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                                                                               Data.ProtoLens.Encoding.Bytes.isolate
+                                                                                                 (Prelude.fromIntegral
+                                                                                                    len)
+                                                                                                 Data.ProtoLens.parseMessage)
+                                                                                           "dest_custom_records"
+                                (let
+                                   key = Lens.Family2.view (Data.ProtoLens.Field.field @"key") entry
+                                   value
+                                     = Lens.Family2.view (Data.ProtoLens.Field.field @"value") entry
+                                 in
+                                   loop
+                                     (Lens.Family2.over
+                                        (Data.ProtoLens.Field.field @"destCustomRecords")
+                                        (\ !t -> Data.Map.insert key value t)
+                                        x)
+                                     mutable'destFeatures
+                                     mutable'outgoingChanIds
+                                     mutable'routeHints)
+                        120
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt)
+                                       "allow_self_payment"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"allowSelfPayment") y x)
+                                  mutable'destFeatures
+                                  mutable'outgoingChanIds
+                                  mutable'routeHints
+                        128
+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                        (Prelude.fmap
+                                           Prelude.toEnum
+                                           (Prelude.fmap
+                                              Prelude.fromIntegral
+                                              Data.ProtoLens.Encoding.Bytes.getVarInt))
+                                        "dest_features"
+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
+                                       (Data.ProtoLens.Encoding.Growing.append
+                                          mutable'destFeatures y)
+                                loop x v mutable'outgoingChanIds mutable'routeHints
+                        130
+                          -> do y <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                        Data.ProtoLens.Encoding.Bytes.isolate
+                                          (Prelude.fromIntegral len)
+                                          ((let
+                                              ploop qs
+                                                = do packedEnd <- Data.ProtoLens.Encoding.Bytes.atEnd
+                                                     if packedEnd then
+                                                         Prelude.return qs
+                                                     else
+                                                         do !q <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                                                    (Prelude.fmap
+                                                                       Prelude.toEnum
+                                                                       (Prelude.fmap
+                                                                          Prelude.fromIntegral
+                                                                          Data.ProtoLens.Encoding.Bytes.getVarInt))
+                                                                    "dest_features"
+                                                            qs' <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
+                                                                     (Data.ProtoLens.Encoding.Growing.append
+                                                                        qs q)
+                                                            ploop qs'
+                                            in ploop)
+                                             mutable'destFeatures)
+                                loop x y mutable'outgoingChanIds mutable'routeHints
+                        136
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          Prelude.fromIntegral
+                                          Data.ProtoLens.Encoding.Bytes.getVarInt)
+                                       "max_parts"
+                                loop
+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"maxParts") y x)
+                                  mutable'destFeatures
+                                  mutable'outgoingChanIds
+                                  mutable'routeHints
+                        144
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt)
+                                       "no_inflight_updates"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"noInflightUpdates") y x)
+                                  mutable'destFeatures
+                                  mutable'outgoingChanIds
+                                  mutable'routeHints
+                        168
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       Data.ProtoLens.Encoding.Bytes.getVarInt "max_shard_size_msat"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"maxShardSizeMsat") y x)
+                                  mutable'destFeatures
+                                  mutable'outgoingChanIds
+                                  mutable'routeHints
+                        176
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt)
+                                       "amp"
+                                loop
+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"amp") y x)
+                                  mutable'destFeatures
+                                  mutable'outgoingChanIds
+                                  mutable'routeHints
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)
+                                  mutable'destFeatures
+                                  mutable'outgoingChanIds
+                                  mutable'routeHints
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do mutable'destFeatures <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
+                                        Data.ProtoLens.Encoding.Growing.new
+              mutable'outgoingChanIds <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
+                                           Data.ProtoLens.Encoding.Growing.new
+              mutable'routeHints <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
+                                      Data.ProtoLens.Encoding.Growing.new
+              loop
+                Data.ProtoLens.defMessage
+                mutable'destFeatures
+                mutable'outgoingChanIds
+                mutable'routeHints)
+          "SendPaymentRequest"
+  buildMessage
+    = \ _x
+        -> (Data.Monoid.<>)
+             (let _v = Lens.Family2.view (Data.ProtoLens.Field.field @"dest") _x
+              in
+                if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                    Data.Monoid.mempty
+                else
+                    (Data.Monoid.<>)
+                      (Data.ProtoLens.Encoding.Bytes.putVarInt 10)
+                      ((\ bs
+                          -> (Data.Monoid.<>)
+                               (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                  (Prelude.fromIntegral (Data.ByteString.length bs)))
+                               (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                         _v))
+             ((Data.Monoid.<>)
+                (let _v = Lens.Family2.view (Data.ProtoLens.Field.field @"amt") _x
+                 in
+                   if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                       Data.Monoid.mempty
+                   else
+                       (Data.Monoid.<>)
+                         (Data.ProtoLens.Encoding.Bytes.putVarInt 16)
+                         ((Prelude..)
+                            Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v))
+                ((Data.Monoid.<>)
+                   (let
+                      _v = Lens.Family2.view (Data.ProtoLens.Field.field @"amtMsat") _x
+                    in
+                      if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                          Data.Monoid.mempty
+                      else
+                          (Data.Monoid.<>)
+                            (Data.ProtoLens.Encoding.Bytes.putVarInt 96)
+                            ((Prelude..)
+                               Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v))
+                   ((Data.Monoid.<>)
+                      (let
+                         _v
+                           = Lens.Family2.view (Data.ProtoLens.Field.field @"paymentHash") _x
+                       in
+                         if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                             Data.Monoid.mempty
+                         else
+                             (Data.Monoid.<>)
+                               (Data.ProtoLens.Encoding.Bytes.putVarInt 26)
+                               ((\ bs
+                                   -> (Data.Monoid.<>)
+                                        (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                           (Prelude.fromIntegral (Data.ByteString.length bs)))
+                                        (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                                  _v))
+                      ((Data.Monoid.<>)
+                         (let
+                            _v
+                              = Lens.Family2.view
+                                  (Data.ProtoLens.Field.field @"finalCltvDelta") _x
+                          in
+                            if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                                Data.Monoid.mempty
+                            else
+                                (Data.Monoid.<>)
+                                  (Data.ProtoLens.Encoding.Bytes.putVarInt 32)
+                                  ((Prelude..)
+                                     Data.ProtoLens.Encoding.Bytes.putVarInt
+                                     Prelude.fromIntegral
+                                     _v))
+                         ((Data.Monoid.<>)
+                            (let
+                               _v
+                                 = Lens.Family2.view (Data.ProtoLens.Field.field @"paymentAddr") _x
+                             in
+                               if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                                   Data.Monoid.mempty
+                               else
+                                   (Data.Monoid.<>)
+                                     (Data.ProtoLens.Encoding.Bytes.putVarInt 162)
+                                     ((\ bs
+                                         -> (Data.Monoid.<>)
+                                              (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                                 (Prelude.fromIntegral (Data.ByteString.length bs)))
+                                              (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                                        _v))
+                            ((Data.Monoid.<>)
+                               (let
+                                  _v
+                                    = Lens.Family2.view
+                                        (Data.ProtoLens.Field.field @"paymentRequest") _x
+                                in
+                                  if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                                      Data.Monoid.mempty
+                                  else
+                                      (Data.Monoid.<>)
+                                        (Data.ProtoLens.Encoding.Bytes.putVarInt 42)
+                                        ((Prelude..)
+                                           (\ bs
+                                              -> (Data.Monoid.<>)
+                                                   (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                                      (Prelude.fromIntegral
+                                                         (Data.ByteString.length bs)))
+                                                   (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                                           Data.Text.Encoding.encodeUtf8
+                                           _v))
+                               ((Data.Monoid.<>)
+                                  (let
+                                     _v
+                                       = Lens.Family2.view
+                                           (Data.ProtoLens.Field.field @"timeoutSeconds") _x
+                                   in
+                                     if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                                         Data.Monoid.mempty
+                                     else
+                                         (Data.Monoid.<>)
+                                           (Data.ProtoLens.Encoding.Bytes.putVarInt 48)
+                                           ((Prelude..)
+                                              Data.ProtoLens.Encoding.Bytes.putVarInt
+                                              Prelude.fromIntegral
+                                              _v))
+                                  ((Data.Monoid.<>)
+                                     (let
+                                        _v
+                                          = Lens.Family2.view
+                                              (Data.ProtoLens.Field.field @"feeLimitSat") _x
+                                      in
+                                        if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                                            Data.Monoid.mempty
+                                        else
+                                            (Data.Monoid.<>)
+                                              (Data.ProtoLens.Encoding.Bytes.putVarInt 56)
+                                              ((Prelude..)
+                                                 Data.ProtoLens.Encoding.Bytes.putVarInt
+                                                 Prelude.fromIntegral
+                                                 _v))
+                                     ((Data.Monoid.<>)
+                                        (let
+                                           _v
+                                             = Lens.Family2.view
+                                                 (Data.ProtoLens.Field.field @"feeLimitMsat") _x
+                                         in
+                                           if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                                               Data.Monoid.mempty
+                                           else
+                                               (Data.Monoid.<>)
+                                                 (Data.ProtoLens.Encoding.Bytes.putVarInt 104)
+                                                 ((Prelude..)
+                                                    Data.ProtoLens.Encoding.Bytes.putVarInt
+                                                    Prelude.fromIntegral
+                                                    _v))
+                                        ((Data.Monoid.<>)
+                                           (let
+                                              _v
+                                                = Lens.Family2.view
+                                                    (Data.ProtoLens.Field.field @"outgoingChanId")
+                                                    _x
+                                            in
+                                              if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                                                  Data.Monoid.mempty
+                                              else
+                                                  (Data.Monoid.<>)
+                                                    (Data.ProtoLens.Encoding.Bytes.putVarInt 64)
+                                                    (Data.ProtoLens.Encoding.Bytes.putVarInt _v))
+                                           ((Data.Monoid.<>)
+                                              (let
+                                                 p = Lens.Family2.view
+                                                       (Data.ProtoLens.Field.field
+                                                          @"vec'outgoingChanIds")
+                                                       _x
+                                               in
+                                                 if Data.Vector.Generic.null p then
+                                                     Data.Monoid.mempty
+                                                 else
+                                                     (Data.Monoid.<>)
+                                                       (Data.ProtoLens.Encoding.Bytes.putVarInt 154)
+                                                       ((\ bs
+                                                           -> (Data.Monoid.<>)
+                                                                (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                                                   (Prelude.fromIntegral
+                                                                      (Data.ByteString.length bs)))
+                                                                (Data.ProtoLens.Encoding.Bytes.putBytes
+                                                                   bs))
+                                                          (Data.ProtoLens.Encoding.Bytes.runBuilder
+                                                             (Data.ProtoLens.Encoding.Bytes.foldMapBuilder
+                                                                Data.ProtoLens.Encoding.Bytes.putVarInt
+                                                                p))))
+                                              ((Data.Monoid.<>)
+                                                 (let
+                                                    _v
+                                                      = Lens.Family2.view
+                                                          (Data.ProtoLens.Field.field
+                                                             @"lastHopPubkey")
+                                                          _x
+                                                  in
+                                                    if (Prelude.==)
+                                                         _v Data.ProtoLens.fieldDefault then
+                                                        Data.Monoid.mempty
+                                                    else
+                                                        (Data.Monoid.<>)
+                                                          (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                                             114)
+                                                          ((\ bs
+                                                              -> (Data.Monoid.<>)
+                                                                   (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                                                      (Prelude.fromIntegral
+                                                                         (Data.ByteString.length
+                                                                            bs)))
+                                                                   (Data.ProtoLens.Encoding.Bytes.putBytes
+                                                                      bs))
+                                                             _v))
+                                                 ((Data.Monoid.<>)
+                                                    (let
+                                                       _v
+                                                         = Lens.Family2.view
+                                                             (Data.ProtoLens.Field.field
+                                                                @"cltvLimit")
+                                                             _x
+                                                     in
+                                                       if (Prelude.==)
+                                                            _v Data.ProtoLens.fieldDefault then
+                                                           Data.Monoid.mempty
+                                                       else
+                                                           (Data.Monoid.<>)
+                                                             (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                                                72)
+                                                             ((Prelude..)
+                                                                Data.ProtoLens.Encoding.Bytes.putVarInt
+                                                                Prelude.fromIntegral
+                                                                _v))
+                                                    ((Data.Monoid.<>)
+                                                       (Data.ProtoLens.Encoding.Bytes.foldMapBuilder
+                                                          (\ _v
+                                                             -> (Data.Monoid.<>)
+                                                                  (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                                                     82)
+                                                                  ((Prelude..)
+                                                                     (\ bs
+                                                                        -> (Data.Monoid.<>)
+                                                                             (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                                                                (Prelude.fromIntegral
+                                                                                   (Data.ByteString.length
+                                                                                      bs)))
+                                                                             (Data.ProtoLens.Encoding.Bytes.putBytes
+                                                                                bs))
+                                                                     Data.ProtoLens.encodeMessage
+                                                                     _v))
+                                                          (Lens.Family2.view
+                                                             (Data.ProtoLens.Field.field
+                                                                @"vec'routeHints")
+                                                             _x))
+                                                       ((Data.Monoid.<>)
+                                                          (Data.Monoid.mconcat
+                                                             (Prelude.map
+                                                                (\ _v
+                                                                   -> (Data.Monoid.<>)
+                                                                        (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                                                           90)
+                                                                        ((Prelude..)
+                                                                           (\ bs
+                                                                              -> (Data.Monoid.<>)
+                                                                                   (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                                                                      (Prelude.fromIntegral
+                                                                                         (Data.ByteString.length
+                                                                                            bs)))
+                                                                                   (Data.ProtoLens.Encoding.Bytes.putBytes
+                                                                                      bs))
+                                                                           Data.ProtoLens.encodeMessage
+                                                                           (Lens.Family2.set
+                                                                              (Data.ProtoLens.Field.field
+                                                                                 @"key")
+                                                                              (Prelude.fst _v)
+                                                                              (Lens.Family2.set
+                                                                                 (Data.ProtoLens.Field.field
+                                                                                    @"value")
+                                                                                 (Prelude.snd _v)
+                                                                                 (Data.ProtoLens.defMessage ::
+                                                                                    SendPaymentRequest'DestCustomRecordsEntry)))))
+                                                                (Data.Map.toList
+                                                                   (Lens.Family2.view
+                                                                      (Data.ProtoLens.Field.field
+                                                                         @"destCustomRecords")
+                                                                      _x))))
+                                                          ((Data.Monoid.<>)
+                                                             (let
+                                                                _v
+                                                                  = Lens.Family2.view
+                                                                      (Data.ProtoLens.Field.field
+                                                                         @"allowSelfPayment")
+                                                                      _x
+                                                              in
+                                                                if (Prelude.==)
+                                                                     _v
+                                                                     Data.ProtoLens.fieldDefault then
+                                                                    Data.Monoid.mempty
+                                                                else
+                                                                    (Data.Monoid.<>)
+                                                                      (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                                                         120)
+                                                                      ((Prelude..)
+                                                                         Data.ProtoLens.Encoding.Bytes.putVarInt
+                                                                         (\ b -> if b then 1 else 0)
+                                                                         _v))
+                                                             ((Data.Monoid.<>)
+                                                                (let
+                                                                   p = Lens.Family2.view
+                                                                         (Data.ProtoLens.Field.field
+                                                                            @"vec'destFeatures")
+                                                                         _x
+                                                                 in
+                                                                   if Data.Vector.Generic.null
+                                                                        p then
+                                                                       Data.Monoid.mempty
+                                                                   else
+                                                                       (Data.Monoid.<>)
+                                                                         (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                                                            130)
+                                                                         ((\ bs
+                                                                             -> (Data.Monoid.<>)
+                                                                                  (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                                                                     (Prelude.fromIntegral
+                                                                                        (Data.ByteString.length
+                                                                                           bs)))
+                                                                                  (Data.ProtoLens.Encoding.Bytes.putBytes
+                                                                                     bs))
+                                                                            (Data.ProtoLens.Encoding.Bytes.runBuilder
+                                                                               (Data.ProtoLens.Encoding.Bytes.foldMapBuilder
+                                                                                  ((Prelude..)
+                                                                                     ((Prelude..)
+                                                                                        Data.ProtoLens.Encoding.Bytes.putVarInt
+                                                                                        Prelude.fromIntegral)
+                                                                                     Prelude.fromEnum)
+                                                                                  p))))
+                                                                ((Data.Monoid.<>)
+                                                                   (let
+                                                                      _v
+                                                                        = Lens.Family2.view
+                                                                            (Data.ProtoLens.Field.field
+                                                                               @"maxParts")
+                                                                            _x
+                                                                    in
+                                                                      if (Prelude.==)
+                                                                           _v
+                                                                           Data.ProtoLens.fieldDefault then
+                                                                          Data.Monoid.mempty
+                                                                      else
+                                                                          (Data.Monoid.<>)
+                                                                            (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                                                               136)
+                                                                            ((Prelude..)
+                                                                               Data.ProtoLens.Encoding.Bytes.putVarInt
+                                                                               Prelude.fromIntegral
+                                                                               _v))
+                                                                   ((Data.Monoid.<>)
+                                                                      (let
+                                                                         _v
+                                                                           = Lens.Family2.view
+                                                                               (Data.ProtoLens.Field.field
+                                                                                  @"noInflightUpdates")
+                                                                               _x
+                                                                       in
+                                                                         if (Prelude.==)
+                                                                              _v
+                                                                              Data.ProtoLens.fieldDefault then
+                                                                             Data.Monoid.mempty
+                                                                         else
+                                                                             (Data.Monoid.<>)
+                                                                               (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                                                                  144)
+                                                                               ((Prelude..)
+                                                                                  Data.ProtoLens.Encoding.Bytes.putVarInt
+                                                                                  (\ b
+                                                                                     -> if b then
+                                                                                            1
+                                                                                        else
+                                                                                            0)
+                                                                                  _v))
+                                                                      ((Data.Monoid.<>)
+                                                                         (let
+                                                                            _v
+                                                                              = Lens.Family2.view
+                                                                                  (Data.ProtoLens.Field.field
+                                                                                     @"maxShardSizeMsat")
+                                                                                  _x
+                                                                          in
+                                                                            if (Prelude.==)
+                                                                                 _v
+                                                                                 Data.ProtoLens.fieldDefault then
+                                                                                Data.Monoid.mempty
+                                                                            else
+                                                                                (Data.Monoid.<>)
+                                                                                  (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                                                                     168)
+                                                                                  (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                                                                     _v))
+                                                                         ((Data.Monoid.<>)
+                                                                            (let
+                                                                               _v
+                                                                                 = Lens.Family2.view
+                                                                                     (Data.ProtoLens.Field.field
+                                                                                        @"amp")
+                                                                                     _x
+                                                                             in
+                                                                               if (Prelude.==)
+                                                                                    _v
+                                                                                    Data.ProtoLens.fieldDefault then
+                                                                                   Data.Monoid.mempty
+                                                                               else
+                                                                                   (Data.Monoid.<>)
+                                                                                     (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                                                                        176)
+                                                                                     ((Prelude..)
+                                                                                        Data.ProtoLens.Encoding.Bytes.putVarInt
+                                                                                        (\ b
+                                                                                           -> if b then
+                                                                                                  1
+                                                                                              else
+                                                                                                  0)
+                                                                                        _v))
+                                                                            (Data.ProtoLens.Encoding.Wire.buildFieldSet
+                                                                               (Lens.Family2.view
+                                                                                  Data.ProtoLens.unknownFields
+                                                                                  _x)))))))))))))))))))))))
+instance Control.DeepSeq.NFData SendPaymentRequest where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_SendPaymentRequest'_unknownFields x__)
+             (Control.DeepSeq.deepseq
+                (_SendPaymentRequest'dest x__)
+                (Control.DeepSeq.deepseq
+                   (_SendPaymentRequest'amt x__)
+                   (Control.DeepSeq.deepseq
+                      (_SendPaymentRequest'amtMsat x__)
+                      (Control.DeepSeq.deepseq
+                         (_SendPaymentRequest'paymentHash x__)
+                         (Control.DeepSeq.deepseq
+                            (_SendPaymentRequest'finalCltvDelta x__)
+                            (Control.DeepSeq.deepseq
+                               (_SendPaymentRequest'paymentAddr x__)
+                               (Control.DeepSeq.deepseq
+                                  (_SendPaymentRequest'paymentRequest x__)
+                                  (Control.DeepSeq.deepseq
+                                     (_SendPaymentRequest'timeoutSeconds x__)
+                                     (Control.DeepSeq.deepseq
+                                        (_SendPaymentRequest'feeLimitSat x__)
+                                        (Control.DeepSeq.deepseq
+                                           (_SendPaymentRequest'feeLimitMsat x__)
+                                           (Control.DeepSeq.deepseq
+                                              (_SendPaymentRequest'outgoingChanId x__)
+                                              (Control.DeepSeq.deepseq
+                                                 (_SendPaymentRequest'outgoingChanIds x__)
+                                                 (Control.DeepSeq.deepseq
+                                                    (_SendPaymentRequest'lastHopPubkey x__)
+                                                    (Control.DeepSeq.deepseq
+                                                       (_SendPaymentRequest'cltvLimit x__)
+                                                       (Control.DeepSeq.deepseq
+                                                          (_SendPaymentRequest'routeHints x__)
+                                                          (Control.DeepSeq.deepseq
+                                                             (_SendPaymentRequest'destCustomRecords
+                                                                x__)
+                                                             (Control.DeepSeq.deepseq
+                                                                (_SendPaymentRequest'allowSelfPayment
+                                                                   x__)
+                                                                (Control.DeepSeq.deepseq
+                                                                   (_SendPaymentRequest'destFeatures
+                                                                      x__)
+                                                                   (Control.DeepSeq.deepseq
+                                                                      (_SendPaymentRequest'maxParts
+                                                                         x__)
+                                                                      (Control.DeepSeq.deepseq
+                                                                         (_SendPaymentRequest'noInflightUpdates
+                                                                            x__)
+                                                                         (Control.DeepSeq.deepseq
+                                                                            (_SendPaymentRequest'maxShardSizeMsat
+                                                                               x__)
+                                                                            (Control.DeepSeq.deepseq
+                                                                               (_SendPaymentRequest'amp
+                                                                                  x__)
+                                                                               ()))))))))))))))))))))))
+{- | Fields :
+     
+         * 'Proto.RouterGrpc_Fields.key' @:: Lens' SendPaymentRequest'DestCustomRecordsEntry Data.Word.Word64@
+         * 'Proto.RouterGrpc_Fields.value' @:: Lens' SendPaymentRequest'DestCustomRecordsEntry Data.ByteString.ByteString@ -}
+data SendPaymentRequest'DestCustomRecordsEntry
+  = SendPaymentRequest'DestCustomRecordsEntry'_constructor {_SendPaymentRequest'DestCustomRecordsEntry'key :: !Data.Word.Word64,
+                                                            _SendPaymentRequest'DestCustomRecordsEntry'value :: !Data.ByteString.ByteString,
+                                                            _SendPaymentRequest'DestCustomRecordsEntry'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show SendPaymentRequest'DestCustomRecordsEntry where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Field.HasField SendPaymentRequest'DestCustomRecordsEntry "key" Data.Word.Word64 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _SendPaymentRequest'DestCustomRecordsEntry'key
+           (\ x__ y__
+              -> x__ {_SendPaymentRequest'DestCustomRecordsEntry'key = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField SendPaymentRequest'DestCustomRecordsEntry "value" Data.ByteString.ByteString where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _SendPaymentRequest'DestCustomRecordsEntry'value
+           (\ x__ y__
+              -> x__ {_SendPaymentRequest'DestCustomRecordsEntry'value = y__}))
+        Prelude.id
+instance Data.ProtoLens.Message SendPaymentRequest'DestCustomRecordsEntry where
+  messageName _
+    = Data.Text.pack
+        "routerrpc.SendPaymentRequest.DestCustomRecordsEntry"
+  packedMessageDescriptor _
+    = "\n\
+      \\SYNDestCustomRecordsEntry\DC2\DLE\n\
+      \\ETXkey\CAN\SOH \SOH(\EOTR\ETXkey\DC2\DC4\n\
+      \\ENQvalue\CAN\STX \SOH(\fR\ENQvalue:\STX8\SOH"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag
+    = let
+        key__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "key"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.UInt64Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Word.Word64)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional (Data.ProtoLens.Field.field @"key")) ::
+              Data.ProtoLens.FieldDescriptor SendPaymentRequest'DestCustomRecordsEntry
+        value__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "value"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional (Data.ProtoLens.Field.field @"value")) ::
+              Data.ProtoLens.FieldDescriptor SendPaymentRequest'DestCustomRecordsEntry
+      in
+        Data.Map.fromList
+          [(Data.ProtoLens.Tag 1, key__field_descriptor),
+           (Data.ProtoLens.Tag 2, value__field_descriptor)]
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _SendPaymentRequest'DestCustomRecordsEntry'_unknownFields
+        (\ x__ y__
+           -> x__
+                {_SendPaymentRequest'DestCustomRecordsEntry'_unknownFields = y__})
+  defMessage
+    = SendPaymentRequest'DestCustomRecordsEntry'_constructor
+        {_SendPaymentRequest'DestCustomRecordsEntry'key = Data.ProtoLens.fieldDefault,
+         _SendPaymentRequest'DestCustomRecordsEntry'value = Data.ProtoLens.fieldDefault,
+         _SendPaymentRequest'DestCustomRecordsEntry'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          SendPaymentRequest'DestCustomRecordsEntry
+          -> Data.ProtoLens.Encoding.Bytes.Parser SendPaymentRequest'DestCustomRecordsEntry
+        loop x
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of
+                        8 -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       Data.ProtoLens.Encoding.Bytes.getVarInt "key"
+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"key") y x)
+                        18
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.getBytes
+                                             (Prelude.fromIntegral len))
+                                       "value"
+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"value") y x)
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do loop Data.ProtoLens.defMessage) "DestCustomRecordsEntry"
+  buildMessage
+    = \ _x
+        -> (Data.Monoid.<>)
+             (let _v = Lens.Family2.view (Data.ProtoLens.Field.field @"key") _x
+              in
+                if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                    Data.Monoid.mempty
+                else
+                    (Data.Monoid.<>)
+                      (Data.ProtoLens.Encoding.Bytes.putVarInt 8)
+                      (Data.ProtoLens.Encoding.Bytes.putVarInt _v))
+             ((Data.Monoid.<>)
+                (let
+                   _v = Lens.Family2.view (Data.ProtoLens.Field.field @"value") _x
+                 in
+                   if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                       Data.Monoid.mempty
+                   else
+                       (Data.Monoid.<>)
+                         (Data.ProtoLens.Encoding.Bytes.putVarInt 18)
+                         ((\ bs
+                             -> (Data.Monoid.<>)
+                                  (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                     (Prelude.fromIntegral (Data.ByteString.length bs)))
+                                  (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                            _v))
+                (Data.ProtoLens.Encoding.Wire.buildFieldSet
+                   (Lens.Family2.view Data.ProtoLens.unknownFields _x)))
+instance Control.DeepSeq.NFData SendPaymentRequest'DestCustomRecordsEntry where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_SendPaymentRequest'DestCustomRecordsEntry'_unknownFields x__)
+             (Control.DeepSeq.deepseq
+                (_SendPaymentRequest'DestCustomRecordsEntry'key x__)
+                (Control.DeepSeq.deepseq
+                   (_SendPaymentRequest'DestCustomRecordsEntry'value x__) ()))
+{- | Fields :
+     
+         * 'Proto.RouterGrpc_Fields.paymentHash' @:: Lens' SendToRouteRequest Data.ByteString.ByteString@
+         * 'Proto.RouterGrpc_Fields.route' @:: Lens' SendToRouteRequest Proto.LndGrpc.Route@
+         * 'Proto.RouterGrpc_Fields.maybe'route' @:: Lens' SendToRouteRequest (Prelude.Maybe Proto.LndGrpc.Route)@ -}
+data SendToRouteRequest
+  = SendToRouteRequest'_constructor {_SendToRouteRequest'paymentHash :: !Data.ByteString.ByteString,
+                                     _SendToRouteRequest'route :: !(Prelude.Maybe Proto.LndGrpc.Route),
+                                     _SendToRouteRequest'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show SendToRouteRequest where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Field.HasField SendToRouteRequest "paymentHash" Data.ByteString.ByteString where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _SendToRouteRequest'paymentHash
+           (\ x__ y__ -> x__ {_SendToRouteRequest'paymentHash = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField SendToRouteRequest "route" Proto.LndGrpc.Route where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _SendToRouteRequest'route
+           (\ x__ y__ -> x__ {_SendToRouteRequest'route = y__}))
+        (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage)
+instance Data.ProtoLens.Field.HasField SendToRouteRequest "maybe'route" (Prelude.Maybe Proto.LndGrpc.Route) where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _SendToRouteRequest'route
+           (\ x__ y__ -> x__ {_SendToRouteRequest'route = y__}))
+        Prelude.id
+instance Data.ProtoLens.Message SendToRouteRequest where
+  messageName _ = Data.Text.pack "routerrpc.SendToRouteRequest"
+  packedMessageDescriptor _
+    = "\n\
+      \\DC2SendToRouteRequest\DC2!\n\
+      \\fpayment_hash\CAN\SOH \SOH(\fR\vpaymentHash\DC2\"\n\
+      \\ENQroute\CAN\STX \SOH(\v2\f.lnrpc.RouteR\ENQroute"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag
+    = let
+        paymentHash__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "payment_hash"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"paymentHash")) ::
+              Data.ProtoLens.FieldDescriptor SendToRouteRequest
+        route__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "route"
+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
+                 Data.ProtoLens.FieldTypeDescriptor Proto.LndGrpc.Route)
+              (Data.ProtoLens.OptionalField
+                 (Data.ProtoLens.Field.field @"maybe'route")) ::
+              Data.ProtoLens.FieldDescriptor SendToRouteRequest
+      in
+        Data.Map.fromList
+          [(Data.ProtoLens.Tag 1, paymentHash__field_descriptor),
+           (Data.ProtoLens.Tag 2, route__field_descriptor)]
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _SendToRouteRequest'_unknownFields
+        (\ x__ y__ -> x__ {_SendToRouteRequest'_unknownFields = y__})
+  defMessage
+    = SendToRouteRequest'_constructor
+        {_SendToRouteRequest'paymentHash = Data.ProtoLens.fieldDefault,
+         _SendToRouteRequest'route = Prelude.Nothing,
+         _SendToRouteRequest'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          SendToRouteRequest
+          -> Data.ProtoLens.Encoding.Bytes.Parser SendToRouteRequest
+        loop x
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of
+                        10
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.getBytes
+                                             (Prelude.fromIntegral len))
+                                       "payment_hash"
+                                loop
+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"paymentHash") y x)
+                        18
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.isolate
+                                             (Prelude.fromIntegral len) Data.ProtoLens.parseMessage)
+                                       "route"
+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"route") y x)
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do loop Data.ProtoLens.defMessage) "SendToRouteRequest"
+  buildMessage
+    = \ _x
+        -> (Data.Monoid.<>)
+             (let
+                _v
+                  = Lens.Family2.view (Data.ProtoLens.Field.field @"paymentHash") _x
+              in
+                if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                    Data.Monoid.mempty
+                else
+                    (Data.Monoid.<>)
+                      (Data.ProtoLens.Encoding.Bytes.putVarInt 10)
+                      ((\ bs
+                          -> (Data.Monoid.<>)
+                               (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                  (Prelude.fromIntegral (Data.ByteString.length bs)))
+                               (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                         _v))
+             ((Data.Monoid.<>)
+                (case
+                     Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'route") _x
+                 of
+                   Prelude.Nothing -> Data.Monoid.mempty
+                   (Prelude.Just _v)
+                     -> (Data.Monoid.<>)
+                          (Data.ProtoLens.Encoding.Bytes.putVarInt 18)
+                          ((Prelude..)
+                             (\ bs
+                                -> (Data.Monoid.<>)
+                                     (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                        (Prelude.fromIntegral (Data.ByteString.length bs)))
+                                     (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                             Data.ProtoLens.encodeMessage
+                             _v))
+                (Data.ProtoLens.Encoding.Wire.buildFieldSet
+                   (Lens.Family2.view Data.ProtoLens.unknownFields _x)))
+instance Control.DeepSeq.NFData SendToRouteRequest where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_SendToRouteRequest'_unknownFields x__)
+             (Control.DeepSeq.deepseq
+                (_SendToRouteRequest'paymentHash x__)
+                (Control.DeepSeq.deepseq (_SendToRouteRequest'route x__) ()))
+{- | Fields :
+     
+         * 'Proto.RouterGrpc_Fields.preimage' @:: Lens' SendToRouteResponse Data.ByteString.ByteString@
+         * 'Proto.RouterGrpc_Fields.failure' @:: Lens' SendToRouteResponse Proto.LndGrpc.Failure@
+         * 'Proto.RouterGrpc_Fields.maybe'failure' @:: Lens' SendToRouteResponse (Prelude.Maybe Proto.LndGrpc.Failure)@ -}
+data SendToRouteResponse
+  = SendToRouteResponse'_constructor {_SendToRouteResponse'preimage :: !Data.ByteString.ByteString,
+                                      _SendToRouteResponse'failure :: !(Prelude.Maybe Proto.LndGrpc.Failure),
+                                      _SendToRouteResponse'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show SendToRouteResponse where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Field.HasField SendToRouteResponse "preimage" Data.ByteString.ByteString where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _SendToRouteResponse'preimage
+           (\ x__ y__ -> x__ {_SendToRouteResponse'preimage = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField SendToRouteResponse "failure" Proto.LndGrpc.Failure where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _SendToRouteResponse'failure
+           (\ x__ y__ -> x__ {_SendToRouteResponse'failure = y__}))
+        (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage)
+instance Data.ProtoLens.Field.HasField SendToRouteResponse "maybe'failure" (Prelude.Maybe Proto.LndGrpc.Failure) where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _SendToRouteResponse'failure
+           (\ x__ y__ -> x__ {_SendToRouteResponse'failure = y__}))
+        Prelude.id
+instance Data.ProtoLens.Message SendToRouteResponse where
+  messageName _ = Data.Text.pack "routerrpc.SendToRouteResponse"
+  packedMessageDescriptor _
+    = "\n\
+      \\DC3SendToRouteResponse\DC2\SUB\n\
+      \\bpreimage\CAN\SOH \SOH(\fR\bpreimage\DC2(\n\
+      \\afailure\CAN\STX \SOH(\v2\SO.lnrpc.FailureR\afailure"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag
+    = let
+        preimage__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "preimage"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"preimage")) ::
+              Data.ProtoLens.FieldDescriptor SendToRouteResponse
+        failure__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "failure"
+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
+                 Data.ProtoLens.FieldTypeDescriptor Proto.LndGrpc.Failure)
+              (Data.ProtoLens.OptionalField
+                 (Data.ProtoLens.Field.field @"maybe'failure")) ::
+              Data.ProtoLens.FieldDescriptor SendToRouteResponse
+      in
+        Data.Map.fromList
+          [(Data.ProtoLens.Tag 1, preimage__field_descriptor),
+           (Data.ProtoLens.Tag 2, failure__field_descriptor)]
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _SendToRouteResponse'_unknownFields
+        (\ x__ y__ -> x__ {_SendToRouteResponse'_unknownFields = y__})
+  defMessage
+    = SendToRouteResponse'_constructor
+        {_SendToRouteResponse'preimage = Data.ProtoLens.fieldDefault,
+         _SendToRouteResponse'failure = Prelude.Nothing,
+         _SendToRouteResponse'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          SendToRouteResponse
+          -> Data.ProtoLens.Encoding.Bytes.Parser SendToRouteResponse
+        loop x
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of
+                        10
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.getBytes
+                                             (Prelude.fromIntegral len))
+                                       "preimage"
+                                loop
+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"preimage") y x)
+                        18
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.isolate
+                                             (Prelude.fromIntegral len) Data.ProtoLens.parseMessage)
+                                       "failure"
+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"failure") y x)
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do loop Data.ProtoLens.defMessage) "SendToRouteResponse"
+  buildMessage
+    = \ _x
+        -> (Data.Monoid.<>)
+             (let
+                _v = Lens.Family2.view (Data.ProtoLens.Field.field @"preimage") _x
+              in
+                if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                    Data.Monoid.mempty
+                else
+                    (Data.Monoid.<>)
+                      (Data.ProtoLens.Encoding.Bytes.putVarInt 10)
+                      ((\ bs
+                          -> (Data.Monoid.<>)
+                               (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                  (Prelude.fromIntegral (Data.ByteString.length bs)))
+                               (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                         _v))
+             ((Data.Monoid.<>)
+                (case
+                     Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'failure") _x
+                 of
+                   Prelude.Nothing -> Data.Monoid.mempty
+                   (Prelude.Just _v)
+                     -> (Data.Monoid.<>)
+                          (Data.ProtoLens.Encoding.Bytes.putVarInt 18)
+                          ((Prelude..)
+                             (\ bs
+                                -> (Data.Monoid.<>)
+                                     (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                        (Prelude.fromIntegral (Data.ByteString.length bs)))
+                                     (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                             Data.ProtoLens.encodeMessage
+                             _v))
+                (Data.ProtoLens.Encoding.Wire.buildFieldSet
+                   (Lens.Family2.view Data.ProtoLens.unknownFields _x)))
+instance Control.DeepSeq.NFData SendToRouteResponse where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_SendToRouteResponse'_unknownFields x__)
+             (Control.DeepSeq.deepseq
+                (_SendToRouteResponse'preimage x__)
+                (Control.DeepSeq.deepseq (_SendToRouteResponse'failure x__) ()))
+{- | Fields :
+     
+         * 'Proto.RouterGrpc_Fields.config' @:: Lens' SetMissionControlConfigRequest MissionControlConfig@
+         * 'Proto.RouterGrpc_Fields.maybe'config' @:: Lens' SetMissionControlConfigRequest (Prelude.Maybe MissionControlConfig)@ -}
+data SetMissionControlConfigRequest
+  = SetMissionControlConfigRequest'_constructor {_SetMissionControlConfigRequest'config :: !(Prelude.Maybe MissionControlConfig),
+                                                 _SetMissionControlConfigRequest'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show SetMissionControlConfigRequest where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Field.HasField SetMissionControlConfigRequest "config" MissionControlConfig where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _SetMissionControlConfigRequest'config
+           (\ x__ y__ -> x__ {_SetMissionControlConfigRequest'config = y__}))
+        (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage)
+instance Data.ProtoLens.Field.HasField SetMissionControlConfigRequest "maybe'config" (Prelude.Maybe MissionControlConfig) where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _SetMissionControlConfigRequest'config
+           (\ x__ y__ -> x__ {_SetMissionControlConfigRequest'config = y__}))
+        Prelude.id
+instance Data.ProtoLens.Message SetMissionControlConfigRequest where
+  messageName _
+    = Data.Text.pack "routerrpc.SetMissionControlConfigRequest"
+  packedMessageDescriptor _
+    = "\n\
+      \\RSSetMissionControlConfigRequest\DC27\n\
+      \\ACKconfig\CAN\SOH \SOH(\v2\US.routerrpc.MissionControlConfigR\ACKconfig"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag
+    = let
+        config__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "config"
+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
+                 Data.ProtoLens.FieldTypeDescriptor MissionControlConfig)
+              (Data.ProtoLens.OptionalField
+                 (Data.ProtoLens.Field.field @"maybe'config")) ::
+              Data.ProtoLens.FieldDescriptor SetMissionControlConfigRequest
+      in
+        Data.Map.fromList
+          [(Data.ProtoLens.Tag 1, config__field_descriptor)]
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _SetMissionControlConfigRequest'_unknownFields
+        (\ x__ y__
+           -> x__ {_SetMissionControlConfigRequest'_unknownFields = y__})
+  defMessage
+    = SetMissionControlConfigRequest'_constructor
+        {_SetMissionControlConfigRequest'config = Prelude.Nothing,
+         _SetMissionControlConfigRequest'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          SetMissionControlConfigRequest
+          -> Data.ProtoLens.Encoding.Bytes.Parser SetMissionControlConfigRequest
+        loop x
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of
+                        10
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.isolate
+                                             (Prelude.fromIntegral len) Data.ProtoLens.parseMessage)
+                                       "config"
+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"config") y x)
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do loop Data.ProtoLens.defMessage)
+          "SetMissionControlConfigRequest"
+  buildMessage
+    = \ _x
+        -> (Data.Monoid.<>)
+             (case
+                  Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'config") _x
+              of
+                Prelude.Nothing -> Data.Monoid.mempty
+                (Prelude.Just _v)
+                  -> (Data.Monoid.<>)
+                       (Data.ProtoLens.Encoding.Bytes.putVarInt 10)
+                       ((Prelude..)
+                          (\ bs
+                             -> (Data.Monoid.<>)
+                                  (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                     (Prelude.fromIntegral (Data.ByteString.length bs)))
+                                  (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                          Data.ProtoLens.encodeMessage
+                          _v))
+             (Data.ProtoLens.Encoding.Wire.buildFieldSet
+                (Lens.Family2.view Data.ProtoLens.unknownFields _x))
+instance Control.DeepSeq.NFData SetMissionControlConfigRequest where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_SetMissionControlConfigRequest'_unknownFields x__)
+             (Control.DeepSeq.deepseq
+                (_SetMissionControlConfigRequest'config x__) ())
+{- | Fields :
+      -}
+data SetMissionControlConfigResponse
+  = SetMissionControlConfigResponse'_constructor {_SetMissionControlConfigResponse'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show SetMissionControlConfigResponse where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Message SetMissionControlConfigResponse where
+  messageName _
+    = Data.Text.pack "routerrpc.SetMissionControlConfigResponse"
+  packedMessageDescriptor _
+    = "\n\
+      \\USSetMissionControlConfigResponse"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag = let in Data.Map.fromList []
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _SetMissionControlConfigResponse'_unknownFields
+        (\ x__ y__
+           -> x__ {_SetMissionControlConfigResponse'_unknownFields = y__})
+  defMessage
+    = SetMissionControlConfigResponse'_constructor
+        {_SetMissionControlConfigResponse'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          SetMissionControlConfigResponse
+          -> Data.ProtoLens.Encoding.Bytes.Parser SetMissionControlConfigResponse
+        loop x
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of {
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) }
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do loop Data.ProtoLens.defMessage)
+          "SetMissionControlConfigResponse"
+  buildMessage
+    = \ _x
+        -> Data.ProtoLens.Encoding.Wire.buildFieldSet
+             (Lens.Family2.view Data.ProtoLens.unknownFields _x)
+instance Control.DeepSeq.NFData SetMissionControlConfigResponse where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_SetMissionControlConfigResponse'_unknownFields x__) ()
+{- | Fields :
+     
+         * 'Proto.RouterGrpc_Fields.preimage' @:: Lens' SettleEvent Data.ByteString.ByteString@ -}
+data SettleEvent
+  = SettleEvent'_constructor {_SettleEvent'preimage :: !Data.ByteString.ByteString,
+                              _SettleEvent'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show SettleEvent where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Field.HasField SettleEvent "preimage" Data.ByteString.ByteString where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _SettleEvent'preimage
+           (\ x__ y__ -> x__ {_SettleEvent'preimage = y__}))
+        Prelude.id
+instance Data.ProtoLens.Message SettleEvent where
+  messageName _ = Data.Text.pack "routerrpc.SettleEvent"
+  packedMessageDescriptor _
+    = "\n\
+      \\vSettleEvent\DC2\SUB\n\
+      \\bpreimage\CAN\SOH \SOH(\fR\bpreimage"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag
+    = let
+        preimage__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "preimage"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"preimage")) ::
+              Data.ProtoLens.FieldDescriptor SettleEvent
+      in
+        Data.Map.fromList
+          [(Data.ProtoLens.Tag 1, preimage__field_descriptor)]
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _SettleEvent'_unknownFields
+        (\ x__ y__ -> x__ {_SettleEvent'_unknownFields = y__})
+  defMessage
+    = SettleEvent'_constructor
+        {_SettleEvent'preimage = Data.ProtoLens.fieldDefault,
+         _SettleEvent'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          SettleEvent -> Data.ProtoLens.Encoding.Bytes.Parser SettleEvent
+        loop x
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of
+                        10
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.getBytes
+                                             (Prelude.fromIntegral len))
+                                       "preimage"
+                                loop
+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"preimage") y x)
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do loop Data.ProtoLens.defMessage) "SettleEvent"
+  buildMessage
+    = \ _x
+        -> (Data.Monoid.<>)
+             (let
+                _v = Lens.Family2.view (Data.ProtoLens.Field.field @"preimage") _x
+              in
+                if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                    Data.Monoid.mempty
+                else
+                    (Data.Monoid.<>)
+                      (Data.ProtoLens.Encoding.Bytes.putVarInt 10)
+                      ((\ bs
+                          -> (Data.Monoid.<>)
+                               (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                  (Prelude.fromIntegral (Data.ByteString.length bs)))
+                               (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                         _v))
+             (Data.ProtoLens.Encoding.Wire.buildFieldSet
+                (Lens.Family2.view Data.ProtoLens.unknownFields _x))
+instance Control.DeepSeq.NFData SettleEvent where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_SettleEvent'_unknownFields x__)
+             (Control.DeepSeq.deepseq (_SettleEvent'preimage x__) ())
+{- | Fields :
+      -}
+data SubscribeHtlcEventsRequest
+  = SubscribeHtlcEventsRequest'_constructor {_SubscribeHtlcEventsRequest'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show SubscribeHtlcEventsRequest where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Message SubscribeHtlcEventsRequest where
+  messageName _
+    = Data.Text.pack "routerrpc.SubscribeHtlcEventsRequest"
+  packedMessageDescriptor _
+    = "\n\
+      \\SUBSubscribeHtlcEventsRequest"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag = let in Data.Map.fromList []
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _SubscribeHtlcEventsRequest'_unknownFields
+        (\ x__ y__
+           -> x__ {_SubscribeHtlcEventsRequest'_unknownFields = y__})
+  defMessage
+    = SubscribeHtlcEventsRequest'_constructor
+        {_SubscribeHtlcEventsRequest'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          SubscribeHtlcEventsRequest
+          -> Data.ProtoLens.Encoding.Bytes.Parser SubscribeHtlcEventsRequest
+        loop x
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of {
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) }
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do loop Data.ProtoLens.defMessage) "SubscribeHtlcEventsRequest"
+  buildMessage
+    = \ _x
+        -> Data.ProtoLens.Encoding.Wire.buildFieldSet
+             (Lens.Family2.view Data.ProtoLens.unknownFields _x)
+instance Control.DeepSeq.NFData SubscribeHtlcEventsRequest where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_SubscribeHtlcEventsRequest'_unknownFields x__) ()
+{- | Fields :
+     
+         * 'Proto.RouterGrpc_Fields.paymentHash' @:: Lens' TrackPaymentRequest Data.ByteString.ByteString@
+         * 'Proto.RouterGrpc_Fields.noInflightUpdates' @:: Lens' TrackPaymentRequest Prelude.Bool@ -}
+data TrackPaymentRequest
+  = TrackPaymentRequest'_constructor {_TrackPaymentRequest'paymentHash :: !Data.ByteString.ByteString,
+                                      _TrackPaymentRequest'noInflightUpdates :: !Prelude.Bool,
+                                      _TrackPaymentRequest'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show TrackPaymentRequest where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Field.HasField TrackPaymentRequest "paymentHash" Data.ByteString.ByteString where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _TrackPaymentRequest'paymentHash
+           (\ x__ y__ -> x__ {_TrackPaymentRequest'paymentHash = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField TrackPaymentRequest "noInflightUpdates" Prelude.Bool where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _TrackPaymentRequest'noInflightUpdates
+           (\ x__ y__ -> x__ {_TrackPaymentRequest'noInflightUpdates = y__}))
+        Prelude.id
+instance Data.ProtoLens.Message TrackPaymentRequest where
+  messageName _ = Data.Text.pack "routerrpc.TrackPaymentRequest"
+  packedMessageDescriptor _
+    = "\n\
+      \\DC3TrackPaymentRequest\DC2!\n\
+      \\fpayment_hash\CAN\SOH \SOH(\fR\vpaymentHash\DC2.\n\
+      \\DC3no_inflight_updates\CAN\STX \SOH(\bR\DC1noInflightUpdates"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag
+    = let
+        paymentHash__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "payment_hash"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"paymentHash")) ::
+              Data.ProtoLens.FieldDescriptor TrackPaymentRequest
+        noInflightUpdates__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "no_inflight_updates"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::
+                 Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"noInflightUpdates")) ::
+              Data.ProtoLens.FieldDescriptor TrackPaymentRequest
+      in
+        Data.Map.fromList
+          [(Data.ProtoLens.Tag 1, paymentHash__field_descriptor),
+           (Data.ProtoLens.Tag 2, noInflightUpdates__field_descriptor)]
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _TrackPaymentRequest'_unknownFields
+        (\ x__ y__ -> x__ {_TrackPaymentRequest'_unknownFields = y__})
+  defMessage
+    = TrackPaymentRequest'_constructor
+        {_TrackPaymentRequest'paymentHash = Data.ProtoLens.fieldDefault,
+         _TrackPaymentRequest'noInflightUpdates = Data.ProtoLens.fieldDefault,
+         _TrackPaymentRequest'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          TrackPaymentRequest
+          -> Data.ProtoLens.Encoding.Bytes.Parser TrackPaymentRequest
+        loop x
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of
+                        10
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.getBytes
+                                             (Prelude.fromIntegral len))
+                                       "payment_hash"
+                                loop
+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"paymentHash") y x)
+                        16
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt)
+                                       "no_inflight_updates"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"noInflightUpdates") y x)
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do loop Data.ProtoLens.defMessage) "TrackPaymentRequest"
+  buildMessage
+    = \ _x
+        -> (Data.Monoid.<>)
+             (let
+                _v
+                  = Lens.Family2.view (Data.ProtoLens.Field.field @"paymentHash") _x
+              in
+                if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                    Data.Monoid.mempty
+                else
+                    (Data.Monoid.<>)
+                      (Data.ProtoLens.Encoding.Bytes.putVarInt 10)
+                      ((\ bs
+                          -> (Data.Monoid.<>)
+                               (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                  (Prelude.fromIntegral (Data.ByteString.length bs)))
+                               (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                         _v))
+             ((Data.Monoid.<>)
+                (let
+                   _v
+                     = Lens.Family2.view
+                         (Data.ProtoLens.Field.field @"noInflightUpdates") _x
+                 in
+                   if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                       Data.Monoid.mempty
+                   else
+                       (Data.Monoid.<>)
+                         (Data.ProtoLens.Encoding.Bytes.putVarInt 16)
+                         ((Prelude..)
+                            Data.ProtoLens.Encoding.Bytes.putVarInt
+                            (\ b -> if b then 1 else 0)
+                            _v))
+                (Data.ProtoLens.Encoding.Wire.buildFieldSet
+                   (Lens.Family2.view Data.ProtoLens.unknownFields _x)))
+instance Control.DeepSeq.NFData TrackPaymentRequest where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_TrackPaymentRequest'_unknownFields x__)
+             (Control.DeepSeq.deepseq
+                (_TrackPaymentRequest'paymentHash x__)
+                (Control.DeepSeq.deepseq
+                   (_TrackPaymentRequest'noInflightUpdates x__) ()))
+{- | Fields :
+     
+         * 'Proto.RouterGrpc_Fields.chanPoint' @:: Lens' UpdateChanStatusRequest Proto.LndGrpc.ChannelPoint@
+         * 'Proto.RouterGrpc_Fields.maybe'chanPoint' @:: Lens' UpdateChanStatusRequest (Prelude.Maybe Proto.LndGrpc.ChannelPoint)@
+         * 'Proto.RouterGrpc_Fields.action' @:: Lens' UpdateChanStatusRequest ChanStatusAction@ -}
+data UpdateChanStatusRequest
+  = UpdateChanStatusRequest'_constructor {_UpdateChanStatusRequest'chanPoint :: !(Prelude.Maybe Proto.LndGrpc.ChannelPoint),
+                                          _UpdateChanStatusRequest'action :: !ChanStatusAction,
+                                          _UpdateChanStatusRequest'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show UpdateChanStatusRequest where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Field.HasField UpdateChanStatusRequest "chanPoint" Proto.LndGrpc.ChannelPoint where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _UpdateChanStatusRequest'chanPoint
+           (\ x__ y__ -> x__ {_UpdateChanStatusRequest'chanPoint = y__}))
+        (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage)
+instance Data.ProtoLens.Field.HasField UpdateChanStatusRequest "maybe'chanPoint" (Prelude.Maybe Proto.LndGrpc.ChannelPoint) where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _UpdateChanStatusRequest'chanPoint
+           (\ x__ y__ -> x__ {_UpdateChanStatusRequest'chanPoint = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField UpdateChanStatusRequest "action" ChanStatusAction where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _UpdateChanStatusRequest'action
+           (\ x__ y__ -> x__ {_UpdateChanStatusRequest'action = y__}))
+        Prelude.id
+instance Data.ProtoLens.Message UpdateChanStatusRequest where
+  messageName _ = Data.Text.pack "routerrpc.UpdateChanStatusRequest"
+  packedMessageDescriptor _
+    = "\n\
+      \\ETBUpdateChanStatusRequest\DC22\n\
+      \\n\
+      \chan_point\CAN\SOH \SOH(\v2\DC3.lnrpc.ChannelPointR\tchanPoint\DC23\n\
+      \\ACKaction\CAN\STX \SOH(\SO2\ESC.routerrpc.ChanStatusActionR\ACKaction"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag
+    = let
+        chanPoint__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "chan_point"
+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
+                 Data.ProtoLens.FieldTypeDescriptor Proto.LndGrpc.ChannelPoint)
+              (Data.ProtoLens.OptionalField
+                 (Data.ProtoLens.Field.field @"maybe'chanPoint")) ::
+              Data.ProtoLens.FieldDescriptor UpdateChanStatusRequest
+        action__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "action"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField ::
+                 Data.ProtoLens.FieldTypeDescriptor ChanStatusAction)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional (Data.ProtoLens.Field.field @"action")) ::
+              Data.ProtoLens.FieldDescriptor UpdateChanStatusRequest
+      in
+        Data.Map.fromList
+          [(Data.ProtoLens.Tag 1, chanPoint__field_descriptor),
+           (Data.ProtoLens.Tag 2, action__field_descriptor)]
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _UpdateChanStatusRequest'_unknownFields
+        (\ x__ y__ -> x__ {_UpdateChanStatusRequest'_unknownFields = y__})
+  defMessage
+    = UpdateChanStatusRequest'_constructor
+        {_UpdateChanStatusRequest'chanPoint = Prelude.Nothing,
+         _UpdateChanStatusRequest'action = Data.ProtoLens.fieldDefault,
+         _UpdateChanStatusRequest'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          UpdateChanStatusRequest
+          -> Data.ProtoLens.Encoding.Bytes.Parser UpdateChanStatusRequest
+        loop x
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of
+                        10
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.isolate
+                                             (Prelude.fromIntegral len) Data.ProtoLens.parseMessage)
+                                       "chan_point"
+                                loop
+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"chanPoint") y x)
+                        16
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          Prelude.toEnum
+                                          (Prelude.fmap
+                                             Prelude.fromIntegral
+                                             Data.ProtoLens.Encoding.Bytes.getVarInt))
+                                       "action"
+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"action") y x)
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do loop Data.ProtoLens.defMessage) "UpdateChanStatusRequest"
+  buildMessage
+    = \ _x
+        -> (Data.Monoid.<>)
+             (case
+                  Lens.Family2.view
+                    (Data.ProtoLens.Field.field @"maybe'chanPoint") _x
+              of
+                Prelude.Nothing -> Data.Monoid.mempty
+                (Prelude.Just _v)
+                  -> (Data.Monoid.<>)
+                       (Data.ProtoLens.Encoding.Bytes.putVarInt 10)
+                       ((Prelude..)
+                          (\ bs
+                             -> (Data.Monoid.<>)
+                                  (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                     (Prelude.fromIntegral (Data.ByteString.length bs)))
+                                  (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                          Data.ProtoLens.encodeMessage
+                          _v))
+             ((Data.Monoid.<>)
+                (let
+                   _v = Lens.Family2.view (Data.ProtoLens.Field.field @"action") _x
+                 in
+                   if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                       Data.Monoid.mempty
+                   else
+                       (Data.Monoid.<>)
+                         (Data.ProtoLens.Encoding.Bytes.putVarInt 16)
+                         ((Prelude..)
+                            ((Prelude..)
+                               Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral)
+                            Prelude.fromEnum
+                            _v))
+                (Data.ProtoLens.Encoding.Wire.buildFieldSet
+                   (Lens.Family2.view Data.ProtoLens.unknownFields _x)))
+instance Control.DeepSeq.NFData UpdateChanStatusRequest where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_UpdateChanStatusRequest'_unknownFields x__)
+             (Control.DeepSeq.deepseq
+                (_UpdateChanStatusRequest'chanPoint x__)
+                (Control.DeepSeq.deepseq (_UpdateChanStatusRequest'action x__) ()))
+{- | Fields :
+      -}
+data UpdateChanStatusResponse
+  = UpdateChanStatusResponse'_constructor {_UpdateChanStatusResponse'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show UpdateChanStatusResponse where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Message UpdateChanStatusResponse where
+  messageName _ = Data.Text.pack "routerrpc.UpdateChanStatusResponse"
+  packedMessageDescriptor _
+    = "\n\
+      \\CANUpdateChanStatusResponse"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag = let in Data.Map.fromList []
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _UpdateChanStatusResponse'_unknownFields
+        (\ x__ y__ -> x__ {_UpdateChanStatusResponse'_unknownFields = y__})
+  defMessage
+    = UpdateChanStatusResponse'_constructor
+        {_UpdateChanStatusResponse'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          UpdateChanStatusResponse
+          -> Data.ProtoLens.Encoding.Bytes.Parser UpdateChanStatusResponse
+        loop x
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of {
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) }
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do loop Data.ProtoLens.defMessage) "UpdateChanStatusResponse"
+  buildMessage
+    = \ _x
+        -> Data.ProtoLens.Encoding.Wire.buildFieldSet
+             (Lens.Family2.view Data.ProtoLens.unknownFields _x)
+instance Control.DeepSeq.NFData UpdateChanStatusResponse where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_UpdateChanStatusResponse'_unknownFields x__) ()
+{- | Fields :
+     
+         * 'Proto.RouterGrpc_Fields.pairs' @:: Lens' XImportMissionControlRequest [PairHistory]@
+         * 'Proto.RouterGrpc_Fields.vec'pairs' @:: Lens' XImportMissionControlRequest (Data.Vector.Vector PairHistory)@ -}
+data XImportMissionControlRequest
+  = XImportMissionControlRequest'_constructor {_XImportMissionControlRequest'pairs :: !(Data.Vector.Vector PairHistory),
+                                               _XImportMissionControlRequest'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show XImportMissionControlRequest where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Field.HasField XImportMissionControlRequest "pairs" [PairHistory] where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _XImportMissionControlRequest'pairs
+           (\ x__ y__ -> x__ {_XImportMissionControlRequest'pairs = y__}))
+        (Lens.Family2.Unchecked.lens
+           Data.Vector.Generic.toList
+           (\ _ y__ -> Data.Vector.Generic.fromList y__))
+instance Data.ProtoLens.Field.HasField XImportMissionControlRequest "vec'pairs" (Data.Vector.Vector PairHistory) where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _XImportMissionControlRequest'pairs
+           (\ x__ y__ -> x__ {_XImportMissionControlRequest'pairs = y__}))
+        Prelude.id
+instance Data.ProtoLens.Message XImportMissionControlRequest where
+  messageName _
+    = Data.Text.pack "routerrpc.XImportMissionControlRequest"
+  packedMessageDescriptor _
+    = "\n\
+      \\FSXImportMissionControlRequest\DC2,\n\
+      \\ENQpairs\CAN\SOH \ETX(\v2\SYN.routerrpc.PairHistoryR\ENQpairs"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag
+    = let
+        pairs__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "pairs"
+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
+                 Data.ProtoLens.FieldTypeDescriptor PairHistory)
+              (Data.ProtoLens.RepeatedField
+                 Data.ProtoLens.Unpacked (Data.ProtoLens.Field.field @"pairs")) ::
+              Data.ProtoLens.FieldDescriptor XImportMissionControlRequest
+      in
+        Data.Map.fromList [(Data.ProtoLens.Tag 1, pairs__field_descriptor)]
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _XImportMissionControlRequest'_unknownFields
+        (\ x__ y__
+           -> x__ {_XImportMissionControlRequest'_unknownFields = y__})
+  defMessage
+    = XImportMissionControlRequest'_constructor
+        {_XImportMissionControlRequest'pairs = Data.Vector.Generic.empty,
+         _XImportMissionControlRequest'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          XImportMissionControlRequest
+          -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld PairHistory
+             -> Data.ProtoLens.Encoding.Bytes.Parser XImportMissionControlRequest
+        loop x mutable'pairs
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do frozen'pairs <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
+                                        (Data.ProtoLens.Encoding.Growing.unsafeFreeze mutable'pairs)
+                      (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields
+                           (\ !t -> Prelude.reverse t)
+                           (Lens.Family2.set
+                              (Data.ProtoLens.Field.field @"vec'pairs") frozen'pairs x))
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of
+                        10
+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                        (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                            Data.ProtoLens.Encoding.Bytes.isolate
+                                              (Prelude.fromIntegral len)
+                                              Data.ProtoLens.parseMessage)
+                                        "pairs"
+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
+                                       (Data.ProtoLens.Encoding.Growing.append mutable'pairs y)
+                                loop x v
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)
+                                  mutable'pairs
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do mutable'pairs <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
+                                 Data.ProtoLens.Encoding.Growing.new
+              loop Data.ProtoLens.defMessage mutable'pairs)
+          "XImportMissionControlRequest"
+  buildMessage
+    = \ _x
+        -> (Data.Monoid.<>)
+             (Data.ProtoLens.Encoding.Bytes.foldMapBuilder
+                (\ _v
+                   -> (Data.Monoid.<>)
+                        (Data.ProtoLens.Encoding.Bytes.putVarInt 10)
+                        ((Prelude..)
+                           (\ bs
+                              -> (Data.Monoid.<>)
+                                   (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                      (Prelude.fromIntegral (Data.ByteString.length bs)))
+                                   (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                           Data.ProtoLens.encodeMessage
+                           _v))
+                (Lens.Family2.view (Data.ProtoLens.Field.field @"vec'pairs") _x))
+             (Data.ProtoLens.Encoding.Wire.buildFieldSet
+                (Lens.Family2.view Data.ProtoLens.unknownFields _x))
+instance Control.DeepSeq.NFData XImportMissionControlRequest where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_XImportMissionControlRequest'_unknownFields x__)
+             (Control.DeepSeq.deepseq
+                (_XImportMissionControlRequest'pairs x__) ())
+{- | Fields :
+      -}
+data XImportMissionControlResponse
+  = XImportMissionControlResponse'_constructor {_XImportMissionControlResponse'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show XImportMissionControlResponse where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Message XImportMissionControlResponse where
+  messageName _
+    = Data.Text.pack "routerrpc.XImportMissionControlResponse"
+  packedMessageDescriptor _
+    = "\n\
+      \\GSXImportMissionControlResponse"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag = let in Data.Map.fromList []
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _XImportMissionControlResponse'_unknownFields
+        (\ x__ y__
+           -> x__ {_XImportMissionControlResponse'_unknownFields = y__})
+  defMessage
+    = XImportMissionControlResponse'_constructor
+        {_XImportMissionControlResponse'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          XImportMissionControlResponse
+          -> Data.ProtoLens.Encoding.Bytes.Parser XImportMissionControlResponse
+        loop x
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of {
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) }
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do loop Data.ProtoLens.defMessage) "XImportMissionControlResponse"
+  buildMessage
+    = \ _x
+        -> Data.ProtoLens.Encoding.Wire.buildFieldSet
+             (Lens.Family2.view Data.ProtoLens.unknownFields _x)
+instance Control.DeepSeq.NFData XImportMissionControlResponse where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_XImportMissionControlResponse'_unknownFields x__) ()
+data Router = Router {}
+instance Data.ProtoLens.Service.Types.Service Router where
+  type ServiceName Router = "Router"
+  type ServicePackage Router = "routerrpc"
+  type ServiceMethods Router = '["buildRoute",
+                                 "estimateRouteFee",
+                                 "getMissionControlConfig",
+                                 "htlcInterceptor",
+                                 "queryMissionControl",
+                                 "queryProbability",
+                                 "resetMissionControl",
+                                 "sendPayment",
+                                 "sendPaymentV2",
+                                 "sendToRoute",
+                                 "sendToRouteV2",
+                                 "setMissionControlConfig",
+                                 "subscribeHtlcEvents",
+                                 "trackPayment",
+                                 "trackPaymentV2",
+                                 "updateChanStatus",
+                                 "ximportMissionControl"]
+instance Data.ProtoLens.Service.Types.HasMethodImpl Router "sendPaymentV2" where
+  type MethodName Router "sendPaymentV2" = "SendPaymentV2"
+  type MethodInput Router "sendPaymentV2" = SendPaymentRequest
+  type MethodOutput Router "sendPaymentV2" = Proto.LndGrpc.Payment
+  type MethodStreamingType Router "sendPaymentV2" =  'Data.ProtoLens.Service.Types.ServerStreaming
+instance Data.ProtoLens.Service.Types.HasMethodImpl Router "trackPaymentV2" where
+  type MethodName Router "trackPaymentV2" = "TrackPaymentV2"
+  type MethodInput Router "trackPaymentV2" = TrackPaymentRequest
+  type MethodOutput Router "trackPaymentV2" = Proto.LndGrpc.Payment
+  type MethodStreamingType Router "trackPaymentV2" =  'Data.ProtoLens.Service.Types.ServerStreaming
+instance Data.ProtoLens.Service.Types.HasMethodImpl Router "estimateRouteFee" where
+  type MethodName Router "estimateRouteFee" = "EstimateRouteFee"
+  type MethodInput Router "estimateRouteFee" = RouteFeeRequest
+  type MethodOutput Router "estimateRouteFee" = RouteFeeResponse
+  type MethodStreamingType Router "estimateRouteFee" =  'Data.ProtoLens.Service.Types.NonStreaming
+instance Data.ProtoLens.Service.Types.HasMethodImpl Router "sendToRoute" where
+  type MethodName Router "sendToRoute" = "SendToRoute"
+  type MethodInput Router "sendToRoute" = SendToRouteRequest
+  type MethodOutput Router "sendToRoute" = SendToRouteResponse
+  type MethodStreamingType Router "sendToRoute" =  'Data.ProtoLens.Service.Types.NonStreaming
+instance Data.ProtoLens.Service.Types.HasMethodImpl Router "sendToRouteV2" where
+  type MethodName Router "sendToRouteV2" = "SendToRouteV2"
+  type MethodInput Router "sendToRouteV2" = SendToRouteRequest
+  type MethodOutput Router "sendToRouteV2" = Proto.LndGrpc.HTLCAttempt
+  type MethodStreamingType Router "sendToRouteV2" =  'Data.ProtoLens.Service.Types.NonStreaming
+instance Data.ProtoLens.Service.Types.HasMethodImpl Router "resetMissionControl" where
+  type MethodName Router "resetMissionControl" = "ResetMissionControl"
+  type MethodInput Router "resetMissionControl" = ResetMissionControlRequest
+  type MethodOutput Router "resetMissionControl" = ResetMissionControlResponse
+  type MethodStreamingType Router "resetMissionControl" =  'Data.ProtoLens.Service.Types.NonStreaming
+instance Data.ProtoLens.Service.Types.HasMethodImpl Router "queryMissionControl" where
+  type MethodName Router "queryMissionControl" = "QueryMissionControl"
+  type MethodInput Router "queryMissionControl" = QueryMissionControlRequest
+  type MethodOutput Router "queryMissionControl" = QueryMissionControlResponse
+  type MethodStreamingType Router "queryMissionControl" =  'Data.ProtoLens.Service.Types.NonStreaming
+instance Data.ProtoLens.Service.Types.HasMethodImpl Router "ximportMissionControl" where
+  type MethodName Router "ximportMissionControl" = "XImportMissionControl"
+  type MethodInput Router "ximportMissionControl" = XImportMissionControlRequest
+  type MethodOutput Router "ximportMissionControl" = XImportMissionControlResponse
+  type MethodStreamingType Router "ximportMissionControl" =  'Data.ProtoLens.Service.Types.NonStreaming
+instance Data.ProtoLens.Service.Types.HasMethodImpl Router "getMissionControlConfig" where
+  type MethodName Router "getMissionControlConfig" = "GetMissionControlConfig"
+  type MethodInput Router "getMissionControlConfig" = GetMissionControlConfigRequest
+  type MethodOutput Router "getMissionControlConfig" = GetMissionControlConfigResponse
+  type MethodStreamingType Router "getMissionControlConfig" =  'Data.ProtoLens.Service.Types.NonStreaming
+instance Data.ProtoLens.Service.Types.HasMethodImpl Router "setMissionControlConfig" where
+  type MethodName Router "setMissionControlConfig" = "SetMissionControlConfig"
+  type MethodInput Router "setMissionControlConfig" = SetMissionControlConfigRequest
+  type MethodOutput Router "setMissionControlConfig" = SetMissionControlConfigResponse
+  type MethodStreamingType Router "setMissionControlConfig" =  'Data.ProtoLens.Service.Types.NonStreaming
+instance Data.ProtoLens.Service.Types.HasMethodImpl Router "queryProbability" where
+  type MethodName Router "queryProbability" = "QueryProbability"
+  type MethodInput Router "queryProbability" = QueryProbabilityRequest
+  type MethodOutput Router "queryProbability" = QueryProbabilityResponse
+  type MethodStreamingType Router "queryProbability" =  'Data.ProtoLens.Service.Types.NonStreaming
+instance Data.ProtoLens.Service.Types.HasMethodImpl Router "buildRoute" where
+  type MethodName Router "buildRoute" = "BuildRoute"
+  type MethodInput Router "buildRoute" = BuildRouteRequest
+  type MethodOutput Router "buildRoute" = BuildRouteResponse
+  type MethodStreamingType Router "buildRoute" =  'Data.ProtoLens.Service.Types.NonStreaming
+instance Data.ProtoLens.Service.Types.HasMethodImpl Router "subscribeHtlcEvents" where
+  type MethodName Router "subscribeHtlcEvents" = "SubscribeHtlcEvents"
+  type MethodInput Router "subscribeHtlcEvents" = SubscribeHtlcEventsRequest
+  type MethodOutput Router "subscribeHtlcEvents" = HtlcEvent
+  type MethodStreamingType Router "subscribeHtlcEvents" =  'Data.ProtoLens.Service.Types.ServerStreaming
+instance Data.ProtoLens.Service.Types.HasMethodImpl Router "sendPayment" where
+  type MethodName Router "sendPayment" = "SendPayment"
+  type MethodInput Router "sendPayment" = SendPaymentRequest
+  type MethodOutput Router "sendPayment" = PaymentStatus
+  type MethodStreamingType Router "sendPayment" =  'Data.ProtoLens.Service.Types.ServerStreaming
+instance Data.ProtoLens.Service.Types.HasMethodImpl Router "trackPayment" where
+  type MethodName Router "trackPayment" = "TrackPayment"
+  type MethodInput Router "trackPayment" = TrackPaymentRequest
+  type MethodOutput Router "trackPayment" = PaymentStatus
+  type MethodStreamingType Router "trackPayment" =  'Data.ProtoLens.Service.Types.ServerStreaming
+instance Data.ProtoLens.Service.Types.HasMethodImpl Router "htlcInterceptor" where
+  type MethodName Router "htlcInterceptor" = "HtlcInterceptor"
+  type MethodInput Router "htlcInterceptor" = ForwardHtlcInterceptResponse
+  type MethodOutput Router "htlcInterceptor" = ForwardHtlcInterceptRequest
+  type MethodStreamingType Router "htlcInterceptor" =  'Data.ProtoLens.Service.Types.BiDiStreaming
+instance Data.ProtoLens.Service.Types.HasMethodImpl Router "updateChanStatus" where
+  type MethodName Router "updateChanStatus" = "UpdateChanStatus"
+  type MethodInput Router "updateChanStatus" = UpdateChanStatusRequest
+  type MethodOutput Router "updateChanStatus" = UpdateChanStatusResponse
+  type MethodStreamingType Router "updateChanStatus" =  'Data.ProtoLens.Service.Types.NonStreaming
+packedFileDescriptor :: Data.ByteString.ByteString
+packedFileDescriptor
+  = "\n\
+    \\DC1router_grpc.proto\DC2\trouterrpc\SUB\SOlnd_grpc.proto\"\215\a\n\
+    \\DC2SendPaymentRequest\DC2\DC2\n\
+    \\EOTdest\CAN\SOH \SOH(\fR\EOTdest\DC2\DLE\n\
+    \\ETXamt\CAN\STX \SOH(\ETXR\ETXamt\DC2\EM\n\
+    \\bamt_msat\CAN\f \SOH(\ETXR\aamtMsat\DC2!\n\
+    \\fpayment_hash\CAN\ETX \SOH(\fR\vpaymentHash\DC2(\n\
+    \\DLEfinal_cltv_delta\CAN\EOT \SOH(\ENQR\SOfinalCltvDelta\DC2!\n\
+    \\fpayment_addr\CAN\DC4 \SOH(\fR\vpaymentAddr\DC2'\n\
+    \\SIpayment_request\CAN\ENQ \SOH(\tR\SOpaymentRequest\DC2'\n\
+    \\SItimeout_seconds\CAN\ACK \SOH(\ENQR\SOtimeoutSeconds\DC2\"\n\
+    \\rfee_limit_sat\CAN\a \SOH(\ETXR\vfeeLimitSat\DC2$\n\
+    \\SOfee_limit_msat\CAN\r \SOH(\ETXR\ffeeLimitMsat\DC2.\n\
+    \\DLEoutgoing_chan_id\CAN\b \SOH(\EOTR\SOoutgoingChanIdB\EOT0\SOH\CAN\SOH\DC2*\n\
+    \\DC1outgoing_chan_ids\CAN\DC3 \ETX(\EOTR\SIoutgoingChanIds\DC2&\n\
+    \\SIlast_hop_pubkey\CAN\SO \SOH(\fR\rlastHopPubkey\DC2\GS\n\
+    \\n\
+    \cltv_limit\CAN\t \SOH(\ENQR\tcltvLimit\DC21\n\
+    \\vroute_hints\CAN\n\
+    \ \ETX(\v2\DLE.lnrpc.RouteHintR\n\
+    \routeHints\DC2d\n\
+    \\DC3dest_custom_records\CAN\v \ETX(\v24.routerrpc.SendPaymentRequest.DestCustomRecordsEntryR\DC1destCustomRecords\DC2,\n\
+    \\DC2allow_self_payment\CAN\SI \SOH(\bR\DLEallowSelfPayment\DC26\n\
+    \\rdest_features\CAN\DLE \ETX(\SO2\DC1.lnrpc.FeatureBitR\fdestFeatures\DC2\ESC\n\
+    \\tmax_parts\CAN\DC1 \SOH(\rR\bmaxParts\DC2.\n\
+    \\DC3no_inflight_updates\CAN\DC2 \SOH(\bR\DC1noInflightUpdates\DC2-\n\
+    \\DC3max_shard_size_msat\CAN\NAK \SOH(\EOTR\DLEmaxShardSizeMsat\DC2\DLE\n\
+    \\ETXamp\CAN\SYN \SOH(\bR\ETXamp\SUBD\n\
+    \\SYNDestCustomRecordsEntry\DC2\DLE\n\
+    \\ETXkey\CAN\SOH \SOH(\EOTR\ETXkey\DC2\DC4\n\
+    \\ENQvalue\CAN\STX \SOH(\fR\ENQvalue:\STX8\SOH\"h\n\
+    \\DC3TrackPaymentRequest\DC2!\n\
+    \\fpayment_hash\CAN\SOH \SOH(\fR\vpaymentHash\DC2.\n\
+    \\DC3no_inflight_updates\CAN\STX \SOH(\bR\DC1noInflightUpdates\">\n\
+    \\SIRouteFeeRequest\DC2\DC2\n\
+    \\EOTdest\CAN\SOH \SOH(\fR\EOTdest\DC2\ETB\n\
+    \\aamt_sat\CAN\STX \SOH(\ETXR\ACKamtSat\"d\n\
+    \\DLERouteFeeResponse\DC2(\n\
+    \\DLErouting_fee_msat\CAN\SOH \SOH(\ETXR\SOroutingFeeMsat\DC2&\n\
+    \\SItime_lock_delay\CAN\STX \SOH(\ETXR\rtimeLockDelay\"[\n\
+    \\DC2SendToRouteRequest\DC2!\n\
+    \\fpayment_hash\CAN\SOH \SOH(\fR\vpaymentHash\DC2\"\n\
+    \\ENQroute\CAN\STX \SOH(\v2\f.lnrpc.RouteR\ENQroute\"[\n\
+    \\DC3SendToRouteResponse\DC2\SUB\n\
+    \\bpreimage\CAN\SOH \SOH(\fR\bpreimage\DC2(\n\
+    \\afailure\CAN\STX \SOH(\v2\SO.lnrpc.FailureR\afailure\"\FS\n\
+    \\SUBResetMissionControlRequest\"\GS\n\
+    \\ESCResetMissionControlResponse\"\FS\n\
+    \\SUBQueryMissionControlRequest\"Q\n\
+    \\ESCQueryMissionControlResponse\DC2,\n\
+    \\ENQpairs\CAN\STX \ETX(\v2\SYN.routerrpc.PairHistoryR\ENQpairsJ\EOT\b\SOH\DLE\STX\"L\n\
+    \\FSXImportMissionControlRequest\DC2,\n\
+    \\ENQpairs\CAN\SOH \ETX(\v2\SYN.routerrpc.PairHistoryR\ENQpairs\"\US\n\
+    \\GSXImportMissionControlResponse\"\138\SOH\n\
+    \\vPairHistory\DC2\ESC\n\
+    \\tnode_from\CAN\SOH \SOH(\fR\bnodeFrom\DC2\ETB\n\
+    \\anode_to\CAN\STX \SOH(\fR\ACKnodeTo\DC2-\n\
+    \\ahistory\CAN\a \SOH(\v2\DC3.routerrpc.PairDataR\ahistoryJ\EOT\b\ETX\DLE\EOTJ\EOT\b\EOT\DLE\ENQJ\EOT\b\ENQ\DLE\ACKJ\EOT\b\ACK\DLE\a\"\232\SOH\n\
+    \\bPairData\DC2\ESC\n\
+    \\tfail_time\CAN\SOH \SOH(\ETXR\bfailTime\DC2 \n\
+    \\ffail_amt_sat\CAN\STX \SOH(\ETXR\n\
+    \failAmtSat\DC2\"\n\
+    \\rfail_amt_msat\CAN\EOT \SOH(\ETXR\vfailAmtMsat\DC2!\n\
+    \\fsuccess_time\CAN\ENQ \SOH(\ETXR\vsuccessTime\DC2&\n\
+    \\SIsuccess_amt_sat\CAN\ACK \SOH(\ETXR\rsuccessAmtSat\DC2(\n\
+    \\DLEsuccess_amt_msat\CAN\a \SOH(\ETXR\SOsuccessAmtMsatJ\EOT\b\ETX\DLE\EOT\" \n\
+    \\RSGetMissionControlConfigRequest\"Z\n\
+    \\USGetMissionControlConfigResponse\DC27\n\
+    \\ACKconfig\CAN\SOH \SOH(\v2\US.routerrpc.MissionControlConfigR\ACKconfig\"Y\n\
+    \\RSSetMissionControlConfigRequest\DC27\n\
+    \\ACKconfig\CAN\SOH \SOH(\v2\US.routerrpc.MissionControlConfigR\ACKconfig\"!\n\
+    \\USSetMissionControlConfigResponse\"\128\STX\n\
+    \\DC4MissionControlConfig\DC2*\n\
+    \\DC1half_life_seconds\CAN\SOH \SOH(\EOTR\SIhalfLifeSeconds\DC2'\n\
+    \\SIhop_probability\CAN\STX \SOH(\STXR\SOhopProbability\DC2\SYN\n\
+    \\ACKweight\CAN\ETX \SOH(\STXR\ACKweight\DC26\n\
+    \\ETBmaximum_payment_results\CAN\EOT \SOH(\rR\NAKmaximumPaymentResults\DC2C\n\
+    \\RSminimum_failure_relax_interval\CAN\ENQ \SOH(\EOTR\ESCminimumFailureRelaxInterval\"j\n\
+    \\ETBQueryProbabilityRequest\DC2\ESC\n\
+    \\tfrom_node\CAN\SOH \SOH(\fR\bfromNode\DC2\ETB\n\
+    \\ato_node\CAN\STX \SOH(\fR\ACKtoNode\DC2\EM\n\
+    \\bamt_msat\CAN\ETX \SOH(\ETXR\aamtMsat\"k\n\
+    \\CANQueryProbabilityResponse\DC2 \n\
+    \\vprobability\CAN\SOH \SOH(\SOHR\vprobability\DC2-\n\
+    \\ahistory\CAN\STX \SOH(\v2\DC3.routerrpc.PairDataR\ahistory\"\202\SOH\n\
+    \\DC1BuildRouteRequest\DC2\EM\n\
+    \\bamt_msat\CAN\SOH \SOH(\ETXR\aamtMsat\DC2(\n\
+    \\DLEfinal_cltv_delta\CAN\STX \SOH(\ENQR\SOfinalCltvDelta\DC2,\n\
+    \\DLEoutgoing_chan_id\CAN\ETX \SOH(\EOTR\SOoutgoingChanIdB\STX0\SOH\DC2\US\n\
+    \\vhop_pubkeys\CAN\EOT \ETX(\fR\n\
+    \hopPubkeys\DC2!\n\
+    \\fpayment_addr\CAN\ENQ \SOH(\fR\vpaymentAddr\"8\n\
+    \\DC2BuildRouteResponse\DC2\"\n\
+    \\ENQroute\CAN\SOH \SOH(\v2\f.lnrpc.RouteR\ENQroute\"\FS\n\
+    \\SUBSubscribeHtlcEventsRequest\"\246\EOT\n\
+    \\tHtlcEvent\DC2.\n\
+    \\DC3incoming_channel_id\CAN\SOH \SOH(\EOTR\DC1incomingChannelId\DC2.\n\
+    \\DC3outgoing_channel_id\CAN\STX \SOH(\EOTR\DC1outgoingChannelId\DC2(\n\
+    \\DLEincoming_htlc_id\CAN\ETX \SOH(\EOTR\SOincomingHtlcId\DC2(\n\
+    \\DLEoutgoing_htlc_id\CAN\EOT \SOH(\EOTR\SOoutgoingHtlcId\DC2!\n\
+    \\ftimestamp_ns\CAN\ENQ \SOH(\EOTR\vtimestampNs\DC2=\n\
+    \\n\
+    \event_type\CAN\ACK \SOH(\SO2\RS.routerrpc.HtlcEvent.EventTypeR\teventType\DC2>\n\
+    \\rforward_event\CAN\a \SOH(\v2\ETB.routerrpc.ForwardEventH\NULR\fforwardEvent\DC2K\n\
+    \\DC2forward_fail_event\CAN\b \SOH(\v2\ESC.routerrpc.ForwardFailEventH\NULR\DLEforwardFailEvent\DC2;\n\
+    \\fsettle_event\CAN\t \SOH(\v2\SYN.routerrpc.SettleEventH\NULR\vsettleEvent\DC2B\n\
+    \\SIlink_fail_event\CAN\n\
+    \ \SOH(\v2\CAN.routerrpc.LinkFailEventH\NULR\rlinkFailEvent\"<\n\
+    \\tEventType\DC2\v\n\
+    \\aUNKNOWN\DLE\NUL\DC2\b\n\
+    \\EOTSEND\DLE\SOH\DC2\v\n\
+    \\aRECEIVE\DLE\STX\DC2\v\n\
+    \\aFORWARD\DLE\ETXB\a\n\
+    \\ENQevent\"\188\SOH\n\
+    \\bHtlcInfo\DC2+\n\
+    \\DC1incoming_timelock\CAN\SOH \SOH(\rR\DLEincomingTimelock\DC2+\n\
+    \\DC1outgoing_timelock\CAN\STX \SOH(\rR\DLEoutgoingTimelock\DC2*\n\
+    \\DC1incoming_amt_msat\CAN\ETX \SOH(\EOTR\SIincomingAmtMsat\DC2*\n\
+    \\DC1outgoing_amt_msat\CAN\EOT \SOH(\EOTR\SIoutgoingAmtMsat\"7\n\
+    \\fForwardEvent\DC2'\n\
+    \\EOTinfo\CAN\SOH \SOH(\v2\DC3.routerrpc.HtlcInfoR\EOTinfo\"\DC2\n\
+    \\DLEForwardFailEvent\")\n\
+    \\vSettleEvent\DC2\SUB\n\
+    \\bpreimage\CAN\SOH \SOH(\fR\bpreimage\"\223\SOH\n\
+    \\rLinkFailEvent\DC2'\n\
+    \\EOTinfo\CAN\SOH \SOH(\v2\DC3.routerrpc.HtlcInfoR\EOTinfo\DC2=\n\
+    \\fwire_failure\CAN\STX \SOH(\SO2\SUB.lnrpc.Failure.FailureCodeR\vwireFailure\DC2?\n\
+    \\SOfailure_detail\CAN\ETX \SOH(\SO2\CAN.routerrpc.FailureDetailR\rfailureDetail\DC2%\n\
+    \\SOfailure_string\CAN\EOT \SOH(\tR\rfailureString\"\138\SOH\n\
+    \\rPaymentStatus\DC2-\n\
+    \\ENQstate\CAN\SOH \SOH(\SO2\ETB.routerrpc.PaymentStateR\ENQstate\DC2\SUB\n\
+    \\bpreimage\CAN\STX \SOH(\fR\bpreimage\DC2(\n\
+    \\ENQhtlcs\CAN\EOT \ETX(\v2\DC2.lnrpc.HTLCAttemptR\ENQhtlcsJ\EOT\b\ETX\DLE\EOT\">\n\
+    \\n\
+    \CircuitKey\DC2\ETB\n\
+    \\achan_id\CAN\SOH \SOH(\EOTR\ACKchanId\DC2\ETB\n\
+    \\ahtlc_id\CAN\STX \SOH(\EOTR\ACKhtlcId\"\191\EOT\n\
+    \\ESCForwardHtlcInterceptRequest\DC2G\n\
+    \\DC4incoming_circuit_key\CAN\SOH \SOH(\v2\NAK.routerrpc.CircuitKeyR\DC2incomingCircuitKey\DC20\n\
+    \\DC4incoming_amount_msat\CAN\ENQ \SOH(\EOTR\DC2incomingAmountMsat\DC2'\n\
+    \\SIincoming_expiry\CAN\ACK \SOH(\rR\SOincomingExpiry\DC2!\n\
+    \\fpayment_hash\CAN\STX \SOH(\fR\vpaymentHash\DC2;\n\
+    \\SUBoutgoing_requested_chan_id\CAN\a \SOH(\EOTR\ETBoutgoingRequestedChanId\DC20\n\
+    \\DC4outgoing_amount_msat\CAN\ETX \SOH(\EOTR\DC2outgoingAmountMsat\DC2'\n\
+    \\SIoutgoing_expiry\CAN\EOT \SOH(\rR\SOoutgoingExpiry\DC2`\n\
+    \\SOcustom_records\CAN\b \ETX(\v29.routerrpc.ForwardHtlcInterceptRequest.CustomRecordsEntryR\rcustomRecords\DC2\GS\n\
+    \\n\
+    \onion_blob\CAN\t \SOH(\fR\tonionBlob\SUB@\n\
+    \\DC2CustomRecordsEntry\DC2\DLE\n\
+    \\ETXkey\CAN\SOH \SOH(\EOTR\ETXkey\DC2\DC4\n\
+    \\ENQvalue\CAN\STX \SOH(\fR\ENQvalue:\STX8\SOH\"\192\SOH\n\
+    \\FSForwardHtlcInterceptResponse\DC2G\n\
+    \\DC4incoming_circuit_key\CAN\SOH \SOH(\v2\NAK.routerrpc.CircuitKeyR\DC2incomingCircuitKey\DC2;\n\
+    \\ACKaction\CAN\STX \SOH(\SO2#.routerrpc.ResolveHoldForwardActionR\ACKaction\DC2\SUB\n\
+    \\bpreimage\CAN\ETX \SOH(\fR\bpreimage\"\130\SOH\n\
+    \\ETBUpdateChanStatusRequest\DC22\n\
+    \\n\
+    \chan_point\CAN\SOH \SOH(\v2\DC3.lnrpc.ChannelPointR\tchanPoint\DC23\n\
+    \\ACKaction\CAN\STX \SOH(\SO2\ESC.routerrpc.ChanStatusActionR\ACKaction\"\SUB\n\
+    \\CANUpdateChanStatusResponse*\129\EOT\n\
+    \\rFailureDetail\DC2\v\n\
+    \\aUNKNOWN\DLE\NUL\DC2\r\n\
+    \\tNO_DETAIL\DLE\SOH\DC2\DLE\n\
+    \\fONION_DECODE\DLE\STX\DC2\NAK\n\
+    \\DC1LINK_NOT_ELIGIBLE\DLE\ETX\DC2\DC4\n\
+    \\DLEON_CHAIN_TIMEOUT\DLE\EOT\DC2\DC4\n\
+    \\DLEHTLC_EXCEEDS_MAX\DLE\ENQ\DC2\CAN\n\
+    \\DC4INSUFFICIENT_BALANCE\DLE\ACK\DC2\SYN\n\
+    \\DC2INCOMPLETE_FORWARD\DLE\a\DC2\DC3\n\
+    \\SIHTLC_ADD_FAILED\DLE\b\DC2\NAK\n\
+    \\DC1FORWARDS_DISABLED\DLE\t\DC2\DC4\n\
+    \\DLEINVOICE_CANCELED\DLE\n\
+    \\DC2\NAK\n\
+    \\DC1INVOICE_UNDERPAID\DLE\v\DC2\ESC\n\
+    \\ETBINVOICE_EXPIRY_TOO_SOON\DLE\f\DC2\DC4\n\
+    \\DLEINVOICE_NOT_OPEN\DLE\r\DC2\ETB\n\
+    \\DC3MPP_INVOICE_TIMEOUT\DLE\SO\DC2\DC4\n\
+    \\DLEADDRESS_MISMATCH\DLE\SI\DC2\SYN\n\
+    \\DC2SET_TOTAL_MISMATCH\DLE\DLE\DC2\NAK\n\
+    \\DC1SET_TOTAL_TOO_LOW\DLE\DC1\DC2\DLE\n\
+    \\fSET_OVERPAID\DLE\DC2\DC2\DC3\n\
+    \\SIUNKNOWN_INVOICE\DLE\DC3\DC2\DC3\n\
+    \\SIINVALID_KEYSEND\DLE\DC4\DC2\DC3\n\
+    \\SIMPP_IN_PROGRESS\DLE\NAK\DC2\DC2\n\
+    \\SOCIRCULAR_ROUTE\DLE\SYN*\174\SOH\n\
+    \\fPaymentState\DC2\r\n\
+    \\tIN_FLIGHT\DLE\NUL\DC2\r\n\
+    \\tSUCCEEDED\DLE\SOH\DC2\DC2\n\
+    \\SOFAILED_TIMEOUT\DLE\STX\DC2\DC3\n\
+    \\SIFAILED_NO_ROUTE\DLE\ETX\DC2\DLE\n\
+    \\fFAILED_ERROR\DLE\EOT\DC2$\n\
+    \ FAILED_INCORRECT_PAYMENT_DETAILS\DLE\ENQ\DC2\US\n\
+    \\ESCFAILED_INSUFFICIENT_BALANCE\DLE\ACK*<\n\
+    \\CANResolveHoldForwardAction\DC2\n\
+    \\n\
+    \\ACKSETTLE\DLE\NUL\DC2\b\n\
+    \\EOTFAIL\DLE\SOH\DC2\n\
+    \\n\
+    \\ACKRESUME\DLE\STX*5\n\
+    \\DLEChanStatusAction\DC2\n\
+    \\n\
+    \\ACKENABLE\DLE\NUL\DC2\v\n\
+    \\aDISABLE\DLE\SOH\DC2\b\n\
+    \\EOTAUTO\DLE\STX2\241\v\n\
+    \\ACKRouter\DC2@\n\
+    \\rSendPaymentV2\DC2\GS.routerrpc.SendPaymentRequest\SUB\SO.lnrpc.Payment0\SOH\DC2B\n\
+    \\SOTrackPaymentV2\DC2\RS.routerrpc.TrackPaymentRequest\SUB\SO.lnrpc.Payment0\SOH\DC2K\n\
+    \\DLEEstimateRouteFee\DC2\SUB.routerrpc.RouteFeeRequest\SUB\ESC.routerrpc.RouteFeeResponse\DC2Q\n\
+    \\vSendToRoute\DC2\GS.routerrpc.SendToRouteRequest\SUB\RS.routerrpc.SendToRouteResponse\"\ETX\136\STX\SOH\DC2B\n\
+    \\rSendToRouteV2\DC2\GS.routerrpc.SendToRouteRequest\SUB\DC2.lnrpc.HTLCAttempt\DC2d\n\
+    \\DC3ResetMissionControl\DC2%.routerrpc.ResetMissionControlRequest\SUB&.routerrpc.ResetMissionControlResponse\DC2d\n\
+    \\DC3QueryMissionControl\DC2%.routerrpc.QueryMissionControlRequest\SUB&.routerrpc.QueryMissionControlResponse\DC2j\n\
+    \\NAKXImportMissionControl\DC2'.routerrpc.XImportMissionControlRequest\SUB(.routerrpc.XImportMissionControlResponse\DC2p\n\
+    \\ETBGetMissionControlConfig\DC2).routerrpc.GetMissionControlConfigRequest\SUB*.routerrpc.GetMissionControlConfigResponse\DC2p\n\
+    \\ETBSetMissionControlConfig\DC2).routerrpc.SetMissionControlConfigRequest\SUB*.routerrpc.SetMissionControlConfigResponse\DC2[\n\
+    \\DLEQueryProbability\DC2\".routerrpc.QueryProbabilityRequest\SUB#.routerrpc.QueryProbabilityResponse\DC2I\n\
+    \\n\
+    \BuildRoute\DC2\FS.routerrpc.BuildRouteRequest\SUB\GS.routerrpc.BuildRouteResponse\DC2T\n\
+    \\DC3SubscribeHtlcEvents\DC2%.routerrpc.SubscribeHtlcEventsRequest\SUB\DC4.routerrpc.HtlcEvent0\SOH\DC2M\n\
+    \\vSendPayment\DC2\GS.routerrpc.SendPaymentRequest\SUB\CAN.routerrpc.PaymentStatus\"\ETX\136\STX\SOH0\SOH\DC2O\n\
+    \\fTrackPayment\DC2\RS.routerrpc.TrackPaymentRequest\SUB\CAN.routerrpc.PaymentStatus\"\ETX\136\STX\SOH0\SOH\DC2f\n\
+    \\SIHtlcInterceptor\DC2'.routerrpc.ForwardHtlcInterceptResponse\SUB&.routerrpc.ForwardHtlcInterceptRequest(\SOH0\SOH\DC2[\n\
+    \\DLEUpdateChanStatus\DC2\".routerrpc.UpdateChanStatusRequest\SUB#.routerrpc.UpdateChanStatusResponseB1Z/github.com/lightningnetwork/lnd/lnrpc/routerrpcJ\196\202\SOH\n\
+    \\a\DC2\ENQ\STX\NUL\161\ACK\SOH\n\
+    \\143\SOH\n\
+    \\SOH\f\DC2\ETX\STX\NUL\DC22\132\SOHsource https://raw.githubusercontent.com/lightningnetwork/lnd/c733c139e95a6ef4e5f9ac88b43328ac96c333ef/lnrpc/routerrpc/router.proto\n\
+    \\n\
+    \\t\n\
+    \\STX\ETX\NUL\DC2\ETX\EOT\NUL\CAN\n\
+    \\b\n\
+    \\SOH\STX\DC2\ETX\ACK\NUL\DC2\n\
+    \\b\n\
+    \\SOH\b\DC2\ETX\b\NULF\n\
+    \\t\n\
+    \\STX\b\v\DC2\ETX\b\NULF\n\
+    \m\n\
+    \\STX\ACK\NUL\DC2\ENQ\f\NUL\143\SOH\SOH\SUB` Router is a service that offers advanced interaction with the router\n\
+    \ subsystem of the daemon.\n\
+    \\n\
+    \\n\
+    \\n\
+    \\ETX\ACK\NUL\SOH\DC2\ETX\f\b\SO\n\
+    \\168\SOH\n\
+    \\EOT\ACK\NUL\STX\NUL\DC2\ETX\DC2\EOTJ\SUB\154\SOH\n\
+    \SendPaymentV2 attempts to route a payment described by the passed\n\
+    \PaymentRequest to the final destination. The call returns a stream of\n\
+    \payment updates.\n\
+    \\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\NUL\SOH\DC2\ETX\DC2\b\NAK\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\NUL\STX\DC2\ETX\DC2\ETB)\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\NUL\ACK\DC2\ETX\DC24:\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\NUL\ETX\DC2\ETX\DC2;H\n\
+    \f\n\
+    \\EOT\ACK\NUL\STX\SOH\DC2\ETX\CAN\EOTL\SUBY\n\
+    \TrackPaymentV2 returns an update stream for the payment identified by the\n\
+    \payment hash.\n\
+    \\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\SOH\SOH\DC2\ETX\CAN\b\SYN\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\SOH\STX\DC2\ETX\CAN\CAN+\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\SOH\ACK\DC2\ETX\CAN6<\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\SOH\ETX\DC2\ETX\CAN=J\n\
+    \\145\SOH\n\
+    \\EOT\ACK\NUL\STX\STX\DC2\ETX\RS\EOTF\SUB\131\SOH\n\
+    \EstimateRouteFee allows callers to obtain a lower bound w.r.t how much it\n\
+    \may cost to send an HTLC to the target end destination.\n\
+    \\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\STX\SOH\DC2\ETX\RS\b\CAN\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\STX\STX\DC2\ETX\RS\SUB)\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\STX\ETX\DC2\ETX\RS4D\n\
+    \\235\STX\n\
+    \\EOT\ACK\NUL\STX\ETX\DC2\EOT'\EOT)\ENQ\SUB\220\STX\n\
+    \Deprecated, use SendToRouteV2. SendToRoute attempts to make a payment via\n\
+    \the specified route. This method differs from SendPayment in that it\n\
+    \allows users to specify a full route manually. This can be used for\n\
+    \things like rebalancing, and atomic swaps. It differs from the newer\n\
+    \SendToRouteV2 in that it doesn't return the full HTLC information.\n\
+    \\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\ETX\SOH\DC2\ETX'\b\DC3\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\ETX\STX\DC2\ETX'\NAK'\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\ETX\ETX\DC2\ETX'2E\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\ETX\EOT\DC2\ETX(\b!\n\
+    \\r\n\
+    \\ACK\ACK\NUL\STX\ETX\EOT!\DC2\ETX(\b!\n\
+    \\240\SOH\n\
+    \\EOT\ACK\NUL\STX\EOT\DC2\ETX1\EOTG\SUB\226\SOH\n\
+    \SendToRouteV2 attempts to make a payment via the specified route. This\n\
+    \method differs from SendPayment in that it allows users to specify a full\n\
+    \route manually. This can be used for things like rebalancing, and atomic\n\
+    \swaps.\n\
+    \\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\EOT\SOH\DC2\ETX1\b\NAK\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\EOT\STX\DC2\ETX1\ETB)\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\EOT\ETX\DC2\ETX14E\n\
+    \c\n\
+    \\EOT\ACK\NUL\STX\ENQ\DC2\EOT7\EOT8.\SUBU\n\
+    \ResetMissionControl clears all mission control state and starts with a clean\n\
+    \slate.\n\
+    \\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\ENQ\SOH\DC2\ETX7\b\ESC\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\ENQ\STX\DC2\ETX7\GS7\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\ENQ\ETX\DC2\ETX8\DC1,\n\
+    \w\n\
+    \\EOT\ACK\NUL\STX\ACK\DC2\EOT>\EOT?.\SUBi\n\
+    \QueryMissionControl exposes the internal mission control state to callers.\n\
+    \It is a development feature.\n\
+    \\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\ACK\SOH\DC2\ETX>\b\ESC\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\ACK\STX\DC2\ETX>\GS7\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\ACK\ETX\DC2\ETX?\DC1,\n\
+    \\161\STX\n\
+    \\EOT\ACK\NUL\STX\a\DC2\EOTG\EOTH0\SUB\146\STX\n\
+    \XImportMissionControl is an experimental API that imports the state provided\n\
+    \to the internal mission control's state, using all results which are more\n\
+    \recent than our existing values. These values will only be imported\n\
+    \in-memory, and will not be persisted across restarts.\n\
+    \\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\a\SOH\DC2\ETXG\b\GS\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\a\STX\DC2\ETXG\US;\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\a\ETX\DC2\ETXH\DC1.\n\
+    \Q\n\
+    \\EOT\ACK\NUL\STX\b\DC2\EOTM\EOTN2\SUBC\n\
+    \GetMissionControlConfig returns mission control's current config.\n\
+    \\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\b\SOH\DC2\ETXM\b\US\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\b\STX\DC2\ETXM!?\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\b\ETX\DC2\ETXN\DC10\n\
+    \k\n\
+    \\EOT\ACK\NUL\STX\t\DC2\EOTT\EOTU2\SUB]\n\
+    \SetMissionControlConfig will set mission control's config, if the config\n\
+    \provided is valid.\n\
+    \\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\t\SOH\DC2\ETXT\b\US\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\t\STX\DC2\ETXT!?\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\t\ETX\DC2\ETXU\DC10\n\
+    \s\n\
+    \\EOT\ACK\NUL\STX\n\
+    \\DC2\EOT[\EOT\\+\SUBe\n\
+    \QueryProbability returns the current success probability estimate for a\n\
+    \given node pair and amount.\n\
+    \\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\n\
+    \\SOH\DC2\ETX[\b\CAN\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\n\
+    \\STX\DC2\ETX[\SUB1\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\n\
+    \\ETX\DC2\ETX\\\DC1)\n\
+    \\206\SOH\n\
+    \\EOT\ACK\NUL\STX\v\DC2\ETXc\EOTD\SUB\192\SOH\n\
+    \BuildRoute builds a fully specified route based on a list of hop public\n\
+    \keys. It retrieves the relevant channel policies from the graph in order to\n\
+    \calculate the correct fees and time locks.\n\
+    \\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\v\SOH\DC2\ETXc\b\DC2\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\v\STX\DC2\ETXc\DC4%\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\v\ETX\DC2\ETXc0B\n\
+    \\138\SOH\n\
+    \\EOT\ACK\NUL\STX\f\DC2\EOTi\EOTj#\SUB|\n\
+    \SubscribeHtlcEvents creates a uni-directional stream from the server to\n\
+    \the client which delivers a stream of htlc events.\n\
+    \\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\f\SOH\DC2\ETXi\b\ESC\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\f\STX\DC2\ETXi\GS7\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\f\ACK\DC2\ETXj\DC1\ETB\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\f\ETX\DC2\ETXj\CAN!\n\
+    \\205\SOH\n\
+    \\EOT\ACK\NUL\STX\r\DC2\EOTq\EOTs\ENQ\SUB\190\SOH\n\
+    \Deprecated, use SendPaymentV2. SendPayment attempts to route a payment\n\
+    \described by the passed PaymentRequest to the final destination. The call\n\
+    \returns a stream of payment status updates.\n\
+    \\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\r\SOH\DC2\ETXq\b\DC3\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\r\STX\DC2\ETXq\NAK'\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\r\ACK\DC2\ETXq28\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\r\ETX\DC2\ETXq9F\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\r\EOT\DC2\ETXr\b!\n\
+    \\r\n\
+    \\ACK\ACK\NUL\STX\r\EOT!\DC2\ETXr\b!\n\
+    \\133\SOH\n\
+    \\EOT\ACK\NUL\STX\SO\DC2\EOTy\EOT{\ENQ\SUBw\n\
+    \Deprecated, use TrackPaymentV2. TrackPayment returns an update stream for\n\
+    \the payment identified by the payment hash.\n\
+    \\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\SO\SOH\DC2\ETXy\b\DC4\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\SO\STX\DC2\ETXy\SYN)\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\SO\ACK\DC2\ETXy4:\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\SO\ETX\DC2\ETXy;H\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\SO\EOT\DC2\ETXz\b!\n\
+    \\r\n\
+    \\ACK\ACK\NUL\STX\SO\EOT!\DC2\ETXz\b!\n\
+    \\221\STX\n\
+    \\EOT\ACK\NUL\STX\SI\DC2\ACK\132\SOH\EOT\133\SOH5\SUB\204\STX*\n\
+    \HtlcInterceptor dispatches a bi-directional streaming RPC in which\n\
+    \Forwarded HTLC requests are sent to the client and the client responds with\n\
+    \a boolean that tells LND if this htlc should be intercepted.\n\
+    \In case of interception, the htlc can be either settled, cancelled or\n\
+    \resumed later by using the ResolveHoldForward endpoint.\n\
+    \\n\
+    \\r\n\
+    \\ENQ\ACK\NUL\STX\SI\SOH\DC2\EOT\132\SOH\b\ETB\n\
+    \\r\n\
+    \\ENQ\ACK\NUL\STX\SI\ENQ\DC2\EOT\132\SOH\EM\US\n\
+    \\r\n\
+    \\ENQ\ACK\NUL\STX\SI\STX\DC2\EOT\132\SOH <\n\
+    \\r\n\
+    \\ENQ\ACK\NUL\STX\SI\ACK\DC2\EOT\133\SOH\DC1\ETB\n\
+    \\r\n\
+    \\ENQ\ACK\NUL\STX\SI\ETX\DC2\EOT\133\SOH\CAN3\n\
+    \\244\SOH\n\
+    \\EOT\ACK\NUL\STX\DLE\DC2\ACK\141\SOH\EOT\142\SOH+\SUB\227\SOH\n\
+    \UpdateChanStatus attempts to manually set the state of a channel\n\
+    \(enabled, disabled, or auto). A manual \"disable\" request will cause the\n\
+    \channel to stay disabled until a subsequent manual request of either\n\
+    \\"enable\" or \"auto\".\n\
+    \\n\
+    \\r\n\
+    \\ENQ\ACK\NUL\STX\DLE\SOH\DC2\EOT\141\SOH\b\CAN\n\
+    \\r\n\
+    \\ENQ\ACK\NUL\STX\DLE\STX\DC2\EOT\141\SOH\SUB1\n\
+    \\r\n\
+    \\ENQ\ACK\NUL\STX\DLE\ETX\DC2\EOT\142\SOH\DC1)\n\
+    \\f\n\
+    \\STX\EOT\NUL\DC2\ACK\145\SOH\NUL\160\STX\SOH\n\
+    \\v\n\
+    \\ETX\EOT\NUL\SOH\DC2\EOT\145\SOH\b\SUB\n\
+    \<\n\
+    \\EOT\EOT\NUL\STX\NUL\DC2\EOT\147\SOH\EOT\DC3\SUB. The identity pubkey of the payment recipient\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\NUL\STX\NUL\EOT\DC2\ACK\147\SOH\EOT\145\SOH\FS\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\NUL\ENQ\DC2\EOT\147\SOH\EOT\t\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\NUL\SOH\DC2\EOT\147\SOH\n\
+    \\SO\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\NUL\ETX\DC2\EOT\147\SOH\DC1\DC2\n\
+    \`\n\
+    \\EOT\EOT\NUL\STX\SOH\DC2\EOT\154\SOH\EOT\DC2\SUBR\n\
+    \Number of satoshis to send.\n\
+    \\n\
+    \The fields amt and amt_msat are mutually exclusive.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\NUL\STX\SOH\EOT\DC2\ACK\154\SOH\EOT\147\SOH\DC3\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\SOH\ENQ\DC2\EOT\154\SOH\EOT\t\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\SOH\SOH\DC2\EOT\154\SOH\n\
+    \\r\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\SOH\ETX\DC2\EOT\154\SOH\DLE\DC1\n\
+    \e\n\
+    \\EOT\EOT\NUL\STX\STX\DC2\EOT\161\SOH\EOT\CAN\SUBW\n\
+    \Number of millisatoshis to send.\n\
+    \\n\
+    \The fields amt and amt_msat are mutually exclusive.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\NUL\STX\STX\EOT\DC2\ACK\161\SOH\EOT\154\SOH\DC2\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\STX\ENQ\DC2\EOT\161\SOH\EOT\t\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\STX\SOH\DC2\EOT\161\SOH\n\
+    \\DC2\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\STX\ETX\DC2\EOT\161\SOH\NAK\ETB\n\
+    \9\n\
+    \\EOT\EOT\NUL\STX\ETX\DC2\EOT\164\SOH\EOT\ESC\SUB+ The hash to use within the payment's HTLC\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\NUL\STX\ETX\EOT\DC2\ACK\164\SOH\EOT\161\SOH\CAN\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\ETX\ENQ\DC2\EOT\164\SOH\EOT\t\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\ETX\SOH\DC2\EOT\164\SOH\n\
+    \\SYN\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\ETX\ETX\DC2\EOT\164\SOH\EM\SUB\n\
+    \q\n\
+    \\EOT\EOT\NUL\STX\EOT\DC2\EOT\170\SOH\EOT\US\SUBc\n\
+    \The CLTV delta from the current height that should be used to set the\n\
+    \timelock for the final hop.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\NUL\STX\EOT\EOT\DC2\ACK\170\SOH\EOT\164\SOH\ESC\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\EOT\ENQ\DC2\EOT\170\SOH\EOT\t\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\EOT\SOH\DC2\EOT\170\SOH\n\
+    \\SUB\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\EOT\ETX\DC2\EOT\170\SOH\GS\RS\n\
+    \Y\n\
+    \\EOT\EOT\NUL\STX\ENQ\DC2\EOT\173\SOH\EOT\FS\SUBK An optional payment addr to be included within the last hop of the route.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\NUL\STX\ENQ\EOT\DC2\ACK\173\SOH\EOT\170\SOH\US\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\ENQ\ENQ\DC2\EOT\173\SOH\EOT\t\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\ENQ\SOH\DC2\EOT\173\SOH\n\
+    \\SYN\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\ENQ\ETX\DC2\EOT\173\SOH\EM\ESC\n\
+    \\137\ETX\n\
+    \\EOT\EOT\NUL\STX\ACK\DC2\EOT\182\SOH\EOT\US\SUB\250\STX\n\
+    \A bare-bones invoice for a payment within the Lightning Network.  With the\n\
+    \details of the invoice, the sender has all the data necessary to send a\n\
+    \payment to the recipient. The amount in the payment request may be zero. In\n\
+    \that case it is required to set the amt field as well. If no payment request\n\
+    \is specified, the following fields are required: dest, amt and payment_hash.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\NUL\STX\ACK\EOT\DC2\ACK\182\SOH\EOT\173\SOH\FS\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\ACK\ENQ\DC2\EOT\182\SOH\EOT\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\ACK\SOH\DC2\EOT\182\SOH\v\SUB\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\ACK\ETX\DC2\EOT\182\SOH\GS\RS\n\
+    \\130\STX\n\
+    \\EOT\EOT\NUL\STX\a\DC2\EOT\190\SOH\EOT\RS\SUB\243\SOH\n\
+    \An upper limit on the amount of time we should spend when attempting to\n\
+    \fulfill the payment. This is expressed in seconds. If we cannot make a\n\
+    \successful payment within this time frame, an error will be returned.\n\
+    \This field must be non-zero.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\NUL\STX\a\EOT\DC2\ACK\190\SOH\EOT\182\SOH\US\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\a\ENQ\DC2\EOT\190\SOH\EOT\t\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\a\SOH\DC2\EOT\190\SOH\n\
+    \\EM\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\a\ETX\DC2\EOT\190\SOH\FS\GS\n\
+    \\129\ETX\n\
+    \\EOT\EOT\NUL\STX\b\DC2\EOT\200\SOH\EOT\FS\SUB\242\STX\n\
+    \The maximum number of satoshis that will be paid as a fee of the payment.\n\
+    \If this field is left to the default value of 0, only zero-fee routes will\n\
+    \be considered. This usually means single hop routes connecting directly to\n\
+    \the destination. To send the payment without a fee limit, use max int here.\n\
+    \\n\
+    \The fields fee_limit_sat and fee_limit_msat are mutually exclusive.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\NUL\STX\b\EOT\DC2\ACK\200\SOH\EOT\190\SOH\RS\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\b\ENQ\DC2\EOT\200\SOH\EOT\t\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\b\SOH\DC2\EOT\200\SOH\n\
+    \\ETB\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\b\ETX\DC2\EOT\200\SOH\SUB\ESC\n\
+    \\134\ETX\n\
+    \\EOT\EOT\NUL\STX\t\DC2\EOT\211\SOH\EOT\RS\SUB\247\STX\n\
+    \The maximum number of millisatoshis that will be paid as a fee of the\n\
+    \payment. If this field is left to the default value of 0, only zero-fee\n\
+    \routes will be considered. This usually means single hop routes connecting\n\
+    \directly to the destination. To send the payment without a fee limit, use\n\
+    \max int here.\n\
+    \\n\
+    \The fields fee_limit_sat and fee_limit_msat are mutually exclusive.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\NUL\STX\t\EOT\DC2\ACK\211\SOH\EOT\200\SOH\FS\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\t\ENQ\DC2\EOT\211\SOH\EOT\t\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\t\SOH\DC2\EOT\211\SOH\n\
+    \\CAN\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\t\ETX\DC2\EOT\211\SOH\ESC\GS\n\
+    \\187\SOH\n\
+    \\EOT\EOT\NUL\STX\n\
+    \\DC2\EOT\218\SOH\EOTH\SUB\172\SOH\n\
+    \Deprecated, use outgoing_chan_ids. The channel id of the channel that must\n\
+    \be taken to the first hop. If zero, any channel may be used (unless\n\
+    \outgoing_chan_ids are set).\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\NUL\STX\n\
+    \\EOT\DC2\ACK\218\SOH\EOT\211\SOH\RS\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\n\
+    \\ENQ\DC2\EOT\218\SOH\EOT\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\n\
+    \\SOH\DC2\EOT\218\SOH\v\ESC\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\n\
+    \\ETX\DC2\EOT\218\SOH\RS\US\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\n\
+    \\b\DC2\EOT\218\SOH G\n\
+    \\SO\n\
+    \\ACK\EOT\NUL\STX\n\
+    \\b\ACK\DC2\EOT\218\SOH!3\n\
+    \\SO\n\
+    \\ACK\EOT\NUL\STX\n\
+    \\b\ETX\DC2\EOT\218\SOH5F\n\
+    \q\n\
+    \\EOT\EOT\NUL\STX\v\DC2\EOT\224\SOH\EOT+\SUBc\n\
+    \The channel ids of the channels are allowed for the first hop. If empty,\n\
+    \any channel may be used.\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\v\EOT\DC2\EOT\224\SOH\EOT\f\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\v\ENQ\DC2\EOT\224\SOH\r\DC3\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\v\SOH\DC2\EOT\224\SOH\DC4%\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\v\ETX\DC2\EOT\224\SOH(*\n\
+    \W\n\
+    \\EOT\EOT\NUL\STX\f\DC2\EOT\229\SOH\EOT\US\SUBI\n\
+    \The pubkey of the last hop of the route. If empty, any hop may be used.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\NUL\STX\f\EOT\DC2\ACK\229\SOH\EOT\224\SOH+\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\f\ENQ\DC2\EOT\229\SOH\EOT\t\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\f\SOH\DC2\EOT\229\SOH\n\
+    \\EM\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\f\ETX\DC2\EOT\229\SOH\FS\RS\n\
+    \\185\SOH\n\
+    \\EOT\EOT\NUL\STX\r\DC2\EOT\236\SOH\EOT\EM\SUB\170\SOH\n\
+    \An optional maximum total time lock for the route. This should not exceed\n\
+    \lnd's `--max-cltv-expiry` setting. If zero, then the value of\n\
+    \`--max-cltv-expiry` is enforced.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\NUL\STX\r\EOT\DC2\ACK\236\SOH\EOT\229\SOH\US\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\r\ENQ\DC2\EOT\236\SOH\EOT\t\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\r\SOH\DC2\EOT\236\SOH\n\
+    \\DC4\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\r\ETX\DC2\EOT\236\SOH\ETB\CAN\n\
+    \W\n\
+    \\EOT\EOT\NUL\STX\SO\DC2\EOT\241\SOH\EOT.\SUBI\n\
+    \Optional route hints to reach the destination through private channels.\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\SO\EOT\DC2\EOT\241\SOH\EOT\f\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\SO\ACK\DC2\EOT\241\SOH\r\FS\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\SO\SOH\DC2\EOT\241\SOH\GS(\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\SO\ETX\DC2\EOT\241\SOH+-\n\
+    \\204\STX\n\
+    \\EOT\EOT\NUL\STX\SI\DC2\EOT\250\SOH\EOT0\SUB\189\STX\n\
+    \An optional field that can be used to pass an arbitrary set of TLV records\n\
+    \to a peer which understands the new records. This can be used to pass\n\
+    \application specific data during the payment attempt. Record types are\n\
+    \required to be in the custom range >= 65536. When using REST, the values\n\
+    \must be encoded as base64.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\NUL\STX\SI\EOT\DC2\ACK\250\SOH\EOT\241\SOH.\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\SI\ACK\DC2\EOT\250\SOH\EOT\SYN\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\SI\SOH\DC2\EOT\250\SOH\ETB*\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\SI\ETX\DC2\EOT\250\SOH-/\n\
+    \@\n\
+    \\EOT\EOT\NUL\STX\DLE\DC2\EOT\253\SOH\EOT!\SUB2 If set, circular payments to self are permitted.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\NUL\STX\DLE\EOT\DC2\ACK\253\SOH\EOT\250\SOH0\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\DLE\ENQ\DC2\EOT\253\SOH\EOT\b\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\DLE\SOH\DC2\EOT\253\SOH\t\ESC\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\DLE\ETX\DC2\EOT\253\SOH\RS \n\
+    \\195\STX\n\
+    \\EOT\EOT\NUL\STX\DC1\DC2\EOT\134\STX\EOT1\SUB\180\STX\n\
+    \Features assumed to be supported by the final node. All transitive feature\n\
+    \dependencies must also be set properly. For a given feature bit pair, either\n\
+    \optional or remote may be set, but not both. If this field is nil or empty,\n\
+    \the router will try to load destination features from the graph as a\n\
+    \fallback.\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\DC1\EOT\DC2\EOT\134\STX\EOT\f\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\DC1\ACK\DC2\EOT\134\STX\r\GS\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\DC1\SOH\DC2\EOT\134\STX\RS+\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\DC1\ETX\DC2\EOT\134\STX.0\n\
+    \c\n\
+    \\EOT\EOT\NUL\STX\DC2\DC2\EOT\140\STX\EOT\SUB\SUBU\n\
+    \The maximum number of partial payments that may be use to complete the full\n\
+    \amount.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\NUL\STX\DC2\EOT\DC2\ACK\140\STX\EOT\134\STX1\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\DC2\ENQ\DC2\EOT\140\STX\EOT\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\DC2\SOH\DC2\EOT\140\STX\v\DC4\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\DC2\ETX\DC2\EOT\140\STX\ETB\EM\n\
+    \\151\SOH\n\
+    \\EOT\EOT\NUL\STX\DC3\DC2\EOT\146\STX\EOT\"\SUB\136\SOH\n\
+    \If set, only the final payment update is streamed back. Intermediate updates\n\
+    \that show which htlcs are still in flight are suppressed.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\NUL\STX\DC3\EOT\DC2\ACK\146\STX\EOT\140\STX\SUB\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\DC3\ENQ\DC2\EOT\146\STX\EOT\b\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\DC3\SOH\DC2\EOT\146\STX\t\FS\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\DC3\ETX\DC2\EOT\146\STX\US!\n\
+    \\141\STX\n\
+    \\EOT\EOT\NUL\STX\DC4\DC2\EOT\154\STX\EOT$\SUB\254\SOH\n\
+    \The largest payment split that should be attempted when making a payment if\n\
+    \splitting is necessary. Setting this value will effectively cause lnd to\n\
+    \split more aggressively, vs only when it thinks it needs to. Note that this\n\
+    \value is in milli-satoshis.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\NUL\STX\DC4\EOT\DC2\ACK\154\STX\EOT\146\STX\"\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\DC4\ENQ\DC2\EOT\154\STX\EOT\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\DC4\SOH\DC2\EOT\154\STX\v\RS\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\DC4\ETX\DC2\EOT\154\STX!#\n\
+    \9\n\
+    \\EOT\EOT\NUL\STX\NAK\DC2\EOT\159\STX\EOT\DC2\SUB+\n\
+    \If set, an AMP-payment will be attempted.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\NUL\STX\NAK\EOT\DC2\ACK\159\STX\EOT\154\STX$\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\NAK\ENQ\DC2\EOT\159\STX\EOT\b\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\NAK\SOH\DC2\EOT\159\STX\t\f\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\NAK\ETX\DC2\EOT\159\STX\SI\DC1\n\
+    \\f\n\
+    \\STX\EOT\SOH\DC2\ACK\162\STX\NUL\171\STX\SOH\n\
+    \\v\n\
+    \\ETX\EOT\SOH\SOH\DC2\EOT\162\STX\b\ESC\n\
+    \3\n\
+    \\EOT\EOT\SOH\STX\NUL\DC2\EOT\164\STX\EOT\ESC\SUB% The hash of the payment to look up.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\SOH\STX\NUL\EOT\DC2\ACK\164\STX\EOT\162\STX\GS\n\
+    \\r\n\
+    \\ENQ\EOT\SOH\STX\NUL\ENQ\DC2\EOT\164\STX\EOT\t\n\
+    \\r\n\
+    \\ENQ\EOT\SOH\STX\NUL\SOH\DC2\EOT\164\STX\n\
+    \\SYN\n\
+    \\r\n\
+    \\ENQ\EOT\SOH\STX\NUL\ETX\DC2\EOT\164\STX\EM\SUB\n\
+    \\151\SOH\n\
+    \\EOT\EOT\SOH\STX\SOH\DC2\EOT\170\STX\EOT!\SUB\136\SOH\n\
+    \If set, only the final payment update is streamed back. Intermediate updates\n\
+    \that show which htlcs are still in flight are suppressed.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\SOH\STX\SOH\EOT\DC2\ACK\170\STX\EOT\164\STX\ESC\n\
+    \\r\n\
+    \\ENQ\EOT\SOH\STX\SOH\ENQ\DC2\EOT\170\STX\EOT\b\n\
+    \\r\n\
+    \\ENQ\EOT\SOH\STX\SOH\SOH\DC2\EOT\170\STX\t\FS\n\
+    \\r\n\
+    \\ENQ\EOT\SOH\STX\SOH\ETX\DC2\EOT\170\STX\US \n\
+    \\f\n\
+    \\STX\EOT\STX\DC2\ACK\173\STX\NUL\183\STX\SOH\n\
+    \\v\n\
+    \\ETX\EOT\STX\SOH\DC2\EOT\173\STX\b\ETB\n\
+    \M\n\
+    \\EOT\EOT\STX\STX\NUL\DC2\EOT\177\STX\EOT\DC3\SUB?\n\
+    \The destination once wishes to obtain a routing fee quote to.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\STX\STX\NUL\EOT\DC2\ACK\177\STX\EOT\173\STX\EM\n\
+    \\r\n\
+    \\ENQ\EOT\STX\STX\NUL\ENQ\DC2\EOT\177\STX\EOT\t\n\
+    \\r\n\
+    \\ENQ\EOT\STX\STX\NUL\SOH\DC2\EOT\177\STX\n\
+    \\SO\n\
+    \\r\n\
+    \\ENQ\EOT\STX\STX\NUL\ETX\DC2\EOT\177\STX\DC1\DC2\n\
+    \H\n\
+    \\EOT\EOT\STX\STX\SOH\DC2\EOT\182\STX\EOT\SYN\SUB:\n\
+    \The amount one wishes to send to the target destination.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\STX\STX\SOH\EOT\DC2\ACK\182\STX\EOT\177\STX\DC3\n\
+    \\r\n\
+    \\ENQ\EOT\STX\STX\SOH\ENQ\DC2\EOT\182\STX\EOT\t\n\
+    \\r\n\
+    \\ENQ\EOT\STX\STX\SOH\SOH\DC2\EOT\182\STX\n\
+    \\DC1\n\
+    \\r\n\
+    \\ENQ\EOT\STX\STX\SOH\ETX\DC2\EOT\182\STX\DC4\NAK\n\
+    \\f\n\
+    \\STX\EOT\ETX\DC2\ACK\185\STX\NUL\198\STX\SOH\n\
+    \\v\n\
+    \\ETX\EOT\ETX\SOH\DC2\EOT\185\STX\b\CAN\n\
+    \}\n\
+    \\EOT\EOT\ETX\STX\NUL\DC2\EOT\190\STX\EOT\US\SUBo\n\
+    \A lower bound of the estimated fee to the target destination within the\n\
+    \network, expressed in milli-satoshis.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\ETX\STX\NUL\EOT\DC2\ACK\190\STX\EOT\185\STX\SUB\n\
+    \\r\n\
+    \\ENQ\EOT\ETX\STX\NUL\ENQ\DC2\EOT\190\STX\EOT\t\n\
+    \\r\n\
+    \\ENQ\EOT\ETX\STX\NUL\SOH\DC2\EOT\190\STX\n\
+    \\SUB\n\
+    \\r\n\
+    \\ENQ\EOT\ETX\STX\NUL\ETX\DC2\EOT\190\STX\GS\RS\n\
+    \\174\SOH\n\
+    \\EOT\EOT\ETX\STX\SOH\DC2\EOT\197\STX\EOT\RS\SUB\159\SOH\n\
+    \An estimate of the worst case time delay that can occur. Note that callers\n\
+    \will still need to factor in the final CLTV delta of the last hop into this\n\
+    \value.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\ETX\STX\SOH\EOT\DC2\ACK\197\STX\EOT\190\STX\US\n\
+    \\r\n\
+    \\ENQ\EOT\ETX\STX\SOH\ENQ\DC2\EOT\197\STX\EOT\t\n\
+    \\r\n\
+    \\ENQ\EOT\ETX\STX\SOH\SOH\DC2\EOT\197\STX\n\
+    \\EM\n\
+    \\r\n\
+    \\ENQ\EOT\ETX\STX\SOH\ETX\DC2\EOT\197\STX\FS\GS\n\
+    \\f\n\
+    \\STX\EOT\EOT\DC2\ACK\200\STX\NUL\206\STX\SOH\n\
+    \\v\n\
+    \\ETX\EOT\EOT\SOH\DC2\EOT\200\STX\b\SUB\n\
+    \5\n\
+    \\EOT\EOT\EOT\STX\NUL\DC2\EOT\202\STX\EOT\ESC\SUB' The payment hash to use for the HTLC.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\EOT\STX\NUL\EOT\DC2\ACK\202\STX\EOT\200\STX\FS\n\
+    \\r\n\
+    \\ENQ\EOT\EOT\STX\NUL\ENQ\DC2\EOT\202\STX\EOT\t\n\
+    \\r\n\
+    \\ENQ\EOT\EOT\STX\NUL\SOH\DC2\EOT\202\STX\n\
+    \\SYN\n\
+    \\r\n\
+    \\ENQ\EOT\EOT\STX\NUL\ETX\DC2\EOT\202\STX\EM\SUB\n\
+    \M\n\
+    \\EOT\EOT\EOT\STX\SOH\DC2\EOT\205\STX\EOT\SUB\SUB? Route that should be used to attempt to complete the payment.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\EOT\STX\SOH\EOT\DC2\ACK\205\STX\EOT\202\STX\ESC\n\
+    \\r\n\
+    \\ENQ\EOT\EOT\STX\SOH\ACK\DC2\EOT\205\STX\EOT\SI\n\
+    \\r\n\
+    \\ENQ\EOT\EOT\STX\SOH\SOH\DC2\EOT\205\STX\DLE\NAK\n\
+    \\r\n\
+    \\ENQ\EOT\EOT\STX\SOH\ETX\DC2\EOT\205\STX\CAN\EM\n\
+    \\f\n\
+    \\STX\EOT\ENQ\DC2\ACK\208\STX\NUL\214\STX\SOH\n\
+    \\v\n\
+    \\ETX\EOT\ENQ\SOH\DC2\EOT\208\STX\b\ESC\n\
+    \<\n\
+    \\EOT\EOT\ENQ\STX\NUL\DC2\EOT\210\STX\EOT\ETB\SUB. The preimage obtained by making the payment.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\ENQ\STX\NUL\EOT\DC2\ACK\210\STX\EOT\208\STX\GS\n\
+    \\r\n\
+    \\ENQ\EOT\ENQ\STX\NUL\ENQ\DC2\EOT\210\STX\EOT\t\n\
+    \\r\n\
+    \\ENQ\EOT\ENQ\STX\NUL\SOH\DC2\EOT\210\STX\n\
+    \\DC2\n\
+    \\r\n\
+    \\ENQ\EOT\ENQ\STX\NUL\ETX\DC2\EOT\210\STX\NAK\SYN\n\
+    \?\n\
+    \\EOT\EOT\ENQ\STX\SOH\DC2\EOT\213\STX\EOT\RS\SUB1 The failure message in case the payment failed.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\ENQ\STX\SOH\EOT\DC2\ACK\213\STX\EOT\210\STX\ETB\n\
+    \\r\n\
+    \\ENQ\EOT\ENQ\STX\SOH\ACK\DC2\EOT\213\STX\EOT\DC1\n\
+    \\r\n\
+    \\ENQ\EOT\ENQ\STX\SOH\SOH\DC2\EOT\213\STX\DC2\EM\n\
+    \\r\n\
+    \\ENQ\EOT\ENQ\STX\SOH\ETX\DC2\EOT\213\STX\FS\GS\n\
+    \\f\n\
+    \\STX\EOT\ACK\DC2\ACK\216\STX\NUL\217\STX\SOH\n\
+    \\v\n\
+    \\ETX\EOT\ACK\SOH\DC2\EOT\216\STX\b\"\n\
+    \\f\n\
+    \\STX\EOT\a\DC2\ACK\219\STX\NUL\220\STX\SOH\n\
+    \\v\n\
+    \\ETX\EOT\a\SOH\DC2\EOT\219\STX\b#\n\
+    \\f\n\
+    \\STX\EOT\b\DC2\ACK\222\STX\NUL\223\STX\SOH\n\
+    \\v\n\
+    \\ETX\EOT\b\SOH\DC2\EOT\222\STX\b\"\n\
+    \K\n\
+    \\STX\EOT\t\DC2\ACK\226\STX\NUL\231\STX\SOH\SUB= QueryMissionControlResponse contains mission control state.\n\
+    \\n\
+    \\v\n\
+    \\ETX\EOT\t\SOH\DC2\EOT\226\STX\b#\n\
+    \\v\n\
+    \\ETX\EOT\t\t\DC2\EOT\227\STX\EOT\SI\n\
+    \\f\n\
+    \\EOT\EOT\t\t\NUL\DC2\EOT\227\STX\r\SO\n\
+    \\r\n\
+    \\ENQ\EOT\t\t\NUL\SOH\DC2\EOT\227\STX\r\SO\n\
+    \\r\n\
+    \\ENQ\EOT\t\t\NUL\STX\DC2\EOT\227\STX\r\SO\n\
+    \6\n\
+    \\EOT\EOT\t\STX\NUL\DC2\EOT\230\STX\EOT#\SUB( Node pair-level mission control state.\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT\t\STX\NUL\EOT\DC2\EOT\230\STX\EOT\f\n\
+    \\r\n\
+    \\ENQ\EOT\t\STX\NUL\ACK\DC2\EOT\230\STX\r\CAN\n\
+    \\r\n\
+    \\ENQ\EOT\t\STX\NUL\SOH\DC2\EOT\230\STX\EM\RS\n\
+    \\r\n\
+    \\ENQ\EOT\t\STX\NUL\ETX\DC2\EOT\230\STX!\"\n\
+    \\f\n\
+    \\STX\EOT\n\
+    \\DC2\ACK\233\STX\NUL\236\STX\SOH\n\
+    \\v\n\
+    \\ETX\EOT\n\
+    \\SOH\DC2\EOT\233\STX\b$\n\
+    \E\n\
+    \\EOT\EOT\n\
+    \\STX\NUL\DC2\EOT\235\STX\EOT#\SUB7 Node pair-level mission control state to be imported.\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT\n\
+    \\STX\NUL\EOT\DC2\EOT\235\STX\EOT\f\n\
+    \\r\n\
+    \\ENQ\EOT\n\
+    \\STX\NUL\ACK\DC2\EOT\235\STX\r\CAN\n\
+    \\r\n\
+    \\ENQ\EOT\n\
+    \\STX\NUL\SOH\DC2\EOT\235\STX\EM\RS\n\
+    \\r\n\
+    \\ENQ\EOT\n\
+    \\STX\NUL\ETX\DC2\EOT\235\STX!\"\n\
+    \\f\n\
+    \\STX\EOT\v\DC2\ACK\238\STX\NUL\239\STX\SOH\n\
+    \\v\n\
+    \\ETX\EOT\v\SOH\DC2\EOT\238\STX\b%\n\
+    \Z\n\
+    \\STX\EOT\f\DC2\ACK\242\STX\NUL\252\STX\SOH\SUBL PairHistory contains the mission control state for a particular node pair.\n\
+    \\n\
+    \\v\n\
+    \\ETX\EOT\f\SOH\DC2\EOT\242\STX\b\DC3\n\
+    \3\n\
+    \\EOT\EOT\f\STX\NUL\DC2\EOT\244\STX\EOT\CAN\SUB% The source node pubkey of the pair.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\f\STX\NUL\EOT\DC2\ACK\244\STX\EOT\242\STX\NAK\n\
+    \\r\n\
+    \\ENQ\EOT\f\STX\NUL\ENQ\DC2\EOT\244\STX\EOT\t\n\
+    \\r\n\
+    \\ENQ\EOT\f\STX\NUL\SOH\DC2\EOT\244\STX\n\
+    \\DC3\n\
+    \\r\n\
+    \\ENQ\EOT\f\STX\NUL\ETX\DC2\EOT\244\STX\SYN\ETB\n\
+    \8\n\
+    \\EOT\EOT\f\STX\SOH\DC2\EOT\247\STX\EOT\SYN\SUB* The destination node pubkey of the pair.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\f\STX\SOH\EOT\DC2\ACK\247\STX\EOT\244\STX\CAN\n\
+    \\r\n\
+    \\ENQ\EOT\f\STX\SOH\ENQ\DC2\EOT\247\STX\EOT\t\n\
+    \\r\n\
+    \\ENQ\EOT\f\STX\SOH\SOH\DC2\EOT\247\STX\n\
+    \\DC1\n\
+    \\r\n\
+    \\ENQ\EOT\f\STX\SOH\ETX\DC2\EOT\247\STX\DC4\NAK\n\
+    \\v\n\
+    \\ETX\EOT\f\t\DC2\EOT\249\STX\EOT\CAN\n\
+    \\f\n\
+    \\EOT\EOT\f\t\NUL\DC2\EOT\249\STX\r\SO\n\
+    \\r\n\
+    \\ENQ\EOT\f\t\NUL\SOH\DC2\EOT\249\STX\r\SO\n\
+    \\r\n\
+    \\ENQ\EOT\f\t\NUL\STX\DC2\EOT\249\STX\r\SO\n\
+    \\f\n\
+    \\EOT\EOT\f\t\SOH\DC2\EOT\249\STX\DLE\DC1\n\
+    \\r\n\
+    \\ENQ\EOT\f\t\SOH\SOH\DC2\EOT\249\STX\DLE\DC1\n\
+    \\r\n\
+    \\ENQ\EOT\f\t\SOH\STX\DC2\EOT\249\STX\DLE\DC1\n\
+    \\f\n\
+    \\EOT\EOT\f\t\STX\DC2\EOT\249\STX\DC3\DC4\n\
+    \\r\n\
+    \\ENQ\EOT\f\t\STX\SOH\DC2\EOT\249\STX\DC3\DC4\n\
+    \\r\n\
+    \\ENQ\EOT\f\t\STX\STX\DC2\EOT\249\STX\DC3\DC4\n\
+    \\f\n\
+    \\EOT\EOT\f\t\ETX\DC2\EOT\249\STX\SYN\ETB\n\
+    \\r\n\
+    \\ENQ\EOT\f\t\ETX\SOH\DC2\EOT\249\STX\SYN\ETB\n\
+    \\r\n\
+    \\ENQ\EOT\f\t\ETX\STX\DC2\EOT\249\STX\SYN\ETB\n\
+    \\f\n\
+    \\EOT\EOT\f\STX\STX\DC2\EOT\251\STX\EOT\EM\n\
+    \\SI\n\
+    \\ENQ\EOT\f\STX\STX\EOT\DC2\ACK\251\STX\EOT\249\STX\CAN\n\
+    \\r\n\
+    \\ENQ\EOT\f\STX\STX\ACK\DC2\EOT\251\STX\EOT\f\n\
+    \\r\n\
+    \\ENQ\EOT\f\STX\STX\SOH\DC2\EOT\251\STX\r\DC4\n\
+    \\r\n\
+    \\ENQ\EOT\f\STX\STX\ETX\DC2\EOT\251\STX\ETB\CAN\n\
+    \\f\n\
+    \\STX\EOT\r\DC2\ACK\254\STX\NUL\152\ETX\SOH\n\
+    \\v\n\
+    \\ETX\EOT\r\SOH\DC2\EOT\254\STX\b\DLE\n\
+    \%\n\
+    \\EOT\EOT\r\STX\NUL\DC2\EOT\128\ETX\EOT\CAN\SUB\ETB Time of last failure.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\r\STX\NUL\EOT\DC2\ACK\128\ETX\EOT\254\STX\DC2\n\
+    \\r\n\
+    \\ENQ\EOT\r\STX\NUL\ENQ\DC2\EOT\128\ETX\EOT\t\n\
+    \\r\n\
+    \\ENQ\EOT\r\STX\NUL\SOH\DC2\EOT\128\ETX\n\
+    \\DC3\n\
+    \\r\n\
+    \\ENQ\EOT\r\STX\NUL\ETX\DC2\EOT\128\ETX\SYN\ETB\n\
+    \\140\SOH\n\
+    \\EOT\EOT\r\STX\SOH\DC2\EOT\134\ETX\EOT\ESC\SUB~\n\
+    \Lowest amount that failed to forward rounded to whole sats. This may be\n\
+    \set to zero if the failure is independent of amount.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\r\STX\SOH\EOT\DC2\ACK\134\ETX\EOT\128\ETX\CAN\n\
+    \\r\n\
+    \\ENQ\EOT\r\STX\SOH\ENQ\DC2\EOT\134\ETX\EOT\t\n\
+    \\r\n\
+    \\ENQ\EOT\r\STX\SOH\SOH\DC2\EOT\134\ETX\n\
+    \\SYN\n\
+    \\r\n\
+    \\ENQ\EOT\r\STX\SOH\ETX\DC2\EOT\134\ETX\EM\SUB\n\
+    \\131\SOH\n\
+    \\EOT\EOT\r\STX\STX\DC2\EOT\140\ETX\EOT\FS\SUBu\n\
+    \Lowest amount that failed to forward in millisats. This may be\n\
+    \set to zero if the failure is independent of amount.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\r\STX\STX\EOT\DC2\ACK\140\ETX\EOT\134\ETX\ESC\n\
+    \\r\n\
+    \\ENQ\EOT\r\STX\STX\ENQ\DC2\EOT\140\ETX\EOT\t\n\
+    \\r\n\
+    \\ENQ\EOT\r\STX\STX\SOH\DC2\EOT\140\ETX\n\
+    \\ETB\n\
+    \\r\n\
+    \\ENQ\EOT\r\STX\STX\ETX\DC2\EOT\140\ETX\SUB\ESC\n\
+    \\v\n\
+    \\ETX\EOT\r\t\DC2\EOT\142\ETX\EOT\SI\n\
+    \\f\n\
+    \\EOT\EOT\r\t\NUL\DC2\EOT\142\ETX\r\SO\n\
+    \\r\n\
+    \\ENQ\EOT\r\t\NUL\SOH\DC2\EOT\142\ETX\r\SO\n\
+    \\r\n\
+    \\ENQ\EOT\r\t\NUL\STX\DC2\EOT\142\ETX\r\SO\n\
+    \%\n\
+    \\EOT\EOT\r\STX\ETX\DC2\EOT\145\ETX\EOT\ESC\SUB\ETB Time of last success.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\r\STX\ETX\EOT\DC2\ACK\145\ETX\EOT\142\ETX\SI\n\
+    \\r\n\
+    \\ENQ\EOT\r\STX\ETX\ENQ\DC2\EOT\145\ETX\EOT\t\n\
+    \\r\n\
+    \\ENQ\EOT\r\STX\ETX\SOH\DC2\EOT\145\ETX\n\
+    \\SYN\n\
+    \\r\n\
+    \\ENQ\EOT\r\STX\ETX\ETX\DC2\EOT\145\ETX\EM\SUB\n\
+    \X\n\
+    \\EOT\EOT\r\STX\EOT\DC2\EOT\148\ETX\EOT\RS\SUBJ Highest amount that we could successfully forward rounded to whole sats.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\r\STX\EOT\EOT\DC2\ACK\148\ETX\EOT\145\ETX\ESC\n\
+    \\r\n\
+    \\ENQ\EOT\r\STX\EOT\ENQ\DC2\EOT\148\ETX\EOT\t\n\
+    \\r\n\
+    \\ENQ\EOT\r\STX\EOT\SOH\DC2\EOT\148\ETX\n\
+    \\EM\n\
+    \\r\n\
+    \\ENQ\EOT\r\STX\EOT\ETX\DC2\EOT\148\ETX\FS\GS\n\
+    \O\n\
+    \\EOT\EOT\r\STX\ENQ\DC2\EOT\151\ETX\EOT\US\SUBA Highest amount that we could successfully forward in millisats.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\r\STX\ENQ\EOT\DC2\ACK\151\ETX\EOT\148\ETX\RS\n\
+    \\r\n\
+    \\ENQ\EOT\r\STX\ENQ\ENQ\DC2\EOT\151\ETX\EOT\t\n\
+    \\r\n\
+    \\ENQ\EOT\r\STX\ENQ\SOH\DC2\EOT\151\ETX\n\
+    \\SUB\n\
+    \\r\n\
+    \\ENQ\EOT\r\STX\ENQ\ETX\DC2\EOT\151\ETX\GS\RS\n\
+    \\f\n\
+    \\STX\EOT\SO\DC2\ACK\154\ETX\NUL\155\ETX\SOH\n\
+    \\v\n\
+    \\ETX\EOT\SO\SOH\DC2\EOT\154\ETX\b&\n\
+    \\f\n\
+    \\STX\EOT\SI\DC2\ACK\157\ETX\NUL\162\ETX\SOH\n\
+    \\v\n\
+    \\ETX\EOT\SI\SOH\DC2\EOT\157\ETX\b'\n\
+    \:\n\
+    \\EOT\EOT\SI\STX\NUL\DC2\EOT\161\ETX\EOT$\SUB,\n\
+    \Mission control's currently active config.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\SI\STX\NUL\EOT\DC2\ACK\161\ETX\EOT\157\ETX)\n\
+    \\r\n\
+    \\ENQ\EOT\SI\STX\NUL\ACK\DC2\EOT\161\ETX\EOT\CAN\n\
+    \\r\n\
+    \\ENQ\EOT\SI\STX\NUL\SOH\DC2\EOT\161\ETX\EM\US\n\
+    \\r\n\
+    \\ENQ\EOT\SI\STX\NUL\ETX\DC2\EOT\161\ETX\"#\n\
+    \\f\n\
+    \\STX\EOT\DLE\DC2\ACK\164\ETX\NUL\170\ETX\SOH\n\
+    \\v\n\
+    \\ETX\EOT\DLE\SOH\DC2\EOT\164\ETX\b&\n\
+    \\131\SOH\n\
+    \\EOT\EOT\DLE\STX\NUL\DC2\EOT\169\ETX\EOT$\SUBu\n\
+    \The config to set for mission control. Note that all values *must* be set,\n\
+    \because the full config will be applied.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\DLE\STX\NUL\EOT\DC2\ACK\169\ETX\EOT\164\ETX(\n\
+    \\r\n\
+    \\ENQ\EOT\DLE\STX\NUL\ACK\DC2\EOT\169\ETX\EOT\CAN\n\
+    \\r\n\
+    \\ENQ\EOT\DLE\STX\NUL\SOH\DC2\EOT\169\ETX\EM\US\n\
+    \\r\n\
+    \\ENQ\EOT\DLE\STX\NUL\ETX\DC2\EOT\169\ETX\"#\n\
+    \\f\n\
+    \\STX\EOT\DC1\DC2\ACK\172\ETX\NUL\173\ETX\SOH\n\
+    \\v\n\
+    \\ETX\EOT\DC1\SOH\DC2\EOT\172\ETX\b'\n\
+    \\f\n\
+    \\STX\EOT\DC2\DC2\ACK\175\ETX\NUL\213\ETX\SOH\n\
+    \\v\n\
+    \\ETX\EOT\DC2\SOH\DC2\EOT\175\ETX\b\FS\n\
+    \\217\STX\n\
+    \\EOT\EOT\DC2\STX\NUL\DC2\EOT\183\ETX\EOT!\SUB\202\STX\n\
+    \The amount of time mission control will take to restore a penalized node\n\
+    \or channel back to 50% success probability, expressed in seconds. Setting\n\
+    \this value to a higher value will penalize failures for longer, making\n\
+    \mission control less likely to route through nodes and channels that we\n\
+    \have previously recorded failures for.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\DC2\STX\NUL\EOT\DC2\ACK\183\ETX\EOT\175\ETX\RS\n\
+    \\r\n\
+    \\ENQ\EOT\DC2\STX\NUL\ENQ\DC2\EOT\183\ETX\EOT\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT\DC2\STX\NUL\SOH\DC2\EOT\183\ETX\v\FS\n\
+    \\r\n\
+    \\ENQ\EOT\DC2\STX\NUL\ETX\DC2\EOT\183\ETX\US \n\
+    \\156\STX\n\
+    \\EOT\EOT\DC2\STX\SOH\DC2\EOT\191\ETX\EOT\RS\SUB\141\STX\n\
+    \The probability of success mission control should assign to hop in a route\n\
+    \where it has no other information available. Higher values will make mission\n\
+    \control more willing to try hops that we have no information about, lower\n\
+    \values will discourage trying these hops.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\DC2\STX\SOH\EOT\DC2\ACK\191\ETX\EOT\183\ETX!\n\
+    \\r\n\
+    \\ENQ\EOT\DC2\STX\SOH\ENQ\DC2\EOT\191\ETX\EOT\t\n\
+    \\r\n\
+    \\ENQ\EOT\DC2\STX\SOH\SOH\DC2\EOT\191\ETX\n\
+    \\EM\n\
+    \\r\n\
+    \\ENQ\EOT\DC2\STX\SOH\ETX\DC2\EOT\191\ETX\FS\GS\n\
+    \\253\STX\n\
+    \\EOT\EOT\DC2\STX\STX\DC2\EOT\201\ETX\EOT\NAK\SUB\238\STX\n\
+    \The importance that mission control should place on historical results,\n\
+    \expressed as a value in [0;1]. Setting this value to 1 will ignore all\n\
+    \historical payments and just use the hop probability to assess the\n\
+    \probability of success for each hop. A zero value ignores hop probability\n\
+    \completely and relies entirely on historical results, unless none are\n\
+    \available.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\DC2\STX\STX\EOT\DC2\ACK\201\ETX\EOT\191\ETX\RS\n\
+    \\r\n\
+    \\ENQ\EOT\DC2\STX\STX\ENQ\DC2\EOT\201\ETX\EOT\t\n\
+    \\r\n\
+    \\ENQ\EOT\DC2\STX\STX\SOH\DC2\EOT\201\ETX\n\
+    \\DLE\n\
+    \\r\n\
+    \\ENQ\EOT\DC2\STX\STX\ETX\DC2\EOT\201\ETX\DC3\DC4\n\
+    \V\n\
+    \\EOT\EOT\DC2\STX\ETX\DC2\EOT\206\ETX\EOT'\SUBH\n\
+    \The maximum number of payment results that mission control will store.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\DC2\STX\ETX\EOT\DC2\ACK\206\ETX\EOT\201\ETX\NAK\n\
+    \\r\n\
+    \\ENQ\EOT\DC2\STX\ETX\ENQ\DC2\EOT\206\ETX\EOT\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT\DC2\STX\ETX\SOH\DC2\EOT\206\ETX\v\"\n\
+    \\r\n\
+    \\ENQ\EOT\DC2\STX\ETX\ETX\DC2\EOT\206\ETX%&\n\
+    \\128\SOH\n\
+    \\EOT\EOT\DC2\STX\EOT\DC2\EOT\212\ETX\EOT.\SUBr\n\
+    \The minimum time that must have passed since the previously recorded failure\n\
+    \before we raise the failure amount.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\DC2\STX\EOT\EOT\DC2\ACK\212\ETX\EOT\206\ETX'\n\
+    \\r\n\
+    \\ENQ\EOT\DC2\STX\EOT\ENQ\DC2\EOT\212\ETX\EOT\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT\DC2\STX\EOT\SOH\DC2\EOT\212\ETX\v)\n\
+    \\r\n\
+    \\ENQ\EOT\DC2\STX\EOT\ETX\DC2\EOT\212\ETX,-\n\
+    \\f\n\
+    \\STX\EOT\DC3\DC2\ACK\215\ETX\NUL\224\ETX\SOH\n\
+    \\v\n\
+    \\ETX\EOT\DC3\SOH\DC2\EOT\215\ETX\b\US\n\
+    \3\n\
+    \\EOT\EOT\DC3\STX\NUL\DC2\EOT\217\ETX\EOT\CAN\SUB% The source node pubkey of the pair.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\DC3\STX\NUL\EOT\DC2\ACK\217\ETX\EOT\215\ETX!\n\
+    \\r\n\
+    \\ENQ\EOT\DC3\STX\NUL\ENQ\DC2\EOT\217\ETX\EOT\t\n\
+    \\r\n\
+    \\ENQ\EOT\DC3\STX\NUL\SOH\DC2\EOT\217\ETX\n\
+    \\DC3\n\
+    \\r\n\
+    \\ENQ\EOT\DC3\STX\NUL\ETX\DC2\EOT\217\ETX\SYN\ETB\n\
+    \8\n\
+    \\EOT\EOT\DC3\STX\SOH\DC2\EOT\220\ETX\EOT\SYN\SUB* The destination node pubkey of the pair.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\DC3\STX\SOH\EOT\DC2\ACK\220\ETX\EOT\217\ETX\CAN\n\
+    \\r\n\
+    \\ENQ\EOT\DC3\STX\SOH\ENQ\DC2\EOT\220\ETX\EOT\t\n\
+    \\r\n\
+    \\ENQ\EOT\DC3\STX\SOH\SOH\DC2\EOT\220\ETX\n\
+    \\DC1\n\
+    \\r\n\
+    \\ENQ\EOT\DC3\STX\SOH\ETX\DC2\EOT\220\ETX\DC4\NAK\n\
+    \@\n\
+    \\EOT\EOT\DC3\STX\STX\DC2\EOT\223\ETX\EOT\ETB\SUB2 The amount for which to calculate a probability.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\DC3\STX\STX\EOT\DC2\ACK\223\ETX\EOT\220\ETX\SYN\n\
+    \\r\n\
+    \\ENQ\EOT\DC3\STX\STX\ENQ\DC2\EOT\223\ETX\EOT\t\n\
+    \\r\n\
+    \\ENQ\EOT\DC3\STX\STX\SOH\DC2\EOT\223\ETX\n\
+    \\DC2\n\
+    \\r\n\
+    \\ENQ\EOT\DC3\STX\STX\ETX\DC2\EOT\223\ETX\NAK\SYN\n\
+    \\f\n\
+    \\STX\EOT\DC4\DC2\ACK\226\ETX\NUL\232\ETX\SOH\n\
+    \\v\n\
+    \\ETX\EOT\DC4\SOH\DC2\EOT\226\ETX\b \n\
+    \?\n\
+    \\EOT\EOT\DC4\STX\NUL\DC2\EOT\228\ETX\EOT\ESC\SUB1 The success probability for the requested pair.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\DC4\STX\NUL\EOT\DC2\ACK\228\ETX\EOT\226\ETX\"\n\
+    \\r\n\
+    \\ENQ\EOT\DC4\STX\NUL\ENQ\DC2\EOT\228\ETX\EOT\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT\DC4\STX\NUL\SOH\DC2\EOT\228\ETX\v\SYN\n\
+    \\r\n\
+    \\ENQ\EOT\DC4\STX\NUL\ETX\DC2\EOT\228\ETX\EM\SUB\n\
+    \;\n\
+    \\EOT\EOT\DC4\STX\SOH\DC2\EOT\231\ETX\EOT\EM\SUB- The historical data for the requested pair.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\DC4\STX\SOH\EOT\DC2\ACK\231\ETX\EOT\228\ETX\ESC\n\
+    \\r\n\
+    \\ENQ\EOT\DC4\STX\SOH\ACK\DC2\EOT\231\ETX\EOT\f\n\
+    \\r\n\
+    \\ENQ\EOT\DC4\STX\SOH\SOH\DC2\EOT\231\ETX\r\DC4\n\
+    \\r\n\
+    \\ENQ\EOT\DC4\STX\SOH\ETX\DC2\EOT\231\ETX\ETB\CAN\n\
+    \\f\n\
+    \\STX\EOT\NAK\DC2\ACK\234\ETX\NUL\133\EOT\SOH\n\
+    \\v\n\
+    \\ETX\EOT\NAK\SOH\DC2\EOT\234\ETX\b\EM\n\
+    \j\n\
+    \\EOT\EOT\NAK\STX\NUL\DC2\EOT\239\ETX\EOT\ETB\SUB\\\n\
+    \The amount to send expressed in msat. If set to zero, the minimum routable\n\
+    \amount is used.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\NAK\STX\NUL\EOT\DC2\ACK\239\ETX\EOT\234\ETX\ESC\n\
+    \\r\n\
+    \\ENQ\EOT\NAK\STX\NUL\ENQ\DC2\EOT\239\ETX\EOT\t\n\
+    \\r\n\
+    \\ENQ\EOT\NAK\STX\NUL\SOH\DC2\EOT\239\ETX\n\
+    \\DC2\n\
+    \\r\n\
+    \\ENQ\EOT\NAK\STX\NUL\ETX\DC2\EOT\239\ETX\NAK\SYN\n\
+    \h\n\
+    \\EOT\EOT\NAK\STX\SOH\DC2\EOT\245\ETX\EOT\US\SUBZ\n\
+    \CLTV delta from the current height that should be used for the timelock\n\
+    \of the final hop\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\NAK\STX\SOH\EOT\DC2\ACK\245\ETX\EOT\239\ETX\ETB\n\
+    \\r\n\
+    \\ENQ\EOT\NAK\STX\SOH\ENQ\DC2\EOT\245\ETX\EOT\t\n\
+    \\r\n\
+    \\ENQ\EOT\NAK\STX\SOH\SOH\DC2\EOT\245\ETX\n\
+    \\SUB\n\
+    \\r\n\
+    \\ENQ\EOT\NAK\STX\SOH\ETX\DC2\EOT\245\ETX\GS\RS\n\
+    \t\n\
+    \\EOT\EOT\NAK\STX\STX\DC2\EOT\251\ETX\EOT5\SUBf\n\
+    \The channel id of the channel that must be taken to the first hop. If zero,\n\
+    \any channel may be used.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\NAK\STX\STX\EOT\DC2\ACK\251\ETX\EOT\245\ETX\US\n\
+    \\r\n\
+    \\ENQ\EOT\NAK\STX\STX\ENQ\DC2\EOT\251\ETX\EOT\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT\NAK\STX\STX\SOH\DC2\EOT\251\ETX\v\ESC\n\
+    \\r\n\
+    \\ENQ\EOT\NAK\STX\STX\ETX\DC2\EOT\251\ETX\RS\US\n\
+    \\r\n\
+    \\ENQ\EOT\NAK\STX\STX\b\DC2\EOT\251\ETX 4\n\
+    \\SO\n\
+    \\ACK\EOT\NAK\STX\STX\b\ACK\DC2\EOT\251\ETX!3\n\
+    \c\n\
+    \\EOT\EOT\NAK\STX\ETX\DC2\EOT\129\EOT\EOT#\SUBU\n\
+    \A list of hops that defines the route. This does not include the source hop\n\
+    \pubkey.\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT\NAK\STX\ETX\EOT\DC2\EOT\129\EOT\EOT\f\n\
+    \\r\n\
+    \\ENQ\EOT\NAK\STX\ETX\ENQ\DC2\EOT\129\EOT\r\DC2\n\
+    \\r\n\
+    \\ENQ\EOT\NAK\STX\ETX\SOH\DC2\EOT\129\EOT\DC3\RS\n\
+    \\r\n\
+    \\ENQ\EOT\NAK\STX\ETX\ETX\DC2\EOT\129\EOT!\"\n\
+    \Y\n\
+    \\EOT\EOT\NAK\STX\EOT\DC2\EOT\132\EOT\EOT\ESC\SUBK An optional payment addr to be included within the last hop of the route.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\NAK\STX\EOT\EOT\DC2\ACK\132\EOT\EOT\129\EOT#\n\
+    \\r\n\
+    \\ENQ\EOT\NAK\STX\EOT\ENQ\DC2\EOT\132\EOT\EOT\t\n\
+    \\r\n\
+    \\ENQ\EOT\NAK\STX\EOT\SOH\DC2\EOT\132\EOT\n\
+    \\SYN\n\
+    \\r\n\
+    \\ENQ\EOT\NAK\STX\EOT\ETX\DC2\EOT\132\EOT\EM\SUB\n\
+    \\f\n\
+    \\STX\EOT\SYN\DC2\ACK\135\EOT\NUL\140\EOT\SOH\n\
+    \\v\n\
+    \\ETX\EOT\SYN\SOH\DC2\EOT\135\EOT\b\SUB\n\
+    \N\n\
+    \\EOT\EOT\SYN\STX\NUL\DC2\EOT\139\EOT\EOT\SUB\SUB@\n\
+    \Fully specified route that can be used to execute the payment.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\SYN\STX\NUL\EOT\DC2\ACK\139\EOT\EOT\135\EOT\FS\n\
+    \\r\n\
+    \\ENQ\EOT\SYN\STX\NUL\ACK\DC2\EOT\139\EOT\EOT\SI\n\
+    \\r\n\
+    \\ENQ\EOT\SYN\STX\NUL\SOH\DC2\EOT\139\EOT\DLE\NAK\n\
+    \\r\n\
+    \\ENQ\EOT\SYN\STX\NUL\ETX\DC2\EOT\139\EOT\CAN\EM\n\
+    \\f\n\
+    \\STX\EOT\ETB\DC2\ACK\142\EOT\NUL\143\EOT\SOH\n\
+    \\v\n\
+    \\ETX\EOT\ETB\SOH\DC2\EOT\142\EOT\b\"\n\
+    \\177\ETX\n\
+    \\STX\EOT\CAN\DC2\ACK\153\EOT\NUL\202\EOT\SOH\SUB\162\ETX\n\
+    \HtlcEvent contains the htlc event that was processed. These are served on a\n\
+    \best-effort basis; events are not persisted, delivery is not guaranteed\n\
+    \(in the event of a crash in the switch, forward events may be lost) and\n\
+    \some events may be replayed upon restart. Events consumed from this package\n\
+    \should be de-duplicated by the htlc's unique combination of incoming and\n\
+    \outgoing channel id and htlc id. [EXPERIMENTAL]\n\
+    \\n\
+    \\v\n\
+    \\ETX\EOT\CAN\SOH\DC2\EOT\153\EOT\b\DC1\n\
+    \q\n\
+    \\EOT\EOT\CAN\STX\NUL\DC2\EOT\158\EOT\EOT#\SUBc\n\
+    \The short channel id that the incoming htlc arrived at our node on. This\n\
+    \value is zero for sends.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\CAN\STX\NUL\EOT\DC2\ACK\158\EOT\EOT\153\EOT\DC3\n\
+    \\r\n\
+    \\ENQ\EOT\CAN\STX\NUL\ENQ\DC2\EOT\158\EOT\EOT\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT\CAN\STX\NUL\SOH\DC2\EOT\158\EOT\v\RS\n\
+    \\r\n\
+    \\ENQ\EOT\CAN\STX\NUL\ETX\DC2\EOT\158\EOT!\"\n\
+    \n\n\
+    \\EOT\EOT\CAN\STX\SOH\DC2\EOT\164\EOT\EOT#\SUB`\n\
+    \The short channel id that the outgoing htlc left our node on. This value\n\
+    \is zero for receives.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\CAN\STX\SOH\EOT\DC2\ACK\164\EOT\EOT\158\EOT#\n\
+    \\r\n\
+    \\ENQ\EOT\CAN\STX\SOH\ENQ\DC2\EOT\164\EOT\EOT\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT\CAN\STX\SOH\SOH\DC2\EOT\164\EOT\v\RS\n\
+    \\r\n\
+    \\ENQ\EOT\CAN\STX\SOH\ETX\DC2\EOT\164\EOT!\"\n\
+    \t\n\
+    \\EOT\EOT\CAN\STX\STX\DC2\EOT\170\EOT\EOT \SUBf\n\
+    \Incoming id is the index of the incoming htlc in the incoming channel.\n\
+    \This value is zero for sends.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\CAN\STX\STX\EOT\DC2\ACK\170\EOT\EOT\164\EOT#\n\
+    \\r\n\
+    \\ENQ\EOT\CAN\STX\STX\ENQ\DC2\EOT\170\EOT\EOT\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT\CAN\STX\STX\SOH\DC2\EOT\170\EOT\v\ESC\n\
+    \\r\n\
+    \\ENQ\EOT\CAN\STX\STX\ETX\DC2\EOT\170\EOT\RS\US\n\
+    \w\n\
+    \\EOT\EOT\CAN\STX\ETX\DC2\EOT\176\EOT\EOT \SUBi\n\
+    \Outgoing id is the index of the outgoing htlc in the outgoing channel.\n\
+    \This value is zero for receives.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\CAN\STX\ETX\EOT\DC2\ACK\176\EOT\EOT\170\EOT \n\
+    \\r\n\
+    \\ENQ\EOT\CAN\STX\ETX\ENQ\DC2\EOT\176\EOT\EOT\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT\CAN\STX\ETX\SOH\DC2\EOT\176\EOT\v\ESC\n\
+    \\r\n\
+    \\ENQ\EOT\CAN\STX\ETX\ETX\DC2\EOT\176\EOT\RS\US\n\
+    \E\n\
+    \\EOT\EOT\CAN\STX\EOT\DC2\EOT\181\EOT\EOT\FS\SUB7\n\
+    \The time in unix nanoseconds that the event occurred.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\CAN\STX\EOT\EOT\DC2\ACK\181\EOT\EOT\176\EOT \n\
+    \\r\n\
+    \\ENQ\EOT\CAN\STX\EOT\ENQ\DC2\EOT\181\EOT\EOT\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT\CAN\STX\EOT\SOH\DC2\EOT\181\EOT\v\ETB\n\
+    \\r\n\
+    \\ENQ\EOT\CAN\STX\EOT\ETX\DC2\EOT\181\EOT\SUB\ESC\n\
+    \\SO\n\
+    \\EOT\EOT\CAN\EOT\NUL\DC2\ACK\183\EOT\EOT\188\EOT\ENQ\n\
+    \\r\n\
+    \\ENQ\EOT\CAN\EOT\NUL\SOH\DC2\EOT\183\EOT\t\DC2\n\
+    \\SO\n\
+    \\ACK\EOT\CAN\EOT\NUL\STX\NUL\DC2\EOT\184\EOT\b\DC4\n\
+    \\SI\n\
+    \\a\EOT\CAN\EOT\NUL\STX\NUL\SOH\DC2\EOT\184\EOT\b\SI\n\
+    \\SI\n\
+    \\a\EOT\CAN\EOT\NUL\STX\NUL\STX\DC2\EOT\184\EOT\DC2\DC3\n\
+    \\SO\n\
+    \\ACK\EOT\CAN\EOT\NUL\STX\SOH\DC2\EOT\185\EOT\b\DC1\n\
+    \\SI\n\
+    \\a\EOT\CAN\EOT\NUL\STX\SOH\SOH\DC2\EOT\185\EOT\b\f\n\
+    \\SI\n\
+    \\a\EOT\CAN\EOT\NUL\STX\SOH\STX\DC2\EOT\185\EOT\SI\DLE\n\
+    \\SO\n\
+    \\ACK\EOT\CAN\EOT\NUL\STX\STX\DC2\EOT\186\EOT\b\DC4\n\
+    \\SI\n\
+    \\a\EOT\CAN\EOT\NUL\STX\STX\SOH\DC2\EOT\186\EOT\b\SI\n\
+    \\SI\n\
+    \\a\EOT\CAN\EOT\NUL\STX\STX\STX\DC2\EOT\186\EOT\DC2\DC3\n\
+    \\SO\n\
+    \\ACK\EOT\CAN\EOT\NUL\STX\ETX\DC2\EOT\187\EOT\b\DC4\n\
+    \\SI\n\
+    \\a\EOT\CAN\EOT\NUL\STX\ETX\SOH\DC2\EOT\187\EOT\b\SI\n\
+    \\SI\n\
+    \\a\EOT\CAN\EOT\NUL\STX\ETX\STX\DC2\EOT\187\EOT\DC2\DC3\n\
+    \a\n\
+    \\EOT\EOT\CAN\STX\ENQ\DC2\EOT\194\EOT\EOT\GS\SUBS\n\
+    \The event type indicates whether the htlc was part of a send, receive or\n\
+    \forward.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\CAN\STX\ENQ\EOT\DC2\ACK\194\EOT\EOT\188\EOT\ENQ\n\
+    \\r\n\
+    \\ENQ\EOT\CAN\STX\ENQ\ACK\DC2\EOT\194\EOT\EOT\r\n\
+    \\r\n\
+    \\ENQ\EOT\CAN\STX\ENQ\SOH\DC2\EOT\194\EOT\SO\CAN\n\
+    \\r\n\
+    \\ENQ\EOT\CAN\STX\ENQ\ETX\DC2\EOT\194\EOT\ESC\FS\n\
+    \\SO\n\
+    \\EOT\EOT\CAN\b\NUL\DC2\ACK\196\EOT\EOT\201\EOT\ENQ\n\
+    \\r\n\
+    \\ENQ\EOT\CAN\b\NUL\SOH\DC2\EOT\196\EOT\n\
+    \\SI\n\
+    \\f\n\
+    \\EOT\EOT\CAN\STX\ACK\DC2\EOT\197\EOT\b'\n\
+    \\r\n\
+    \\ENQ\EOT\CAN\STX\ACK\ACK\DC2\EOT\197\EOT\b\DC4\n\
+    \\r\n\
+    \\ENQ\EOT\CAN\STX\ACK\SOH\DC2\EOT\197\EOT\NAK\"\n\
+    \\r\n\
+    \\ENQ\EOT\CAN\STX\ACK\ETX\DC2\EOT\197\EOT%&\n\
+    \\f\n\
+    \\EOT\EOT\CAN\STX\a\DC2\EOT\198\EOT\b0\n\
+    \\r\n\
+    \\ENQ\EOT\CAN\STX\a\ACK\DC2\EOT\198\EOT\b\CAN\n\
+    \\r\n\
+    \\ENQ\EOT\CAN\STX\a\SOH\DC2\EOT\198\EOT\EM+\n\
+    \\r\n\
+    \\ENQ\EOT\CAN\STX\a\ETX\DC2\EOT\198\EOT./\n\
+    \\f\n\
+    \\EOT\EOT\CAN\STX\b\DC2\EOT\199\EOT\b%\n\
+    \\r\n\
+    \\ENQ\EOT\CAN\STX\b\ACK\DC2\EOT\199\EOT\b\DC3\n\
+    \\r\n\
+    \\ENQ\EOT\CAN\STX\b\SOH\DC2\EOT\199\EOT\DC4 \n\
+    \\r\n\
+    \\ENQ\EOT\CAN\STX\b\ETX\DC2\EOT\199\EOT#$\n\
+    \\f\n\
+    \\EOT\EOT\CAN\STX\t\DC2\EOT\200\EOT\b+\n\
+    \\r\n\
+    \\ENQ\EOT\CAN\STX\t\ACK\DC2\EOT\200\EOT\b\NAK\n\
+    \\r\n\
+    \\ENQ\EOT\CAN\STX\t\SOH\DC2\EOT\200\EOT\SYN%\n\
+    \\r\n\
+    \\ENQ\EOT\CAN\STX\t\ETX\DC2\EOT\200\EOT(*\n\
+    \\f\n\
+    \\STX\EOT\EM\DC2\ACK\204\EOT\NUL\216\EOT\SOH\n\
+    \\v\n\
+    \\ETX\EOT\EM\SOH\DC2\EOT\204\EOT\b\DLE\n\
+    \2\n\
+    \\EOT\EOT\EM\STX\NUL\DC2\EOT\206\EOT\EOT!\SUB$ The timelock on the incoming htlc.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\EM\STX\NUL\EOT\DC2\ACK\206\EOT\EOT\204\EOT\DC2\n\
+    \\r\n\
+    \\ENQ\EOT\EM\STX\NUL\ENQ\DC2\EOT\206\EOT\EOT\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT\EM\STX\NUL\SOH\DC2\EOT\206\EOT\v\FS\n\
+    \\r\n\
+    \\ENQ\EOT\EM\STX\NUL\ETX\DC2\EOT\206\EOT\US \n\
+    \2\n\
+    \\EOT\EOT\EM\STX\SOH\DC2\EOT\209\EOT\EOT!\SUB$ The timelock on the outgoing htlc.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\EM\STX\SOH\EOT\DC2\ACK\209\EOT\EOT\206\EOT!\n\
+    \\r\n\
+    \\ENQ\EOT\EM\STX\SOH\ENQ\DC2\EOT\209\EOT\EOT\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT\EM\STX\SOH\SOH\DC2\EOT\209\EOT\v\FS\n\
+    \\r\n\
+    \\ENQ\EOT\EM\STX\SOH\ETX\DC2\EOT\209\EOT\US \n\
+    \0\n\
+    \\EOT\EOT\EM\STX\STX\DC2\EOT\212\EOT\EOT!\SUB\" The amount of the incoming htlc.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\EM\STX\STX\EOT\DC2\ACK\212\EOT\EOT\209\EOT!\n\
+    \\r\n\
+    \\ENQ\EOT\EM\STX\STX\ENQ\DC2\EOT\212\EOT\EOT\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT\EM\STX\STX\SOH\DC2\EOT\212\EOT\v\FS\n\
+    \\r\n\
+    \\ENQ\EOT\EM\STX\STX\ETX\DC2\EOT\212\EOT\US \n\
+    \0\n\
+    \\EOT\EOT\EM\STX\ETX\DC2\EOT\215\EOT\EOT!\SUB\" The amount of the outgoing htlc.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\EM\STX\ETX\EOT\DC2\ACK\215\EOT\EOT\212\EOT!\n\
+    \\r\n\
+    \\ENQ\EOT\EM\STX\ETX\ENQ\DC2\EOT\215\EOT\EOT\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT\EM\STX\ETX\SOH\DC2\EOT\215\EOT\v\FS\n\
+    \\r\n\
+    \\ENQ\EOT\EM\STX\ETX\ETX\DC2\EOT\215\EOT\US \n\
+    \\f\n\
+    \\STX\EOT\SUB\DC2\ACK\218\EOT\NUL\221\EOT\SOH\n\
+    \\v\n\
+    \\ETX\EOT\SUB\SOH\DC2\EOT\218\EOT\b\DC4\n\
+    \H\n\
+    \\EOT\EOT\SUB\STX\NUL\DC2\EOT\220\EOT\EOT\SYN\SUB: Info contains details about the htlc that was forwarded.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\SUB\STX\NUL\EOT\DC2\ACK\220\EOT\EOT\218\EOT\SYN\n\
+    \\r\n\
+    \\ENQ\EOT\SUB\STX\NUL\ACK\DC2\EOT\220\EOT\EOT\f\n\
+    \\r\n\
+    \\ENQ\EOT\SUB\STX\NUL\SOH\DC2\EOT\220\EOT\r\DC1\n\
+    \\r\n\
+    \\ENQ\EOT\SUB\STX\NUL\ETX\DC2\EOT\220\EOT\DC4\NAK\n\
+    \\f\n\
+    \\STX\EOT\ESC\DC2\ACK\223\EOT\NUL\224\EOT\SOH\n\
+    \\v\n\
+    \\ETX\EOT\ESC\SOH\DC2\EOT\223\EOT\b\CAN\n\
+    \\f\n\
+    \\STX\EOT\FS\DC2\ACK\226\EOT\NUL\229\EOT\SOH\n\
+    \\v\n\
+    \\ETX\EOT\FS\SOH\DC2\EOT\226\EOT\b\DC3\n\
+    \&\n\
+    \\EOT\EOT\FS\STX\NUL\DC2\EOT\228\EOT\EOT\ETB\SUB\CAN The revealed preimage.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\FS\STX\NUL\EOT\DC2\ACK\228\EOT\EOT\226\EOT\NAK\n\
+    \\r\n\
+    \\ENQ\EOT\FS\STX\NUL\ENQ\DC2\EOT\228\EOT\EOT\t\n\
+    \\r\n\
+    \\ENQ\EOT\FS\STX\NUL\SOH\DC2\EOT\228\EOT\n\
+    \\DC2\n\
+    \\r\n\
+    \\ENQ\EOT\FS\STX\NUL\ETX\DC2\EOT\228\EOT\NAK\SYN\n\
+    \\f\n\
+    \\STX\EOT\GS\DC2\ACK\231\EOT\NUL\247\EOT\SOH\n\
+    \\v\n\
+    \\ETX\EOT\GS\SOH\DC2\EOT\231\EOT\b\NAK\n\
+    \D\n\
+    \\EOT\EOT\GS\STX\NUL\DC2\EOT\233\EOT\EOT\SYN\SUB6 Info contains details about the htlc that we failed.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\GS\STX\NUL\EOT\DC2\ACK\233\EOT\EOT\231\EOT\ETB\n\
+    \\r\n\
+    \\ENQ\EOT\GS\STX\NUL\ACK\DC2\EOT\233\EOT\EOT\f\n\
+    \\r\n\
+    \\ENQ\EOT\GS\STX\NUL\SOH\DC2\EOT\233\EOT\r\DC1\n\
+    \\r\n\
+    \\ENQ\EOT\GS\STX\NUL\ETX\DC2\EOT\233\EOT\DC4\NAK\n\
+    \C\n\
+    \\EOT\EOT\GS\STX\SOH\DC2\EOT\236\EOT\EOT/\SUB5 FailureCode is the BOLT error code for the failure.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\GS\STX\SOH\EOT\DC2\ACK\236\EOT\EOT\233\EOT\SYN\n\
+    \\r\n\
+    \\ENQ\EOT\GS\STX\SOH\ACK\DC2\EOT\236\EOT\EOT\GS\n\
+    \\r\n\
+    \\ENQ\EOT\GS\STX\SOH\SOH\DC2\EOT\236\EOT\RS*\n\
+    \\r\n\
+    \\ENQ\EOT\GS\STX\SOH\ETX\DC2\EOT\236\EOT-.\n\
+    \\238\SOH\n\
+    \\EOT\EOT\GS\STX\STX\DC2\EOT\243\EOT\EOT%\SUB\223\SOH\n\
+    \FailureDetail provides additional information about the reason for the\n\
+    \failure. This detail enriches the information provided by the wire message\n\
+    \and may be 'no detail' if the wire message requires no additional metadata.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\GS\STX\STX\EOT\DC2\ACK\243\EOT\EOT\236\EOT/\n\
+    \\r\n\
+    \\ENQ\EOT\GS\STX\STX\ACK\DC2\EOT\243\EOT\EOT\DC1\n\
+    \\r\n\
+    \\ENQ\EOT\GS\STX\STX\SOH\DC2\EOT\243\EOT\DC2 \n\
+    \\r\n\
+    \\ENQ\EOT\GS\STX\STX\ETX\DC2\EOT\243\EOT#$\n\
+    \<\n\
+    \\EOT\EOT\GS\STX\ETX\DC2\EOT\246\EOT\EOT\RS\SUB. A string representation of the link failure.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\GS\STX\ETX\EOT\DC2\ACK\246\EOT\EOT\243\EOT%\n\
+    \\r\n\
+    \\ENQ\EOT\GS\STX\ETX\ENQ\DC2\EOT\246\EOT\EOT\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT\GS\STX\ETX\SOH\DC2\EOT\246\EOT\v\EM\n\
+    \\r\n\
+    \\ENQ\EOT\GS\STX\ETX\ETX\DC2\EOT\246\EOT\FS\GS\n\
+    \\f\n\
+    \\STX\ENQ\NUL\DC2\ACK\249\EOT\NUL\145\ENQ\SOH\n\
+    \\v\n\
+    \\ETX\ENQ\NUL\SOH\DC2\EOT\249\EOT\ENQ\DC2\n\
+    \\f\n\
+    \\EOT\ENQ\NUL\STX\NUL\DC2\EOT\250\EOT\EOT\DLE\n\
+    \\r\n\
+    \\ENQ\ENQ\NUL\STX\NUL\SOH\DC2\EOT\250\EOT\EOT\v\n\
+    \\r\n\
+    \\ENQ\ENQ\NUL\STX\NUL\STX\DC2\EOT\250\EOT\SO\SI\n\
+    \\f\n\
+    \\EOT\ENQ\NUL\STX\SOH\DC2\EOT\251\EOT\EOT\DC2\n\
+    \\r\n\
+    \\ENQ\ENQ\NUL\STX\SOH\SOH\DC2\EOT\251\EOT\EOT\r\n\
+    \\r\n\
+    \\ENQ\ENQ\NUL\STX\SOH\STX\DC2\EOT\251\EOT\DLE\DC1\n\
+    \\f\n\
+    \\EOT\ENQ\NUL\STX\STX\DC2\EOT\252\EOT\EOT\NAK\n\
+    \\r\n\
+    \\ENQ\ENQ\NUL\STX\STX\SOH\DC2\EOT\252\EOT\EOT\DLE\n\
+    \\r\n\
+    \\ENQ\ENQ\NUL\STX\STX\STX\DC2\EOT\252\EOT\DC3\DC4\n\
+    \\f\n\
+    \\EOT\ENQ\NUL\STX\ETX\DC2\EOT\253\EOT\EOT\SUB\n\
+    \\r\n\
+    \\ENQ\ENQ\NUL\STX\ETX\SOH\DC2\EOT\253\EOT\EOT\NAK\n\
+    \\r\n\
+    \\ENQ\ENQ\NUL\STX\ETX\STX\DC2\EOT\253\EOT\CAN\EM\n\
+    \\f\n\
+    \\EOT\ENQ\NUL\STX\EOT\DC2\EOT\254\EOT\EOT\EM\n\
+    \\r\n\
+    \\ENQ\ENQ\NUL\STX\EOT\SOH\DC2\EOT\254\EOT\EOT\DC4\n\
+    \\r\n\
+    \\ENQ\ENQ\NUL\STX\EOT\STX\DC2\EOT\254\EOT\ETB\CAN\n\
+    \\f\n\
+    \\EOT\ENQ\NUL\STX\ENQ\DC2\EOT\255\EOT\EOT\EM\n\
+    \\r\n\
+    \\ENQ\ENQ\NUL\STX\ENQ\SOH\DC2\EOT\255\EOT\EOT\DC4\n\
+    \\r\n\
+    \\ENQ\ENQ\NUL\STX\ENQ\STX\DC2\EOT\255\EOT\ETB\CAN\n\
+    \\f\n\
+    \\EOT\ENQ\NUL\STX\ACK\DC2\EOT\128\ENQ\EOT\GS\n\
+    \\r\n\
+    \\ENQ\ENQ\NUL\STX\ACK\SOH\DC2\EOT\128\ENQ\EOT\CAN\n\
+    \\r\n\
+    \\ENQ\ENQ\NUL\STX\ACK\STX\DC2\EOT\128\ENQ\ESC\FS\n\
+    \\f\n\
+    \\EOT\ENQ\NUL\STX\a\DC2\EOT\129\ENQ\EOT\ESC\n\
+    \\r\n\
+    \\ENQ\ENQ\NUL\STX\a\SOH\DC2\EOT\129\ENQ\EOT\SYN\n\
+    \\r\n\
+    \\ENQ\ENQ\NUL\STX\a\STX\DC2\EOT\129\ENQ\EM\SUB\n\
+    \\f\n\
+    \\EOT\ENQ\NUL\STX\b\DC2\EOT\130\ENQ\EOT\CAN\n\
+    \\r\n\
+    \\ENQ\ENQ\NUL\STX\b\SOH\DC2\EOT\130\ENQ\EOT\DC3\n\
+    \\r\n\
+    \\ENQ\ENQ\NUL\STX\b\STX\DC2\EOT\130\ENQ\SYN\ETB\n\
+    \\f\n\
+    \\EOT\ENQ\NUL\STX\t\DC2\EOT\131\ENQ\EOT\SUB\n\
+    \\r\n\
+    \\ENQ\ENQ\NUL\STX\t\SOH\DC2\EOT\131\ENQ\EOT\NAK\n\
+    \\r\n\
+    \\ENQ\ENQ\NUL\STX\t\STX\DC2\EOT\131\ENQ\CAN\EM\n\
+    \\f\n\
+    \\EOT\ENQ\NUL\STX\n\
+    \\DC2\EOT\132\ENQ\EOT\SUB\n\
+    \\r\n\
+    \\ENQ\ENQ\NUL\STX\n\
+    \\SOH\DC2\EOT\132\ENQ\EOT\DC4\n\
+    \\r\n\
+    \\ENQ\ENQ\NUL\STX\n\
+    \\STX\DC2\EOT\132\ENQ\ETB\EM\n\
+    \\f\n\
+    \\EOT\ENQ\NUL\STX\v\DC2\EOT\133\ENQ\EOT\ESC\n\
+    \\r\n\
+    \\ENQ\ENQ\NUL\STX\v\SOH\DC2\EOT\133\ENQ\EOT\NAK\n\
+    \\r\n\
+    \\ENQ\ENQ\NUL\STX\v\STX\DC2\EOT\133\ENQ\CAN\SUB\n\
+    \\f\n\
+    \\EOT\ENQ\NUL\STX\f\DC2\EOT\134\ENQ\EOT!\n\
+    \\r\n\
+    \\ENQ\ENQ\NUL\STX\f\SOH\DC2\EOT\134\ENQ\EOT\ESC\n\
+    \\r\n\
+    \\ENQ\ENQ\NUL\STX\f\STX\DC2\EOT\134\ENQ\RS \n\
+    \\f\n\
+    \\EOT\ENQ\NUL\STX\r\DC2\EOT\135\ENQ\EOT\SUB\n\
+    \\r\n\
+    \\ENQ\ENQ\NUL\STX\r\SOH\DC2\EOT\135\ENQ\EOT\DC4\n\
+    \\r\n\
+    \\ENQ\ENQ\NUL\STX\r\STX\DC2\EOT\135\ENQ\ETB\EM\n\
+    \\f\n\
+    \\EOT\ENQ\NUL\STX\SO\DC2\EOT\136\ENQ\EOT\GS\n\
+    \\r\n\
+    \\ENQ\ENQ\NUL\STX\SO\SOH\DC2\EOT\136\ENQ\EOT\ETB\n\
+    \\r\n\
+    \\ENQ\ENQ\NUL\STX\SO\STX\DC2\EOT\136\ENQ\SUB\FS\n\
+    \\f\n\
+    \\EOT\ENQ\NUL\STX\SI\DC2\EOT\137\ENQ\EOT\SUB\n\
+    \\r\n\
+    \\ENQ\ENQ\NUL\STX\SI\SOH\DC2\EOT\137\ENQ\EOT\DC4\n\
+    \\r\n\
+    \\ENQ\ENQ\NUL\STX\SI\STX\DC2\EOT\137\ENQ\ETB\EM\n\
+    \\f\n\
+    \\EOT\ENQ\NUL\STX\DLE\DC2\EOT\138\ENQ\EOT\FS\n\
+    \\r\n\
+    \\ENQ\ENQ\NUL\STX\DLE\SOH\DC2\EOT\138\ENQ\EOT\SYN\n\
+    \\r\n\
+    \\ENQ\ENQ\NUL\STX\DLE\STX\DC2\EOT\138\ENQ\EM\ESC\n\
+    \\f\n\
+    \\EOT\ENQ\NUL\STX\DC1\DC2\EOT\139\ENQ\EOT\ESC\n\
+    \\r\n\
+    \\ENQ\ENQ\NUL\STX\DC1\SOH\DC2\EOT\139\ENQ\EOT\NAK\n\
+    \\r\n\
+    \\ENQ\ENQ\NUL\STX\DC1\STX\DC2\EOT\139\ENQ\CAN\SUB\n\
+    \\f\n\
+    \\EOT\ENQ\NUL\STX\DC2\DC2\EOT\140\ENQ\EOT\SYN\n\
+    \\r\n\
+    \\ENQ\ENQ\NUL\STX\DC2\SOH\DC2\EOT\140\ENQ\EOT\DLE\n\
+    \\r\n\
+    \\ENQ\ENQ\NUL\STX\DC2\STX\DC2\EOT\140\ENQ\DC3\NAK\n\
+    \\f\n\
+    \\EOT\ENQ\NUL\STX\DC3\DC2\EOT\141\ENQ\EOT\EM\n\
+    \\r\n\
+    \\ENQ\ENQ\NUL\STX\DC3\SOH\DC2\EOT\141\ENQ\EOT\DC3\n\
+    \\r\n\
+    \\ENQ\ENQ\NUL\STX\DC3\STX\DC2\EOT\141\ENQ\SYN\CAN\n\
+    \\f\n\
+    \\EOT\ENQ\NUL\STX\DC4\DC2\EOT\142\ENQ\EOT\EM\n\
+    \\r\n\
+    \\ENQ\ENQ\NUL\STX\DC4\SOH\DC2\EOT\142\ENQ\EOT\DC3\n\
+    \\r\n\
+    \\ENQ\ENQ\NUL\STX\DC4\STX\DC2\EOT\142\ENQ\SYN\CAN\n\
+    \\f\n\
+    \\EOT\ENQ\NUL\STX\NAK\DC2\EOT\143\ENQ\EOT\EM\n\
+    \\r\n\
+    \\ENQ\ENQ\NUL\STX\NAK\SOH\DC2\EOT\143\ENQ\EOT\DC3\n\
+    \\r\n\
+    \\ENQ\ENQ\NUL\STX\NAK\STX\DC2\EOT\143\ENQ\SYN\CAN\n\
+    \\f\n\
+    \\EOT\ENQ\NUL\STX\SYN\DC2\EOT\144\ENQ\EOT\CAN\n\
+    \\r\n\
+    \\ENQ\ENQ\NUL\STX\SYN\SOH\DC2\EOT\144\ENQ\EOT\DC2\n\
+    \\r\n\
+    \\ENQ\ENQ\NUL\STX\SYN\STX\DC2\EOT\144\ENQ\NAK\ETB\n\
+    \\f\n\
+    \\STX\ENQ\SOH\DC2\ACK\147\ENQ\NUL\184\ENQ\SOH\n\
+    \\v\n\
+    \\ETX\ENQ\SOH\SOH\DC2\EOT\147\ENQ\ENQ\DC1\n\
+    \+\n\
+    \\EOT\ENQ\SOH\STX\NUL\DC2\EOT\151\ENQ\EOT\DC2\SUB\GS\n\
+    \Payment is still in flight.\n\
+    \\n\
+    \\r\n\
+    \\ENQ\ENQ\SOH\STX\NUL\SOH\DC2\EOT\151\ENQ\EOT\r\n\
+    \\r\n\
+    \\ENQ\ENQ\SOH\STX\NUL\STX\DC2\EOT\151\ENQ\DLE\DC1\n\
+    \/\n\
+    \\EOT\ENQ\SOH\STX\SOH\DC2\EOT\156\ENQ\EOT\DC2\SUB!\n\
+    \Payment completed successfully.\n\
+    \\n\
+    \\r\n\
+    \\ENQ\ENQ\SOH\STX\SOH\SOH\DC2\EOT\156\ENQ\EOT\r\n\
+    \\r\n\
+    \\ENQ\ENQ\SOH\STX\SOH\STX\DC2\EOT\156\ENQ\DLE\DC1\n\
+    \S\n\
+    \\EOT\ENQ\SOH\STX\STX\DC2\EOT\161\ENQ\EOT\ETB\SUBE\n\
+    \There are more routes to try, but the payment timeout was exceeded.\n\
+    \\n\
+    \\r\n\
+    \\ENQ\ENQ\SOH\STX\STX\SOH\DC2\EOT\161\ENQ\EOT\DC2\n\
+    \\r\n\
+    \\ENQ\ENQ\SOH\STX\STX\STX\DC2\EOT\161\ENQ\NAK\SYN\n\
+    \s\n\
+    \\EOT\ENQ\SOH\STX\ETX\DC2\EOT\167\ENQ\EOT\CAN\SUBe\n\
+    \All possible routes were tried and failed permanently. Or were no\n\
+    \routes to the destination at all.\n\
+    \\n\
+    \\r\n\
+    \\ENQ\ENQ\SOH\STX\ETX\SOH\DC2\EOT\167\ENQ\EOT\DC3\n\
+    \\r\n\
+    \\ENQ\ENQ\SOH\STX\ETX\STX\DC2\EOT\167\ENQ\SYN\ETB\n\
+    \4\n\
+    \\EOT\ENQ\SOH\STX\EOT\DC2\EOT\172\ENQ\EOT\NAK\SUB&\n\
+    \A non-recoverable error has occured.\n\
+    \\n\
+    \\r\n\
+    \\ENQ\ENQ\SOH\STX\EOT\SOH\DC2\EOT\172\ENQ\EOT\DLE\n\
+    \\r\n\
+    \\ENQ\ENQ\SOH\STX\EOT\STX\DC2\EOT\172\ENQ\DC3\DC4\n\
+    \a\n\
+    \\EOT\ENQ\SOH\STX\ENQ\DC2\EOT\178\ENQ\EOT)\SUBS\n\
+    \Payment details incorrect (unknown hash, invalid amt or\n\
+    \invalid final cltv delta)\n\
+    \\n\
+    \\r\n\
+    \\ENQ\ENQ\SOH\STX\ENQ\SOH\DC2\EOT\178\ENQ\EOT$\n\
+    \\r\n\
+    \\ENQ\ENQ\SOH\STX\ENQ\STX\DC2\EOT\178\ENQ'(\n\
+    \+\n\
+    \\EOT\ENQ\SOH\STX\ACK\DC2\EOT\183\ENQ\EOT$\SUB\GS\n\
+    \Insufficient local balance.\n\
+    \\n\
+    \\r\n\
+    \\ENQ\ENQ\SOH\STX\ACK\SOH\DC2\EOT\183\ENQ\EOT\US\n\
+    \\r\n\
+    \\ENQ\ENQ\SOH\STX\ACK\STX\DC2\EOT\183\ENQ\"#\n\
+    \\f\n\
+    \\STX\EOT\RS\DC2\ACK\186\ENQ\NUL\201\ENQ\SOH\n\
+    \\v\n\
+    \\ETX\EOT\RS\SOH\DC2\EOT\186\ENQ\b\NAK\n\
+    \0\n\
+    \\EOT\EOT\RS\STX\NUL\DC2\EOT\188\ENQ\EOT\ESC\SUB\" Current state the payment is in.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\RS\STX\NUL\EOT\DC2\ACK\188\ENQ\EOT\186\ENQ\ETB\n\
+    \\r\n\
+    \\ENQ\EOT\RS\STX\NUL\ACK\DC2\EOT\188\ENQ\EOT\DLE\n\
+    \\r\n\
+    \\ENQ\EOT\RS\STX\NUL\SOH\DC2\EOT\188\ENQ\DC1\SYN\n\
+    \\r\n\
+    \\ENQ\EOT\RS\STX\NUL\ETX\DC2\EOT\188\ENQ\EM\SUB\n\
+    \E\n\
+    \\EOT\EOT\RS\STX\SOH\DC2\EOT\193\ENQ\EOT\ETB\SUB7\n\
+    \The pre-image of the payment when state is SUCCEEDED.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\RS\STX\SOH\EOT\DC2\ACK\193\ENQ\EOT\188\ENQ\ESC\n\
+    \\r\n\
+    \\ENQ\EOT\RS\STX\SOH\ENQ\DC2\EOT\193\ENQ\EOT\t\n\
+    \\r\n\
+    \\ENQ\EOT\RS\STX\SOH\SOH\DC2\EOT\193\ENQ\n\
+    \\DC2\n\
+    \\r\n\
+    \\ENQ\EOT\RS\STX\SOH\ETX\DC2\EOT\193\ENQ\NAK\SYN\n\
+    \\v\n\
+    \\ETX\EOT\RS\t\DC2\EOT\195\ENQ\EOT\SI\n\
+    \\f\n\
+    \\EOT\EOT\RS\t\NUL\DC2\EOT\195\ENQ\r\SO\n\
+    \\r\n\
+    \\ENQ\EOT\RS\t\NUL\SOH\DC2\EOT\195\ENQ\r\SO\n\
+    \\r\n\
+    \\ENQ\EOT\RS\t\NUL\STX\DC2\EOT\195\ENQ\r\SO\n\
+    \O\n\
+    \\EOT\EOT\RS\STX\STX\DC2\EOT\200\ENQ\EOT)\SUBA\n\
+    \The HTLCs made in attempt to settle the payment [EXPERIMENTAL].\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT\RS\STX\STX\EOT\DC2\EOT\200\ENQ\EOT\f\n\
+    \\r\n\
+    \\ENQ\EOT\RS\STX\STX\ACK\DC2\EOT\200\ENQ\r\RS\n\
+    \\r\n\
+    \\ENQ\EOT\RS\STX\STX\SOH\DC2\EOT\200\ENQ\US$\n\
+    \\r\n\
+    \\ENQ\EOT\RS\STX\STX\ETX\DC2\EOT\200\ENQ'(\n\
+    \\f\n\
+    \\STX\EOT\US\DC2\ACK\203\ENQ\NUL\209\ENQ\SOH\n\
+    \\v\n\
+    \\ETX\EOT\US\SOH\DC2\EOT\203\ENQ\b\DC2\n\
+    \H\n\
+    \\EOT\EOT\US\STX\NUL\DC2\EOT\205\ENQ\EOT\ETB\SUB:/ The id of the channel that the is part of this circuit.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\US\STX\NUL\EOT\DC2\ACK\205\ENQ\EOT\203\ENQ\DC4\n\
+    \\r\n\
+    \\ENQ\EOT\US\STX\NUL\ENQ\DC2\EOT\205\ENQ\EOT\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT\US\STX\NUL\SOH\DC2\EOT\205\ENQ\v\DC2\n\
+    \\r\n\
+    \\ENQ\EOT\US\STX\NUL\ETX\DC2\EOT\205\ENQ\NAK\SYN\n\
+    \H\n\
+    \\EOT\EOT\US\STX\SOH\DC2\EOT\208\ENQ\EOT\ETB\SUB:/ The index of the incoming htlc in the incoming channel.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\US\STX\SOH\EOT\DC2\ACK\208\ENQ\EOT\205\ENQ\ETB\n\
+    \\r\n\
+    \\ENQ\EOT\US\STX\SOH\ENQ\DC2\EOT\208\ENQ\EOT\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT\US\STX\SOH\SOH\DC2\EOT\208\ENQ\v\DC2\n\
+    \\r\n\
+    \\ENQ\EOT\US\STX\SOH\ETX\DC2\EOT\208\ENQ\NAK\SYN\n\
+    \\f\n\
+    \\STX\EOT \DC2\ACK\211\ENQ\NUL\247\ENQ\SOH\n\
+    \\v\n\
+    \\ETX\EOT \SOH\DC2\EOT\211\ENQ\b#\n\
+    \q\n\
+    \\EOT\EOT \STX\NUL\DC2\EOT\216\ENQ\EOT(\SUBc\n\
+    \The key of this forwarded htlc. It defines the incoming channel id and\n\
+    \the index in this channel.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT \STX\NUL\EOT\DC2\ACK\216\ENQ\EOT\211\ENQ%\n\
+    \\r\n\
+    \\ENQ\EOT \STX\NUL\ACK\DC2\EOT\216\ENQ\EOT\SO\n\
+    \\r\n\
+    \\ENQ\EOT \STX\NUL\SOH\DC2\EOT\216\ENQ\SI#\n\
+    \\r\n\
+    \\ENQ\EOT \STX\NUL\ETX\DC2\EOT\216\ENQ&'\n\
+    \)\n\
+    \\EOT\EOT \STX\SOH\DC2\EOT\219\ENQ\EOT$\SUB\ESC The incoming htlc amount.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT \STX\SOH\EOT\DC2\ACK\219\ENQ\EOT\216\ENQ(\n\
+    \\r\n\
+    \\ENQ\EOT \STX\SOH\ENQ\DC2\EOT\219\ENQ\EOT\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT \STX\SOH\SOH\DC2\EOT\219\ENQ\v\US\n\
+    \\r\n\
+    \\ENQ\EOT \STX\SOH\ETX\DC2\EOT\219\ENQ\"#\n\
+    \)\n\
+    \\EOT\EOT \STX\STX\DC2\EOT\222\ENQ\EOT\US\SUB\ESC The incoming htlc expiry.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT \STX\STX\EOT\DC2\ACK\222\ENQ\EOT\219\ENQ$\n\
+    \\r\n\
+    \\ENQ\EOT \STX\STX\ENQ\DC2\EOT\222\ENQ\EOT\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT \STX\STX\SOH\DC2\EOT\222\ENQ\v\SUB\n\
+    \\r\n\
+    \\ENQ\EOT \STX\STX\ETX\DC2\EOT\222\ENQ\GS\RS\n\
+    \]\n\
+    \\EOT\EOT \STX\ETX\DC2\EOT\228\ENQ\EOT\ESC\SUBO\n\
+    \The htlc payment hash. This value is not guaranteed to be unique per\n\
+    \request.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT \STX\ETX\EOT\DC2\ACK\228\ENQ\EOT\222\ENQ\US\n\
+    \\r\n\
+    \\ENQ\EOT \STX\ETX\ENQ\DC2\EOT\228\ENQ\EOT\t\n\
+    \\r\n\
+    \\ENQ\EOT \STX\ETX\SOH\DC2\EOT\228\ENQ\n\
+    \\SYN\n\
+    \\r\n\
+    \\ENQ\EOT \STX\ETX\ETX\DC2\EOT\228\ENQ\EM\SUB\n\
+    \\133\STX\n\
+    \\EOT\EOT \STX\EOT\DC2\EOT\234\ENQ\EOT*\SUB\246\SOH The requested outgoing channel id for this forwarded htlc. Because of\n\
+    \ non-strict forwarding, this isn't necessarily the channel over which the\n\
+    \ packet will be forwarded eventually. A different channel to the same peer\n\
+    \ may be selected as well.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT \STX\EOT\EOT\DC2\ACK\234\ENQ\EOT\228\ENQ\ESC\n\
+    \\r\n\
+    \\ENQ\EOT \STX\EOT\ENQ\DC2\EOT\234\ENQ\EOT\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT \STX\EOT\SOH\DC2\EOT\234\ENQ\v%\n\
+    \\r\n\
+    \\ENQ\EOT \STX\EOT\ETX\DC2\EOT\234\ENQ()\n\
+    \)\n\
+    \\EOT\EOT \STX\ENQ\DC2\EOT\237\ENQ\EOT$\SUB\ESC The outgoing htlc amount.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT \STX\ENQ\EOT\DC2\ACK\237\ENQ\EOT\234\ENQ*\n\
+    \\r\n\
+    \\ENQ\EOT \STX\ENQ\ENQ\DC2\EOT\237\ENQ\EOT\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT \STX\ENQ\SOH\DC2\EOT\237\ENQ\v\US\n\
+    \\r\n\
+    \\ENQ\EOT \STX\ENQ\ETX\DC2\EOT\237\ENQ\"#\n\
+    \)\n\
+    \\EOT\EOT \STX\ACK\DC2\EOT\240\ENQ\EOT\US\SUB\ESC The outgoing htlc expiry.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT \STX\ACK\EOT\DC2\ACK\240\ENQ\EOT\237\ENQ$\n\
+    \\r\n\
+    \\ENQ\EOT \STX\ACK\ENQ\DC2\EOT\240\ENQ\EOT\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT \STX\ACK\SOH\DC2\EOT\240\ENQ\v\SUB\n\
+    \\r\n\
+    \\ENQ\EOT \STX\ACK\ETX\DC2\EOT\240\ENQ\GS\RS\n\
+    \D\n\
+    \\EOT\EOT \STX\a\DC2\EOT\243\ENQ\EOT*\SUB6 Any custom records that were present in the payload.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT \STX\a\EOT\DC2\ACK\243\ENQ\EOT\240\ENQ\US\n\
+    \\r\n\
+    \\ENQ\EOT \STX\a\ACK\DC2\EOT\243\ENQ\EOT\SYN\n\
+    \\r\n\
+    \\ENQ\EOT \STX\a\SOH\DC2\EOT\243\ENQ\ETB%\n\
+    \\r\n\
+    \\ENQ\EOT \STX\a\ETX\DC2\EOT\243\ENQ()\n\
+    \/\n\
+    \\EOT\EOT \STX\b\DC2\EOT\246\ENQ\EOT\EM\SUB! The onion blob for the next hop\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT \STX\b\EOT\DC2\ACK\246\ENQ\EOT\243\ENQ*\n\
+    \\r\n\
+    \\ENQ\EOT \STX\b\ENQ\DC2\EOT\246\ENQ\EOT\t\n\
+    \\r\n\
+    \\ENQ\EOT \STX\b\SOH\DC2\EOT\246\ENQ\n\
+    \\DC4\n\
+    \\r\n\
+    \\ENQ\EOT \STX\b\ETX\DC2\EOT\246\ENQ\ETB\CAN\n\
+    \\157\STX\n\
+    \\STX\EOT!\DC2\ACK\128\ACK\NUL\140\ACK\SOH\SUB\142\STX*\n\
+    \ForwardHtlcInterceptResponse enables the caller to resolve a previously hold\n\
+    \forward. The caller can choose either to:\n\
+    \- `Resume`: Execute the default behavior (usually forward).\n\
+    \- `Reject`: Fail the htlc backwards.\n\
+    \- `Settle`: Settle this htlc with a given preimage.\n\
+    \\n\
+    \\v\n\
+    \\ETX\EOT!\SOH\DC2\EOT\128\ACK\b$\n\
+    \r\n\
+    \\EOT\EOT!\STX\NUL\DC2\EOT\133\ACK\EOT(\SUBd*\n\
+    \The key of this forwarded htlc. It defines the incoming channel id and\n\
+    \the index in this channel.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT!\STX\NUL\EOT\DC2\ACK\133\ACK\EOT\128\ACK&\n\
+    \\r\n\
+    \\ENQ\EOT!\STX\NUL\ACK\DC2\EOT\133\ACK\EOT\SO\n\
+    \\r\n\
+    \\ENQ\EOT!\STX\NUL\SOH\DC2\EOT\133\ACK\SI#\n\
+    \\r\n\
+    \\ENQ\EOT!\STX\NUL\ETX\DC2\EOT\133\ACK&'\n\
+    \=\n\
+    \\EOT\EOT!\STX\SOH\DC2\EOT\136\ACK\EOT(\SUB/ The resolve action for this intercepted htlc.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT!\STX\SOH\EOT\DC2\ACK\136\ACK\EOT\133\ACK(\n\
+    \\r\n\
+    \\ENQ\EOT!\STX\SOH\ACK\DC2\EOT\136\ACK\EOT\FS\n\
+    \\r\n\
+    \\ENQ\EOT!\STX\SOH\SOH\DC2\EOT\136\ACK\GS#\n\
+    \\r\n\
+    \\ENQ\EOT!\STX\SOH\ETX\DC2\EOT\136\ACK&'\n\
+    \B\n\
+    \\EOT\EOT!\STX\STX\DC2\EOT\139\ACK\EOT\ETB\SUB4 The preimage in case the resolve action is Settle.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT!\STX\STX\EOT\DC2\ACK\139\ACK\EOT\136\ACK(\n\
+    \\r\n\
+    \\ENQ\EOT!\STX\STX\ENQ\DC2\EOT\139\ACK\EOT\t\n\
+    \\r\n\
+    \\ENQ\EOT!\STX\STX\SOH\DC2\EOT\139\ACK\n\
+    \\DC2\n\
+    \\r\n\
+    \\ENQ\EOT!\STX\STX\ETX\DC2\EOT\139\ACK\NAK\SYN\n\
+    \\f\n\
+    \\STX\ENQ\STX\DC2\ACK\142\ACK\NUL\146\ACK\SOH\n\
+    \\v\n\
+    \\ETX\ENQ\STX\SOH\DC2\EOT\142\ACK\ENQ\GS\n\
+    \\f\n\
+    \\EOT\ENQ\STX\STX\NUL\DC2\EOT\143\ACK\EOT\SI\n\
+    \\r\n\
+    \\ENQ\ENQ\STX\STX\NUL\SOH\DC2\EOT\143\ACK\EOT\n\
+    \\n\
+    \\r\n\
+    \\ENQ\ENQ\STX\STX\NUL\STX\DC2\EOT\143\ACK\r\SO\n\
+    \\f\n\
+    \\EOT\ENQ\STX\STX\SOH\DC2\EOT\144\ACK\EOT\r\n\
+    \\r\n\
+    \\ENQ\ENQ\STX\STX\SOH\SOH\DC2\EOT\144\ACK\EOT\b\n\
+    \\r\n\
+    \\ENQ\ENQ\STX\STX\SOH\STX\DC2\EOT\144\ACK\v\f\n\
+    \\f\n\
+    \\EOT\ENQ\STX\STX\STX\DC2\EOT\145\ACK\EOT\SI\n\
+    \\r\n\
+    \\ENQ\ENQ\STX\STX\STX\SOH\DC2\EOT\145\ACK\EOT\n\
+    \\n\
+    \\r\n\
+    \\ENQ\ENQ\STX\STX\STX\STX\DC2\EOT\145\ACK\r\SO\n\
+    \\f\n\
+    \\STX\EOT\"\DC2\ACK\148\ACK\NUL\152\ACK\SOH\n\
+    \\v\n\
+    \\ETX\EOT\"\SOH\DC2\EOT\148\ACK\b\US\n\
+    \\f\n\
+    \\EOT\EOT\"\STX\NUL\DC2\EOT\149\ACK\EOT&\n\
+    \\SI\n\
+    \\ENQ\EOT\"\STX\NUL\EOT\DC2\ACK\149\ACK\EOT\148\ACK!\n\
+    \\r\n\
+    \\ENQ\EOT\"\STX\NUL\ACK\DC2\EOT\149\ACK\EOT\SYN\n\
+    \\r\n\
+    \\ENQ\EOT\"\STX\NUL\SOH\DC2\EOT\149\ACK\ETB!\n\
+    \\r\n\
+    \\ENQ\EOT\"\STX\NUL\ETX\DC2\EOT\149\ACK$%\n\
+    \\f\n\
+    \\EOT\EOT\"\STX\SOH\DC2\EOT\151\ACK\EOT \n\
+    \\SI\n\
+    \\ENQ\EOT\"\STX\SOH\EOT\DC2\ACK\151\ACK\EOT\149\ACK&\n\
+    \\r\n\
+    \\ENQ\EOT\"\STX\SOH\ACK\DC2\EOT\151\ACK\EOT\DC4\n\
+    \\r\n\
+    \\ENQ\EOT\"\STX\SOH\SOH\DC2\EOT\151\ACK\NAK\ESC\n\
+    \\r\n\
+    \\ENQ\EOT\"\STX\SOH\ETX\DC2\EOT\151\ACK\RS\US\n\
+    \\f\n\
+    \\STX\ENQ\ETX\DC2\ACK\154\ACK\NUL\158\ACK\SOH\n\
+    \\v\n\
+    \\ETX\ENQ\ETX\SOH\DC2\EOT\154\ACK\ENQ\NAK\n\
+    \\f\n\
+    \\EOT\ENQ\ETX\STX\NUL\DC2\EOT\155\ACK\EOT\SI\n\
+    \\r\n\
+    \\ENQ\ENQ\ETX\STX\NUL\SOH\DC2\EOT\155\ACK\EOT\n\
+    \\n\
+    \\r\n\
+    \\ENQ\ENQ\ETX\STX\NUL\STX\DC2\EOT\155\ACK\r\SO\n\
+    \\f\n\
+    \\EOT\ENQ\ETX\STX\SOH\DC2\EOT\156\ACK\EOT\DLE\n\
+    \\r\n\
+    \\ENQ\ENQ\ETX\STX\SOH\SOH\DC2\EOT\156\ACK\EOT\v\n\
+    \\r\n\
+    \\ENQ\ENQ\ETX\STX\SOH\STX\DC2\EOT\156\ACK\SO\SI\n\
+    \\f\n\
+    \\EOT\ENQ\ETX\STX\STX\DC2\EOT\157\ACK\EOT\r\n\
+    \\r\n\
+    \\ENQ\ENQ\ETX\STX\STX\SOH\DC2\EOT\157\ACK\EOT\b\n\
+    \\r\n\
+    \\ENQ\ENQ\ETX\STX\STX\STX\DC2\EOT\157\ACK\v\f\n\
+    \\f\n\
+    \\STX\EOT#\DC2\ACK\160\ACK\NUL\161\ACK\SOH\n\
+    \\v\n\
+    \\ETX\EOT#\SOH\DC2\EOT\160\ACK\b b\ACKproto3"
diff --git a/src/Proto/RouterGrpc_Fields.hs b/src/Proto/RouterGrpc_Fields.hs
new file mode 100644
--- /dev/null
+++ b/src/Proto/RouterGrpc_Fields.hs
@@ -0,0 +1,620 @@
+{- This file was auto-generated from router_grpc.proto by the proto-lens-protoc program. -}
+{-# LANGUAGE ScopedTypeVariables, DataKinds, TypeFamilies, UndecidableInstances, GeneralizedNewtypeDeriving, MultiParamTypeClasses, FlexibleContexts, FlexibleInstances, PatternSynonyms, MagicHash, NoImplicitPrelude, DataKinds, BangPatterns, TypeApplications, OverloadedStrings, DerivingStrategies#-}
+{-# OPTIONS_GHC -Wno-unused-imports#-}
+{-# OPTIONS_GHC -Wno-duplicate-exports#-}
+{-# OPTIONS_GHC -Wno-dodgy-exports#-}
+module Proto.RouterGrpc_Fields where
+import qualified Data.ProtoLens.Runtime.Prelude as Prelude
+import qualified Data.ProtoLens.Runtime.Data.Int as Data.Int
+import qualified Data.ProtoLens.Runtime.Data.Monoid as Data.Monoid
+import qualified Data.ProtoLens.Runtime.Data.Word as Data.Word
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens as Data.ProtoLens
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Bytes as Data.ProtoLens.Encoding.Bytes
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Growing as Data.ProtoLens.Encoding.Growing
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Parser.Unsafe as Data.ProtoLens.Encoding.Parser.Unsafe
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Wire as Data.ProtoLens.Encoding.Wire
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Field as Data.ProtoLens.Field
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Message.Enum as Data.ProtoLens.Message.Enum
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Service.Types as Data.ProtoLens.Service.Types
+import qualified Data.ProtoLens.Runtime.Lens.Family2 as Lens.Family2
+import qualified Data.ProtoLens.Runtime.Lens.Family2.Unchecked as Lens.Family2.Unchecked
+import qualified Data.ProtoLens.Runtime.Data.Text as Data.Text
+import qualified Data.ProtoLens.Runtime.Data.Map as Data.Map
+import qualified Data.ProtoLens.Runtime.Data.ByteString as Data.ByteString
+import qualified Data.ProtoLens.Runtime.Data.ByteString.Char8 as Data.ByteString.Char8
+import qualified Data.ProtoLens.Runtime.Data.Text.Encoding as Data.Text.Encoding
+import qualified Data.ProtoLens.Runtime.Data.Vector as Data.Vector
+import qualified Data.ProtoLens.Runtime.Data.Vector.Generic as Data.Vector.Generic
+import qualified Data.ProtoLens.Runtime.Data.Vector.Unboxed as Data.Vector.Unboxed
+import qualified Data.ProtoLens.Runtime.Text.Read as Text.Read
+import qualified Proto.LndGrpc
+action ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "action" a) =>
+  Lens.Family2.LensLike' f s a
+action = Data.ProtoLens.Field.field @"action"
+allowSelfPayment ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "allowSelfPayment" a) =>
+  Lens.Family2.LensLike' f s a
+allowSelfPayment = Data.ProtoLens.Field.field @"allowSelfPayment"
+amp ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "amp" a) =>
+  Lens.Family2.LensLike' f s a
+amp = Data.ProtoLens.Field.field @"amp"
+amt ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "amt" a) =>
+  Lens.Family2.LensLike' f s a
+amt = Data.ProtoLens.Field.field @"amt"
+amtMsat ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "amtMsat" a) =>
+  Lens.Family2.LensLike' f s a
+amtMsat = Data.ProtoLens.Field.field @"amtMsat"
+amtSat ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "amtSat" a) =>
+  Lens.Family2.LensLike' f s a
+amtSat = Data.ProtoLens.Field.field @"amtSat"
+chanId ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "chanId" a) =>
+  Lens.Family2.LensLike' f s a
+chanId = Data.ProtoLens.Field.field @"chanId"
+chanPoint ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "chanPoint" a) =>
+  Lens.Family2.LensLike' f s a
+chanPoint = Data.ProtoLens.Field.field @"chanPoint"
+cltvLimit ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "cltvLimit" a) =>
+  Lens.Family2.LensLike' f s a
+cltvLimit = Data.ProtoLens.Field.field @"cltvLimit"
+config ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "config" a) =>
+  Lens.Family2.LensLike' f s a
+config = Data.ProtoLens.Field.field @"config"
+customRecords ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "customRecords" a) =>
+  Lens.Family2.LensLike' f s a
+customRecords = Data.ProtoLens.Field.field @"customRecords"
+dest ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "dest" a) =>
+  Lens.Family2.LensLike' f s a
+dest = Data.ProtoLens.Field.field @"dest"
+destCustomRecords ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "destCustomRecords" a) =>
+  Lens.Family2.LensLike' f s a
+destCustomRecords = Data.ProtoLens.Field.field @"destCustomRecords"
+destFeatures ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "destFeatures" a) =>
+  Lens.Family2.LensLike' f s a
+destFeatures = Data.ProtoLens.Field.field @"destFeatures"
+eventType ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "eventType" a) =>
+  Lens.Family2.LensLike' f s a
+eventType = Data.ProtoLens.Field.field @"eventType"
+failAmtMsat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "failAmtMsat" a) =>
+  Lens.Family2.LensLike' f s a
+failAmtMsat = Data.ProtoLens.Field.field @"failAmtMsat"
+failAmtSat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "failAmtSat" a) =>
+  Lens.Family2.LensLike' f s a
+failAmtSat = Data.ProtoLens.Field.field @"failAmtSat"
+failTime ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "failTime" a) =>
+  Lens.Family2.LensLike' f s a
+failTime = Data.ProtoLens.Field.field @"failTime"
+failure ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "failure" a) =>
+  Lens.Family2.LensLike' f s a
+failure = Data.ProtoLens.Field.field @"failure"
+failureDetail ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "failureDetail" a) =>
+  Lens.Family2.LensLike' f s a
+failureDetail = Data.ProtoLens.Field.field @"failureDetail"
+failureString ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "failureString" a) =>
+  Lens.Family2.LensLike' f s a
+failureString = Data.ProtoLens.Field.field @"failureString"
+feeLimitMsat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "feeLimitMsat" a) =>
+  Lens.Family2.LensLike' f s a
+feeLimitMsat = Data.ProtoLens.Field.field @"feeLimitMsat"
+feeLimitSat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "feeLimitSat" a) =>
+  Lens.Family2.LensLike' f s a
+feeLimitSat = Data.ProtoLens.Field.field @"feeLimitSat"
+finalCltvDelta ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "finalCltvDelta" a) =>
+  Lens.Family2.LensLike' f s a
+finalCltvDelta = Data.ProtoLens.Field.field @"finalCltvDelta"
+forwardEvent ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "forwardEvent" a) =>
+  Lens.Family2.LensLike' f s a
+forwardEvent = Data.ProtoLens.Field.field @"forwardEvent"
+forwardFailEvent ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "forwardFailEvent" a) =>
+  Lens.Family2.LensLike' f s a
+forwardFailEvent = Data.ProtoLens.Field.field @"forwardFailEvent"
+fromNode ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "fromNode" a) =>
+  Lens.Family2.LensLike' f s a
+fromNode = Data.ProtoLens.Field.field @"fromNode"
+halfLifeSeconds ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "halfLifeSeconds" a) =>
+  Lens.Family2.LensLike' f s a
+halfLifeSeconds = Data.ProtoLens.Field.field @"halfLifeSeconds"
+history ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "history" a) =>
+  Lens.Family2.LensLike' f s a
+history = Data.ProtoLens.Field.field @"history"
+hopProbability ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "hopProbability" a) =>
+  Lens.Family2.LensLike' f s a
+hopProbability = Data.ProtoLens.Field.field @"hopProbability"
+hopPubkeys ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "hopPubkeys" a) =>
+  Lens.Family2.LensLike' f s a
+hopPubkeys = Data.ProtoLens.Field.field @"hopPubkeys"
+htlcId ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "htlcId" a) =>
+  Lens.Family2.LensLike' f s a
+htlcId = Data.ProtoLens.Field.field @"htlcId"
+htlcs ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "htlcs" a) =>
+  Lens.Family2.LensLike' f s a
+htlcs = Data.ProtoLens.Field.field @"htlcs"
+incomingAmountMsat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "incomingAmountMsat" a) =>
+  Lens.Family2.LensLike' f s a
+incomingAmountMsat
+  = Data.ProtoLens.Field.field @"incomingAmountMsat"
+incomingAmtMsat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "incomingAmtMsat" a) =>
+  Lens.Family2.LensLike' f s a
+incomingAmtMsat = Data.ProtoLens.Field.field @"incomingAmtMsat"
+incomingChannelId ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "incomingChannelId" a) =>
+  Lens.Family2.LensLike' f s a
+incomingChannelId = Data.ProtoLens.Field.field @"incomingChannelId"
+incomingCircuitKey ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "incomingCircuitKey" a) =>
+  Lens.Family2.LensLike' f s a
+incomingCircuitKey
+  = Data.ProtoLens.Field.field @"incomingCircuitKey"
+incomingExpiry ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "incomingExpiry" a) =>
+  Lens.Family2.LensLike' f s a
+incomingExpiry = Data.ProtoLens.Field.field @"incomingExpiry"
+incomingHtlcId ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "incomingHtlcId" a) =>
+  Lens.Family2.LensLike' f s a
+incomingHtlcId = Data.ProtoLens.Field.field @"incomingHtlcId"
+incomingTimelock ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "incomingTimelock" a) =>
+  Lens.Family2.LensLike' f s a
+incomingTimelock = Data.ProtoLens.Field.field @"incomingTimelock"
+info ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "info" a) =>
+  Lens.Family2.LensLike' f s a
+info = Data.ProtoLens.Field.field @"info"
+key ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "key" a) =>
+  Lens.Family2.LensLike' f s a
+key = Data.ProtoLens.Field.field @"key"
+lastHopPubkey ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "lastHopPubkey" a) =>
+  Lens.Family2.LensLike' f s a
+lastHopPubkey = Data.ProtoLens.Field.field @"lastHopPubkey"
+linkFailEvent ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "linkFailEvent" a) =>
+  Lens.Family2.LensLike' f s a
+linkFailEvent = Data.ProtoLens.Field.field @"linkFailEvent"
+maxParts ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maxParts" a) =>
+  Lens.Family2.LensLike' f s a
+maxParts = Data.ProtoLens.Field.field @"maxParts"
+maxShardSizeMsat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maxShardSizeMsat" a) =>
+  Lens.Family2.LensLike' f s a
+maxShardSizeMsat = Data.ProtoLens.Field.field @"maxShardSizeMsat"
+maximumPaymentResults ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maximumPaymentResults" a) =>
+  Lens.Family2.LensLike' f s a
+maximumPaymentResults
+  = Data.ProtoLens.Field.field @"maximumPaymentResults"
+maybe'chanPoint ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'chanPoint" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'chanPoint = Data.ProtoLens.Field.field @"maybe'chanPoint"
+maybe'config ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'config" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'config = Data.ProtoLens.Field.field @"maybe'config"
+maybe'event ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'event" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'event = Data.ProtoLens.Field.field @"maybe'event"
+maybe'failure ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'failure" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'failure = Data.ProtoLens.Field.field @"maybe'failure"
+maybe'forwardEvent ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'forwardEvent" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'forwardEvent
+  = Data.ProtoLens.Field.field @"maybe'forwardEvent"
+maybe'forwardFailEvent ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'forwardFailEvent" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'forwardFailEvent
+  = Data.ProtoLens.Field.field @"maybe'forwardFailEvent"
+maybe'history ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'history" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'history = Data.ProtoLens.Field.field @"maybe'history"
+maybe'incomingCircuitKey ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'incomingCircuitKey" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'incomingCircuitKey
+  = Data.ProtoLens.Field.field @"maybe'incomingCircuitKey"
+maybe'info ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'info" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'info = Data.ProtoLens.Field.field @"maybe'info"
+maybe'linkFailEvent ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'linkFailEvent" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'linkFailEvent
+  = Data.ProtoLens.Field.field @"maybe'linkFailEvent"
+maybe'route ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'route" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'route = Data.ProtoLens.Field.field @"maybe'route"
+maybe'settleEvent ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'settleEvent" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'settleEvent = Data.ProtoLens.Field.field @"maybe'settleEvent"
+minimumFailureRelaxInterval ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "minimumFailureRelaxInterval" a) =>
+  Lens.Family2.LensLike' f s a
+minimumFailureRelaxInterval
+  = Data.ProtoLens.Field.field @"minimumFailureRelaxInterval"
+noInflightUpdates ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "noInflightUpdates" a) =>
+  Lens.Family2.LensLike' f s a
+noInflightUpdates = Data.ProtoLens.Field.field @"noInflightUpdates"
+nodeFrom ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "nodeFrom" a) =>
+  Lens.Family2.LensLike' f s a
+nodeFrom = Data.ProtoLens.Field.field @"nodeFrom"
+nodeTo ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "nodeTo" a) =>
+  Lens.Family2.LensLike' f s a
+nodeTo = Data.ProtoLens.Field.field @"nodeTo"
+onionBlob ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "onionBlob" a) =>
+  Lens.Family2.LensLike' f s a
+onionBlob = Data.ProtoLens.Field.field @"onionBlob"
+outgoingAmountMsat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "outgoingAmountMsat" a) =>
+  Lens.Family2.LensLike' f s a
+outgoingAmountMsat
+  = Data.ProtoLens.Field.field @"outgoingAmountMsat"
+outgoingAmtMsat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "outgoingAmtMsat" a) =>
+  Lens.Family2.LensLike' f s a
+outgoingAmtMsat = Data.ProtoLens.Field.field @"outgoingAmtMsat"
+outgoingChanId ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "outgoingChanId" a) =>
+  Lens.Family2.LensLike' f s a
+outgoingChanId = Data.ProtoLens.Field.field @"outgoingChanId"
+outgoingChanIds ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "outgoingChanIds" a) =>
+  Lens.Family2.LensLike' f s a
+outgoingChanIds = Data.ProtoLens.Field.field @"outgoingChanIds"
+outgoingChannelId ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "outgoingChannelId" a) =>
+  Lens.Family2.LensLike' f s a
+outgoingChannelId = Data.ProtoLens.Field.field @"outgoingChannelId"
+outgoingExpiry ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "outgoingExpiry" a) =>
+  Lens.Family2.LensLike' f s a
+outgoingExpiry = Data.ProtoLens.Field.field @"outgoingExpiry"
+outgoingHtlcId ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "outgoingHtlcId" a) =>
+  Lens.Family2.LensLike' f s a
+outgoingHtlcId = Data.ProtoLens.Field.field @"outgoingHtlcId"
+outgoingRequestedChanId ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "outgoingRequestedChanId" a) =>
+  Lens.Family2.LensLike' f s a
+outgoingRequestedChanId
+  = Data.ProtoLens.Field.field @"outgoingRequestedChanId"
+outgoingTimelock ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "outgoingTimelock" a) =>
+  Lens.Family2.LensLike' f s a
+outgoingTimelock = Data.ProtoLens.Field.field @"outgoingTimelock"
+pairs ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "pairs" a) =>
+  Lens.Family2.LensLike' f s a
+pairs = Data.ProtoLens.Field.field @"pairs"
+paymentAddr ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "paymentAddr" a) =>
+  Lens.Family2.LensLike' f s a
+paymentAddr = Data.ProtoLens.Field.field @"paymentAddr"
+paymentHash ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "paymentHash" a) =>
+  Lens.Family2.LensLike' f s a
+paymentHash = Data.ProtoLens.Field.field @"paymentHash"
+paymentRequest ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "paymentRequest" a) =>
+  Lens.Family2.LensLike' f s a
+paymentRequest = Data.ProtoLens.Field.field @"paymentRequest"
+preimage ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "preimage" a) =>
+  Lens.Family2.LensLike' f s a
+preimage = Data.ProtoLens.Field.field @"preimage"
+probability ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "probability" a) =>
+  Lens.Family2.LensLike' f s a
+probability = Data.ProtoLens.Field.field @"probability"
+route ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "route" a) =>
+  Lens.Family2.LensLike' f s a
+route = Data.ProtoLens.Field.field @"route"
+routeHints ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "routeHints" a) =>
+  Lens.Family2.LensLike' f s a
+routeHints = Data.ProtoLens.Field.field @"routeHints"
+routingFeeMsat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "routingFeeMsat" a) =>
+  Lens.Family2.LensLike' f s a
+routingFeeMsat = Data.ProtoLens.Field.field @"routingFeeMsat"
+settleEvent ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "settleEvent" a) =>
+  Lens.Family2.LensLike' f s a
+settleEvent = Data.ProtoLens.Field.field @"settleEvent"
+state ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "state" a) =>
+  Lens.Family2.LensLike' f s a
+state = Data.ProtoLens.Field.field @"state"
+successAmtMsat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "successAmtMsat" a) =>
+  Lens.Family2.LensLike' f s a
+successAmtMsat = Data.ProtoLens.Field.field @"successAmtMsat"
+successAmtSat ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "successAmtSat" a) =>
+  Lens.Family2.LensLike' f s a
+successAmtSat = Data.ProtoLens.Field.field @"successAmtSat"
+successTime ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "successTime" a) =>
+  Lens.Family2.LensLike' f s a
+successTime = Data.ProtoLens.Field.field @"successTime"
+timeLockDelay ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "timeLockDelay" a) =>
+  Lens.Family2.LensLike' f s a
+timeLockDelay = Data.ProtoLens.Field.field @"timeLockDelay"
+timeoutSeconds ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "timeoutSeconds" a) =>
+  Lens.Family2.LensLike' f s a
+timeoutSeconds = Data.ProtoLens.Field.field @"timeoutSeconds"
+timestampNs ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "timestampNs" a) =>
+  Lens.Family2.LensLike' f s a
+timestampNs = Data.ProtoLens.Field.field @"timestampNs"
+toNode ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "toNode" a) =>
+  Lens.Family2.LensLike' f s a
+toNode = Data.ProtoLens.Field.field @"toNode"
+value ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "value" a) =>
+  Lens.Family2.LensLike' f s a
+value = Data.ProtoLens.Field.field @"value"
+vec'destFeatures ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'destFeatures" a) =>
+  Lens.Family2.LensLike' f s a
+vec'destFeatures = Data.ProtoLens.Field.field @"vec'destFeatures"
+vec'hopPubkeys ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'hopPubkeys" a) =>
+  Lens.Family2.LensLike' f s a
+vec'hopPubkeys = Data.ProtoLens.Field.field @"vec'hopPubkeys"
+vec'htlcs ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'htlcs" a) =>
+  Lens.Family2.LensLike' f s a
+vec'htlcs = Data.ProtoLens.Field.field @"vec'htlcs"
+vec'outgoingChanIds ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'outgoingChanIds" a) =>
+  Lens.Family2.LensLike' f s a
+vec'outgoingChanIds
+  = Data.ProtoLens.Field.field @"vec'outgoingChanIds"
+vec'pairs ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'pairs" a) =>
+  Lens.Family2.LensLike' f s a
+vec'pairs = Data.ProtoLens.Field.field @"vec'pairs"
+vec'routeHints ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'routeHints" a) =>
+  Lens.Family2.LensLike' f s a
+vec'routeHints = Data.ProtoLens.Field.field @"vec'routeHints"
+weight ::
+  forall f s a.
+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "weight" a) =>
+  Lens.Family2.LensLike' f s a
+weight = Data.ProtoLens.Field.field @"weight"
+wireFailure ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "wireFailure" a) =>
+  Lens.Family2.LensLike' f s a
+wireFailure = Data.ProtoLens.Field.field @"wireFailure"
diff --git a/src/Proto/WalletUnlockerGrpc.hs b/src/Proto/WalletUnlockerGrpc.hs
new file mode 100644
--- /dev/null
+++ b/src/Proto/WalletUnlockerGrpc.hs
@@ -0,0 +1,2121 @@
+{- This file was auto-generated from wallet_unlocker_grpc.proto by the proto-lens-protoc program. -}
+{-# LANGUAGE ScopedTypeVariables, DataKinds, TypeFamilies, UndecidableInstances, GeneralizedNewtypeDeriving, MultiParamTypeClasses, FlexibleContexts, FlexibleInstances, PatternSynonyms, MagicHash, NoImplicitPrelude, DataKinds, BangPatterns, TypeApplications, OverloadedStrings, DerivingStrategies#-}
+{-# OPTIONS_GHC -Wno-unused-imports#-}
+{-# OPTIONS_GHC -Wno-duplicate-exports#-}
+{-# OPTIONS_GHC -Wno-dodgy-exports#-}
+module Proto.WalletUnlockerGrpc (
+        WalletUnlocker(..), ChangePasswordRequest(),
+        ChangePasswordResponse(), GenSeedRequest(), GenSeedResponse(),
+        InitWalletRequest(), InitWalletResponse(), UnlockWalletRequest(),
+        UnlockWalletResponse()
+    ) where
+import qualified Data.ProtoLens.Runtime.Control.DeepSeq as Control.DeepSeq
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Prism as Data.ProtoLens.Prism
+import qualified Data.ProtoLens.Runtime.Prelude as Prelude
+import qualified Data.ProtoLens.Runtime.Data.Int as Data.Int
+import qualified Data.ProtoLens.Runtime.Data.Monoid as Data.Monoid
+import qualified Data.ProtoLens.Runtime.Data.Word as Data.Word
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens as Data.ProtoLens
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Bytes as Data.ProtoLens.Encoding.Bytes
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Growing as Data.ProtoLens.Encoding.Growing
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Parser.Unsafe as Data.ProtoLens.Encoding.Parser.Unsafe
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Wire as Data.ProtoLens.Encoding.Wire
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Field as Data.ProtoLens.Field
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Message.Enum as Data.ProtoLens.Message.Enum
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Service.Types as Data.ProtoLens.Service.Types
+import qualified Data.ProtoLens.Runtime.Lens.Family2 as Lens.Family2
+import qualified Data.ProtoLens.Runtime.Lens.Family2.Unchecked as Lens.Family2.Unchecked
+import qualified Data.ProtoLens.Runtime.Data.Text as Data.Text
+import qualified Data.ProtoLens.Runtime.Data.Map as Data.Map
+import qualified Data.ProtoLens.Runtime.Data.ByteString as Data.ByteString
+import qualified Data.ProtoLens.Runtime.Data.ByteString.Char8 as Data.ByteString.Char8
+import qualified Data.ProtoLens.Runtime.Data.Text.Encoding as Data.Text.Encoding
+import qualified Data.ProtoLens.Runtime.Data.Vector as Data.Vector
+import qualified Data.ProtoLens.Runtime.Data.Vector.Generic as Data.Vector.Generic
+import qualified Data.ProtoLens.Runtime.Data.Vector.Unboxed as Data.Vector.Unboxed
+import qualified Data.ProtoLens.Runtime.Text.Read as Text.Read
+import qualified Proto.LndGrpc
+{- | Fields :
+     
+         * 'Proto.WalletUnlockerGrpc_Fields.currentPassword' @:: Lens' ChangePasswordRequest Data.ByteString.ByteString@
+         * 'Proto.WalletUnlockerGrpc_Fields.newPassword' @:: Lens' ChangePasswordRequest Data.ByteString.ByteString@
+         * 'Proto.WalletUnlockerGrpc_Fields.statelessInit' @:: Lens' ChangePasswordRequest Prelude.Bool@
+         * 'Proto.WalletUnlockerGrpc_Fields.newMacaroonRootKey' @:: Lens' ChangePasswordRequest Prelude.Bool@ -}
+data ChangePasswordRequest
+  = ChangePasswordRequest'_constructor {_ChangePasswordRequest'currentPassword :: !Data.ByteString.ByteString,
+                                        _ChangePasswordRequest'newPassword :: !Data.ByteString.ByteString,
+                                        _ChangePasswordRequest'statelessInit :: !Prelude.Bool,
+                                        _ChangePasswordRequest'newMacaroonRootKey :: !Prelude.Bool,
+                                        _ChangePasswordRequest'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show ChangePasswordRequest where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Field.HasField ChangePasswordRequest "currentPassword" Data.ByteString.ByteString where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _ChangePasswordRequest'currentPassword
+           (\ x__ y__ -> x__ {_ChangePasswordRequest'currentPassword = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField ChangePasswordRequest "newPassword" Data.ByteString.ByteString where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _ChangePasswordRequest'newPassword
+           (\ x__ y__ -> x__ {_ChangePasswordRequest'newPassword = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField ChangePasswordRequest "statelessInit" Prelude.Bool where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _ChangePasswordRequest'statelessInit
+           (\ x__ y__ -> x__ {_ChangePasswordRequest'statelessInit = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField ChangePasswordRequest "newMacaroonRootKey" Prelude.Bool where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _ChangePasswordRequest'newMacaroonRootKey
+           (\ x__ y__
+              -> x__ {_ChangePasswordRequest'newMacaroonRootKey = y__}))
+        Prelude.id
+instance Data.ProtoLens.Message ChangePasswordRequest where
+  messageName _ = Data.Text.pack "lnrpc.ChangePasswordRequest"
+  packedMessageDescriptor _
+    = "\n\
+      \\NAKChangePasswordRequest\DC2)\n\
+      \\DLEcurrent_password\CAN\SOH \SOH(\fR\SIcurrentPassword\DC2!\n\
+      \\fnew_password\CAN\STX \SOH(\fR\vnewPassword\DC2%\n\
+      \\SOstateless_init\CAN\ETX \SOH(\bR\rstatelessInit\DC21\n\
+      \\NAKnew_macaroon_root_key\CAN\EOT \SOH(\bR\DC2newMacaroonRootKey"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag
+    = let
+        currentPassword__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "current_password"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"currentPassword")) ::
+              Data.ProtoLens.FieldDescriptor ChangePasswordRequest
+        newPassword__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "new_password"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"newPassword")) ::
+              Data.ProtoLens.FieldDescriptor ChangePasswordRequest
+        statelessInit__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "stateless_init"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::
+                 Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"statelessInit")) ::
+              Data.ProtoLens.FieldDescriptor ChangePasswordRequest
+        newMacaroonRootKey__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "new_macaroon_root_key"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::
+                 Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"newMacaroonRootKey")) ::
+              Data.ProtoLens.FieldDescriptor ChangePasswordRequest
+      in
+        Data.Map.fromList
+          [(Data.ProtoLens.Tag 1, currentPassword__field_descriptor),
+           (Data.ProtoLens.Tag 2, newPassword__field_descriptor),
+           (Data.ProtoLens.Tag 3, statelessInit__field_descriptor),
+           (Data.ProtoLens.Tag 4, newMacaroonRootKey__field_descriptor)]
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _ChangePasswordRequest'_unknownFields
+        (\ x__ y__ -> x__ {_ChangePasswordRequest'_unknownFields = y__})
+  defMessage
+    = ChangePasswordRequest'_constructor
+        {_ChangePasswordRequest'currentPassword = Data.ProtoLens.fieldDefault,
+         _ChangePasswordRequest'newPassword = Data.ProtoLens.fieldDefault,
+         _ChangePasswordRequest'statelessInit = Data.ProtoLens.fieldDefault,
+         _ChangePasswordRequest'newMacaroonRootKey = Data.ProtoLens.fieldDefault,
+         _ChangePasswordRequest'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          ChangePasswordRequest
+          -> Data.ProtoLens.Encoding.Bytes.Parser ChangePasswordRequest
+        loop x
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of
+                        10
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.getBytes
+                                             (Prelude.fromIntegral len))
+                                       "current_password"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"currentPassword") y x)
+                        18
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.getBytes
+                                             (Prelude.fromIntegral len))
+                                       "new_password"
+                                loop
+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"newPassword") y x)
+                        24
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt)
+                                       "stateless_init"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"statelessInit") y x)
+                        32
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt)
+                                       "new_macaroon_root_key"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"newMacaroonRootKey") y x)
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do loop Data.ProtoLens.defMessage) "ChangePasswordRequest"
+  buildMessage
+    = \ _x
+        -> (Data.Monoid.<>)
+             (let
+                _v
+                  = Lens.Family2.view
+                      (Data.ProtoLens.Field.field @"currentPassword") _x
+              in
+                if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                    Data.Monoid.mempty
+                else
+                    (Data.Monoid.<>)
+                      (Data.ProtoLens.Encoding.Bytes.putVarInt 10)
+                      ((\ bs
+                          -> (Data.Monoid.<>)
+                               (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                  (Prelude.fromIntegral (Data.ByteString.length bs)))
+                               (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                         _v))
+             ((Data.Monoid.<>)
+                (let
+                   _v
+                     = Lens.Family2.view (Data.ProtoLens.Field.field @"newPassword") _x
+                 in
+                   if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                       Data.Monoid.mempty
+                   else
+                       (Data.Monoid.<>)
+                         (Data.ProtoLens.Encoding.Bytes.putVarInt 18)
+                         ((\ bs
+                             -> (Data.Monoid.<>)
+                                  (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                     (Prelude.fromIntegral (Data.ByteString.length bs)))
+                                  (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                            _v))
+                ((Data.Monoid.<>)
+                   (let
+                      _v
+                        = Lens.Family2.view
+                            (Data.ProtoLens.Field.field @"statelessInit") _x
+                    in
+                      if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                          Data.Monoid.mempty
+                      else
+                          (Data.Monoid.<>)
+                            (Data.ProtoLens.Encoding.Bytes.putVarInt 24)
+                            ((Prelude..)
+                               Data.ProtoLens.Encoding.Bytes.putVarInt
+                               (\ b -> if b then 1 else 0)
+                               _v))
+                   ((Data.Monoid.<>)
+                      (let
+                         _v
+                           = Lens.Family2.view
+                               (Data.ProtoLens.Field.field @"newMacaroonRootKey") _x
+                       in
+                         if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                             Data.Monoid.mempty
+                         else
+                             (Data.Monoid.<>)
+                               (Data.ProtoLens.Encoding.Bytes.putVarInt 32)
+                               ((Prelude..)
+                                  Data.ProtoLens.Encoding.Bytes.putVarInt
+                                  (\ b -> if b then 1 else 0)
+                                  _v))
+                      (Data.ProtoLens.Encoding.Wire.buildFieldSet
+                         (Lens.Family2.view Data.ProtoLens.unknownFields _x)))))
+instance Control.DeepSeq.NFData ChangePasswordRequest where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_ChangePasswordRequest'_unknownFields x__)
+             (Control.DeepSeq.deepseq
+                (_ChangePasswordRequest'currentPassword x__)
+                (Control.DeepSeq.deepseq
+                   (_ChangePasswordRequest'newPassword x__)
+                   (Control.DeepSeq.deepseq
+                      (_ChangePasswordRequest'statelessInit x__)
+                      (Control.DeepSeq.deepseq
+                         (_ChangePasswordRequest'newMacaroonRootKey x__) ()))))
+{- | Fields :
+     
+         * 'Proto.WalletUnlockerGrpc_Fields.adminMacaroon' @:: Lens' ChangePasswordResponse Data.ByteString.ByteString@ -}
+data ChangePasswordResponse
+  = ChangePasswordResponse'_constructor {_ChangePasswordResponse'adminMacaroon :: !Data.ByteString.ByteString,
+                                         _ChangePasswordResponse'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show ChangePasswordResponse where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Field.HasField ChangePasswordResponse "adminMacaroon" Data.ByteString.ByteString where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _ChangePasswordResponse'adminMacaroon
+           (\ x__ y__ -> x__ {_ChangePasswordResponse'adminMacaroon = y__}))
+        Prelude.id
+instance Data.ProtoLens.Message ChangePasswordResponse where
+  messageName _ = Data.Text.pack "lnrpc.ChangePasswordResponse"
+  packedMessageDescriptor _
+    = "\n\
+      \\SYNChangePasswordResponse\DC2%\n\
+      \\SOadmin_macaroon\CAN\SOH \SOH(\fR\radminMacaroon"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag
+    = let
+        adminMacaroon__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "admin_macaroon"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"adminMacaroon")) ::
+              Data.ProtoLens.FieldDescriptor ChangePasswordResponse
+      in
+        Data.Map.fromList
+          [(Data.ProtoLens.Tag 1, adminMacaroon__field_descriptor)]
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _ChangePasswordResponse'_unknownFields
+        (\ x__ y__ -> x__ {_ChangePasswordResponse'_unknownFields = y__})
+  defMessage
+    = ChangePasswordResponse'_constructor
+        {_ChangePasswordResponse'adminMacaroon = Data.ProtoLens.fieldDefault,
+         _ChangePasswordResponse'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          ChangePasswordResponse
+          -> Data.ProtoLens.Encoding.Bytes.Parser ChangePasswordResponse
+        loop x
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of
+                        10
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.getBytes
+                                             (Prelude.fromIntegral len))
+                                       "admin_macaroon"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"adminMacaroon") y x)
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do loop Data.ProtoLens.defMessage) "ChangePasswordResponse"
+  buildMessage
+    = \ _x
+        -> (Data.Monoid.<>)
+             (let
+                _v
+                  = Lens.Family2.view
+                      (Data.ProtoLens.Field.field @"adminMacaroon") _x
+              in
+                if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                    Data.Monoid.mempty
+                else
+                    (Data.Monoid.<>)
+                      (Data.ProtoLens.Encoding.Bytes.putVarInt 10)
+                      ((\ bs
+                          -> (Data.Monoid.<>)
+                               (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                  (Prelude.fromIntegral (Data.ByteString.length bs)))
+                               (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                         _v))
+             (Data.ProtoLens.Encoding.Wire.buildFieldSet
+                (Lens.Family2.view Data.ProtoLens.unknownFields _x))
+instance Control.DeepSeq.NFData ChangePasswordResponse where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_ChangePasswordResponse'_unknownFields x__)
+             (Control.DeepSeq.deepseq
+                (_ChangePasswordResponse'adminMacaroon x__) ())
+{- | Fields :
+     
+         * 'Proto.WalletUnlockerGrpc_Fields.aezeedPassphrase' @:: Lens' GenSeedRequest Data.ByteString.ByteString@
+         * 'Proto.WalletUnlockerGrpc_Fields.seedEntropy' @:: Lens' GenSeedRequest Data.ByteString.ByteString@ -}
+data GenSeedRequest
+  = GenSeedRequest'_constructor {_GenSeedRequest'aezeedPassphrase :: !Data.ByteString.ByteString,
+                                 _GenSeedRequest'seedEntropy :: !Data.ByteString.ByteString,
+                                 _GenSeedRequest'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show GenSeedRequest where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Field.HasField GenSeedRequest "aezeedPassphrase" Data.ByteString.ByteString where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _GenSeedRequest'aezeedPassphrase
+           (\ x__ y__ -> x__ {_GenSeedRequest'aezeedPassphrase = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField GenSeedRequest "seedEntropy" Data.ByteString.ByteString where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _GenSeedRequest'seedEntropy
+           (\ x__ y__ -> x__ {_GenSeedRequest'seedEntropy = y__}))
+        Prelude.id
+instance Data.ProtoLens.Message GenSeedRequest where
+  messageName _ = Data.Text.pack "lnrpc.GenSeedRequest"
+  packedMessageDescriptor _
+    = "\n\
+      \\SOGenSeedRequest\DC2+\n\
+      \\DC1aezeed_passphrase\CAN\SOH \SOH(\fR\DLEaezeedPassphrase\DC2!\n\
+      \\fseed_entropy\CAN\STX \SOH(\fR\vseedEntropy"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag
+    = let
+        aezeedPassphrase__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "aezeed_passphrase"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"aezeedPassphrase")) ::
+              Data.ProtoLens.FieldDescriptor GenSeedRequest
+        seedEntropy__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "seed_entropy"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"seedEntropy")) ::
+              Data.ProtoLens.FieldDescriptor GenSeedRequest
+      in
+        Data.Map.fromList
+          [(Data.ProtoLens.Tag 1, aezeedPassphrase__field_descriptor),
+           (Data.ProtoLens.Tag 2, seedEntropy__field_descriptor)]
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _GenSeedRequest'_unknownFields
+        (\ x__ y__ -> x__ {_GenSeedRequest'_unknownFields = y__})
+  defMessage
+    = GenSeedRequest'_constructor
+        {_GenSeedRequest'aezeedPassphrase = Data.ProtoLens.fieldDefault,
+         _GenSeedRequest'seedEntropy = Data.ProtoLens.fieldDefault,
+         _GenSeedRequest'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          GenSeedRequest
+          -> Data.ProtoLens.Encoding.Bytes.Parser GenSeedRequest
+        loop x
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of
+                        10
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.getBytes
+                                             (Prelude.fromIntegral len))
+                                       "aezeed_passphrase"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"aezeedPassphrase") y x)
+                        18
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.getBytes
+                                             (Prelude.fromIntegral len))
+                                       "seed_entropy"
+                                loop
+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"seedEntropy") y x)
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do loop Data.ProtoLens.defMessage) "GenSeedRequest"
+  buildMessage
+    = \ _x
+        -> (Data.Monoid.<>)
+             (let
+                _v
+                  = Lens.Family2.view
+                      (Data.ProtoLens.Field.field @"aezeedPassphrase") _x
+              in
+                if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                    Data.Monoid.mempty
+                else
+                    (Data.Monoid.<>)
+                      (Data.ProtoLens.Encoding.Bytes.putVarInt 10)
+                      ((\ bs
+                          -> (Data.Monoid.<>)
+                               (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                  (Prelude.fromIntegral (Data.ByteString.length bs)))
+                               (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                         _v))
+             ((Data.Monoid.<>)
+                (let
+                   _v
+                     = Lens.Family2.view (Data.ProtoLens.Field.field @"seedEntropy") _x
+                 in
+                   if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                       Data.Monoid.mempty
+                   else
+                       (Data.Monoid.<>)
+                         (Data.ProtoLens.Encoding.Bytes.putVarInt 18)
+                         ((\ bs
+                             -> (Data.Monoid.<>)
+                                  (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                     (Prelude.fromIntegral (Data.ByteString.length bs)))
+                                  (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                            _v))
+                (Data.ProtoLens.Encoding.Wire.buildFieldSet
+                   (Lens.Family2.view Data.ProtoLens.unknownFields _x)))
+instance Control.DeepSeq.NFData GenSeedRequest where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_GenSeedRequest'_unknownFields x__)
+             (Control.DeepSeq.deepseq
+                (_GenSeedRequest'aezeedPassphrase x__)
+                (Control.DeepSeq.deepseq (_GenSeedRequest'seedEntropy x__) ()))
+{- | Fields :
+     
+         * 'Proto.WalletUnlockerGrpc_Fields.cipherSeedMnemonic' @:: Lens' GenSeedResponse [Data.Text.Text]@
+         * 'Proto.WalletUnlockerGrpc_Fields.vec'cipherSeedMnemonic' @:: Lens' GenSeedResponse (Data.Vector.Vector Data.Text.Text)@
+         * 'Proto.WalletUnlockerGrpc_Fields.encipheredSeed' @:: Lens' GenSeedResponse Data.ByteString.ByteString@ -}
+data GenSeedResponse
+  = GenSeedResponse'_constructor {_GenSeedResponse'cipherSeedMnemonic :: !(Data.Vector.Vector Data.Text.Text),
+                                  _GenSeedResponse'encipheredSeed :: !Data.ByteString.ByteString,
+                                  _GenSeedResponse'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show GenSeedResponse where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Field.HasField GenSeedResponse "cipherSeedMnemonic" [Data.Text.Text] where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _GenSeedResponse'cipherSeedMnemonic
+           (\ x__ y__ -> x__ {_GenSeedResponse'cipherSeedMnemonic = y__}))
+        (Lens.Family2.Unchecked.lens
+           Data.Vector.Generic.toList
+           (\ _ y__ -> Data.Vector.Generic.fromList y__))
+instance Data.ProtoLens.Field.HasField GenSeedResponse "vec'cipherSeedMnemonic" (Data.Vector.Vector Data.Text.Text) where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _GenSeedResponse'cipherSeedMnemonic
+           (\ x__ y__ -> x__ {_GenSeedResponse'cipherSeedMnemonic = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField GenSeedResponse "encipheredSeed" Data.ByteString.ByteString where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _GenSeedResponse'encipheredSeed
+           (\ x__ y__ -> x__ {_GenSeedResponse'encipheredSeed = y__}))
+        Prelude.id
+instance Data.ProtoLens.Message GenSeedResponse where
+  messageName _ = Data.Text.pack "lnrpc.GenSeedResponse"
+  packedMessageDescriptor _
+    = "\n\
+      \\SIGenSeedResponse\DC20\n\
+      \\DC4cipher_seed_mnemonic\CAN\SOH \ETX(\tR\DC2cipherSeedMnemonic\DC2'\n\
+      \\SIenciphered_seed\CAN\STX \SOH(\fR\SOencipheredSeed"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag
+    = let
+        cipherSeedMnemonic__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "cipher_seed_mnemonic"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
+              (Data.ProtoLens.RepeatedField
+                 Data.ProtoLens.Unpacked
+                 (Data.ProtoLens.Field.field @"cipherSeedMnemonic")) ::
+              Data.ProtoLens.FieldDescriptor GenSeedResponse
+        encipheredSeed__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "enciphered_seed"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"encipheredSeed")) ::
+              Data.ProtoLens.FieldDescriptor GenSeedResponse
+      in
+        Data.Map.fromList
+          [(Data.ProtoLens.Tag 1, cipherSeedMnemonic__field_descriptor),
+           (Data.ProtoLens.Tag 2, encipheredSeed__field_descriptor)]
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _GenSeedResponse'_unknownFields
+        (\ x__ y__ -> x__ {_GenSeedResponse'_unknownFields = y__})
+  defMessage
+    = GenSeedResponse'_constructor
+        {_GenSeedResponse'cipherSeedMnemonic = Data.Vector.Generic.empty,
+         _GenSeedResponse'encipheredSeed = Data.ProtoLens.fieldDefault,
+         _GenSeedResponse'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          GenSeedResponse
+          -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld Data.Text.Text
+             -> Data.ProtoLens.Encoding.Bytes.Parser GenSeedResponse
+        loop x mutable'cipherSeedMnemonic
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do frozen'cipherSeedMnemonic <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
+                                                     (Data.ProtoLens.Encoding.Growing.unsafeFreeze
+                                                        mutable'cipherSeedMnemonic)
+                      (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields
+                           (\ !t -> Prelude.reverse t)
+                           (Lens.Family2.set
+                              (Data.ProtoLens.Field.field @"vec'cipherSeedMnemonic")
+                              frozen'cipherSeedMnemonic
+                              x))
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of
+                        10
+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                        (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                                        Data.ProtoLens.Encoding.Bytes.getBytes
+                                                          (Prelude.fromIntegral len)
+                                            Data.ProtoLens.Encoding.Bytes.runEither
+                                              (case Data.Text.Encoding.decodeUtf8' value of
+                                                 (Prelude.Left err)
+                                                   -> Prelude.Left (Prelude.show err)
+                                                 (Prelude.Right r) -> Prelude.Right r))
+                                        "cipher_seed_mnemonic"
+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
+                                       (Data.ProtoLens.Encoding.Growing.append
+                                          mutable'cipherSeedMnemonic y)
+                                loop x v
+                        18
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.getBytes
+                                             (Prelude.fromIntegral len))
+                                       "enciphered_seed"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"encipheredSeed") y x)
+                                  mutable'cipherSeedMnemonic
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)
+                                  mutable'cipherSeedMnemonic
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do mutable'cipherSeedMnemonic <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
+                                              Data.ProtoLens.Encoding.Growing.new
+              loop Data.ProtoLens.defMessage mutable'cipherSeedMnemonic)
+          "GenSeedResponse"
+  buildMessage
+    = \ _x
+        -> (Data.Monoid.<>)
+             (Data.ProtoLens.Encoding.Bytes.foldMapBuilder
+                (\ _v
+                   -> (Data.Monoid.<>)
+                        (Data.ProtoLens.Encoding.Bytes.putVarInt 10)
+                        ((Prelude..)
+                           (\ bs
+                              -> (Data.Monoid.<>)
+                                   (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                      (Prelude.fromIntegral (Data.ByteString.length bs)))
+                                   (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                           Data.Text.Encoding.encodeUtf8
+                           _v))
+                (Lens.Family2.view
+                   (Data.ProtoLens.Field.field @"vec'cipherSeedMnemonic") _x))
+             ((Data.Monoid.<>)
+                (let
+                   _v
+                     = Lens.Family2.view
+                         (Data.ProtoLens.Field.field @"encipheredSeed") _x
+                 in
+                   if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                       Data.Monoid.mempty
+                   else
+                       (Data.Monoid.<>)
+                         (Data.ProtoLens.Encoding.Bytes.putVarInt 18)
+                         ((\ bs
+                             -> (Data.Monoid.<>)
+                                  (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                     (Prelude.fromIntegral (Data.ByteString.length bs)))
+                                  (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                            _v))
+                (Data.ProtoLens.Encoding.Wire.buildFieldSet
+                   (Lens.Family2.view Data.ProtoLens.unknownFields _x)))
+instance Control.DeepSeq.NFData GenSeedResponse where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_GenSeedResponse'_unknownFields x__)
+             (Control.DeepSeq.deepseq
+                (_GenSeedResponse'cipherSeedMnemonic x__)
+                (Control.DeepSeq.deepseq (_GenSeedResponse'encipheredSeed x__) ()))
+{- | Fields :
+     
+         * 'Proto.WalletUnlockerGrpc_Fields.walletPassword' @:: Lens' InitWalletRequest Data.ByteString.ByteString@
+         * 'Proto.WalletUnlockerGrpc_Fields.cipherSeedMnemonic' @:: Lens' InitWalletRequest [Data.Text.Text]@
+         * 'Proto.WalletUnlockerGrpc_Fields.vec'cipherSeedMnemonic' @:: Lens' InitWalletRequest (Data.Vector.Vector Data.Text.Text)@
+         * 'Proto.WalletUnlockerGrpc_Fields.aezeedPassphrase' @:: Lens' InitWalletRequest Data.ByteString.ByteString@
+         * 'Proto.WalletUnlockerGrpc_Fields.recoveryWindow' @:: Lens' InitWalletRequest Data.Int.Int32@
+         * 'Proto.WalletUnlockerGrpc_Fields.channelBackups' @:: Lens' InitWalletRequest Proto.LndGrpc.ChanBackupSnapshot@
+         * 'Proto.WalletUnlockerGrpc_Fields.maybe'channelBackups' @:: Lens' InitWalletRequest (Prelude.Maybe Proto.LndGrpc.ChanBackupSnapshot)@
+         * 'Proto.WalletUnlockerGrpc_Fields.statelessInit' @:: Lens' InitWalletRequest Prelude.Bool@ -}
+data InitWalletRequest
+  = InitWalletRequest'_constructor {_InitWalletRequest'walletPassword :: !Data.ByteString.ByteString,
+                                    _InitWalletRequest'cipherSeedMnemonic :: !(Data.Vector.Vector Data.Text.Text),
+                                    _InitWalletRequest'aezeedPassphrase :: !Data.ByteString.ByteString,
+                                    _InitWalletRequest'recoveryWindow :: !Data.Int.Int32,
+                                    _InitWalletRequest'channelBackups :: !(Prelude.Maybe Proto.LndGrpc.ChanBackupSnapshot),
+                                    _InitWalletRequest'statelessInit :: !Prelude.Bool,
+                                    _InitWalletRequest'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show InitWalletRequest where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Field.HasField InitWalletRequest "walletPassword" Data.ByteString.ByteString where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _InitWalletRequest'walletPassword
+           (\ x__ y__ -> x__ {_InitWalletRequest'walletPassword = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField InitWalletRequest "cipherSeedMnemonic" [Data.Text.Text] where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _InitWalletRequest'cipherSeedMnemonic
+           (\ x__ y__ -> x__ {_InitWalletRequest'cipherSeedMnemonic = y__}))
+        (Lens.Family2.Unchecked.lens
+           Data.Vector.Generic.toList
+           (\ _ y__ -> Data.Vector.Generic.fromList y__))
+instance Data.ProtoLens.Field.HasField InitWalletRequest "vec'cipherSeedMnemonic" (Data.Vector.Vector Data.Text.Text) where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _InitWalletRequest'cipherSeedMnemonic
+           (\ x__ y__ -> x__ {_InitWalletRequest'cipherSeedMnemonic = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField InitWalletRequest "aezeedPassphrase" Data.ByteString.ByteString where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _InitWalletRequest'aezeedPassphrase
+           (\ x__ y__ -> x__ {_InitWalletRequest'aezeedPassphrase = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField InitWalletRequest "recoveryWindow" Data.Int.Int32 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _InitWalletRequest'recoveryWindow
+           (\ x__ y__ -> x__ {_InitWalletRequest'recoveryWindow = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField InitWalletRequest "channelBackups" Proto.LndGrpc.ChanBackupSnapshot where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _InitWalletRequest'channelBackups
+           (\ x__ y__ -> x__ {_InitWalletRequest'channelBackups = y__}))
+        (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage)
+instance Data.ProtoLens.Field.HasField InitWalletRequest "maybe'channelBackups" (Prelude.Maybe Proto.LndGrpc.ChanBackupSnapshot) where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _InitWalletRequest'channelBackups
+           (\ x__ y__ -> x__ {_InitWalletRequest'channelBackups = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField InitWalletRequest "statelessInit" Prelude.Bool where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _InitWalletRequest'statelessInit
+           (\ x__ y__ -> x__ {_InitWalletRequest'statelessInit = y__}))
+        Prelude.id
+instance Data.ProtoLens.Message InitWalletRequest where
+  messageName _ = Data.Text.pack "lnrpc.InitWalletRequest"
+  packedMessageDescriptor _
+    = "\n\
+      \\DC1InitWalletRequest\DC2'\n\
+      \\SIwallet_password\CAN\SOH \SOH(\fR\SOwalletPassword\DC20\n\
+      \\DC4cipher_seed_mnemonic\CAN\STX \ETX(\tR\DC2cipherSeedMnemonic\DC2+\n\
+      \\DC1aezeed_passphrase\CAN\ETX \SOH(\fR\DLEaezeedPassphrase\DC2'\n\
+      \\SIrecovery_window\CAN\EOT \SOH(\ENQR\SOrecoveryWindow\DC2B\n\
+      \\SIchannel_backups\CAN\ENQ \SOH(\v2\EM.lnrpc.ChanBackupSnapshotR\SOchannelBackups\DC2%\n\
+      \\SOstateless_init\CAN\ACK \SOH(\bR\rstatelessInit"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag
+    = let
+        walletPassword__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "wallet_password"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"walletPassword")) ::
+              Data.ProtoLens.FieldDescriptor InitWalletRequest
+        cipherSeedMnemonic__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "cipher_seed_mnemonic"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
+              (Data.ProtoLens.RepeatedField
+                 Data.ProtoLens.Unpacked
+                 (Data.ProtoLens.Field.field @"cipherSeedMnemonic")) ::
+              Data.ProtoLens.FieldDescriptor InitWalletRequest
+        aezeedPassphrase__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "aezeed_passphrase"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"aezeedPassphrase")) ::
+              Data.ProtoLens.FieldDescriptor InitWalletRequest
+        recoveryWindow__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "recovery_window"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"recoveryWindow")) ::
+              Data.ProtoLens.FieldDescriptor InitWalletRequest
+        channelBackups__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "channel_backups"
+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
+                 Data.ProtoLens.FieldTypeDescriptor Proto.LndGrpc.ChanBackupSnapshot)
+              (Data.ProtoLens.OptionalField
+                 (Data.ProtoLens.Field.field @"maybe'channelBackups")) ::
+              Data.ProtoLens.FieldDescriptor InitWalletRequest
+        statelessInit__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "stateless_init"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::
+                 Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"statelessInit")) ::
+              Data.ProtoLens.FieldDescriptor InitWalletRequest
+      in
+        Data.Map.fromList
+          [(Data.ProtoLens.Tag 1, walletPassword__field_descriptor),
+           (Data.ProtoLens.Tag 2, cipherSeedMnemonic__field_descriptor),
+           (Data.ProtoLens.Tag 3, aezeedPassphrase__field_descriptor),
+           (Data.ProtoLens.Tag 4, recoveryWindow__field_descriptor),
+           (Data.ProtoLens.Tag 5, channelBackups__field_descriptor),
+           (Data.ProtoLens.Tag 6, statelessInit__field_descriptor)]
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _InitWalletRequest'_unknownFields
+        (\ x__ y__ -> x__ {_InitWalletRequest'_unknownFields = y__})
+  defMessage
+    = InitWalletRequest'_constructor
+        {_InitWalletRequest'walletPassword = Data.ProtoLens.fieldDefault,
+         _InitWalletRequest'cipherSeedMnemonic = Data.Vector.Generic.empty,
+         _InitWalletRequest'aezeedPassphrase = Data.ProtoLens.fieldDefault,
+         _InitWalletRequest'recoveryWindow = Data.ProtoLens.fieldDefault,
+         _InitWalletRequest'channelBackups = Prelude.Nothing,
+         _InitWalletRequest'statelessInit = Data.ProtoLens.fieldDefault,
+         _InitWalletRequest'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          InitWalletRequest
+          -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld Data.Text.Text
+             -> Data.ProtoLens.Encoding.Bytes.Parser InitWalletRequest
+        loop x mutable'cipherSeedMnemonic
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do frozen'cipherSeedMnemonic <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
+                                                     (Data.ProtoLens.Encoding.Growing.unsafeFreeze
+                                                        mutable'cipherSeedMnemonic)
+                      (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields
+                           (\ !t -> Prelude.reverse t)
+                           (Lens.Family2.set
+                              (Data.ProtoLens.Field.field @"vec'cipherSeedMnemonic")
+                              frozen'cipherSeedMnemonic
+                              x))
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of
+                        10
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.getBytes
+                                             (Prelude.fromIntegral len))
+                                       "wallet_password"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"walletPassword") y x)
+                                  mutable'cipherSeedMnemonic
+                        18
+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                        (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                                        Data.ProtoLens.Encoding.Bytes.getBytes
+                                                          (Prelude.fromIntegral len)
+                                            Data.ProtoLens.Encoding.Bytes.runEither
+                                              (case Data.Text.Encoding.decodeUtf8' value of
+                                                 (Prelude.Left err)
+                                                   -> Prelude.Left (Prelude.show err)
+                                                 (Prelude.Right r) -> Prelude.Right r))
+                                        "cipher_seed_mnemonic"
+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
+                                       (Data.ProtoLens.Encoding.Growing.append
+                                          mutable'cipherSeedMnemonic y)
+                                loop x v
+                        26
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.getBytes
+                                             (Prelude.fromIntegral len))
+                                       "aezeed_passphrase"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"aezeedPassphrase") y x)
+                                  mutable'cipherSeedMnemonic
+                        32
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          Prelude.fromIntegral
+                                          Data.ProtoLens.Encoding.Bytes.getVarInt)
+                                       "recovery_window"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"recoveryWindow") y x)
+                                  mutable'cipherSeedMnemonic
+                        42
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.isolate
+                                             (Prelude.fromIntegral len) Data.ProtoLens.parseMessage)
+                                       "channel_backups"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"channelBackups") y x)
+                                  mutable'cipherSeedMnemonic
+                        48
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt)
+                                       "stateless_init"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"statelessInit") y x)
+                                  mutable'cipherSeedMnemonic
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)
+                                  mutable'cipherSeedMnemonic
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do mutable'cipherSeedMnemonic <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
+                                              Data.ProtoLens.Encoding.Growing.new
+              loop Data.ProtoLens.defMessage mutable'cipherSeedMnemonic)
+          "InitWalletRequest"
+  buildMessage
+    = \ _x
+        -> (Data.Monoid.<>)
+             (let
+                _v
+                  = Lens.Family2.view
+                      (Data.ProtoLens.Field.field @"walletPassword") _x
+              in
+                if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                    Data.Monoid.mempty
+                else
+                    (Data.Monoid.<>)
+                      (Data.ProtoLens.Encoding.Bytes.putVarInt 10)
+                      ((\ bs
+                          -> (Data.Monoid.<>)
+                               (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                  (Prelude.fromIntegral (Data.ByteString.length bs)))
+                               (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                         _v))
+             ((Data.Monoid.<>)
+                (Data.ProtoLens.Encoding.Bytes.foldMapBuilder
+                   (\ _v
+                      -> (Data.Monoid.<>)
+                           (Data.ProtoLens.Encoding.Bytes.putVarInt 18)
+                           ((Prelude..)
+                              (\ bs
+                                 -> (Data.Monoid.<>)
+                                      (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                         (Prelude.fromIntegral (Data.ByteString.length bs)))
+                                      (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                              Data.Text.Encoding.encodeUtf8
+                              _v))
+                   (Lens.Family2.view
+                      (Data.ProtoLens.Field.field @"vec'cipherSeedMnemonic") _x))
+                ((Data.Monoid.<>)
+                   (let
+                      _v
+                        = Lens.Family2.view
+                            (Data.ProtoLens.Field.field @"aezeedPassphrase") _x
+                    in
+                      if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                          Data.Monoid.mempty
+                      else
+                          (Data.Monoid.<>)
+                            (Data.ProtoLens.Encoding.Bytes.putVarInt 26)
+                            ((\ bs
+                                -> (Data.Monoid.<>)
+                                     (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                        (Prelude.fromIntegral (Data.ByteString.length bs)))
+                                     (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                               _v))
+                   ((Data.Monoid.<>)
+                      (let
+                         _v
+                           = Lens.Family2.view
+                               (Data.ProtoLens.Field.field @"recoveryWindow") _x
+                       in
+                         if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                             Data.Monoid.mempty
+                         else
+                             (Data.Monoid.<>)
+                               (Data.ProtoLens.Encoding.Bytes.putVarInt 32)
+                               ((Prelude..)
+                                  Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v))
+                      ((Data.Monoid.<>)
+                         (case
+                              Lens.Family2.view
+                                (Data.ProtoLens.Field.field @"maybe'channelBackups") _x
+                          of
+                            Prelude.Nothing -> Data.Monoid.mempty
+                            (Prelude.Just _v)
+                              -> (Data.Monoid.<>)
+                                   (Data.ProtoLens.Encoding.Bytes.putVarInt 42)
+                                   ((Prelude..)
+                                      (\ bs
+                                         -> (Data.Monoid.<>)
+                                              (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                                 (Prelude.fromIntegral (Data.ByteString.length bs)))
+                                              (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                                      Data.ProtoLens.encodeMessage
+                                      _v))
+                         ((Data.Monoid.<>)
+                            (let
+                               _v
+                                 = Lens.Family2.view
+                                     (Data.ProtoLens.Field.field @"statelessInit") _x
+                             in
+                               if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                                   Data.Monoid.mempty
+                               else
+                                   (Data.Monoid.<>)
+                                     (Data.ProtoLens.Encoding.Bytes.putVarInt 48)
+                                     ((Prelude..)
+                                        Data.ProtoLens.Encoding.Bytes.putVarInt
+                                        (\ b -> if b then 1 else 0)
+                                        _v))
+                            (Data.ProtoLens.Encoding.Wire.buildFieldSet
+                               (Lens.Family2.view Data.ProtoLens.unknownFields _x)))))))
+instance Control.DeepSeq.NFData InitWalletRequest where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_InitWalletRequest'_unknownFields x__)
+             (Control.DeepSeq.deepseq
+                (_InitWalletRequest'walletPassword x__)
+                (Control.DeepSeq.deepseq
+                   (_InitWalletRequest'cipherSeedMnemonic x__)
+                   (Control.DeepSeq.deepseq
+                      (_InitWalletRequest'aezeedPassphrase x__)
+                      (Control.DeepSeq.deepseq
+                         (_InitWalletRequest'recoveryWindow x__)
+                         (Control.DeepSeq.deepseq
+                            (_InitWalletRequest'channelBackups x__)
+                            (Control.DeepSeq.deepseq
+                               (_InitWalletRequest'statelessInit x__) ()))))))
+{- | Fields :
+     
+         * 'Proto.WalletUnlockerGrpc_Fields.adminMacaroon' @:: Lens' InitWalletResponse Data.ByteString.ByteString@ -}
+data InitWalletResponse
+  = InitWalletResponse'_constructor {_InitWalletResponse'adminMacaroon :: !Data.ByteString.ByteString,
+                                     _InitWalletResponse'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show InitWalletResponse where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Field.HasField InitWalletResponse "adminMacaroon" Data.ByteString.ByteString where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _InitWalletResponse'adminMacaroon
+           (\ x__ y__ -> x__ {_InitWalletResponse'adminMacaroon = y__}))
+        Prelude.id
+instance Data.ProtoLens.Message InitWalletResponse where
+  messageName _ = Data.Text.pack "lnrpc.InitWalletResponse"
+  packedMessageDescriptor _
+    = "\n\
+      \\DC2InitWalletResponse\DC2%\n\
+      \\SOadmin_macaroon\CAN\SOH \SOH(\fR\radminMacaroon"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag
+    = let
+        adminMacaroon__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "admin_macaroon"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"adminMacaroon")) ::
+              Data.ProtoLens.FieldDescriptor InitWalletResponse
+      in
+        Data.Map.fromList
+          [(Data.ProtoLens.Tag 1, adminMacaroon__field_descriptor)]
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _InitWalletResponse'_unknownFields
+        (\ x__ y__ -> x__ {_InitWalletResponse'_unknownFields = y__})
+  defMessage
+    = InitWalletResponse'_constructor
+        {_InitWalletResponse'adminMacaroon = Data.ProtoLens.fieldDefault,
+         _InitWalletResponse'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          InitWalletResponse
+          -> Data.ProtoLens.Encoding.Bytes.Parser InitWalletResponse
+        loop x
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of
+                        10
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.getBytes
+                                             (Prelude.fromIntegral len))
+                                       "admin_macaroon"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"adminMacaroon") y x)
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do loop Data.ProtoLens.defMessage) "InitWalletResponse"
+  buildMessage
+    = \ _x
+        -> (Data.Monoid.<>)
+             (let
+                _v
+                  = Lens.Family2.view
+                      (Data.ProtoLens.Field.field @"adminMacaroon") _x
+              in
+                if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                    Data.Monoid.mempty
+                else
+                    (Data.Monoid.<>)
+                      (Data.ProtoLens.Encoding.Bytes.putVarInt 10)
+                      ((\ bs
+                          -> (Data.Monoid.<>)
+                               (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                  (Prelude.fromIntegral (Data.ByteString.length bs)))
+                               (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                         _v))
+             (Data.ProtoLens.Encoding.Wire.buildFieldSet
+                (Lens.Family2.view Data.ProtoLens.unknownFields _x))
+instance Control.DeepSeq.NFData InitWalletResponse where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_InitWalletResponse'_unknownFields x__)
+             (Control.DeepSeq.deepseq
+                (_InitWalletResponse'adminMacaroon x__) ())
+{- | Fields :
+     
+         * 'Proto.WalletUnlockerGrpc_Fields.walletPassword' @:: Lens' UnlockWalletRequest Data.ByteString.ByteString@
+         * 'Proto.WalletUnlockerGrpc_Fields.recoveryWindow' @:: Lens' UnlockWalletRequest Data.Int.Int32@
+         * 'Proto.WalletUnlockerGrpc_Fields.channelBackups' @:: Lens' UnlockWalletRequest Proto.LndGrpc.ChanBackupSnapshot@
+         * 'Proto.WalletUnlockerGrpc_Fields.maybe'channelBackups' @:: Lens' UnlockWalletRequest (Prelude.Maybe Proto.LndGrpc.ChanBackupSnapshot)@
+         * 'Proto.WalletUnlockerGrpc_Fields.statelessInit' @:: Lens' UnlockWalletRequest Prelude.Bool@ -}
+data UnlockWalletRequest
+  = UnlockWalletRequest'_constructor {_UnlockWalletRequest'walletPassword :: !Data.ByteString.ByteString,
+                                      _UnlockWalletRequest'recoveryWindow :: !Data.Int.Int32,
+                                      _UnlockWalletRequest'channelBackups :: !(Prelude.Maybe Proto.LndGrpc.ChanBackupSnapshot),
+                                      _UnlockWalletRequest'statelessInit :: !Prelude.Bool,
+                                      _UnlockWalletRequest'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show UnlockWalletRequest where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Field.HasField UnlockWalletRequest "walletPassword" Data.ByteString.ByteString where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _UnlockWalletRequest'walletPassword
+           (\ x__ y__ -> x__ {_UnlockWalletRequest'walletPassword = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField UnlockWalletRequest "recoveryWindow" Data.Int.Int32 where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _UnlockWalletRequest'recoveryWindow
+           (\ x__ y__ -> x__ {_UnlockWalletRequest'recoveryWindow = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField UnlockWalletRequest "channelBackups" Proto.LndGrpc.ChanBackupSnapshot where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _UnlockWalletRequest'channelBackups
+           (\ x__ y__ -> x__ {_UnlockWalletRequest'channelBackups = y__}))
+        (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage)
+instance Data.ProtoLens.Field.HasField UnlockWalletRequest "maybe'channelBackups" (Prelude.Maybe Proto.LndGrpc.ChanBackupSnapshot) where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _UnlockWalletRequest'channelBackups
+           (\ x__ y__ -> x__ {_UnlockWalletRequest'channelBackups = y__}))
+        Prelude.id
+instance Data.ProtoLens.Field.HasField UnlockWalletRequest "statelessInit" Prelude.Bool where
+  fieldOf _
+    = (Prelude..)
+        (Lens.Family2.Unchecked.lens
+           _UnlockWalletRequest'statelessInit
+           (\ x__ y__ -> x__ {_UnlockWalletRequest'statelessInit = y__}))
+        Prelude.id
+instance Data.ProtoLens.Message UnlockWalletRequest where
+  messageName _ = Data.Text.pack "lnrpc.UnlockWalletRequest"
+  packedMessageDescriptor _
+    = "\n\
+      \\DC3UnlockWalletRequest\DC2'\n\
+      \\SIwallet_password\CAN\SOH \SOH(\fR\SOwalletPassword\DC2'\n\
+      \\SIrecovery_window\CAN\STX \SOH(\ENQR\SOrecoveryWindow\DC2B\n\
+      \\SIchannel_backups\CAN\ETX \SOH(\v2\EM.lnrpc.ChanBackupSnapshotR\SOchannelBackups\DC2%\n\
+      \\SOstateless_init\CAN\EOT \SOH(\bR\rstatelessInit"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag
+    = let
+        walletPassword__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "wallet_password"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"walletPassword")) ::
+              Data.ProtoLens.FieldDescriptor UnlockWalletRequest
+        recoveryWindow__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "recovery_window"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::
+                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"recoveryWindow")) ::
+              Data.ProtoLens.FieldDescriptor UnlockWalletRequest
+        channelBackups__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "channel_backups"
+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
+                 Data.ProtoLens.FieldTypeDescriptor Proto.LndGrpc.ChanBackupSnapshot)
+              (Data.ProtoLens.OptionalField
+                 (Data.ProtoLens.Field.field @"maybe'channelBackups")) ::
+              Data.ProtoLens.FieldDescriptor UnlockWalletRequest
+        statelessInit__field_descriptor
+          = Data.ProtoLens.FieldDescriptor
+              "stateless_init"
+              (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::
+                 Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)
+              (Data.ProtoLens.PlainField
+                 Data.ProtoLens.Optional
+                 (Data.ProtoLens.Field.field @"statelessInit")) ::
+              Data.ProtoLens.FieldDescriptor UnlockWalletRequest
+      in
+        Data.Map.fromList
+          [(Data.ProtoLens.Tag 1, walletPassword__field_descriptor),
+           (Data.ProtoLens.Tag 2, recoveryWindow__field_descriptor),
+           (Data.ProtoLens.Tag 3, channelBackups__field_descriptor),
+           (Data.ProtoLens.Tag 4, statelessInit__field_descriptor)]
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _UnlockWalletRequest'_unknownFields
+        (\ x__ y__ -> x__ {_UnlockWalletRequest'_unknownFields = y__})
+  defMessage
+    = UnlockWalletRequest'_constructor
+        {_UnlockWalletRequest'walletPassword = Data.ProtoLens.fieldDefault,
+         _UnlockWalletRequest'recoveryWindow = Data.ProtoLens.fieldDefault,
+         _UnlockWalletRequest'channelBackups = Prelude.Nothing,
+         _UnlockWalletRequest'statelessInit = Data.ProtoLens.fieldDefault,
+         _UnlockWalletRequest'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          UnlockWalletRequest
+          -> Data.ProtoLens.Encoding.Bytes.Parser UnlockWalletRequest
+        loop x
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of
+                        10
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.getBytes
+                                             (Prelude.fromIntegral len))
+                                       "wallet_password"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"walletPassword") y x)
+                        16
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          Prelude.fromIntegral
+                                          Data.ProtoLens.Encoding.Bytes.getVarInt)
+                                       "recovery_window"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"recoveryWindow") y x)
+                        26
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                                           Data.ProtoLens.Encoding.Bytes.isolate
+                                             (Prelude.fromIntegral len) Data.ProtoLens.parseMessage)
+                                       "channel_backups"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"channelBackups") y x)
+                        32
+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)
+                                       (Prelude.fmap
+                                          ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt)
+                                       "stateless_init"
+                                loop
+                                  (Lens.Family2.set
+                                     (Data.ProtoLens.Field.field @"statelessInit") y x)
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do loop Data.ProtoLens.defMessage) "UnlockWalletRequest"
+  buildMessage
+    = \ _x
+        -> (Data.Monoid.<>)
+             (let
+                _v
+                  = Lens.Family2.view
+                      (Data.ProtoLens.Field.field @"walletPassword") _x
+              in
+                if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                    Data.Monoid.mempty
+                else
+                    (Data.Monoid.<>)
+                      (Data.ProtoLens.Encoding.Bytes.putVarInt 10)
+                      ((\ bs
+                          -> (Data.Monoid.<>)
+                               (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                  (Prelude.fromIntegral (Data.ByteString.length bs)))
+                               (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                         _v))
+             ((Data.Monoid.<>)
+                (let
+                   _v
+                     = Lens.Family2.view
+                         (Data.ProtoLens.Field.field @"recoveryWindow") _x
+                 in
+                   if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                       Data.Monoid.mempty
+                   else
+                       (Data.Monoid.<>)
+                         (Data.ProtoLens.Encoding.Bytes.putVarInt 16)
+                         ((Prelude..)
+                            Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v))
+                ((Data.Monoid.<>)
+                   (case
+                        Lens.Family2.view
+                          (Data.ProtoLens.Field.field @"maybe'channelBackups") _x
+                    of
+                      Prelude.Nothing -> Data.Monoid.mempty
+                      (Prelude.Just _v)
+                        -> (Data.Monoid.<>)
+                             (Data.ProtoLens.Encoding.Bytes.putVarInt 26)
+                             ((Prelude..)
+                                (\ bs
+                                   -> (Data.Monoid.<>)
+                                        (Data.ProtoLens.Encoding.Bytes.putVarInt
+                                           (Prelude.fromIntegral (Data.ByteString.length bs)))
+                                        (Data.ProtoLens.Encoding.Bytes.putBytes bs))
+                                Data.ProtoLens.encodeMessage
+                                _v))
+                   ((Data.Monoid.<>)
+                      (let
+                         _v
+                           = Lens.Family2.view
+                               (Data.ProtoLens.Field.field @"statelessInit") _x
+                       in
+                         if (Prelude.==) _v Data.ProtoLens.fieldDefault then
+                             Data.Monoid.mempty
+                         else
+                             (Data.Monoid.<>)
+                               (Data.ProtoLens.Encoding.Bytes.putVarInt 32)
+                               ((Prelude..)
+                                  Data.ProtoLens.Encoding.Bytes.putVarInt
+                                  (\ b -> if b then 1 else 0)
+                                  _v))
+                      (Data.ProtoLens.Encoding.Wire.buildFieldSet
+                         (Lens.Family2.view Data.ProtoLens.unknownFields _x)))))
+instance Control.DeepSeq.NFData UnlockWalletRequest where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_UnlockWalletRequest'_unknownFields x__)
+             (Control.DeepSeq.deepseq
+                (_UnlockWalletRequest'walletPassword x__)
+                (Control.DeepSeq.deepseq
+                   (_UnlockWalletRequest'recoveryWindow x__)
+                   (Control.DeepSeq.deepseq
+                      (_UnlockWalletRequest'channelBackups x__)
+                      (Control.DeepSeq.deepseq
+                         (_UnlockWalletRequest'statelessInit x__) ()))))
+{- | Fields :
+      -}
+data UnlockWalletResponse
+  = UnlockWalletResponse'_constructor {_UnlockWalletResponse'_unknownFields :: !Data.ProtoLens.FieldSet}
+  deriving stock (Prelude.Eq, Prelude.Ord)
+instance Prelude.Show UnlockWalletResponse where
+  showsPrec _ __x __s
+    = Prelude.showChar
+        '{'
+        (Prelude.showString
+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))
+instance Data.ProtoLens.Message UnlockWalletResponse where
+  messageName _ = Data.Text.pack "lnrpc.UnlockWalletResponse"
+  packedMessageDescriptor _
+    = "\n\
+      \\DC4UnlockWalletResponse"
+  packedFileDescriptor _ = packedFileDescriptor
+  fieldsByTag = let in Data.Map.fromList []
+  unknownFields
+    = Lens.Family2.Unchecked.lens
+        _UnlockWalletResponse'_unknownFields
+        (\ x__ y__ -> x__ {_UnlockWalletResponse'_unknownFields = y__})
+  defMessage
+    = UnlockWalletResponse'_constructor
+        {_UnlockWalletResponse'_unknownFields = []}
+  parseMessage
+    = let
+        loop ::
+          UnlockWalletResponse
+          -> Data.ProtoLens.Encoding.Bytes.Parser UnlockWalletResponse
+        loop x
+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
+               if end then
+                   do (let missing = []
+                       in
+                         if Prelude.null missing then
+                             Prelude.return ()
+                         else
+                             Prelude.fail
+                               ((Prelude.++)
+                                  "Missing required fields: "
+                                  (Prelude.show (missing :: [Prelude.String]))))
+                      Prelude.return
+                        (Lens.Family2.over
+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)
+               else
+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
+                      case tag of {
+                        wire
+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
+                                        wire
+                                loop
+                                  (Lens.Family2.over
+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x) }
+      in
+        (Data.ProtoLens.Encoding.Bytes.<?>)
+          (do loop Data.ProtoLens.defMessage) "UnlockWalletResponse"
+  buildMessage
+    = \ _x
+        -> Data.ProtoLens.Encoding.Wire.buildFieldSet
+             (Lens.Family2.view Data.ProtoLens.unknownFields _x)
+instance Control.DeepSeq.NFData UnlockWalletResponse where
+  rnf
+    = \ x__
+        -> Control.DeepSeq.deepseq
+             (_UnlockWalletResponse'_unknownFields x__) ()
+data WalletUnlocker = WalletUnlocker {}
+instance Data.ProtoLens.Service.Types.Service WalletUnlocker where
+  type ServiceName WalletUnlocker = "WalletUnlocker"
+  type ServicePackage WalletUnlocker = "lnrpc"
+  type ServiceMethods WalletUnlocker = '["changePassword",
+                                         "genSeed",
+                                         "initWallet",
+                                         "unlockWallet"]
+instance Data.ProtoLens.Service.Types.HasMethodImpl WalletUnlocker "genSeed" where
+  type MethodName WalletUnlocker "genSeed" = "GenSeed"
+  type MethodInput WalletUnlocker "genSeed" = GenSeedRequest
+  type MethodOutput WalletUnlocker "genSeed" = GenSeedResponse
+  type MethodStreamingType WalletUnlocker "genSeed" =  'Data.ProtoLens.Service.Types.NonStreaming
+instance Data.ProtoLens.Service.Types.HasMethodImpl WalletUnlocker "initWallet" where
+  type MethodName WalletUnlocker "initWallet" = "InitWallet"
+  type MethodInput WalletUnlocker "initWallet" = InitWalletRequest
+  type MethodOutput WalletUnlocker "initWallet" = InitWalletResponse
+  type MethodStreamingType WalletUnlocker "initWallet" =  'Data.ProtoLens.Service.Types.NonStreaming
+instance Data.ProtoLens.Service.Types.HasMethodImpl WalletUnlocker "unlockWallet" where
+  type MethodName WalletUnlocker "unlockWallet" = "UnlockWallet"
+  type MethodInput WalletUnlocker "unlockWallet" = UnlockWalletRequest
+  type MethodOutput WalletUnlocker "unlockWallet" = UnlockWalletResponse
+  type MethodStreamingType WalletUnlocker "unlockWallet" =  'Data.ProtoLens.Service.Types.NonStreaming
+instance Data.ProtoLens.Service.Types.HasMethodImpl WalletUnlocker "changePassword" where
+  type MethodName WalletUnlocker "changePassword" = "ChangePassword"
+  type MethodInput WalletUnlocker "changePassword" = ChangePasswordRequest
+  type MethodOutput WalletUnlocker "changePassword" = ChangePasswordResponse
+  type MethodStreamingType WalletUnlocker "changePassword" =  'Data.ProtoLens.Service.Types.NonStreaming
+packedFileDescriptor :: Data.ByteString.ByteString
+packedFileDescriptor
+  = "\n\
+    \\SUBwallet_unlocker_grpc.proto\DC2\ENQlnrpc\SUB\SOlnd_grpc.proto\"`\n\
+    \\SOGenSeedRequest\DC2+\n\
+    \\DC1aezeed_passphrase\CAN\SOH \SOH(\fR\DLEaezeedPassphrase\DC2!\n\
+    \\fseed_entropy\CAN\STX \SOH(\fR\vseedEntropy\"l\n\
+    \\SIGenSeedResponse\DC20\n\
+    \\DC4cipher_seed_mnemonic\CAN\SOH \ETX(\tR\DC2cipherSeedMnemonic\DC2'\n\
+    \\SIenciphered_seed\CAN\STX \SOH(\fR\SOencipheredSeed\"\175\STX\n\
+    \\DC1InitWalletRequest\DC2'\n\
+    \\SIwallet_password\CAN\SOH \SOH(\fR\SOwalletPassword\DC20\n\
+    \\DC4cipher_seed_mnemonic\CAN\STX \ETX(\tR\DC2cipherSeedMnemonic\DC2+\n\
+    \\DC1aezeed_passphrase\CAN\ETX \SOH(\fR\DLEaezeedPassphrase\DC2'\n\
+    \\SIrecovery_window\CAN\EOT \SOH(\ENQR\SOrecoveryWindow\DC2B\n\
+    \\SIchannel_backups\CAN\ENQ \SOH(\v2\EM.lnrpc.ChanBackupSnapshotR\SOchannelBackups\DC2%\n\
+    \\SOstateless_init\CAN\ACK \SOH(\bR\rstatelessInit\";\n\
+    \\DC2InitWalletResponse\DC2%\n\
+    \\SOadmin_macaroon\CAN\SOH \SOH(\fR\radminMacaroon\"\210\SOH\n\
+    \\DC3UnlockWalletRequest\DC2'\n\
+    \\SIwallet_password\CAN\SOH \SOH(\fR\SOwalletPassword\DC2'\n\
+    \\SIrecovery_window\CAN\STX \SOH(\ENQR\SOrecoveryWindow\DC2B\n\
+    \\SIchannel_backups\CAN\ETX \SOH(\v2\EM.lnrpc.ChanBackupSnapshotR\SOchannelBackups\DC2%\n\
+    \\SOstateless_init\CAN\EOT \SOH(\bR\rstatelessInit\"\SYN\n\
+    \\DC4UnlockWalletResponse\"\191\SOH\n\
+    \\NAKChangePasswordRequest\DC2)\n\
+    \\DLEcurrent_password\CAN\SOH \SOH(\fR\SIcurrentPassword\DC2!\n\
+    \\fnew_password\CAN\STX \SOH(\fR\vnewPassword\DC2%\n\
+    \\SOstateless_init\CAN\ETX \SOH(\bR\rstatelessInit\DC21\n\
+    \\NAKnew_macaroon_root_key\CAN\EOT \SOH(\bR\DC2newMacaroonRootKey\"?\n\
+    \\SYNChangePasswordResponse\DC2%\n\
+    \\SOadmin_macaroon\CAN\SOH \SOH(\fR\radminMacaroon2\165\STX\n\
+    \\SOWalletUnlocker\DC28\n\
+    \\aGenSeed\DC2\NAK.lnrpc.GenSeedRequest\SUB\SYN.lnrpc.GenSeedResponse\DC2A\n\
+    \\n\
+    \InitWallet\DC2\CAN.lnrpc.InitWalletRequest\SUB\EM.lnrpc.InitWalletResponse\DC2G\n\
+    \\fUnlockWallet\DC2\SUB.lnrpc.UnlockWalletRequest\SUB\ESC.lnrpc.UnlockWalletResponse\DC2M\n\
+    \\SOChangePassword\DC2\FS.lnrpc.ChangePasswordRequest\SUB\GS.lnrpc.ChangePasswordResponseB'Z%github.com/lightningnetwork/lnd/lnrpcJ\232I\n\
+    \\a\DC2\ENQ\STX\NUL\239\SOH\SOH\n\
+    \\141\SOH\n\
+    \\SOH\f\DC2\ETX\STX\NUL\DC22\130\SOHsource https://raw.githubusercontent.com/lightningnetwork/lnd/c733c139e95a6ef4e5f9ac88b43328ac96c333ef/lnrpc/walletunlocker.proto\n\
+    \\n\
+    \\t\n\
+    \\STX\ETX\NUL\DC2\ETX\EOT\NUL\CAN\n\
+    \\b\n\
+    \\SOH\STX\DC2\ETX\ACK\NUL\SO\n\
+    \\b\n\
+    \\SOH\b\DC2\ETX\b\NUL<\n\
+    \\t\n\
+    \\STX\b\v\DC2\ETX\b\NUL<\n\
+    \\187\ACK\n\
+    \\STX\ACK\NUL\DC2\EOT\RS\NULF\SOH\SUB\136\SOH WalletUnlocker is a service that is used to set up a wallet password for\n\
+    \ lnd at first startup, and unlock a previously set up wallet.\n\
+    \2\163\ENQ\n\
+    \ Comments in this file will be directly parsed into the API\n\
+    \ Documentation as descriptions of the associated method, message, or field.\n\
+    \ These descriptions should go right above the definition of the object, and\n\
+    \ can be in either block or // comment format.\n\
+    \\n\
+    \ An RPC method can be matched to an lncli command by placing a line in the\n\
+    \ beginning of the description in exactly the following format:\n\
+    \ lncli: `methodname`\n\
+    \\n\
+    \ Failure to specify the exact name of the command will cause documentation\n\
+    \ generation to fail.\n\
+    \\n\
+    \ More information on how exactly the gRPC documentation is generated from\n\
+    \ this proto file can be found here:\n\
+    \ https://github.com/lightninglabs/lightning-api\n\
+    \\n\
+    \\n\
+    \\n\
+    \\ETX\ACK\NUL\SOH\DC2\ETX\RS\b\SYN\n\
+    \\200\ETX\n\
+    \\EOT\ACK\NUL\STX\NUL\DC2\ETX)\EOT;\SUB\186\ETX\n\
+    \GenSeed is the first method that should be used to instantiate a new lnd\n\
+    \instance. This method allows a caller to generate a new aezeed cipher seed\n\
+    \given an optional passphrase. If provided, the passphrase will be necessary\n\
+    \to decrypt the cipherseed to expose the internal wallet seed.\n\
+    \\n\
+    \Once the cipherseed is obtained and verified by the user, the InitWallet\n\
+    \method should be used to commit the newly generated seed, and create the\n\
+    \wallet.\n\
+    \\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\NUL\SOH\DC2\ETX)\b\SI\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\NUL\STX\DC2\ETX)\DC1\US\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\NUL\ETX\DC2\ETX)*9\n\
+    \\133\ENQ\n\
+    \\EOT\ACK\NUL\STX\SOH\DC2\ETX9\EOTD\SUB\247\EOT\n\
+    \InitWallet is used when lnd is starting up for the first time to fully\n\
+    \initialize the daemon and its internal wallet. At the very least a wallet\n\
+    \password must be provided. This will be used to encrypt sensitive material\n\
+    \on disk.\n\
+    \\n\
+    \In the case of a recovery scenario, the user can also specify their aezeed\n\
+    \mnemonic and passphrase. If set, then the daemon will use this prior state\n\
+    \to initialize its internal wallet.\n\
+    \\n\
+    \Alternatively, this can be used along with the GenSeed RPC to obtain a\n\
+    \seed, then present it to the user. Once it has been verified by the user,\n\
+    \the seed can be fed into this RPC in order to commit the new wallet.\n\
+    \\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\SOH\SOH\DC2\ETX9\b\DC2\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\SOH\STX\DC2\ETX9\DC4%\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\SOH\ETX\DC2\ETX90B\n\
+    \z\n\
+    \\EOT\ACK\NUL\STX\STX\DC2\ETX?\EOTJ\SUBm lncli: `unlock`\n\
+    \UnlockWallet is used at startup of lnd to provide a password to unlock\n\
+    \the wallet database.\n\
+    \\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\STX\SOH\DC2\ETX?\b\DC4\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\STX\STX\DC2\ETX?\SYN)\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\STX\ETX\DC2\ETX?4H\n\
+    \\166\SOH\n\
+    \\EOT\ACK\NUL\STX\ETX\DC2\ETXE\EOTP\SUB\152\SOH lncli: `changepassword`\n\
+    \ChangePassword changes the password of the encrypted wallet. This will\n\
+    \automatically unlock the wallet database if successful.\n\
+    \\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\ETX\SOH\DC2\ETXE\b\SYN\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\ETX\STX\DC2\ETXE\CAN-\n\
+    \\f\n\
+    \\ENQ\ACK\NUL\STX\ETX\ETX\DC2\ETXE8N\n\
+    \\n\
+    \\n\
+    \\STX\EOT\NUL\DC2\EOTH\NULV\SOH\n\
+    \\n\
+    \\n\
+    \\ETX\EOT\NUL\SOH\DC2\ETXH\b\SYN\n\
+    \\191\SOH\n\
+    \\EOT\EOT\NUL\STX\NUL\DC2\ETXN\EOT \SUB\177\SOH\n\
+    \aezeed_passphrase is an optional user provided passphrase that will be used\n\
+    \to encrypt the generated aezeed cipher seed. When using REST, this field\n\
+    \must be encoded as base64.\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\NUL\EOT\DC2\EOTN\EOTH\CAN\n\
+    \\f\n\
+    \\ENQ\EOT\NUL\STX\NUL\ENQ\DC2\ETXN\EOT\t\n\
+    \\f\n\
+    \\ENQ\EOT\NUL\STX\NUL\SOH\DC2\ETXN\n\
+    \\ESC\n\
+    \\f\n\
+    \\ENQ\EOT\NUL\STX\NUL\ETX\DC2\ETXN\RS\US\n\
+    \\211\SOH\n\
+    \\EOT\EOT\NUL\STX\SOH\DC2\ETXU\EOT\ESC\SUB\197\SOH\n\
+    \seed_entropy is an optional 16-bytes generated via CSPRNG. If not\n\
+    \specified, then a fresh set of randomness will be used to create the seed.\n\
+    \When using REST, this field must be encoded as base64.\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT\NUL\STX\SOH\EOT\DC2\EOTU\EOTN \n\
+    \\f\n\
+    \\ENQ\EOT\NUL\STX\SOH\ENQ\DC2\ETXU\EOT\t\n\
+    \\f\n\
+    \\ENQ\EOT\NUL\STX\SOH\SOH\DC2\ETXU\n\
+    \\SYN\n\
+    \\f\n\
+    \\ENQ\EOT\NUL\STX\SOH\ETX\DC2\ETXU\EM\SUB\n\
+    \\n\
+    \\n\
+    \\STX\EOT\SOH\DC2\EOTW\NULf\SOH\n\
+    \\n\
+    \\n\
+    \\ETX\EOT\SOH\SOH\DC2\ETXW\b\ETB\n\
+    \\194\STX\n\
+    \\EOT\EOT\SOH\STX\NUL\DC2\ETX_\EOT-\SUB\180\STX\n\
+    \cipher_seed_mnemonic is a 24-word mnemonic that encodes a prior aezeed\n\
+    \cipher seed obtained by the user. This field is optional, as if not\n\
+    \provided, then the daemon will generate a new cipher seed for the user.\n\
+    \Otherwise, then the daemon will attempt to recover the wallet state linked\n\
+    \to this cipher seed.\n\
+    \\n\
+    \\f\n\
+    \\ENQ\EOT\SOH\STX\NUL\EOT\DC2\ETX_\EOT\f\n\
+    \\f\n\
+    \\ENQ\EOT\SOH\STX\NUL\ENQ\DC2\ETX_\r\DC3\n\
+    \\f\n\
+    \\ENQ\EOT\SOH\STX\NUL\SOH\DC2\ETX_\DC4(\n\
+    \\f\n\
+    \\ENQ\EOT\SOH\STX\NUL\ETX\DC2\ETX_+,\n\
+    \\146\SOH\n\
+    \\EOT\EOT\SOH\STX\SOH\DC2\ETXe\EOT\RS\SUB\132\SOH\n\
+    \enciphered_seed are the raw aezeed cipher seed bytes. This is the raw\n\
+    \cipher text before run through our mnemonic encoding scheme.\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT\SOH\STX\SOH\EOT\DC2\EOTe\EOT_-\n\
+    \\f\n\
+    \\ENQ\EOT\SOH\STX\SOH\ENQ\DC2\ETXe\EOT\t\n\
+    \\f\n\
+    \\ENQ\EOT\SOH\STX\SOH\SOH\DC2\ETXe\n\
+    \\EM\n\
+    \\f\n\
+    \\ENQ\EOT\SOH\STX\SOH\ETX\DC2\ETXe\FS\GS\n\
+    \\v\n\
+    \\STX\EOT\STX\DC2\ENQh\NUL\153\SOH\SOH\n\
+    \\n\
+    \\n\
+    \\ETX\EOT\STX\SOH\DC2\ETXh\b\EM\n\
+    \\252\SOH\n\
+    \\EOT\EOT\STX\STX\NUL\DC2\ETXo\EOT\RS\SUB\238\SOH\n\
+    \wallet_password is the passphrase that should be used to encrypt the\n\
+    \wallet. This MUST be at least 8 chars in length. After creation, this\n\
+    \password is required to unlock the daemon. When using REST, this field\n\
+    \must be encoded as base64.\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT\STX\STX\NUL\EOT\DC2\EOTo\EOTh\ESC\n\
+    \\f\n\
+    \\ENQ\EOT\STX\STX\NUL\ENQ\DC2\ETXo\EOT\t\n\
+    \\f\n\
+    \\ENQ\EOT\STX\STX\NUL\SOH\DC2\ETXo\n\
+    \\EM\n\
+    \\f\n\
+    \\ENQ\EOT\STX\STX\NUL\ETX\DC2\ETXo\FS\GS\n\
+    \\196\SOH\n\
+    \\EOT\EOT\STX\STX\SOH\DC2\ETXv\EOT-\SUB\182\SOH\n\
+    \cipher_seed_mnemonic is a 24-word mnemonic that encodes a prior aezeed\n\
+    \cipher seed obtained by the user. This may have been generated by the\n\
+    \GenSeed method, or be an existing seed.\n\
+    \\n\
+    \\f\n\
+    \\ENQ\EOT\STX\STX\SOH\EOT\DC2\ETXv\EOT\f\n\
+    \\f\n\
+    \\ENQ\EOT\STX\STX\SOH\ENQ\DC2\ETXv\r\DC3\n\
+    \\f\n\
+    \\ENQ\EOT\STX\STX\SOH\SOH\DC2\ETXv\DC4(\n\
+    \\f\n\
+    \\ENQ\EOT\STX\STX\SOH\ETX\DC2\ETXv+,\n\
+    \\191\SOH\n\
+    \\EOT\EOT\STX\STX\STX\DC2\ETX}\EOT \SUB\177\SOH\n\
+    \aezeed_passphrase is an optional user provided passphrase that will be used\n\
+    \to encrypt the generated aezeed cipher seed. When using REST, this field\n\
+    \must be encoded as base64.\n\
+    \\n\
+    \\r\n\
+    \\ENQ\EOT\STX\STX\STX\EOT\DC2\EOT}\EOTv-\n\
+    \\f\n\
+    \\ENQ\EOT\STX\STX\STX\ENQ\DC2\ETX}\EOT\t\n\
+    \\f\n\
+    \\ENQ\EOT\STX\STX\STX\SOH\DC2\ETX}\n\
+    \\ESC\n\
+    \\f\n\
+    \\ENQ\EOT\STX\STX\STX\ETX\DC2\ETX}\RS\US\n\
+    \\212\STX\n\
+    \\EOT\EOT\STX\STX\ETX\DC2\EOT\134\SOH\EOT\RS\SUB\197\STX\n\
+    \recovery_window is an optional argument specifying the address lookahead\n\
+    \when restoring a wallet seed. The recovery window applies to each\n\
+    \individual branch of the BIP44 derivation paths. Supplying a recovery\n\
+    \window of zero indicates that no addresses should be recovered, such after\n\
+    \the first initialization of the wallet.\n\
+    \\n\
+    \\SO\n\
+    \\ENQ\EOT\STX\STX\ETX\EOT\DC2\ENQ\134\SOH\EOT} \n\
+    \\r\n\
+    \\ENQ\EOT\STX\STX\ETX\ENQ\DC2\EOT\134\SOH\EOT\t\n\
+    \\r\n\
+    \\ENQ\EOT\STX\STX\ETX\SOH\DC2\EOT\134\SOH\n\
+    \\EM\n\
+    \\r\n\
+    \\ENQ\EOT\STX\STX\ETX\ETX\DC2\EOT\134\SOH\FS\GS\n\
+    \\203\ETX\n\
+    \\EOT\EOT\STX\STX\EOT\DC2\EOT\144\SOH\EOT+\SUB\188\ETX\n\
+    \channel_backups is an optional argument that allows clients to recover the\n\
+    \settled funds within a set of channels. This should be populated if the\n\
+    \user was unable to close out all channels and sweep funds before partial or\n\
+    \total data loss occurred. If specified, then after on-chain recovery of\n\
+    \funds, lnd begin to carry out the data loss recovery protocol in order to\n\
+    \recover the funds in each channel from a remote force closed transaction.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\STX\STX\EOT\EOT\DC2\ACK\144\SOH\EOT\134\SOH\RS\n\
+    \\r\n\
+    \\ENQ\EOT\STX\STX\EOT\ACK\DC2\EOT\144\SOH\EOT\SYN\n\
+    \\r\n\
+    \\ENQ\EOT\STX\STX\EOT\SOH\DC2\EOT\144\SOH\ETB&\n\
+    \\r\n\
+    \\ENQ\EOT\STX\STX\EOT\ETX\DC2\EOT\144\SOH)*\n\
+    \\171\STX\n\
+    \\EOT\EOT\STX\STX\ENQ\DC2\EOT\152\SOH\EOT\FS\SUB\156\STX\n\
+    \stateless_init is an optional argument instructing the daemon NOT to create\n\
+    \any *.macaroon files in its filesystem. If this parameter is set, then the\n\
+    \admin macaroon returned in the response MUST be stored by the caller of the\n\
+    \RPC as otherwise all access to the daemon will be lost!\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\STX\STX\ENQ\EOT\DC2\ACK\152\SOH\EOT\144\SOH+\n\
+    \\r\n\
+    \\ENQ\EOT\STX\STX\ENQ\ENQ\DC2\EOT\152\SOH\EOT\b\n\
+    \\r\n\
+    \\ENQ\EOT\STX\STX\ENQ\SOH\DC2\EOT\152\SOH\t\ETB\n\
+    \\r\n\
+    \\ENQ\EOT\STX\STX\ENQ\ETX\DC2\EOT\152\SOH\SUB\ESC\n\
+    \\f\n\
+    \\STX\EOT\ETX\DC2\ACK\154\SOH\NUL\163\SOH\SOH\n\
+    \\v\n\
+    \\ETX\EOT\ETX\SOH\DC2\EOT\154\SOH\b\SUB\n\
+    \\229\STX\n\
+    \\EOT\EOT\ETX\STX\NUL\DC2\EOT\162\SOH\EOT\GS\SUB\214\STX\n\
+    \The binary serialized admin macaroon that can be used to access the daemon\n\
+    \after creating the wallet. If the stateless_init parameter was set to true,\n\
+    \this is the ONLY copy of the macaroon and MUST be stored safely by the\n\
+    \caller. Otherwise a copy of this macaroon is also persisted on disk by the\n\
+    \daemon, together with other macaroon files.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\ETX\STX\NUL\EOT\DC2\ACK\162\SOH\EOT\154\SOH\FS\n\
+    \\r\n\
+    \\ENQ\EOT\ETX\STX\NUL\ENQ\DC2\EOT\162\SOH\EOT\t\n\
+    \\r\n\
+    \\ENQ\EOT\ETX\STX\NUL\SOH\DC2\EOT\162\SOH\n\
+    \\CAN\n\
+    \\r\n\
+    \\ENQ\EOT\ETX\STX\NUL\ETX\DC2\EOT\162\SOH\ESC\FS\n\
+    \\f\n\
+    \\STX\EOT\EOT\DC2\ACK\165\SOH\NUL\197\SOH\SOH\n\
+    \\v\n\
+    \\ETX\EOT\EOT\SOH\DC2\EOT\165\SOH\b\ESC\n\
+    \\239\SOH\n\
+    \\EOT\EOT\EOT\STX\NUL\DC2\EOT\171\SOH\EOT\RS\SUB\224\SOH\n\
+    \wallet_password should be the current valid passphrase for the daemon. This\n\
+    \will be required to decrypt on-disk material that the daemon requires to\n\
+    \function properly. When using REST, this field must be encoded as base64.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\EOT\STX\NUL\EOT\DC2\ACK\171\SOH\EOT\165\SOH\GS\n\
+    \\r\n\
+    \\ENQ\EOT\EOT\STX\NUL\ENQ\DC2\EOT\171\SOH\EOT\t\n\
+    \\r\n\
+    \\ENQ\EOT\EOT\STX\NUL\SOH\DC2\EOT\171\SOH\n\
+    \\EM\n\
+    \\r\n\
+    \\ENQ\EOT\EOT\STX\NUL\ETX\DC2\EOT\171\SOH\FS\GS\n\
+    \\212\STX\n\
+    \\EOT\EOT\EOT\STX\SOH\DC2\EOT\180\SOH\EOT\RS\SUB\197\STX\n\
+    \recovery_window is an optional argument specifying the address lookahead\n\
+    \when restoring a wallet seed. The recovery window applies to each\n\
+    \individual branch of the BIP44 derivation paths. Supplying a recovery\n\
+    \window of zero indicates that no addresses should be recovered, such after\n\
+    \the first initialization of the wallet.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\EOT\STX\SOH\EOT\DC2\ACK\180\SOH\EOT\171\SOH\RS\n\
+    \\r\n\
+    \\ENQ\EOT\EOT\STX\SOH\ENQ\DC2\EOT\180\SOH\EOT\t\n\
+    \\r\n\
+    \\ENQ\EOT\EOT\STX\SOH\SOH\DC2\EOT\180\SOH\n\
+    \\EM\n\
+    \\r\n\
+    \\ENQ\EOT\EOT\STX\SOH\ETX\DC2\EOT\180\SOH\FS\GS\n\
+    \\203\ETX\n\
+    \\EOT\EOT\EOT\STX\STX\DC2\EOT\190\SOH\EOT+\SUB\188\ETX\n\
+    \channel_backups is an optional argument that allows clients to recover the\n\
+    \settled funds within a set of channels. This should be populated if the\n\
+    \user was unable to close out all channels and sweep funds before partial or\n\
+    \total data loss occurred. If specified, then after on-chain recovery of\n\
+    \funds, lnd begin to carry out the data loss recovery protocol in order to\n\
+    \recover the funds in each channel from a remote force closed transaction.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\EOT\STX\STX\EOT\DC2\ACK\190\SOH\EOT\180\SOH\RS\n\
+    \\r\n\
+    \\ENQ\EOT\EOT\STX\STX\ACK\DC2\EOT\190\SOH\EOT\SYN\n\
+    \\r\n\
+    \\ENQ\EOT\EOT\STX\STX\SOH\DC2\EOT\190\SOH\ETB&\n\
+    \\r\n\
+    \\ENQ\EOT\EOT\STX\STX\ETX\DC2\EOT\190\SOH)*\n\
+    \\132\SOH\n\
+    \\EOT\EOT\EOT\STX\ETX\DC2\EOT\196\SOH\EOT\FS\SUBv\n\
+    \stateless_init is an optional argument instructing the daemon NOT to create\n\
+    \any *.macaroon files in its file system.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\EOT\STX\ETX\EOT\DC2\ACK\196\SOH\EOT\190\SOH+\n\
+    \\r\n\
+    \\ENQ\EOT\EOT\STX\ETX\ENQ\DC2\EOT\196\SOH\EOT\b\n\
+    \\r\n\
+    \\ENQ\EOT\EOT\STX\ETX\SOH\DC2\EOT\196\SOH\t\ETB\n\
+    \\r\n\
+    \\ENQ\EOT\EOT\STX\ETX\ETX\DC2\EOT\196\SOH\SUB\ESC\n\
+    \\f\n\
+    \\STX\EOT\ENQ\DC2\ACK\198\SOH\NUL\199\SOH\SOH\n\
+    \\v\n\
+    \\ETX\EOT\ENQ\SOH\DC2\EOT\198\SOH\b\FS\n\
+    \\f\n\
+    \\STX\EOT\ACK\DC2\ACK\201\SOH\NUL\228\SOH\SOH\n\
+    \\v\n\
+    \\ETX\EOT\ACK\SOH\DC2\EOT\201\SOH\b\GS\n\
+    \\154\SOH\n\
+    \\EOT\EOT\ACK\STX\NUL\DC2\EOT\206\SOH\EOT\US\SUB\139\SOH\n\
+    \current_password should be the current valid passphrase used to unlock the\n\
+    \daemon. When using REST, this field must be encoded as base64.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\ACK\STX\NUL\EOT\DC2\ACK\206\SOH\EOT\201\SOH\US\n\
+    \\r\n\
+    \\ENQ\EOT\ACK\STX\NUL\ENQ\DC2\EOT\206\SOH\EOT\t\n\
+    \\r\n\
+    \\ENQ\EOT\ACK\STX\NUL\SOH\DC2\EOT\206\SOH\n\
+    \\SUB\n\
+    \\r\n\
+    \\ENQ\EOT\ACK\STX\NUL\ETX\DC2\EOT\206\SOH\GS\RS\n\
+    \\155\SOH\n\
+    \\EOT\EOT\ACK\STX\SOH\DC2\EOT\212\SOH\EOT\ESC\SUB\140\SOH\n\
+    \new_password should be the new passphrase that will be needed to unlock the\n\
+    \daemon. When using REST, this field must be encoded as base64.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\ACK\STX\SOH\EOT\DC2\ACK\212\SOH\EOT\206\SOH\US\n\
+    \\r\n\
+    \\ENQ\EOT\ACK\STX\SOH\ENQ\DC2\EOT\212\SOH\EOT\t\n\
+    \\r\n\
+    \\ENQ\EOT\ACK\STX\SOH\SOH\DC2\EOT\212\SOH\n\
+    \\SYN\n\
+    \\r\n\
+    \\ENQ\EOT\ACK\STX\SOH\ETX\DC2\EOT\212\SOH\EM\SUB\n\
+    \\171\STX\n\
+    \\EOT\EOT\ACK\STX\STX\DC2\EOT\220\SOH\EOT\FS\SUB\156\STX\n\
+    \stateless_init is an optional argument instructing the daemon NOT to create\n\
+    \any *.macaroon files in its filesystem. If this parameter is set, then the\n\
+    \admin macaroon returned in the response MUST be stored by the caller of the\n\
+    \RPC as otherwise all access to the daemon will be lost!\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\ACK\STX\STX\EOT\DC2\ACK\220\SOH\EOT\212\SOH\ESC\n\
+    \\r\n\
+    \\ENQ\EOT\ACK\STX\STX\ENQ\DC2\EOT\220\SOH\EOT\b\n\
+    \\r\n\
+    \\ENQ\EOT\ACK\STX\STX\SOH\DC2\EOT\220\SOH\t\ETB\n\
+    \\r\n\
+    \\ENQ\EOT\ACK\STX\STX\ETX\DC2\EOT\220\SOH\SUB\ESC\n\
+    \\192\SOH\n\
+    \\EOT\EOT\ACK\STX\ETX\DC2\EOT\227\SOH\EOT#\SUB\177\SOH\n\
+    \new_macaroon_root_key is an optional argument instructing the daemon to\n\
+    \rotate the macaroon root key when set to true. This will invalidate all\n\
+    \previously generated macaroons.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\ACK\STX\ETX\EOT\DC2\ACK\227\SOH\EOT\220\SOH\FS\n\
+    \\r\n\
+    \\ENQ\EOT\ACK\STX\ETX\ENQ\DC2\EOT\227\SOH\EOT\b\n\
+    \\r\n\
+    \\ENQ\EOT\ACK\STX\ETX\SOH\DC2\EOT\227\SOH\t\RS\n\
+    \\r\n\
+    \\ENQ\EOT\ACK\STX\ETX\ETX\DC2\EOT\227\SOH!\"\n\
+    \\f\n\
+    \\STX\EOT\a\DC2\ACK\229\SOH\NUL\239\SOH\SOH\n\
+    \\v\n\
+    \\ETX\EOT\a\SOH\DC2\EOT\229\SOH\b\RS\n\
+    \\183\ETX\n\
+    \\EOT\EOT\a\STX\NUL\DC2\EOT\238\SOH\EOT\GS\SUB\168\ETX\n\
+    \The binary serialized admin macaroon that can be used to access the daemon\n\
+    \after rotating the macaroon root key. If both the stateless_init and\n\
+    \new_macaroon_root_key parameter were set to true, this is the ONLY copy of\n\
+    \the macaroon that was created from the new root key and MUST be stored\n\
+    \safely by the caller. Otherwise a copy of this macaroon is also persisted on\n\
+    \disk by the daemon, together with other macaroon files.\n\
+    \\n\
+    \\SI\n\
+    \\ENQ\EOT\a\STX\NUL\EOT\DC2\ACK\238\SOH\EOT\229\SOH \n\
+    \\r\n\
+    \\ENQ\EOT\a\STX\NUL\ENQ\DC2\EOT\238\SOH\EOT\t\n\
+    \\r\n\
+    \\ENQ\EOT\a\STX\NUL\SOH\DC2\EOT\238\SOH\n\
+    \\CAN\n\
+    \\r\n\
+    \\ENQ\EOT\a\STX\NUL\ETX\DC2\EOT\238\SOH\ESC\FSb\ACKproto3"
diff --git a/src/Proto/WalletUnlockerGrpc_Fields.hs b/src/Proto/WalletUnlockerGrpc_Fields.hs
new file mode 100644
--- /dev/null
+++ b/src/Proto/WalletUnlockerGrpc_Fields.hs
@@ -0,0 +1,118 @@
+{- This file was auto-generated from wallet_unlocker_grpc.proto by the proto-lens-protoc program. -}
+{-# LANGUAGE ScopedTypeVariables, DataKinds, TypeFamilies, UndecidableInstances, GeneralizedNewtypeDeriving, MultiParamTypeClasses, FlexibleContexts, FlexibleInstances, PatternSynonyms, MagicHash, NoImplicitPrelude, DataKinds, BangPatterns, TypeApplications, OverloadedStrings, DerivingStrategies#-}
+{-# OPTIONS_GHC -Wno-unused-imports#-}
+{-# OPTIONS_GHC -Wno-duplicate-exports#-}
+{-# OPTIONS_GHC -Wno-dodgy-exports#-}
+module Proto.WalletUnlockerGrpc_Fields where
+import qualified Data.ProtoLens.Runtime.Prelude as Prelude
+import qualified Data.ProtoLens.Runtime.Data.Int as Data.Int
+import qualified Data.ProtoLens.Runtime.Data.Monoid as Data.Monoid
+import qualified Data.ProtoLens.Runtime.Data.Word as Data.Word
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens as Data.ProtoLens
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Bytes as Data.ProtoLens.Encoding.Bytes
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Growing as Data.ProtoLens.Encoding.Growing
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Parser.Unsafe as Data.ProtoLens.Encoding.Parser.Unsafe
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Wire as Data.ProtoLens.Encoding.Wire
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Field as Data.ProtoLens.Field
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Message.Enum as Data.ProtoLens.Message.Enum
+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Service.Types as Data.ProtoLens.Service.Types
+import qualified Data.ProtoLens.Runtime.Lens.Family2 as Lens.Family2
+import qualified Data.ProtoLens.Runtime.Lens.Family2.Unchecked as Lens.Family2.Unchecked
+import qualified Data.ProtoLens.Runtime.Data.Text as Data.Text
+import qualified Data.ProtoLens.Runtime.Data.Map as Data.Map
+import qualified Data.ProtoLens.Runtime.Data.ByteString as Data.ByteString
+import qualified Data.ProtoLens.Runtime.Data.ByteString.Char8 as Data.ByteString.Char8
+import qualified Data.ProtoLens.Runtime.Data.Text.Encoding as Data.Text.Encoding
+import qualified Data.ProtoLens.Runtime.Data.Vector as Data.Vector
+import qualified Data.ProtoLens.Runtime.Data.Vector.Generic as Data.Vector.Generic
+import qualified Data.ProtoLens.Runtime.Data.Vector.Unboxed as Data.Vector.Unboxed
+import qualified Data.ProtoLens.Runtime.Text.Read as Text.Read
+import qualified Proto.LndGrpc
+adminMacaroon ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "adminMacaroon" a) =>
+  Lens.Family2.LensLike' f s a
+adminMacaroon = Data.ProtoLens.Field.field @"adminMacaroon"
+aezeedPassphrase ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "aezeedPassphrase" a) =>
+  Lens.Family2.LensLike' f s a
+aezeedPassphrase = Data.ProtoLens.Field.field @"aezeedPassphrase"
+channelBackups ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "channelBackups" a) =>
+  Lens.Family2.LensLike' f s a
+channelBackups = Data.ProtoLens.Field.field @"channelBackups"
+cipherSeedMnemonic ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "cipherSeedMnemonic" a) =>
+  Lens.Family2.LensLike' f s a
+cipherSeedMnemonic
+  = Data.ProtoLens.Field.field @"cipherSeedMnemonic"
+currentPassword ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "currentPassword" a) =>
+  Lens.Family2.LensLike' f s a
+currentPassword = Data.ProtoLens.Field.field @"currentPassword"
+encipheredSeed ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "encipheredSeed" a) =>
+  Lens.Family2.LensLike' f s a
+encipheredSeed = Data.ProtoLens.Field.field @"encipheredSeed"
+maybe'channelBackups ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "maybe'channelBackups" a) =>
+  Lens.Family2.LensLike' f s a
+maybe'channelBackups
+  = Data.ProtoLens.Field.field @"maybe'channelBackups"
+newMacaroonRootKey ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "newMacaroonRootKey" a) =>
+  Lens.Family2.LensLike' f s a
+newMacaroonRootKey
+  = Data.ProtoLens.Field.field @"newMacaroonRootKey"
+newPassword ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "newPassword" a) =>
+  Lens.Family2.LensLike' f s a
+newPassword = Data.ProtoLens.Field.field @"newPassword"
+recoveryWindow ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "recoveryWindow" a) =>
+  Lens.Family2.LensLike' f s a
+recoveryWindow = Data.ProtoLens.Field.field @"recoveryWindow"
+seedEntropy ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "seedEntropy" a) =>
+  Lens.Family2.LensLike' f s a
+seedEntropy = Data.ProtoLens.Field.field @"seedEntropy"
+statelessInit ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "statelessInit" a) =>
+  Lens.Family2.LensLike' f s a
+statelessInit = Data.ProtoLens.Field.field @"statelessInit"
+vec'cipherSeedMnemonic ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "vec'cipherSeedMnemonic" a) =>
+  Lens.Family2.LensLike' f s a
+vec'cipherSeedMnemonic
+  = Data.ProtoLens.Field.field @"vec'cipherSeedMnemonic"
+walletPassword ::
+  forall f s a.
+  (Prelude.Functor f,
+   Data.ProtoLens.Field.HasField s "walletPassword" a) =>
+  Lens.Family2.LensLike' f s a
+walletPassword = Data.ProtoLens.Field.field @"walletPassword"
diff --git a/test/LndClient/RPCSpec.hs b/test/LndClient/RPCSpec.hs
new file mode 100644
--- /dev/null
+++ b/test/LndClient/RPCSpec.hs
@@ -0,0 +1,341 @@
+{-# LANGUAGE DuplicateRecordFields #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE GeneralisedNewtypeDeriving #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TupleSections #-}
+{-# LANGUAGE TypeFamilies #-}
+
+module LndClient.RPCSpec
+  ( spec,
+  )
+where
+
+import LndClient.Data.AddHodlInvoice as HodlInvoice (AddHodlInvoiceRequest (..))
+import LndClient.Data.AddInvoice as AddInvoice
+  ( AddInvoiceRequest (..),
+    AddInvoiceResponse (..),
+  )
+import LndClient.Data.Channel as Channel (Channel (..))
+import LndClient.Data.CloseChannel (CloseChannelRequest (..))
+import qualified LndClient.Data.CloseChannel as CloseChannel
+import qualified LndClient.Data.ClosedChannels as ClosedChannels
+import LndClient.Data.GetInfo (GetInfoResponse (..))
+import LndClient.Data.Invoice as Invoice (Invoice (..), InvoiceState (..))
+import LndClient.Data.ListChannels as LC (ListChannelsRequest (..))
+import LndClient.Data.ListInvoices as ListInvoices
+  ( ListInvoiceRequest (..),
+    ListInvoiceResponse (..),
+  )
+import LndClient.Data.OpenChannel (OpenChannelRequest (..))
+import LndClient.Data.PayReq as PayReq (PayReq (..))
+import LndClient.Data.SendPayment (SendPaymentRequest (..))
+import LndClient.Data.SubscribeInvoices
+  ( SubscribeInvoicesRequest (..),
+  )
+import LndClient.Import
+import LndClient.LndTest
+import LndClient.QRCode
+import LndClient.RPC.Katip
+import LndClient.TestApp
+import qualified LndClient.Watcher as Watcher
+import Test.Hspec
+
+spec :: Spec
+spec = do
+  it "fromJSON" $ do
+    x <- readLndEnv
+    envLndSyncGrpcTimeout x `shouldBe` newGrpcTimeout 59
+    envLndAsyncGrpcTimeout x `shouldBe` Nothing
+  it "decodePayReq" $ withEnv $ do
+    lnd <- getLndEnv Bob
+    x0 <- liftLndResult =<< addInvoice lnd addInvoiceRequest
+    x1 <-
+      liftLndResult
+        =<< decodePayReq lnd (AddInvoice.paymentRequest x0)
+    liftIO $ do
+      PayReq.paymentHash x1
+        `shouldBe` AddInvoice.rHash x0
+      PayReq.numMsat x1
+        `shouldBe` AddInvoice.valueMsat addInvoiceRequest
+      Just (PayReq.expiry x1)
+        `shouldBe` AddInvoice.expiry addInvoiceRequest
+  it "lookupInvoice" $ withEnv $ do
+    lnd <- getLndEnv Bob
+    x0 <- liftLndResult =<< addInvoice lnd addInvoiceRequest
+    x1 <- liftLndResult =<< lookupInvoice lnd (AddInvoice.rHash x0)
+    liftIO $ do
+      Invoice.rHash x1
+        `shouldBe` AddInvoice.rHash x0
+      Invoice.paymentRequest x1
+        `shouldBe` AddInvoice.paymentRequest x0
+      Invoice.addIndex x1
+        `shouldBe` AddInvoice.addIndex x0
+      Just (Invoice.memo x1)
+        `shouldBe` AddInvoice.memo addInvoiceRequest
+      Invoice.valueMsat x1
+        `shouldBe` AddInvoice.valueMsat addInvoiceRequest
+  it "addInvoice" $ withEnv $ do
+    lnd <- getLndEnv Bob
+    res <- addInvoice lnd addInvoiceRequest
+    liftIO $ res `shouldSatisfy` isRight
+  it "addInvoiceQrCode" $ withEnv $ do
+    lnd <- getLndEnv Bob
+    res <- liftLndResult =<< addInvoice lnd addInvoiceRequest
+    let qr = qrPngDataUrl qrDefOpts (AddInvoice.paymentRequest res)
+    liftIO $ qr `shouldSatisfy` isJust
+  it "addNormalInvoice" $ withEnv $ do
+    queue <- getInvoiceTChan Bob
+    lnd <- getLndEnv Bob
+    inv <- liftLndResult =<< addInvoice lnd addInvoiceRequest
+    res <-
+      receiveInvoice
+        (AddInvoice.rHash inv)
+        Invoice.OPEN
+        queue
+    liftIO $ res `shouldSatisfy` isRight
+  it "settleNormalInvoice" $ withEnv $ do
+    void $ setupOneChannel Alice Bob
+    chan <- getInvoiceTChan Bob
+    bob <- getLndEnv Bob
+    inv <- liftLndResult =<< addInvoice bob addInvoiceRequest
+    let rh = AddInvoice.rHash inv
+    liftLndResult
+      =<< receiveInvoice rh Invoice.OPEN chan
+    alice <- getLndEnv Alice
+    let pr = AddInvoice.paymentRequest inv
+    let spr = SendPaymentRequest pr $ MSat 1000000
+    void $ liftLndResult =<< sendPayment alice spr
+    res <- receiveInvoice rh Invoice.SETTLED chan
+    liftIO $ res `shouldSatisfy` isRight
+  it "addHodlInvoice" $ withEnv $ do
+    lnd <- getLndEnv Bob
+    r <- newRPreimage
+    let req =
+          AddHodlInvoiceRequest
+            { memo = Just "HELLO",
+              hash = newRHash r,
+              valueMsat = MSat 1000000,
+              expiry = Just $ Seconds 1000
+            }
+    x0 <- addHodlInvoice lnd req
+    x1 <- ensureHodlInvoice lnd req
+    liftIO $ do
+      x0 `shouldSatisfy` isRight
+      x0 `shouldBe` AddInvoice.paymentRequest <$> x1
+  it "watchNormal" $ withEnv $ do
+    bob <- getLndEnv Bob
+    w <- Watcher.spawnLink bob subscribeInvoicesChan ignore3
+    chan <- Watcher.dupLndTChan w
+    Watcher.watch w subscribeInvoicesRequest
+    inv <- liftLndResult =<< addInvoice bob addInvoiceRequest
+    res <-
+      receiveInvoice
+        (AddInvoice.rHash inv)
+        Invoice.OPEN
+        chan
+    Watcher.delete w
+    liftIO $ res `shouldSatisfy` isRight
+  it "watchUnit" $ withEnv $ do
+    bob <- getLndEnv Bob
+    alice <- getLndEnv Alice
+    w <- Watcher.spawnLinkUnit bob subscribeChannelEventsChan ignore2
+    chan <- Watcher.dupLndTChan w
+    Watcher.watchUnit w
+    GetInfoResponse bobPubKey _ _ <- liftLndResult =<< getInfo bob
+    let openChannelRequest =
+          OpenChannelRequest
+            { nodePubkey = bobPubKey,
+              localFundingAmount = MSat 20000000,
+              pushSat = Just $ MSat 1000000,
+              targetConf = Nothing,
+              satPerByte = Nothing,
+              private = Nothing,
+              minHtlcMsat = Nothing,
+              remoteCsvDelay = Nothing,
+              minConfs = Nothing,
+              spendUnconfirmed = Nothing,
+              closeAddress = Nothing
+            }
+    cp <- liftLndResult =<< openChannelSync alice openChannelRequest
+    res <- receiveActiveChannel proxyOwner cp chan
+    Watcher.delete w
+    liftIO $ res `shouldSatisfy` isRight
+  it "unWatch" $ withEnv $ do
+    lnd <- getLndEnv Bob
+    w <-
+      Watcher.spawnLink
+        lnd
+        subscribeInvoicesChan
+        -- can unWatch from the callback
+        $ \w k _ -> Watcher.unWatch w k
+    chan <- Watcher.dupLndTChan w
+    Watcher.watch w subscribeInvoicesRequest
+    void . liftLndResult =<< addInvoice lnd addInvoiceRequest
+    -- can unWatch from the outside as well
+    Watcher.unWatch w subscribeInvoicesRequest
+    purgeChan chan
+    void . liftLndResult =<< addInvoice lnd addInvoiceRequest
+    res <- readTChanTimeout (MicroSecondsDelay 500000) chan
+    Watcher.delete w
+    liftIO $ res `shouldBe` Nothing
+  it "ensureHodlInvoice" $ withEnv $ do
+    r <- newRPreimage
+    let req =
+          AddHodlInvoiceRequest
+            { memo = Just "HELLO",
+              hash = newRHash r,
+              valueMsat = MSat 1000000,
+              expiry = Just $ Seconds 1000
+            }
+    bob <- getLndEnv Bob
+    res <- ensureHodlInvoice bob req
+    liftIO $ res `shouldSatisfy` isRight
+  it "cancelInvoice" $ withEnv $ do
+    void $ setupOneChannel Alice Bob
+    r <- newRPreimage
+    let rh = newRHash r
+    let hipr =
+          AddHodlInvoiceRequest
+            Nothing
+            rh
+            (MSat 1000000)
+            Nothing
+    bob <- getLndEnv Bob
+    q <- getInvoiceTChan Bob
+    qq <- getSingleInvoiceTChan Bob
+    pr <-
+      liftLndResult
+        =<< addHodlInvoice bob hipr
+    watchSingleInvoice Bob rh
+    liftLndResult
+      =<< receiveInvoice rh Invoice.OPEN q
+    let spr = SendPaymentRequest pr $ MSat 1000000
+    alice <- getLndEnv Alice
+    withSpawnLink
+      (liftLndResult =<< sendPayment alice spr)
+      ( const $ do
+          --
+          -- NOTE : this is working only in coingaming LND fork
+          -- which is fixing this bug
+          -- https://github.com/lightningnetwork/lnd/issues/4544
+          --
+          liftLndResult
+            =<< receiveInvoice rh Invoice.ACCEPTED qq
+          res <- cancelInvoice bob rh
+          liftLndResult
+            =<< receiveInvoice rh Invoice.CANCELED qq
+          liftIO $ res `shouldSatisfy` isRight
+      )
+  it "settleInvoice" $ withEnv $ do
+    void $ setupOneChannel Alice Bob
+    r <- newRPreimage
+    let rh = newRHash r
+    let hipr =
+          AddHodlInvoiceRequest Nothing rh (MSat 1000000) Nothing
+    bob <- getLndEnv Bob
+    q <- getInvoiceTChan Bob
+    qq <- getSingleInvoiceTChan Bob
+    pr <- liftLndResult =<< addHodlInvoice bob hipr
+    watchSingleInvoice Bob rh
+    liftLndResult
+      =<< receiveInvoice rh Invoice.OPEN q
+    let spr = SendPaymentRequest pr $ MSat 1000000
+    alice <- getLndEnv Alice
+    withSpawnLink
+      (liftLndResult =<< sendPayment alice spr)
+      ( const $ do
+          --
+          -- NOTE : this is working only in coingaming LND fork
+          -- which is fixing this bug
+          -- https://github.com/lightningnetwork/lnd/issues/4544
+          --
+          liftLndResult
+            =<< receiveInvoice rh Invoice.ACCEPTED qq
+          res <- settleInvoice bob r
+          liftLndResult
+            =<< receiveInvoice rh Invoice.SETTLED qq
+          liftIO $ res `shouldSatisfy` isRight
+      )
+  it "listInvoices" $ withEnv $ do
+    lnd <- getLndEnv Bob
+    rh <-
+      AddInvoice.rHash
+        <$> (liftLndResult =<< addInvoice lnd addInvoiceRequest)
+    let listReq =
+          ListInvoiceRequest
+            { pendingOnly = False,
+              indexOffset = AddIndex 0,
+              numMaxInvoices = 0,
+              reversed = False
+            }
+    xs <-
+      ListInvoices.invoices
+        <$> (liftLndResult =<< listInvoices lnd listReq)
+    liftIO $ xs `shouldSatisfy` any ((rh ==) . Invoice.rHash)
+  it "listChannelAndClose" $ withEnv $ do
+    void $ setupOneChannel Alice Bob
+    lnd <- getLndEnv Bob
+    let listReq = ListChannelsRequest False False False False Nothing
+    cs0 <- liftLndResult =<< listChannels lnd listReq
+    lazyConnectNodes proxyOwner
+    cp <-
+      liftMaybe "ChannelPoint is required" $
+        Channel.channelPoint <$> safeHead cs0
+    withSpawnLink
+      ( closeChannel
+          (const $ return ())
+          lnd
+          (CloseChannelRequest cp False Nothing Nothing Nothing)
+      )
+      ( const $ do
+          liftLndResult =<< receiveClosedChannels proxyOwner [cp]
+          cs1 <- liftLndResult =<< listChannels lnd listReq
+          liftIO $ (length cs0 - length cs1) `shouldBe` 1
+      )
+  it "closedChannels" $ withEnv $ do
+    cp <- setupOneChannel Alice Bob
+    closeAllChannels proxyOwner
+    lnd <- getLndEnv Bob
+    res <- closedChannels lnd ClosedChannels.defReq
+    liftIO $
+      res
+        `shouldSatisfy` ( \case
+                            Left {} -> False
+                            Right xs -> any ((cp ==) . CloseChannel.chPoint) xs
+                        )
+  where
+    --
+    -- TODO : fix this, it's not really working for some reason
+    -- LND says "payment isn't initiated" error in logs
+    --
+    --it "trackPaymentV2" $ withEnv $ do
+    --  setupOneChannel
+    --  --
+    --  -- prepare invoice and subscription
+    --  --
+    --  bob <- getLndEnv Bob
+    --  inv <- liftLndResult =<< addInvoice bob addInvoiceRequest
+    --  let rh = AddInvoice.rHash inv
+    --  let pr = AddInvoice.paymentRequest inv
+    --  let spr = SendPaymentRequest pr $ MSat 1000
+    --  --
+    --  -- spawn payment watcher and settle invoice
+    --  --
+    --  w <- Watcher.spawnLink bob trackPaymentV2Chan $ \_ _ _ -> pure ()
+    --  chan <- Watcher.dupLndTChan w
+    --  Watcher.watch w $ TrackPaymentRequest rh False
+    --  alice <- getLndEnv Alice
+    --  void $ liftLndResult =<< sendPayment alice spr
+    --  res <- readTChanTimeout (MicroSecondsDelay 500000) chan
+    --  Watcher.delete w
+    --  liftIO $ res `shouldSatisfy` isJust
+    subscribeInvoicesRequest =
+      SubscribeInvoicesRequest (Just $ AddIndex 1) Nothing
+    addInvoiceRequest =
+      AddInvoiceRequest
+        { memo = Just "HELLO",
+          valueMsat = MSat 1000000,
+          expiry = Just $ Seconds 1000
+        }
diff --git a/test/LndClient/TestApp.hs b/test/LndClient/TestApp.hs
new file mode 100644
--- /dev/null
+++ b/test/LndClient/TestApp.hs
@@ -0,0 +1,160 @@
+{-# LANGUAGE DeriveFunctor #-}
+{-# LANGUAGE DuplicateRecordFields #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE GeneralisedNewtypeDeriving #-}
+{-# LANGUAGE LambdaCase #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeFamilies #-}
+
+module LndClient.TestApp
+  ( withEnv,
+    Owner (..),
+    proxyOwner,
+  )
+where
+
+import LndClient.Data.LndEnv
+import LndClient.Import
+import LndClient.LndTest
+import qualified Network.Bitcoin as BTC (Client)
+import Network.GRPC.Client.Helpers (GrpcClientConfig (..))
+
+data Env
+  = Env
+      { envAlice :: TestEnv,
+        envBob :: TestEnv,
+        envBtc :: BTC.Client,
+        envKatipNS :: Namespace,
+        envKatipCTX :: LogContexts,
+        envKatipLE :: LogEnv
+      }
+
+data Owner = Alice | Bob
+  deriving (Eq, Ord, Show, Bounded, Enum)
+
+proxyOwner :: Proxy Owner
+proxyOwner = Proxy
+
+newBobEnv :: LndEnv -> LndEnv
+newBobEnv x =
+  x
+    { envLndConfig =
+        (envLndConfig x)
+          { _grpcClientConfigPort = 11009
+          },
+      envLndCipherSeedMnemonic =
+        Just $
+          CipherSeedMnemonic
+            [ "absent",
+              "betray",
+              "direct",
+              "scheme",
+              "sunset",
+              "mechanic",
+              "exhaust",
+              "suggest",
+              "boy",
+              "arena",
+              "sketch",
+              "bone",
+              "news",
+              "south",
+              "way",
+              "survey",
+              "clip",
+              "dutch",
+              "depart",
+              "green",
+              "furnace",
+              "wire",
+              "wave",
+              "fall"
+            ],
+      envLndAezeedPassphrase = Nothing
+    }
+
+readEnv :: IO Env
+readEnv = do
+  handleScribe <-
+    mkHandleScribeWithFormatter
+      bracketFormat
+      ColorIfTerminal
+      stdout
+      (permitItem DebugS)
+      V2
+  le <-
+    registerScribe "stdout" handleScribe defaultScribeSettings
+      =<< initLogEnv "LndClient" "test"
+  bc <- newBtcClient btcEnv
+  aliceLndEnv <- liftIO readLndEnv
+  runKatipContextT le (mempty :: LogContexts) mempty $ do
+    alice <-
+      newTestEnv
+        aliceLndEnv
+        $ NodeLocation "localhost:9735"
+    bob <-
+      newTestEnv
+        (newBobEnv aliceLndEnv)
+        $ NodeLocation "localhost:9734"
+    pure
+      Env
+        { envAlice = alice,
+          envBob = bob,
+          envBtc = bc,
+          envKatipLE = le,
+          envKatipCTX = mempty,
+          envKatipNS = mempty
+        }
+
+withEnv :: AppM IO () -> IO ()
+withEnv this = do
+  env <- readEnv
+  runApp env $ setupZeroChannels proxyOwner >> this
+  void . closeScribes $ envKatipLE env
+
+btcEnv :: BtcEnv
+btcEnv =
+  BtcEnv
+    { btcUrl = BtcUrl "http://localhost:18443",
+      btcLogin = BtcLogin "developer",
+      btcPassword = BtcPassword "developer"
+    }
+
+newtype AppM m a
+  = AppM
+      { unAppM :: ReaderT Env m a
+      }
+  deriving (Functor, Applicative, Monad, MonadIO, MonadReader Env)
+
+instance (MonadUnliftIO m) => MonadUnliftIO (AppM m) where
+  withRunInIO run = AppM (withRunInIO (\k -> run (k . unAppM)))
+  askUnliftIO =
+    AppM
+      ( fmap
+          (\(UnliftIO run) -> UnliftIO (run . unAppM))
+          askUnliftIO
+      )
+
+instance (MonadIO m) => Katip (AppM m) where
+  getLogEnv = asks envKatipLE
+  localLogEnv f (AppM m) =
+    AppM (local (\s -> s {envKatipLE = f (envKatipLE s)}) m)
+
+instance (MonadIO m) => KatipContext (AppM m) where
+  getKatipContext = asks envKatipCTX
+  localKatipContext f (AppM m) =
+    AppM (local (\s -> s {envKatipCTX = f (envKatipCTX s)}) m)
+  getKatipNamespace = asks envKatipNS
+  localKatipNamespace f (AppM m) =
+    AppM (local (\s -> s {envKatipNS = f (envKatipNS s)}) m)
+
+instance (MonadUnliftIO m) => LndTest (AppM m) Owner where
+  getBtcClient = const $ asks envBtc
+  getTestEnv = \case
+    Alice -> asks envAlice
+    Bob -> asks envBob
+
+runApp :: Env -> AppM m a -> m a
+runApp env app = runReaderT (unAppM app) env
diff --git a/test/Spec.hs b/test/Spec.hs
new file mode 100644
--- /dev/null
+++ b/test/Spec.hs
@@ -0,0 +1,2 @@
+{-# OPTIONS_GHC -Wno-missing-export-lists #-}
+{-# OPTIONS_GHC -F -pgmF hspec-discover #-}