You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1226 lines
56 KiB
1226 lines
56 KiB
# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
|
|
import grpc
|
|
|
|
import rpc_pb2 as rpc__pb2
|
|
|
|
|
|
class WalletUnlockerStub(object):
|
|
"""*
|
|
Comments in this file will be directly parsed into the API
|
|
Documentation as descriptions of the associated method, message, or field.
|
|
These descriptions should go right above the definition of the object, and
|
|
can be in either block or /// comment format.
|
|
|
|
One edge case exists where a // comment followed by a /// comment in the
|
|
next line will cause the description not to show up in the documentation. In
|
|
that instance, simply separate the two comments with a blank line.
|
|
|
|
An RPC method can be matched to an lncli command by placing a line in the
|
|
beginning of the description in exactly the following format:
|
|
lncli: `methodname`
|
|
|
|
Failure to specify the exact name of the command will cause documentation
|
|
generation to fail.
|
|
|
|
More information on how exactly the gRPC documentation is generated from
|
|
this proto file can be found here:
|
|
https://github.com/lightninglabs/lightning-api
|
|
|
|
The WalletUnlocker service is used to set up a wallet password for
|
|
lnd at first startup, and unlock a previously set up wallet.
|
|
"""
|
|
|
|
def __init__(self, channel):
|
|
"""Constructor.
|
|
|
|
Args:
|
|
channel: A grpc.Channel.
|
|
"""
|
|
self.GenSeed = channel.unary_unary(
|
|
'/lnrpc.WalletUnlocker/GenSeed',
|
|
request_serializer=rpc__pb2.GenSeedRequest.SerializeToString,
|
|
response_deserializer=rpc__pb2.GenSeedResponse.FromString,
|
|
)
|
|
self.InitWallet = channel.unary_unary(
|
|
'/lnrpc.WalletUnlocker/InitWallet',
|
|
request_serializer=rpc__pb2.InitWalletRequest.SerializeToString,
|
|
response_deserializer=rpc__pb2.InitWalletResponse.FromString,
|
|
)
|
|
self.UnlockWallet = channel.unary_unary(
|
|
'/lnrpc.WalletUnlocker/UnlockWallet',
|
|
request_serializer=rpc__pb2.UnlockWalletRequest.SerializeToString,
|
|
response_deserializer=rpc__pb2.UnlockWalletResponse.FromString,
|
|
)
|
|
self.ChangePassword = channel.unary_unary(
|
|
'/lnrpc.WalletUnlocker/ChangePassword',
|
|
request_serializer=rpc__pb2.ChangePasswordRequest.SerializeToString,
|
|
response_deserializer=rpc__pb2.ChangePasswordResponse.FromString,
|
|
)
|
|
|
|
|
|
class WalletUnlockerServicer(object):
|
|
"""*
|
|
Comments in this file will be directly parsed into the API
|
|
Documentation as descriptions of the associated method, message, or field.
|
|
These descriptions should go right above the definition of the object, and
|
|
can be in either block or /// comment format.
|
|
|
|
One edge case exists where a // comment followed by a /// comment in the
|
|
next line will cause the description not to show up in the documentation. In
|
|
that instance, simply separate the two comments with a blank line.
|
|
|
|
An RPC method can be matched to an lncli command by placing a line in the
|
|
beginning of the description in exactly the following format:
|
|
lncli: `methodname`
|
|
|
|
Failure to specify the exact name of the command will cause documentation
|
|
generation to fail.
|
|
|
|
More information on how exactly the gRPC documentation is generated from
|
|
this proto file can be found here:
|
|
https://github.com/lightninglabs/lightning-api
|
|
|
|
The WalletUnlocker service is used to set up a wallet password for
|
|
lnd at first startup, and unlock a previously set up wallet.
|
|
"""
|
|
|
|
def GenSeed(self, request, context):
|
|
"""*
|
|
GenSeed is the first method that should be used to instantiate a new lnd
|
|
instance. This method allows a caller to generate a new aezeed cipher seed
|
|
given an optional passphrase. If provided, the passphrase will be necessary
|
|
to decrypt the cipherseed to expose the internal wallet seed.
|
|
|
|
Once the cipherseed is obtained and verified by the user, the InitWallet
|
|
method should be used to commit the newly generated seed, and create the
|
|
wallet.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def InitWallet(self, request, context):
|
|
"""*
|
|
InitWallet is used when lnd is starting up for the first time to fully
|
|
initialize the daemon and its internal wallet. At the very least a wallet
|
|
password must be provided. This will be used to encrypt sensitive material
|
|
on disk.
|
|
|
|
In the case of a recovery scenario, the user can also specify their aezeed
|
|
mnemonic and passphrase. If set, then the daemon will use this prior state
|
|
to initialize its internal wallet.
|
|
|
|
Alternatively, this can be used along with the GenSeed RPC to obtain a
|
|
seed, then present it to the user. Once it has been verified by the user,
|
|
the seed can be fed into this RPC in order to commit the new wallet.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def UnlockWallet(self, request, context):
|
|
"""* lncli: `unlock`
|
|
UnlockWallet is used at startup of lnd to provide a password to unlock
|
|
the wallet database.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def ChangePassword(self, request, context):
|
|
"""* lncli: `changepassword`
|
|
ChangePassword changes the password of the encrypted wallet. This will
|
|
automatically unlock the wallet database if successful.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
|
|
def add_WalletUnlockerServicer_to_server(servicer, server):
|
|
rpc_method_handlers = {
|
|
'GenSeed': grpc.unary_unary_rpc_method_handler(
|
|
servicer.GenSeed,
|
|
request_deserializer=rpc__pb2.GenSeedRequest.FromString,
|
|
response_serializer=rpc__pb2.GenSeedResponse.SerializeToString,
|
|
),
|
|
'InitWallet': grpc.unary_unary_rpc_method_handler(
|
|
servicer.InitWallet,
|
|
request_deserializer=rpc__pb2.InitWalletRequest.FromString,
|
|
response_serializer=rpc__pb2.InitWalletResponse.SerializeToString,
|
|
),
|
|
'UnlockWallet': grpc.unary_unary_rpc_method_handler(
|
|
servicer.UnlockWallet,
|
|
request_deserializer=rpc__pb2.UnlockWalletRequest.FromString,
|
|
response_serializer=rpc__pb2.UnlockWalletResponse.SerializeToString,
|
|
),
|
|
'ChangePassword': grpc.unary_unary_rpc_method_handler(
|
|
servicer.ChangePassword,
|
|
request_deserializer=rpc__pb2.ChangePasswordRequest.FromString,
|
|
response_serializer=rpc__pb2.ChangePasswordResponse.SerializeToString,
|
|
),
|
|
}
|
|
generic_handler = grpc.method_handlers_generic_handler(
|
|
'lnrpc.WalletUnlocker', rpc_method_handlers)
|
|
server.add_generic_rpc_handlers((generic_handler,))
|
|
|
|
|
|
class LightningStub(object):
|
|
# missing associated documentation comment in .proto file
|
|
pass
|
|
|
|
def __init__(self, channel):
|
|
"""Constructor.
|
|
|
|
Args:
|
|
channel: A grpc.Channel.
|
|
"""
|
|
self.WalletBalance = channel.unary_unary(
|
|
'/lnrpc.Lightning/WalletBalance',
|
|
request_serializer=rpc__pb2.WalletBalanceRequest.SerializeToString,
|
|
response_deserializer=rpc__pb2.WalletBalanceResponse.FromString,
|
|
)
|
|
self.ChannelBalance = channel.unary_unary(
|
|
'/lnrpc.Lightning/ChannelBalance',
|
|
request_serializer=rpc__pb2.ChannelBalanceRequest.SerializeToString,
|
|
response_deserializer=rpc__pb2.ChannelBalanceResponse.FromString,
|
|
)
|
|
self.GetTransactions = channel.unary_unary(
|
|
'/lnrpc.Lightning/GetTransactions',
|
|
request_serializer=rpc__pb2.GetTransactionsRequest.SerializeToString,
|
|
response_deserializer=rpc__pb2.TransactionDetails.FromString,
|
|
)
|
|
self.EstimateFee = channel.unary_unary(
|
|
'/lnrpc.Lightning/EstimateFee',
|
|
request_serializer=rpc__pb2.EstimateFeeRequest.SerializeToString,
|
|
response_deserializer=rpc__pb2.EstimateFeeResponse.FromString,
|
|
)
|
|
self.SendCoins = channel.unary_unary(
|
|
'/lnrpc.Lightning/SendCoins',
|
|
request_serializer=rpc__pb2.SendCoinsRequest.SerializeToString,
|
|
response_deserializer=rpc__pb2.SendCoinsResponse.FromString,
|
|
)
|
|
self.ListUnspent = channel.unary_unary(
|
|
'/lnrpc.Lightning/ListUnspent',
|
|
request_serializer=rpc__pb2.ListUnspentRequest.SerializeToString,
|
|
response_deserializer=rpc__pb2.ListUnspentResponse.FromString,
|
|
)
|
|
self.SubscribeTransactions = channel.unary_stream(
|
|
'/lnrpc.Lightning/SubscribeTransactions',
|
|
request_serializer=rpc__pb2.GetTransactionsRequest.SerializeToString,
|
|
response_deserializer=rpc__pb2.Transaction.FromString,
|
|
)
|
|
self.SendMany = channel.unary_unary(
|
|
'/lnrpc.Lightning/SendMany',
|
|
request_serializer=rpc__pb2.SendManyRequest.SerializeToString,
|
|
response_deserializer=rpc__pb2.SendManyResponse.FromString,
|
|
)
|
|
self.NewAddress = channel.unary_unary(
|
|
'/lnrpc.Lightning/NewAddress',
|
|
request_serializer=rpc__pb2.NewAddressRequest.SerializeToString,
|
|
response_deserializer=rpc__pb2.NewAddressResponse.FromString,
|
|
)
|
|
self.SignMessage = channel.unary_unary(
|
|
'/lnrpc.Lightning/SignMessage',
|
|
request_serializer=rpc__pb2.SignMessageRequest.SerializeToString,
|
|
response_deserializer=rpc__pb2.SignMessageResponse.FromString,
|
|
)
|
|
self.VerifyMessage = channel.unary_unary(
|
|
'/lnrpc.Lightning/VerifyMessage',
|
|
request_serializer=rpc__pb2.VerifyMessageRequest.SerializeToString,
|
|
response_deserializer=rpc__pb2.VerifyMessageResponse.FromString,
|
|
)
|
|
self.ConnectPeer = channel.unary_unary(
|
|
'/lnrpc.Lightning/ConnectPeer',
|
|
request_serializer=rpc__pb2.ConnectPeerRequest.SerializeToString,
|
|
response_deserializer=rpc__pb2.ConnectPeerResponse.FromString,
|
|
)
|
|
self.DisconnectPeer = channel.unary_unary(
|
|
'/lnrpc.Lightning/DisconnectPeer',
|
|
request_serializer=rpc__pb2.DisconnectPeerRequest.SerializeToString,
|
|
response_deserializer=rpc__pb2.DisconnectPeerResponse.FromString,
|
|
)
|
|
self.ListPeers = channel.unary_unary(
|
|
'/lnrpc.Lightning/ListPeers',
|
|
request_serializer=rpc__pb2.ListPeersRequest.SerializeToString,
|
|
response_deserializer=rpc__pb2.ListPeersResponse.FromString,
|
|
)
|
|
self.GetInfo = channel.unary_unary(
|
|
'/lnrpc.Lightning/GetInfo',
|
|
request_serializer=rpc__pb2.GetInfoRequest.SerializeToString,
|
|
response_deserializer=rpc__pb2.GetInfoResponse.FromString,
|
|
)
|
|
self.PendingChannels = channel.unary_unary(
|
|
'/lnrpc.Lightning/PendingChannels',
|
|
request_serializer=rpc__pb2.PendingChannelsRequest.SerializeToString,
|
|
response_deserializer=rpc__pb2.PendingChannelsResponse.FromString,
|
|
)
|
|
self.ListChannels = channel.unary_unary(
|
|
'/lnrpc.Lightning/ListChannels',
|
|
request_serializer=rpc__pb2.ListChannelsRequest.SerializeToString,
|
|
response_deserializer=rpc__pb2.ListChannelsResponse.FromString,
|
|
)
|
|
self.SubscribeChannelEvents = channel.unary_stream(
|
|
'/lnrpc.Lightning/SubscribeChannelEvents',
|
|
request_serializer=rpc__pb2.ChannelEventSubscription.SerializeToString,
|
|
response_deserializer=rpc__pb2.ChannelEventUpdate.FromString,
|
|
)
|
|
self.ClosedChannels = channel.unary_unary(
|
|
'/lnrpc.Lightning/ClosedChannels',
|
|
request_serializer=rpc__pb2.ClosedChannelsRequest.SerializeToString,
|
|
response_deserializer=rpc__pb2.ClosedChannelsResponse.FromString,
|
|
)
|
|
self.OpenChannelSync = channel.unary_unary(
|
|
'/lnrpc.Lightning/OpenChannelSync',
|
|
request_serializer=rpc__pb2.OpenChannelRequest.SerializeToString,
|
|
response_deserializer=rpc__pb2.ChannelPoint.FromString,
|
|
)
|
|
self.OpenChannel = channel.unary_stream(
|
|
'/lnrpc.Lightning/OpenChannel',
|
|
request_serializer=rpc__pb2.OpenChannelRequest.SerializeToString,
|
|
response_deserializer=rpc__pb2.OpenStatusUpdate.FromString,
|
|
)
|
|
self.CloseChannel = channel.unary_stream(
|
|
'/lnrpc.Lightning/CloseChannel',
|
|
request_serializer=rpc__pb2.CloseChannelRequest.SerializeToString,
|
|
response_deserializer=rpc__pb2.CloseStatusUpdate.FromString,
|
|
)
|
|
self.AbandonChannel = channel.unary_unary(
|
|
'/lnrpc.Lightning/AbandonChannel',
|
|
request_serializer=rpc__pb2.AbandonChannelRequest.SerializeToString,
|
|
response_deserializer=rpc__pb2.AbandonChannelResponse.FromString,
|
|
)
|
|
self.SendPayment = channel.stream_stream(
|
|
'/lnrpc.Lightning/SendPayment',
|
|
request_serializer=rpc__pb2.SendRequest.SerializeToString,
|
|
response_deserializer=rpc__pb2.SendResponse.FromString,
|
|
)
|
|
self.SendPaymentSync = channel.unary_unary(
|
|
'/lnrpc.Lightning/SendPaymentSync',
|
|
request_serializer=rpc__pb2.SendRequest.SerializeToString,
|
|
response_deserializer=rpc__pb2.SendResponse.FromString,
|
|
)
|
|
self.SendToRoute = channel.stream_stream(
|
|
'/lnrpc.Lightning/SendToRoute',
|
|
request_serializer=rpc__pb2.SendToRouteRequest.SerializeToString,
|
|
response_deserializer=rpc__pb2.SendResponse.FromString,
|
|
)
|
|
self.SendToRouteSync = channel.unary_unary(
|
|
'/lnrpc.Lightning/SendToRouteSync',
|
|
request_serializer=rpc__pb2.SendToRouteRequest.SerializeToString,
|
|
response_deserializer=rpc__pb2.SendResponse.FromString,
|
|
)
|
|
self.AddInvoice = channel.unary_unary(
|
|
'/lnrpc.Lightning/AddInvoice',
|
|
request_serializer=rpc__pb2.Invoice.SerializeToString,
|
|
response_deserializer=rpc__pb2.AddInvoiceResponse.FromString,
|
|
)
|
|
self.ListInvoices = channel.unary_unary(
|
|
'/lnrpc.Lightning/ListInvoices',
|
|
request_serializer=rpc__pb2.ListInvoiceRequest.SerializeToString,
|
|
response_deserializer=rpc__pb2.ListInvoiceResponse.FromString,
|
|
)
|
|
self.LookupInvoice = channel.unary_unary(
|
|
'/lnrpc.Lightning/LookupInvoice',
|
|
request_serializer=rpc__pb2.PaymentHash.SerializeToString,
|
|
response_deserializer=rpc__pb2.Invoice.FromString,
|
|
)
|
|
self.SubscribeInvoices = channel.unary_stream(
|
|
'/lnrpc.Lightning/SubscribeInvoices',
|
|
request_serializer=rpc__pb2.InvoiceSubscription.SerializeToString,
|
|
response_deserializer=rpc__pb2.Invoice.FromString,
|
|
)
|
|
self.DecodePayReq = channel.unary_unary(
|
|
'/lnrpc.Lightning/DecodePayReq',
|
|
request_serializer=rpc__pb2.PayReqString.SerializeToString,
|
|
response_deserializer=rpc__pb2.PayReq.FromString,
|
|
)
|
|
self.ListPayments = channel.unary_unary(
|
|
'/lnrpc.Lightning/ListPayments',
|
|
request_serializer=rpc__pb2.ListPaymentsRequest.SerializeToString,
|
|
response_deserializer=rpc__pb2.ListPaymentsResponse.FromString,
|
|
)
|
|
self.DeleteAllPayments = channel.unary_unary(
|
|
'/lnrpc.Lightning/DeleteAllPayments',
|
|
request_serializer=rpc__pb2.DeleteAllPaymentsRequest.SerializeToString,
|
|
response_deserializer=rpc__pb2.DeleteAllPaymentsResponse.FromString,
|
|
)
|
|
self.DescribeGraph = channel.unary_unary(
|
|
'/lnrpc.Lightning/DescribeGraph',
|
|
request_serializer=rpc__pb2.ChannelGraphRequest.SerializeToString,
|
|
response_deserializer=rpc__pb2.ChannelGraph.FromString,
|
|
)
|
|
self.GetChanInfo = channel.unary_unary(
|
|
'/lnrpc.Lightning/GetChanInfo',
|
|
request_serializer=rpc__pb2.ChanInfoRequest.SerializeToString,
|
|
response_deserializer=rpc__pb2.ChannelEdge.FromString,
|
|
)
|
|
self.GetNodeInfo = channel.unary_unary(
|
|
'/lnrpc.Lightning/GetNodeInfo',
|
|
request_serializer=rpc__pb2.NodeInfoRequest.SerializeToString,
|
|
response_deserializer=rpc__pb2.NodeInfo.FromString,
|
|
)
|
|
self.QueryRoutes = channel.unary_unary(
|
|
'/lnrpc.Lightning/QueryRoutes',
|
|
request_serializer=rpc__pb2.QueryRoutesRequest.SerializeToString,
|
|
response_deserializer=rpc__pb2.QueryRoutesResponse.FromString,
|
|
)
|
|
self.GetNetworkInfo = channel.unary_unary(
|
|
'/lnrpc.Lightning/GetNetworkInfo',
|
|
request_serializer=rpc__pb2.NetworkInfoRequest.SerializeToString,
|
|
response_deserializer=rpc__pb2.NetworkInfo.FromString,
|
|
)
|
|
self.StopDaemon = channel.unary_unary(
|
|
'/lnrpc.Lightning/StopDaemon',
|
|
request_serializer=rpc__pb2.StopRequest.SerializeToString,
|
|
response_deserializer=rpc__pb2.StopResponse.FromString,
|
|
)
|
|
self.SubscribeChannelGraph = channel.unary_stream(
|
|
'/lnrpc.Lightning/SubscribeChannelGraph',
|
|
request_serializer=rpc__pb2.GraphTopologySubscription.SerializeToString,
|
|
response_deserializer=rpc__pb2.GraphTopologyUpdate.FromString,
|
|
)
|
|
self.DebugLevel = channel.unary_unary(
|
|
'/lnrpc.Lightning/DebugLevel',
|
|
request_serializer=rpc__pb2.DebugLevelRequest.SerializeToString,
|
|
response_deserializer=rpc__pb2.DebugLevelResponse.FromString,
|
|
)
|
|
self.FeeReport = channel.unary_unary(
|
|
'/lnrpc.Lightning/FeeReport',
|
|
request_serializer=rpc__pb2.FeeReportRequest.SerializeToString,
|
|
response_deserializer=rpc__pb2.FeeReportResponse.FromString,
|
|
)
|
|
self.UpdateChannelPolicy = channel.unary_unary(
|
|
'/lnrpc.Lightning/UpdateChannelPolicy',
|
|
request_serializer=rpc__pb2.PolicyUpdateRequest.SerializeToString,
|
|
response_deserializer=rpc__pb2.PolicyUpdateResponse.FromString,
|
|
)
|
|
self.ForwardingHistory = channel.unary_unary(
|
|
'/lnrpc.Lightning/ForwardingHistory',
|
|
request_serializer=rpc__pb2.ForwardingHistoryRequest.SerializeToString,
|
|
response_deserializer=rpc__pb2.ForwardingHistoryResponse.FromString,
|
|
)
|
|
self.ExportChannelBackup = channel.unary_unary(
|
|
'/lnrpc.Lightning/ExportChannelBackup',
|
|
request_serializer=rpc__pb2.ExportChannelBackupRequest.SerializeToString,
|
|
response_deserializer=rpc__pb2.ChannelBackup.FromString,
|
|
)
|
|
self.ExportAllChannelBackups = channel.unary_unary(
|
|
'/lnrpc.Lightning/ExportAllChannelBackups',
|
|
request_serializer=rpc__pb2.ChanBackupExportRequest.SerializeToString,
|
|
response_deserializer=rpc__pb2.ChanBackupSnapshot.FromString,
|
|
)
|
|
self.VerifyChanBackup = channel.unary_unary(
|
|
'/lnrpc.Lightning/VerifyChanBackup',
|
|
request_serializer=rpc__pb2.ChanBackupSnapshot.SerializeToString,
|
|
response_deserializer=rpc__pb2.VerifyChanBackupResponse.FromString,
|
|
)
|
|
self.RestoreChannelBackups = channel.unary_unary(
|
|
'/lnrpc.Lightning/RestoreChannelBackups',
|
|
request_serializer=rpc__pb2.RestoreChanBackupRequest.SerializeToString,
|
|
response_deserializer=rpc__pb2.RestoreBackupResponse.FromString,
|
|
)
|
|
self.SubscribeChannelBackups = channel.unary_stream(
|
|
'/lnrpc.Lightning/SubscribeChannelBackups',
|
|
request_serializer=rpc__pb2.ChannelBackupSubscription.SerializeToString,
|
|
response_deserializer=rpc__pb2.ChanBackupSnapshot.FromString,
|
|
)
|
|
|
|
|
|
class LightningServicer(object):
|
|
# missing associated documentation comment in .proto file
|
|
pass
|
|
|
|
def WalletBalance(self, request, context):
|
|
"""* lncli: `walletbalance`
|
|
WalletBalance returns total unspent outputs(confirmed and unconfirmed), all
|
|
confirmed unspent outputs and all unconfirmed unspent outputs under control
|
|
of the wallet.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def ChannelBalance(self, request, context):
|
|
"""* lncli: `channelbalance`
|
|
ChannelBalance returns the total funds available across all open channels
|
|
in satoshis.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def GetTransactions(self, request, context):
|
|
"""* lncli: `listchaintxns`
|
|
GetTransactions returns a list describing all the known transactions
|
|
relevant to the wallet.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def EstimateFee(self, request, context):
|
|
"""* lncli: `estimatefee`
|
|
EstimateFee asks the chain backend to estimate the fee rate and total fees
|
|
for a transaction that pays to multiple specified outputs.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def SendCoins(self, request, context):
|
|
"""* lncli: `sendcoins`
|
|
SendCoins executes a request to send coins to a particular address. Unlike
|
|
SendMany, this RPC call only allows creating a single output at a time. If
|
|
neither target_conf, or sat_per_byte are set, then the internal wallet will
|
|
consult its fee model to determine a fee for the default confirmation
|
|
target.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def ListUnspent(self, request, context):
|
|
"""* lncli: `listunspent`
|
|
ListUnspent returns a list of all utxos spendable by the wallet with a
|
|
number of confirmations between the specified minimum and maximum.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def SubscribeTransactions(self, request, context):
|
|
"""*
|
|
SubscribeTransactions creates a uni-directional stream from the server to
|
|
the client in which any newly discovered transactions relevant to the
|
|
wallet are sent over.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def SendMany(self, request, context):
|
|
"""* lncli: `sendmany`
|
|
SendMany handles a request for a transaction that creates multiple specified
|
|
outputs in parallel. If neither target_conf, or sat_per_byte are set, then
|
|
the internal wallet will consult its fee model to determine a fee for the
|
|
default confirmation target.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def NewAddress(self, request, context):
|
|
"""* lncli: `newaddress`
|
|
NewAddress creates a new address under control of the local wallet.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def SignMessage(self, request, context):
|
|
"""* lncli: `signmessage`
|
|
SignMessage signs a message with this node's private key. The returned
|
|
signature string is `zbase32` encoded and pubkey recoverable, meaning that
|
|
only the message digest and signature are needed for verification.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def VerifyMessage(self, request, context):
|
|
"""* lncli: `verifymessage`
|
|
VerifyMessage verifies a signature over a msg. The signature must be
|
|
zbase32 encoded and signed by an active node in the resident node's
|
|
channel database. In addition to returning the validity of the signature,
|
|
VerifyMessage also returns the recovered pubkey from the signature.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def ConnectPeer(self, request, context):
|
|
"""* lncli: `connect`
|
|
ConnectPeer attempts to establish a connection to a remote peer. This is at
|
|
the networking level, and is used for communication between nodes. This is
|
|
distinct from establishing a channel with a peer.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def DisconnectPeer(self, request, context):
|
|
"""* lncli: `disconnect`
|
|
DisconnectPeer attempts to disconnect one peer from another identified by a
|
|
given pubKey. In the case that we currently have a pending or active channel
|
|
with the target peer, then this action will be not be allowed.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def ListPeers(self, request, context):
|
|
"""* lncli: `listpeers`
|
|
ListPeers returns a verbose listing of all currently active peers.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def GetInfo(self, request, context):
|
|
"""* lncli: `getinfo`
|
|
GetInfo returns general information concerning the lightning node including
|
|
it's identity pubkey, alias, the chains it is connected to, and information
|
|
concerning the number of open+pending channels.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def PendingChannels(self, request, context):
|
|
"""TODO(roasbeef): merge with below with bool?
|
|
|
|
* lncli: `pendingchannels`
|
|
PendingChannels returns a list of all the channels that are currently
|
|
considered "pending". A channel is pending if it has finished the funding
|
|
workflow and is waiting for confirmations for the funding txn, or is in the
|
|
process of closure, either initiated cooperatively or non-cooperatively.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def ListChannels(self, request, context):
|
|
"""* lncli: `listchannels`
|
|
ListChannels returns a description of all the open channels that this node
|
|
is a participant in.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def SubscribeChannelEvents(self, request, context):
|
|
"""* lncli: `subscribechannelevents`
|
|
SubscribeChannelEvents creates a uni-directional stream from the server to
|
|
the client in which any updates relevant to the state of the channels are
|
|
sent over. Events include new active channels, inactive channels, and closed
|
|
channels.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def ClosedChannels(self, request, context):
|
|
"""* lncli: `closedchannels`
|
|
ClosedChannels returns a description of all the closed channels that
|
|
this node was a participant in.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def OpenChannelSync(self, request, context):
|
|
"""*
|
|
OpenChannelSync is a synchronous version of the OpenChannel RPC call. This
|
|
call is meant to be consumed by clients to the REST proxy. As with all
|
|
other sync calls, all byte slices are intended to be populated as hex
|
|
encoded strings.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def OpenChannel(self, request, context):
|
|
"""* lncli: `openchannel`
|
|
OpenChannel attempts to open a singly funded channel specified in the
|
|
request to a remote peer. Users are able to specify a target number of
|
|
blocks that the funding transaction should be confirmed in, or a manual fee
|
|
rate to us for the funding transaction. If neither are specified, then a
|
|
lax block confirmation target is used.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def CloseChannel(self, request, context):
|
|
"""* lncli: `closechannel`
|
|
CloseChannel attempts to close an active channel identified by its channel
|
|
outpoint (ChannelPoint). The actions of this method can additionally be
|
|
augmented to attempt a force close after a timeout period in the case of an
|
|
inactive peer. If a non-force close (cooperative closure) is requested,
|
|
then the user can specify either a target number of blocks until the
|
|
closure transaction is confirmed, or a manual fee rate. If neither are
|
|
specified, then a default lax, block confirmation target is used.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def AbandonChannel(self, request, context):
|
|
"""* lncli: `abandonchannel`
|
|
AbandonChannel removes all channel state from the database except for a
|
|
close summary. This method can be used to get rid of permanently unusable
|
|
channels due to bugs fixed in newer versions of lnd. Only available
|
|
when in debug builds of lnd.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def SendPayment(self, request_iterator, context):
|
|
"""* lncli: `sendpayment`
|
|
SendPayment dispatches a bi-directional streaming RPC for sending payments
|
|
through the Lightning Network. A single RPC invocation creates a persistent
|
|
bi-directional stream allowing clients to rapidly send payments through the
|
|
Lightning Network with a single persistent connection.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def SendPaymentSync(self, request, context):
|
|
"""*
|
|
SendPaymentSync is the synchronous non-streaming version of SendPayment.
|
|
This RPC is intended to be consumed by clients of the REST proxy.
|
|
Additionally, this RPC expects the destination's public key and the payment
|
|
hash (if any) to be encoded as hex strings.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def SendToRoute(self, request_iterator, context):
|
|
"""* lncli: `sendtoroute`
|
|
SendToRoute is a bi-directional streaming RPC for sending payment through
|
|
the Lightning Network. This method differs from SendPayment in that it
|
|
allows users to specify a full route manually. This can be used for things
|
|
like rebalancing, and atomic swaps.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def SendToRouteSync(self, request, context):
|
|
"""*
|
|
SendToRouteSync is a synchronous version of SendToRoute. It Will block
|
|
until the payment either fails or succeeds.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def AddInvoice(self, request, context):
|
|
"""* lncli: `addinvoice`
|
|
AddInvoice attempts to add a new invoice to the invoice database. Any
|
|
duplicated invoices are rejected, therefore all invoices *must* have a
|
|
unique payment preimage.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def ListInvoices(self, request, context):
|
|
"""* lncli: `listinvoices`
|
|
ListInvoices returns a list of all the invoices currently stored within the
|
|
database. Any active debug invoices are ignored. It has full support for
|
|
paginated responses, allowing users to query for specific invoices through
|
|
their add_index. This can be done by using either the first_index_offset or
|
|
last_index_offset fields included in the response as the index_offset of the
|
|
next request. By default, the first 100 invoices created will be returned.
|
|
Backwards pagination is also supported through the Reversed flag.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def LookupInvoice(self, request, context):
|
|
"""* lncli: `lookupinvoice`
|
|
LookupInvoice attempts to look up an invoice according to its payment hash.
|
|
The passed payment hash *must* be exactly 32 bytes, if not, an error is
|
|
returned.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def SubscribeInvoices(self, request, context):
|
|
"""*
|
|
SubscribeInvoices returns a uni-directional stream (server -> client) for
|
|
notifying the client of newly added/settled invoices. The caller can
|
|
optionally specify the add_index and/or the settle_index. If the add_index
|
|
is specified, then we'll first start by sending add invoice events for all
|
|
invoices with an add_index greater than the specified value. If the
|
|
settle_index is specified, the next, we'll send out all settle events for
|
|
invoices with a settle_index greater than the specified value. One or both
|
|
of these fields can be set. If no fields are set, then we'll only send out
|
|
the latest add/settle events.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def DecodePayReq(self, request, context):
|
|
"""* lncli: `decodepayreq`
|
|
DecodePayReq takes an encoded payment request string and attempts to decode
|
|
it, returning a full description of the conditions encoded within the
|
|
payment request.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def ListPayments(self, request, context):
|
|
"""* lncli: `listpayments`
|
|
ListPayments returns a list of all outgoing payments.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def DeleteAllPayments(self, request, context):
|
|
"""*
|
|
DeleteAllPayments deletes all outgoing payments from DB.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def DescribeGraph(self, request, context):
|
|
"""* lncli: `describegraph`
|
|
DescribeGraph returns a description of the latest graph state from the
|
|
point of view of the node. The graph information is partitioned into two
|
|
components: all the nodes/vertexes, and all the edges that connect the
|
|
vertexes themselves. As this is a directed graph, the edges also contain
|
|
the node directional specific routing policy which includes: the time lock
|
|
delta, fee information, etc.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def GetChanInfo(self, request, context):
|
|
"""* lncli: `getchaninfo`
|
|
GetChanInfo returns the latest authenticated network announcement for the
|
|
given channel identified by its channel ID: an 8-byte integer which
|
|
uniquely identifies the location of transaction's funding output within the
|
|
blockchain.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def GetNodeInfo(self, request, context):
|
|
"""* lncli: `getnodeinfo`
|
|
GetNodeInfo returns the latest advertised, aggregated, and authenticated
|
|
channel information for the specified node identified by its public key.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def QueryRoutes(self, request, context):
|
|
"""* lncli: `queryroutes`
|
|
QueryRoutes attempts to query the daemon's Channel Router for a possible
|
|
route to a target destination capable of carrying a specific amount of
|
|
satoshis. The retuned route contains the full details required to craft and
|
|
send an HTLC, also including the necessary information that should be
|
|
present within the Sphinx packet encapsulated within the HTLC.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def GetNetworkInfo(self, request, context):
|
|
"""* lncli: `getnetworkinfo`
|
|
GetNetworkInfo returns some basic stats about the known channel graph from
|
|
the point of view of the node.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def StopDaemon(self, request, context):
|
|
"""* lncli: `stop`
|
|
StopDaemon will send a shutdown request to the interrupt handler, triggering
|
|
a graceful shutdown of the daemon.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def SubscribeChannelGraph(self, request, context):
|
|
"""*
|
|
SubscribeChannelGraph launches a streaming RPC that allows the caller to
|
|
receive notifications upon any changes to the channel graph topology from
|
|
the point of view of the responding node. Events notified include: new
|
|
nodes coming online, nodes updating their authenticated attributes, new
|
|
channels being advertised, updates in the routing policy for a directional
|
|
channel edge, and when channels are closed on-chain.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def DebugLevel(self, request, context):
|
|
"""* lncli: `debuglevel`
|
|
DebugLevel allows a caller to programmatically set the logging verbosity of
|
|
lnd. The logging can be targeted according to a coarse daemon-wide logging
|
|
level, or in a granular fashion to specify the logging for a target
|
|
sub-system.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def FeeReport(self, request, context):
|
|
"""* lncli: `feereport`
|
|
FeeReport allows the caller to obtain a report detailing the current fee
|
|
schedule enforced by the node globally for each channel.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def UpdateChannelPolicy(self, request, context):
|
|
"""* lncli: `updatechanpolicy`
|
|
UpdateChannelPolicy allows the caller to update the fee schedule and
|
|
channel policies for all channels globally, or a particular channel.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def ForwardingHistory(self, request, context):
|
|
"""* lncli: `fwdinghistory`
|
|
ForwardingHistory allows the caller to query the htlcswitch for a record of
|
|
all HTLCs forwarded within the target time range, and integer offset
|
|
within that time range. If no time-range is specified, then the first chunk
|
|
of the past 24 hrs of forwarding history are returned.
|
|
|
|
A list of forwarding events are returned. The size of each forwarding event
|
|
is 40 bytes, and the max message size able to be returned in gRPC is 4 MiB.
|
|
As a result each message can only contain 50k entries. Each response has
|
|
the index offset of the last entry. The index offset can be provided to the
|
|
request to allow the caller to skip a series of records.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def ExportChannelBackup(self, request, context):
|
|
"""* lncli: `exportchanbackup`
|
|
ExportChannelBackup attempts to return an encrypted static channel backup
|
|
for the target channel identified by it channel point. The backup is
|
|
encrypted with a key generated from the aezeed seed of the user. The
|
|
returned backup can either be restored using the RestoreChannelBackup
|
|
method once lnd is running, or via the InitWallet and UnlockWallet methods
|
|
from the WalletUnlocker service.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def ExportAllChannelBackups(self, request, context):
|
|
"""*
|
|
ExportAllChannelBackups returns static channel backups for all existing
|
|
channels known to lnd. A set of regular singular static channel backups for
|
|
each channel are returned. Additionally, a multi-channel backup is returned
|
|
as well, which contains a single encrypted blob containing the backups of
|
|
each channel.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def VerifyChanBackup(self, request, context):
|
|
"""*
|
|
VerifyChanBackup allows a caller to verify the integrity of a channel backup
|
|
snapshot. This method will accept either a packed Single or a packed Multi.
|
|
Specifying both will result in an error.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def RestoreChannelBackups(self, request, context):
|
|
"""* lncli: `restorechanbackup`
|
|
RestoreChannelBackups accepts a set of singular channel backups, or a
|
|
single encrypted multi-chan backup and attempts to recover any funds
|
|
remaining within the channel. If we are able to unpack the backup, then the
|
|
new channel will be shown under listchannels, as well as pending channels.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def SubscribeChannelBackups(self, request, context):
|
|
"""*
|
|
SubscribeChannelBackups allows a client to sub-subscribe to the most up to
|
|
date information concerning the state of all channel backups. Each time a
|
|
new channel is added, we return the new set of channels, along with a
|
|
multi-chan backup containing the backup info for all channels. Each time a
|
|
channel is closed, we send a new update, which contains new new chan back
|
|
ups, but the updated set of encrypted multi-chan backups with the closed
|
|
channel(s) removed.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
|
|
def add_LightningServicer_to_server(servicer, server):
|
|
rpc_method_handlers = {
|
|
'WalletBalance': grpc.unary_unary_rpc_method_handler(
|
|
servicer.WalletBalance,
|
|
request_deserializer=rpc__pb2.WalletBalanceRequest.FromString,
|
|
response_serializer=rpc__pb2.WalletBalanceResponse.SerializeToString,
|
|
),
|
|
'ChannelBalance': grpc.unary_unary_rpc_method_handler(
|
|
servicer.ChannelBalance,
|
|
request_deserializer=rpc__pb2.ChannelBalanceRequest.FromString,
|
|
response_serializer=rpc__pb2.ChannelBalanceResponse.SerializeToString,
|
|
),
|
|
'GetTransactions': grpc.unary_unary_rpc_method_handler(
|
|
servicer.GetTransactions,
|
|
request_deserializer=rpc__pb2.GetTransactionsRequest.FromString,
|
|
response_serializer=rpc__pb2.TransactionDetails.SerializeToString,
|
|
),
|
|
'EstimateFee': grpc.unary_unary_rpc_method_handler(
|
|
servicer.EstimateFee,
|
|
request_deserializer=rpc__pb2.EstimateFeeRequest.FromString,
|
|
response_serializer=rpc__pb2.EstimateFeeResponse.SerializeToString,
|
|
),
|
|
'SendCoins': grpc.unary_unary_rpc_method_handler(
|
|
servicer.SendCoins,
|
|
request_deserializer=rpc__pb2.SendCoinsRequest.FromString,
|
|
response_serializer=rpc__pb2.SendCoinsResponse.SerializeToString,
|
|
),
|
|
'ListUnspent': grpc.unary_unary_rpc_method_handler(
|
|
servicer.ListUnspent,
|
|
request_deserializer=rpc__pb2.ListUnspentRequest.FromString,
|
|
response_serializer=rpc__pb2.ListUnspentResponse.SerializeToString,
|
|
),
|
|
'SubscribeTransactions': grpc.unary_stream_rpc_method_handler(
|
|
servicer.SubscribeTransactions,
|
|
request_deserializer=rpc__pb2.GetTransactionsRequest.FromString,
|
|
response_serializer=rpc__pb2.Transaction.SerializeToString,
|
|
),
|
|
'SendMany': grpc.unary_unary_rpc_method_handler(
|
|
servicer.SendMany,
|
|
request_deserializer=rpc__pb2.SendManyRequest.FromString,
|
|
response_serializer=rpc__pb2.SendManyResponse.SerializeToString,
|
|
),
|
|
'NewAddress': grpc.unary_unary_rpc_method_handler(
|
|
servicer.NewAddress,
|
|
request_deserializer=rpc__pb2.NewAddressRequest.FromString,
|
|
response_serializer=rpc__pb2.NewAddressResponse.SerializeToString,
|
|
),
|
|
'SignMessage': grpc.unary_unary_rpc_method_handler(
|
|
servicer.SignMessage,
|
|
request_deserializer=rpc__pb2.SignMessageRequest.FromString,
|
|
response_serializer=rpc__pb2.SignMessageResponse.SerializeToString,
|
|
),
|
|
'VerifyMessage': grpc.unary_unary_rpc_method_handler(
|
|
servicer.VerifyMessage,
|
|
request_deserializer=rpc__pb2.VerifyMessageRequest.FromString,
|
|
response_serializer=rpc__pb2.VerifyMessageResponse.SerializeToString,
|
|
),
|
|
'ConnectPeer': grpc.unary_unary_rpc_method_handler(
|
|
servicer.ConnectPeer,
|
|
request_deserializer=rpc__pb2.ConnectPeerRequest.FromString,
|
|
response_serializer=rpc__pb2.ConnectPeerResponse.SerializeToString,
|
|
),
|
|
'DisconnectPeer': grpc.unary_unary_rpc_method_handler(
|
|
servicer.DisconnectPeer,
|
|
request_deserializer=rpc__pb2.DisconnectPeerRequest.FromString,
|
|
response_serializer=rpc__pb2.DisconnectPeerResponse.SerializeToString,
|
|
),
|
|
'ListPeers': grpc.unary_unary_rpc_method_handler(
|
|
servicer.ListPeers,
|
|
request_deserializer=rpc__pb2.ListPeersRequest.FromString,
|
|
response_serializer=rpc__pb2.ListPeersResponse.SerializeToString,
|
|
),
|
|
'GetInfo': grpc.unary_unary_rpc_method_handler(
|
|
servicer.GetInfo,
|
|
request_deserializer=rpc__pb2.GetInfoRequest.FromString,
|
|
response_serializer=rpc__pb2.GetInfoResponse.SerializeToString,
|
|
),
|
|
'PendingChannels': grpc.unary_unary_rpc_method_handler(
|
|
servicer.PendingChannels,
|
|
request_deserializer=rpc__pb2.PendingChannelsRequest.FromString,
|
|
response_serializer=rpc__pb2.PendingChannelsResponse.SerializeToString,
|
|
),
|
|
'ListChannels': grpc.unary_unary_rpc_method_handler(
|
|
servicer.ListChannels,
|
|
request_deserializer=rpc__pb2.ListChannelsRequest.FromString,
|
|
response_serializer=rpc__pb2.ListChannelsResponse.SerializeToString,
|
|
),
|
|
'SubscribeChannelEvents': grpc.unary_stream_rpc_method_handler(
|
|
servicer.SubscribeChannelEvents,
|
|
request_deserializer=rpc__pb2.ChannelEventSubscription.FromString,
|
|
response_serializer=rpc__pb2.ChannelEventUpdate.SerializeToString,
|
|
),
|
|
'ClosedChannels': grpc.unary_unary_rpc_method_handler(
|
|
servicer.ClosedChannels,
|
|
request_deserializer=rpc__pb2.ClosedChannelsRequest.FromString,
|
|
response_serializer=rpc__pb2.ClosedChannelsResponse.SerializeToString,
|
|
),
|
|
'OpenChannelSync': grpc.unary_unary_rpc_method_handler(
|
|
servicer.OpenChannelSync,
|
|
request_deserializer=rpc__pb2.OpenChannelRequest.FromString,
|
|
response_serializer=rpc__pb2.ChannelPoint.SerializeToString,
|
|
),
|
|
'OpenChannel': grpc.unary_stream_rpc_method_handler(
|
|
servicer.OpenChannel,
|
|
request_deserializer=rpc__pb2.OpenChannelRequest.FromString,
|
|
response_serializer=rpc__pb2.OpenStatusUpdate.SerializeToString,
|
|
),
|
|
'CloseChannel': grpc.unary_stream_rpc_method_handler(
|
|
servicer.CloseChannel,
|
|
request_deserializer=rpc__pb2.CloseChannelRequest.FromString,
|
|
response_serializer=rpc__pb2.CloseStatusUpdate.SerializeToString,
|
|
),
|
|
'AbandonChannel': grpc.unary_unary_rpc_method_handler(
|
|
servicer.AbandonChannel,
|
|
request_deserializer=rpc__pb2.AbandonChannelRequest.FromString,
|
|
response_serializer=rpc__pb2.AbandonChannelResponse.SerializeToString,
|
|
),
|
|
'SendPayment': grpc.stream_stream_rpc_method_handler(
|
|
servicer.SendPayment,
|
|
request_deserializer=rpc__pb2.SendRequest.FromString,
|
|
response_serializer=rpc__pb2.SendResponse.SerializeToString,
|
|
),
|
|
'SendPaymentSync': grpc.unary_unary_rpc_method_handler(
|
|
servicer.SendPaymentSync,
|
|
request_deserializer=rpc__pb2.SendRequest.FromString,
|
|
response_serializer=rpc__pb2.SendResponse.SerializeToString,
|
|
),
|
|
'SendToRoute': grpc.stream_stream_rpc_method_handler(
|
|
servicer.SendToRoute,
|
|
request_deserializer=rpc__pb2.SendToRouteRequest.FromString,
|
|
response_serializer=rpc__pb2.SendResponse.SerializeToString,
|
|
),
|
|
'SendToRouteSync': grpc.unary_unary_rpc_method_handler(
|
|
servicer.SendToRouteSync,
|
|
request_deserializer=rpc__pb2.SendToRouteRequest.FromString,
|
|
response_serializer=rpc__pb2.SendResponse.SerializeToString,
|
|
),
|
|
'AddInvoice': grpc.unary_unary_rpc_method_handler(
|
|
servicer.AddInvoice,
|
|
request_deserializer=rpc__pb2.Invoice.FromString,
|
|
response_serializer=rpc__pb2.AddInvoiceResponse.SerializeToString,
|
|
),
|
|
'ListInvoices': grpc.unary_unary_rpc_method_handler(
|
|
servicer.ListInvoices,
|
|
request_deserializer=rpc__pb2.ListInvoiceRequest.FromString,
|
|
response_serializer=rpc__pb2.ListInvoiceResponse.SerializeToString,
|
|
),
|
|
'LookupInvoice': grpc.unary_unary_rpc_method_handler(
|
|
servicer.LookupInvoice,
|
|
request_deserializer=rpc__pb2.PaymentHash.FromString,
|
|
response_serializer=rpc__pb2.Invoice.SerializeToString,
|
|
),
|
|
'SubscribeInvoices': grpc.unary_stream_rpc_method_handler(
|
|
servicer.SubscribeInvoices,
|
|
request_deserializer=rpc__pb2.InvoiceSubscription.FromString,
|
|
response_serializer=rpc__pb2.Invoice.SerializeToString,
|
|
),
|
|
'DecodePayReq': grpc.unary_unary_rpc_method_handler(
|
|
servicer.DecodePayReq,
|
|
request_deserializer=rpc__pb2.PayReqString.FromString,
|
|
response_serializer=rpc__pb2.PayReq.SerializeToString,
|
|
),
|
|
'ListPayments': grpc.unary_unary_rpc_method_handler(
|
|
servicer.ListPayments,
|
|
request_deserializer=rpc__pb2.ListPaymentsRequest.FromString,
|
|
response_serializer=rpc__pb2.ListPaymentsResponse.SerializeToString,
|
|
),
|
|
'DeleteAllPayments': grpc.unary_unary_rpc_method_handler(
|
|
servicer.DeleteAllPayments,
|
|
request_deserializer=rpc__pb2.DeleteAllPaymentsRequest.FromString,
|
|
response_serializer=rpc__pb2.DeleteAllPaymentsResponse.SerializeToString,
|
|
),
|
|
'DescribeGraph': grpc.unary_unary_rpc_method_handler(
|
|
servicer.DescribeGraph,
|
|
request_deserializer=rpc__pb2.ChannelGraphRequest.FromString,
|
|
response_serializer=rpc__pb2.ChannelGraph.SerializeToString,
|
|
),
|
|
'GetChanInfo': grpc.unary_unary_rpc_method_handler(
|
|
servicer.GetChanInfo,
|
|
request_deserializer=rpc__pb2.ChanInfoRequest.FromString,
|
|
response_serializer=rpc__pb2.ChannelEdge.SerializeToString,
|
|
),
|
|
'GetNodeInfo': grpc.unary_unary_rpc_method_handler(
|
|
servicer.GetNodeInfo,
|
|
request_deserializer=rpc__pb2.NodeInfoRequest.FromString,
|
|
response_serializer=rpc__pb2.NodeInfo.SerializeToString,
|
|
),
|
|
'QueryRoutes': grpc.unary_unary_rpc_method_handler(
|
|
servicer.QueryRoutes,
|
|
request_deserializer=rpc__pb2.QueryRoutesRequest.FromString,
|
|
response_serializer=rpc__pb2.QueryRoutesResponse.SerializeToString,
|
|
),
|
|
'GetNetworkInfo': grpc.unary_unary_rpc_method_handler(
|
|
servicer.GetNetworkInfo,
|
|
request_deserializer=rpc__pb2.NetworkInfoRequest.FromString,
|
|
response_serializer=rpc__pb2.NetworkInfo.SerializeToString,
|
|
),
|
|
'StopDaemon': grpc.unary_unary_rpc_method_handler(
|
|
servicer.StopDaemon,
|
|
request_deserializer=rpc__pb2.StopRequest.FromString,
|
|
response_serializer=rpc__pb2.StopResponse.SerializeToString,
|
|
),
|
|
'SubscribeChannelGraph': grpc.unary_stream_rpc_method_handler(
|
|
servicer.SubscribeChannelGraph,
|
|
request_deserializer=rpc__pb2.GraphTopologySubscription.FromString,
|
|
response_serializer=rpc__pb2.GraphTopologyUpdate.SerializeToString,
|
|
),
|
|
'DebugLevel': grpc.unary_unary_rpc_method_handler(
|
|
servicer.DebugLevel,
|
|
request_deserializer=rpc__pb2.DebugLevelRequest.FromString,
|
|
response_serializer=rpc__pb2.DebugLevelResponse.SerializeToString,
|
|
),
|
|
'FeeReport': grpc.unary_unary_rpc_method_handler(
|
|
servicer.FeeReport,
|
|
request_deserializer=rpc__pb2.FeeReportRequest.FromString,
|
|
response_serializer=rpc__pb2.FeeReportResponse.SerializeToString,
|
|
),
|
|
'UpdateChannelPolicy': grpc.unary_unary_rpc_method_handler(
|
|
servicer.UpdateChannelPolicy,
|
|
request_deserializer=rpc__pb2.PolicyUpdateRequest.FromString,
|
|
response_serializer=rpc__pb2.PolicyUpdateResponse.SerializeToString,
|
|
),
|
|
'ForwardingHistory': grpc.unary_unary_rpc_method_handler(
|
|
servicer.ForwardingHistory,
|
|
request_deserializer=rpc__pb2.ForwardingHistoryRequest.FromString,
|
|
response_serializer=rpc__pb2.ForwardingHistoryResponse.SerializeToString,
|
|
),
|
|
'ExportChannelBackup': grpc.unary_unary_rpc_method_handler(
|
|
servicer.ExportChannelBackup,
|
|
request_deserializer=rpc__pb2.ExportChannelBackupRequest.FromString,
|
|
response_serializer=rpc__pb2.ChannelBackup.SerializeToString,
|
|
),
|
|
'ExportAllChannelBackups': grpc.unary_unary_rpc_method_handler(
|
|
servicer.ExportAllChannelBackups,
|
|
request_deserializer=rpc__pb2.ChanBackupExportRequest.FromString,
|
|
response_serializer=rpc__pb2.ChanBackupSnapshot.SerializeToString,
|
|
),
|
|
'VerifyChanBackup': grpc.unary_unary_rpc_method_handler(
|
|
servicer.VerifyChanBackup,
|
|
request_deserializer=rpc__pb2.ChanBackupSnapshot.FromString,
|
|
response_serializer=rpc__pb2.VerifyChanBackupResponse.SerializeToString,
|
|
),
|
|
'RestoreChannelBackups': grpc.unary_unary_rpc_method_handler(
|
|
servicer.RestoreChannelBackups,
|
|
request_deserializer=rpc__pb2.RestoreChanBackupRequest.FromString,
|
|
response_serializer=rpc__pb2.RestoreBackupResponse.SerializeToString,
|
|
),
|
|
'SubscribeChannelBackups': grpc.unary_stream_rpc_method_handler(
|
|
servicer.SubscribeChannelBackups,
|
|
request_deserializer=rpc__pb2.ChannelBackupSubscription.FromString,
|
|
response_serializer=rpc__pb2.ChanBackupSnapshot.SerializeToString,
|
|
),
|
|
}
|
|
generic_handler = grpc.method_handlers_generic_handler(
|
|
'lnrpc.Lightning', rpc_method_handlers)
|
|
server.add_generic_rpc_handlers((generic_handler,))
|
|
|