From d388508521875803735d238c6855f91379f2379e Mon Sep 17 00:00:00 2001 From: lollerfirst <43107113+lollerfirst@users.noreply.github.com> Date: Mon, 29 Jul 2024 17:16:40 +0200 Subject: [PATCH] Mint: Talk to LND via gRPC (#595) * protos + lnd_grpc.py + __init__ + status method * `create_invoice` * `pay_invoice`, `pay_partial_invoice` and router pb2 * `get_invoice_status` * channel keep-alive options * Update lnd_grpc.py * `get_payment_status` + make format * `get_payment_quote` and `paid_invoices_stream`. This was suspiciously easy... * download_and_build script modified to fix the imports on generated code * pyproject with new dependencies * update poetry.lock * fixed errors in `pay_partial_invoice` * update .env.example * make format * enable regtest * update .env.example * suggested fixes * suggested changes pt.2 * Update cashu/core/settings.py Co-authored-by: callebtc <93376500+callebtc@users.noreply.github.com> --------- Co-authored-by: callebtc <93376500+callebtc@users.noreply.github.com> --- .env.example | 24 +- .github/workflows/ci.yml | 2 +- .github/workflows/regtest.yml | 7 + cashu/core/settings.py | 5 + cashu/lightning/__init__.py | 1 + cashu/lightning/lnd_grpc/lnd_grpc.py | 372 + .../lnd_grpc/protos/download_and_build.sh | 36 + .../lightning/lnd_grpc/protos/lightning.proto | 5062 ++++++++++ .../lnd_grpc/protos/lightning_pb2.py | 674 ++ .../lnd_grpc/protos/lightning_pb2.pyi | 8506 +++++++++++++++++ .../lnd_grpc/protos/lightning_pb2_grpc.py | 3382 +++++++ .../lnd_grpc/protos/lightning_pb2_grpc.pyi | 2481 +++++ cashu/lightning/lnd_grpc/protos/router.proto | 1023 ++ cashu/lightning/lnd_grpc/protos/router_pb2.py | 146 + .../lightning/lnd_grpc/protos/router_pb2.pyi | 1572 +++ .../lnd_grpc/protos/router_pb2_grpc.py | 972 ++ .../lnd_grpc/protos/router_pb2_grpc.pyi | 693 ++ poetry.lock | 375 +- pyproject.toml | 5 + 19 files changed, 25240 insertions(+), 98 deletions(-) create mode 100644 cashu/lightning/lnd_grpc/lnd_grpc.py create mode 100644 cashu/lightning/lnd_grpc/protos/download_and_build.sh create mode 100644 cashu/lightning/lnd_grpc/protos/lightning.proto create mode 100644 cashu/lightning/lnd_grpc/protos/lightning_pb2.py create mode 100644 cashu/lightning/lnd_grpc/protos/lightning_pb2.pyi create mode 100644 cashu/lightning/lnd_grpc/protos/lightning_pb2_grpc.py create mode 100644 cashu/lightning/lnd_grpc/protos/lightning_pb2_grpc.pyi create mode 100644 cashu/lightning/lnd_grpc/protos/router.proto create mode 100644 cashu/lightning/lnd_grpc/protos/router_pb2.py create mode 100644 cashu/lightning/lnd_grpc/protos/router_pb2.pyi create mode 100644 cashu/lightning/lnd_grpc/protos/router_pb2_grpc.py create mode 100644 cashu/lightning/lnd_grpc/protos/router_pb2_grpc.pyi diff --git a/.env.example b/.env.example index 8f2a8104..c10fa187 100644 --- a/.env.example +++ b/.env.example @@ -60,14 +60,20 @@ MINT_DATABASE=data/mint # MINT_DATABASE=postgres://cashu:cashu@localhost:5432/cashu # Funding source backends -# Supported: FakeWallet, LndRestWallet, CLNRestWallet, BlinkWallet, LNbitsWallet, StrikeWallet, CoreLightningRestWallet (deprecated) +# Set one funding source backend for each unit +# Supported: FakeWallet, LndRestWallet, LndRPCWallet, CLNRestWallet, BlinkWallet, LNbitsWallet, StrikeWallet, CoreLightningRestWallet (deprecated) + MINT_BACKEND_BOLT11_SAT=FakeWallet # Only works if a usd derivation path is set -# MINT_BACKEND_BOLT11_SAT=FakeWallet +# MINT_BACKEND_BOLT11_USD=FakeWallet +# MINT_BACKEND_BOLT11_EUR=FakeWallet -# for use with LNbitsWallet -MINT_LNBITS_ENDPOINT=https://legend.lnbits.com -MINT_LNBITS_KEY=yourkeyasdasdasd +# Funding source settings + +# Use with LndRPCWallet +MINT_LND_RPC_ENDPOINT=localhost:10009 +MINT_LND_RPC_CERT="/path/to/tls.cert" +MINT_LND_RPC_MACAROON="/path/to/admin.macaroon" # Use with LndRestWallet MINT_LND_REST_ENDPOINT=https://127.0.0.1:8086 @@ -75,6 +81,10 @@ MINT_LND_REST_CERT="/home/lnd/.lnd/tls.cert" MINT_LND_REST_MACAROON="/home/lnd/.lnd/data/chain/bitcoin/regtest/admin.macaroon" MINT_LND_REST_CERT_VERIFY=True +# Use with LND +# This setting enables MPP support for Partial multi-path payments (NUT-15) +MINT_LND_ENABLE_MPP=TRUE + # Use with CLNRestWallet MINT_CLNREST_URL=https://localhost:3010 MINT_CLNREST_CERT="./clightning-2/regtest/ca.pem" @@ -86,6 +96,10 @@ MINT_CORELIGHTNING_REST_URL=https://localhost:3001 MINT_CORELIGHTNING_REST_MACAROON="./clightning-rest/access.macaroon" MINT_CORELIGHTNING_REST_CERT="./clightning-2-rest/certificate.pem" +# Use with LNbitsWallet +MINT_LNBITS_ENDPOINT=https://legend.lnbits.com +MINT_LNBITS_KEY=yourkeyasdasdasd + # Use with BlinkWallet MINT_BLINK_KEY=blink_abcdefgh diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 94f7254a..784f93eb 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -33,7 +33,7 @@ jobs: python-version: ["3.10"] poetry-version: ["1.7.1"] backend-wallet-class: - ["LndRestWallet", "CLNRestWallet", "CoreLightningRestWallet", "LNbitsWallet"] + ["LndRPCWallet", "LndRestWallet", "CLNRestWallet", "CoreLightningRestWallet", "LNbitsWallet"] mint-database: ["./test_data/test_mint", "postgres://cashu:cashu@localhost:5432/cashu"] # mint-database: ["./test_data/test_mint"] with: diff --git a/.github/workflows/regtest.yml b/.github/workflows/regtest.yml index 63f33b8a..72692fa7 100644 --- a/.github/workflows/regtest.yml +++ b/.github/workflows/regtest.yml @@ -52,11 +52,18 @@ jobs: MINT_TEST_DATABASE: ${{ inputs.mint-database }} TOR: false MINT_BACKEND_BOLT11_SAT: ${{ inputs.backend-wallet-class }} + # LNbits wallet MINT_LNBITS_ENDPOINT: http://localhost:5001 MINT_LNBITS_KEY: d08a3313322a4514af75d488bcc27eee + # LndRestWallet MINT_LND_REST_ENDPOINT: https://localhost:8081/ MINT_LND_REST_CERT: ./regtest/data/lnd-3/tls.cert MINT_LND_REST_MACAROON: ./regtest/data/lnd-3/data/chain/bitcoin/regtest/admin.macaroon + # LndRPCWallet + MINT_LND_RPC_ENDPOINT: localhost:10009 + MINT_LND_RPC_CERT: ./regtest/data/lnd-3/tls.cert + MINT_LND_RPC_MACAROON: ./regtest/data/lnd-3/data/chain/bitcoin/regtest/admin.macaroon + MINT_LND_ENABLE_MPP: true # LND_GRPC_ENDPOINT: localhost # LND_GRPC_PORT: 10009 diff --git a/cashu/core/settings.py b/cashu/core/settings.py index 1c012ad7..5104cf15 100644 --- a/cashu/core/settings.py +++ b/cashu/core/settings.py @@ -201,6 +201,10 @@ class LndRestFundingSource(MintSettings): mint_lnd_rest_invoice_macaroon: Optional[str] = Field(default=None) mint_lnd_enable_mpp: bool = Field(default=False) +class LndRPCFundingSource(MintSettings): + mint_lnd_rpc_endpoint: Optional[str] = Field(default=None) + mint_lnd_rpc_cert: Optional[str] = Field(default=None) + mint_lnd_rpc_macaroon: Optional[str] = Field(default=None) class CLNRestFundingSource(MintSettings): mint_clnrest_url: Optional[str] = Field(default=None) @@ -217,6 +221,7 @@ class CoreLightningRestFundingSource(MintSettings): class Settings( EnvSettings, + LndRPCFundingSource, LndRestFundingSource, CoreLightningRestFundingSource, CLNRestFundingSource, diff --git a/cashu/lightning/__init__.py b/cashu/lightning/__init__.py index a2bf5662..dfa66b94 100644 --- a/cashu/lightning/__init__.py +++ b/cashu/lightning/__init__.py @@ -5,6 +5,7 @@ from .corelightningrest import CoreLightningRestWallet # noqa: F401 from .fake import FakeWallet # noqa: F401 from .lnbits import LNbitsWallet # noqa: F401 +from .lnd_grpc.lnd_grpc import LndRPCWallet # noqa: F401 from .lndrest import LndRestWallet # noqa: F401 from .strike import StrikeWallet # noqa: F401 diff --git a/cashu/lightning/lnd_grpc/lnd_grpc.py b/cashu/lightning/lnd_grpc/lnd_grpc.py new file mode 100644 index 00000000..0c38e623 --- /dev/null +++ b/cashu/lightning/lnd_grpc/lnd_grpc.py @@ -0,0 +1,372 @@ +import asyncio +import codecs +import hashlib +import os +from typing import AsyncGenerator, Optional + +import bolt11 +import grpc +from bolt11 import ( + TagChar, +) +from grpc.aio import AioRpcError +from loguru import logger + +import cashu.lightning.lnd_grpc.protos.lightning_pb2 as lnrpc +import cashu.lightning.lnd_grpc.protos.lightning_pb2_grpc as lightningstub +import cashu.lightning.lnd_grpc.protos.router_pb2 as routerrpc +import cashu.lightning.lnd_grpc.protos.router_pb2_grpc as routerstub +from cashu.core.base import Amount, MeltQuote, Unit +from cashu.core.helpers import fee_reserve +from cashu.core.settings import settings +from cashu.lightning.base import ( + InvoiceResponse, + LightningBackend, + PaymentQuoteResponse, + PaymentResponse, + PaymentStatus, + PostMeltQuoteRequest, + StatusResponse, +) + +# maps statuses to None, False, True: +# https://api.lightning.community/?python=#paymentpaymentstatus +PAYMENT_STATUSES = { + lnrpc.Payment.PaymentStatus.UNKNOWN: None, + lnrpc.Payment.PaymentStatus.IN_FLIGHT: None, + lnrpc.Payment.PaymentStatus.INITIATED: None, + lnrpc.Payment.PaymentStatus.SUCCEEDED: True, + lnrpc.Payment.PaymentStatus.FAILED: False, +} +INVOICE_STATUSES = { + lnrpc.Invoice.InvoiceState.OPEN: None, + lnrpc.Invoice.InvoiceState.SETTLED: True, + lnrpc.Invoice.InvoiceState.CANCELED: None, + lnrpc.Invoice.InvoiceState.ACCEPTED: None, +} + +class LndRPCWallet(LightningBackend): + + supports_mpp = settings.mint_lnd_enable_mpp + supports_incoming_payment_stream = True + supported_units = set([Unit.sat, Unit.msat]) + unit = Unit.sat + + def __init__(self, unit: Unit = Unit.sat, **kwargs): + self.assert_unit_supported(unit) + self.unit = unit + self.endpoint = settings.mint_lnd_rpc_endpoint + cert_path = settings.mint_lnd_rpc_cert + + macaroon_path = settings.mint_lnd_rpc_macaroon + + if not self.endpoint: + raise Exception("cannot initialize LndRPCWallet: no endpoint") + + if not macaroon_path: + raise Exception("cannot initialize LndRPCWallet: no macaroon") + + if not cert_path: + raise Exception("no certificate for LndRPCWallet provided") + + self.macaroon = codecs.encode(open(macaroon_path, 'rb').read(), 'hex') + + def metadata_callback(context, callback): + callback([('macaroon', self.macaroon)], None) + auth_creds = grpc.metadata_call_credentials(metadata_callback) + + # create SSL credentials + os.environ['GRPC_SSL_CIPHER_SUITES'] = 'HIGH+ECDSA' + cert = open(cert_path, 'rb').read() + ssl_creds = grpc.ssl_channel_credentials(cert) + + # combine macaroon and SSL credentials + self.combined_creds = grpc.composite_channel_credentials(ssl_creds, auth_creds) + + if self.supports_mpp: + logger.info("LndRPCWallet enabling MPP feature") + + + async def status(self) -> StatusResponse: + r = None + try: + async with grpc.aio.secure_channel(self.endpoint, self.combined_creds) as channel: + lnstub = lightningstub.LightningStub(channel) + r = await lnstub.ChannelBalance(lnrpc.ChannelBalanceRequest()) + except AioRpcError as e: + return StatusResponse( + error_message=f"Error calling Lnd gRPC: {e}", balance=0 + ) + # NOTE: `balance` field is deprecated. Change this. + return StatusResponse(error_message=None, balance=r.balance*1000) + + + async def create_invoice( + self, + amount: Amount, + memo: Optional[str] = None, + description_hash: Optional[bytes] = None, + unhashed_description: Optional[bytes] = None, + **kwargs, + ) -> InvoiceResponse: + self.assert_unit_supported(amount.unit) + data = lnrpc.Invoice( + value=amount.to(Unit.sat).amount, + private=True, + memo=memo or "", + ) + if kwargs.get("expiry"): + data.expiry = kwargs["expiry"] + if description_hash: + data.description_hash = description_hash + elif unhashed_description: + data.description_hash = hashlib.sha256(unhashed_description).digest() + + r = None + try: + async with grpc.aio.secure_channel(self.endpoint, self.combined_creds) as channel: + lnstub = lightningstub.LightningStub(channel) + r = await lnstub.AddInvoice(data) + except AioRpcError as e: + logger.error(f"AddInvoice failed: {e}") + return InvoiceResponse( + ok=False, + error_message=f"AddInvoice failed: {e}", + ) + + payment_request = r.payment_request + payment_hash = r.r_hash.hex() + checking_id = payment_hash + + return InvoiceResponse( + ok=True, + checking_id=checking_id, + payment_request=payment_request, + error_message=None, + ) + + async def pay_invoice( + self, quote: MeltQuote, fee_limit_msat: int + ) -> PaymentResponse: + # if the amount of the melt quote is different from the request + # call pay_partial_invoice instead + invoice = bolt11.decode(quote.request) + if invoice.amount_msat: + amount_msat = int(invoice.amount_msat) + if amount_msat != quote.amount * 1000 and self.supports_mpp: + return await self.pay_partial_invoice( + quote, Amount(Unit.sat, quote.amount), fee_limit_msat + ) + + # set the fee limit for the payment + feelimit = lnrpc.FeeLimit( + fixed_msat=fee_limit_msat + ) + r = None + try: + async with grpc.aio.secure_channel(self.endpoint, self.combined_creds) as channel: + lnstub = lightningstub.LightningStub(channel) + r = await lnstub.SendPaymentSync( + lnrpc.SendRequest( + payment_request=quote.request, + fee_limit=feelimit, + ) + ) + except AioRpcError as e: + error_message = f"SendPaymentSync failed: {e}" + return PaymentResponse( + ok=False, + error_message=error_message, + ) + + if r.payment_error: + return PaymentResponse( + ok=False, + error_message=r.payment_error, + ) + + checking_id = r.payment_hash.hex() + fee_msat = r.payment_route.total_fees_msat + preimage = r.payment_preimage.hex() + return PaymentResponse( + ok=True, + checking_id=checking_id, + fee=Amount(unit=Unit.msat, amount=fee_msat) if fee_msat else None, + preimage=preimage, + error_message=None, + ) + + async def pay_partial_invoice( + self, quote: MeltQuote, amount: Amount, fee_limit_msat: int + ) -> PaymentResponse: + # set the fee limit for the payment + feelimit = lnrpc.FeeLimit( + fixed_msat=fee_limit_msat + ) + invoice = bolt11.decode(quote.request) + + invoice_amount = invoice.amount_msat + assert invoice_amount, "invoice has no amount." + total_amount_msat = int(invoice_amount) + + payee = invoice.tags.get(TagChar.payee) + assert payee + pubkey = str(payee.data) + + payer_addr_tag = invoice.tags.get(bolt11.TagChar("s")) + assert payer_addr_tag + payer_addr = str(payer_addr_tag.data) + + # get the route + r = None + try: + async with grpc.aio.secure_channel(self.endpoint, self.combined_creds) as channel: + lnstub = lightningstub.LightningStub(channel) + router_stub = routerstub.RouterStub(channel) + r = await lnstub.QueryRoutes( + lnrpc.QueryRoutesRequest( + pub_key=pubkey, + amt=amount.to(Unit.sat).amount, + fee_limit=feelimit, + ) + ) + ''' + # We need to set the mpp_record for a partial payment + mpp_record = lnrpc.MPPRecord( + payment_addr=bytes.fromhex(payer_addr), + total_amt_msat=total_amount_msat, + ) + ''' + # modify the mpp_record in the last hop + route_nr = 0 + r.routes[route_nr].hops[-1].mpp_record.payment_addr = bytes.fromhex(payer_addr) + r.routes[route_nr].hops[-1].mpp_record.total_amt_msat = total_amount_msat + + # Send to route request + r = await router_stub.SendToRouteV2( + routerrpc.SendToRouteRequest( + payment_hash=bytes.fromhex(invoice.payment_hash), + route=r.routes[route_nr], + ) + ) + except AioRpcError as e: + logger.error(f"QueryRoute or SendToRouteV2 failed: {e}") + return PaymentResponse( + ok=False, + error_message=str(e), + ) + + if r.status == lnrpc.HTLCAttempt.HTLCStatus.FAILED: + error_message = f"Sending to route failed with code {r.failure.code}" + logger.error(error_message) + return PaymentResponse( + ok=False, + error_message=error_message, + ) + + ok = r.status == lnrpc.HTLCAttempt.HTLCStatus.SUCCEEDED + checking_id = invoice.payment_hash + fee_msat = r.route.total_fees_msat + preimage = r.preimage.hex() + return PaymentResponse( + ok=ok, + checking_id=checking_id, + fee=Amount(unit=Unit.msat, amount=fee_msat) if fee_msat else None, + preimage=preimage, + error_message=None, + ) + + async def get_invoice_status(self, checking_id: str) -> PaymentStatus: + r = None + try: + async with grpc.aio.secure_channel(self.endpoint, self.combined_creds) as channel: + lnstub = lightningstub.LightningStub(channel) + r = await lnstub.LookupInvoice( + lnrpc.PaymentHash( + r_hash=bytes.fromhex(checking_id) + ) + ) + except AioRpcError as e: + error_message = f"LookupInvoice failed: {e}" + logger.error(error_message) + return PaymentStatus(paid=None) + + return PaymentStatus(paid=INVOICE_STATUSES[r.state]) + + async def get_payment_status(self, checking_id: str) -> PaymentStatus: + """ + This routine checks the payment status using routerpc.TrackPaymentV2. + """ + # convert checking_id from hex to bytes and some LND magic + try: + checking_id_bytes = bytes.fromhex(checking_id) + except ValueError: + logger.error(f"Couldn't convert {checking_id = } to bytes") + return PaymentStatus(paid=None) + + request = routerrpc.TrackPaymentRequest(payment_hash=checking_id_bytes) + + try: + async with grpc.aio.secure_channel(self.endpoint, self.combined_creds) as channel: + router_stub = routerstub.RouterStub(channel) + async for payment in router_stub.TrackPaymentV2(request): + if payment is not None and payment.status: + return PaymentStatus( + paid=PAYMENT_STATUSES[payment.status], + fee=( + Amount(unit=Unit.msat, amount=payment.fee_msat) + if payment.fee_msat + else None + ), + preimage=payment.payment_preimage, + ) + except AioRpcError as e: + error_message = f"TrackPaymentV2 failed: {e}" + logger.error(error_message) + + return PaymentStatus(paid=None) + + async def paid_invoices_stream(self) -> AsyncGenerator[str, None]: + while True: + try: + async with grpc.aio.secure_channel(self.endpoint, self.combined_creds) as channel: + lnstub = lightningstub.LightningStub(channel) + async for invoice in lnstub.SubscribeInvoices(lnrpc.InvoiceSubscription()): + if invoice.state != lnrpc.Invoice.InvoiceState.SETTLED: + continue + payment_hash = invoice.r_hash.hex() + yield payment_hash + except AioRpcError as exc: + logger.error( + f"SubscribeInvoices failed: {exc}. Retrying in 1 sec..." + ) + await asyncio.sleep(1) + + async def get_payment_quote( + self, melt_quote: PostMeltQuoteRequest + ) -> PaymentQuoteResponse: + # get amount from melt_quote or from bolt11 + amount = ( + Amount(Unit[melt_quote.unit], melt_quote.mpp_amount) + if melt_quote.is_mpp + else None + ) + + invoice_obj = bolt11.decode(melt_quote.request) + assert invoice_obj.amount_msat, "invoice has no amount." + + if amount: + amount_msat = amount.to(Unit.msat).amount + else: + amount_msat = int(invoice_obj.amount_msat) + + fees_msat = fee_reserve(amount_msat) + fees = Amount(unit=Unit.msat, amount=fees_msat) + + amount = Amount(unit=Unit.msat, amount=amount_msat) + + return PaymentQuoteResponse( + checking_id=invoice_obj.payment_hash, + fee=fees.to(self.unit, round="up"), + amount=amount.to(self.unit, round="up"), + ) diff --git a/cashu/lightning/lnd_grpc/protos/download_and_build.sh b/cashu/lightning/lnd_grpc/protos/download_and_build.sh new file mode 100644 index 00000000..cd235842 --- /dev/null +++ b/cashu/lightning/lnd_grpc/protos/download_and_build.sh @@ -0,0 +1,36 @@ +#!/bin/bash + +# *** RUN THIS FROM THE ROOT OF THE PROJECT *** + +BASE_DIR=./cashu/lightning/lnd_grpc/protos +echo "base dir: $BASE_DIR" + +# Check if the googleapis directory exists +if [ -d "$BASE_DIR/googleapis" ]; then + echo "$BASE_DIR/googleapis directory already exists. Skipping clone." +else + echo "Cloning googleapis..." + echo "If this doesn't work, clone it manually." + git clone https://github.com/googleapis/googleapis.git $BASE_DIR/googleapis +fi + +echo "Installing pip packages..." +poetry add grpcio grpcio-tools googleapis-common-protos mypy-protobuf types-protobuf + +echo "curl-ing protos" +curl -o $BASE_DIR/lightning.proto -s https://raw.githubusercontent.com/lightningnetwork/lnd/master/lnrpc/lightning.proto +curl -o $BASE_DIR/router.proto -s https://raw.githubusercontent.com/lightningnetwork/lnd/master/lnrpc/routerrpc/router.proto + +echo "auto-generate code from protos..." +python -m grpc_tools.protoc --proto_path=$BASE_DIR/googleapis:$BASE_DIR --mypy_out=$BASE_DIR --python_out=$BASE_DIR --grpc_python_out=$BASE_DIR $BASE_DIR/lightning.proto +python -m grpc_tools.protoc --proto_path=$BASE_DIR/googleapis:$BASE_DIR --mypy_out=$BASE_DIR --python_out=$BASE_DIR --grpc_python_out=$BASE_DIR $BASE_DIR/router.proto + +echo "fixing imports on autogenerated files..." +for file in $BASE_DIR/*.{py,pyi}; do + if [ -f "$file" ]; then + sed -i -e 's/lightning_pb2/cashu.lightning.lnd_grpc.protos.lightning_pb2/g' -e 's/router_pb2/cashu.lightning.lnd_grpc.protos.router_pb2/g' $file + fi +done + +echo "Done!" + diff --git a/cashu/lightning/lnd_grpc/protos/lightning.proto b/cashu/lightning/lnd_grpc/protos/lightning.proto new file mode 100644 index 00000000..5b912e9c --- /dev/null +++ b/cashu/lightning/lnd_grpc/protos/lightning.proto @@ -0,0 +1,5062 @@ +syntax = "proto3"; + +package lnrpc; + +option go_package = "github.com/lightningnetwork/lnd/lnrpc"; + +/* + * 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. + * + * 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 + */ + +// Lightning is the main RPC server of the daemon. +service Lightning { + /* lncli: `walletbalance` + WalletBalance returns total unspent outputs(confirmed and unconfirmed), all + confirmed unspent outputs and all unconfirmed unspent outputs under control + of the wallet. + */ + rpc WalletBalance (WalletBalanceRequest) returns (WalletBalanceResponse); + + /* lncli: `channelbalance` + ChannelBalance returns a report on the total funds across all open channels, + categorized in local/remote, pending local/remote and unsettled local/remote + balances. + */ + rpc ChannelBalance (ChannelBalanceRequest) returns (ChannelBalanceResponse); + + /* lncli: `listchaintxns` + GetTransactions returns a list describing all the known transactions + relevant to the wallet. + */ + rpc GetTransactions (GetTransactionsRequest) returns (TransactionDetails); + + /* lncli: `estimatefee` + EstimateFee asks the chain backend to estimate the fee rate and total fees + for a transaction that pays to multiple specified outputs. + + When using REST, the `AddrToAmount` map type can be set by appending + `&AddrToAmount[
]=` to the URL. Unfortunately this + map type doesn't appear in the REST API documentation because of a bug in + the grpc-gateway library. + */ + rpc EstimateFee (EstimateFeeRequest) returns (EstimateFeeResponse); + + /* 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_vbyte are set, then the internal wallet will + consult its fee model to determine a fee for the default confirmation + target. + */ + rpc SendCoins (SendCoinsRequest) returns (SendCoinsResponse); + + /* lncli: `listunspent` + Deprecated, use walletrpc.ListUnspent instead. + + ListUnspent returns a list of all utxos spendable by the wallet with a + number of confirmations between the specified minimum and maximum. + */ + rpc ListUnspent (ListUnspentRequest) returns (ListUnspentResponse); + + /* + 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. + */ + rpc SubscribeTransactions (GetTransactionsRequest) + returns (stream Transaction); + + /* lncli: `sendmany` + SendMany handles a request for a transaction that creates multiple specified + outputs in parallel. If neither target_conf, or sat_per_vbyte are set, then + the internal wallet will consult its fee model to determine a fee for the + default confirmation target. + */ + rpc SendMany (SendManyRequest) returns (SendManyResponse); + + /* lncli: `newaddress` + NewAddress creates a new address under control of the local wallet. + */ + rpc NewAddress (NewAddressRequest) returns (NewAddressResponse); + + /* 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. + */ + rpc SignMessage (SignMessageRequest) returns (SignMessageResponse); + + /* lncli: `verifymessage` + VerifyMessage verifies a signature over a message and recovers the signer's + public key. The signature is only deemed valid if the recovered public key + corresponds to a node key in the public Lightning network. 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. + */ + rpc VerifyMessage (VerifyMessageRequest) returns (VerifyMessageResponse); + + /* 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. + */ + rpc ConnectPeer (ConnectPeerRequest) returns (ConnectPeerResponse); + + /* 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. + */ + rpc DisconnectPeer (DisconnectPeerRequest) returns (DisconnectPeerResponse); + + /* lncli: `listpeers` + ListPeers returns a verbose listing of all currently active peers. + */ + rpc ListPeers (ListPeersRequest) returns (ListPeersResponse); + + /* + SubscribePeerEvents creates a uni-directional stream from the server to + the client in which any events relevant to the state of peers are sent + over. Events include peers going online and offline. + */ + rpc SubscribePeerEvents (PeerEventSubscription) returns (stream PeerEvent); + + /* 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. + */ + rpc GetInfo (GetInfoRequest) returns (GetInfoResponse); + + /* lncli: 'getdebuginfo' + GetDebugInfo returns debug information concerning the state of the daemon + and its subsystems. This includes the full configuration and the latest log + entries from the log file. + */ + rpc GetDebugInfo (GetDebugInfoRequest) returns (GetDebugInfoResponse); + + /** lncli: `getrecoveryinfo` + GetRecoveryInfo returns information concerning the recovery mode including + whether it's in a recovery mode, whether the recovery is finished, and the + progress made so far. + */ + rpc GetRecoveryInfo (GetRecoveryInfoRequest) + returns (GetRecoveryInfoResponse); + + // 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. + */ + rpc PendingChannels (PendingChannelsRequest) + returns (PendingChannelsResponse); + + /* lncli: `listchannels` + ListChannels returns a description of all the open channels that this node + is a participant in. + */ + rpc ListChannels (ListChannelsRequest) returns (ListChannelsResponse); + + /* + 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. + */ + rpc SubscribeChannelEvents (ChannelEventSubscription) + returns (stream ChannelEventUpdate); + + /* lncli: `closedchannels` + ClosedChannels returns a description of all the closed channels that + this node was a participant in. + */ + rpc ClosedChannels (ClosedChannelsRequest) returns (ClosedChannelsResponse); + + /* + 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. + */ + rpc OpenChannelSync (OpenChannelRequest) returns (ChannelPoint); + + /* 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. Each OpenStatusUpdate will return + the pending channel ID of the in-progress channel. Depending on the + arguments specified in the OpenChannelRequest, this pending channel ID can + then be used to manually progress the channel funding flow. + */ + rpc OpenChannel (OpenChannelRequest) returns (stream OpenStatusUpdate); + + /* lncli: `batchopenchannel` + BatchOpenChannel attempts to open multiple single-funded channels in a + single transaction in an atomic way. This means either all channel open + requests succeed at once or all attempts are aborted if any of them fail. + This is the safer variant of using PSBTs to manually fund a batch of + channels through the OpenChannel RPC. + */ + rpc BatchOpenChannel (BatchOpenChannelRequest) + returns (BatchOpenChannelResponse); + + /* + FundingStateStep is an advanced funding related call that allows the caller + to either execute some preparatory steps for a funding workflow, or + manually progress a funding workflow. The primary way a funding flow is + identified is via its pending channel ID. As an example, this method can be + used to specify that we're expecting a funding flow for a particular + pending channel ID, for which we need to use specific parameters. + Alternatively, this can be used to interactively drive PSBT signing for + funding for partially complete funding transactions. + */ + rpc FundingStateStep (FundingTransitionMsg) returns (FundingStateStepResp); + + /* + ChannelAcceptor dispatches a bi-directional streaming RPC in which + OpenChannel requests are sent to the client and the client responds with + a boolean that tells LND whether or not to accept the channel. This allows + node operators to specify their own criteria for accepting inbound channels + through a single persistent connection. + */ + rpc ChannelAcceptor (stream ChannelAcceptResponse) + returns (stream ChannelAcceptRequest); + + /* 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. + */ + rpc CloseChannel (CloseChannelRequest) returns (stream CloseStatusUpdate); + + /* 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. This method can also be + used to remove externally funded channels where the funding transaction was + never broadcast. Only available for non-externally funded channels in dev + build. + */ + rpc AbandonChannel (AbandonChannelRequest) returns (AbandonChannelResponse); + + /* lncli: `sendpayment` + Deprecated, use routerrpc.SendPaymentV2. 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. + */ + rpc SendPayment (stream SendRequest) returns (stream SendResponse) { + option deprecated = true; + } + + /* + 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. + */ + rpc SendPaymentSync (SendRequest) returns (SendResponse); + + /* lncli: `sendtoroute` + Deprecated, use routerrpc.SendToRouteV2. 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. + */ + rpc SendToRoute (stream SendToRouteRequest) returns (stream SendResponse) { + option deprecated = true; + } + + /* + SendToRouteSync is a synchronous version of SendToRoute. It Will block + until the payment either fails or succeeds. + */ + rpc SendToRouteSync (SendToRouteRequest) returns (SendResponse); + + /* 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. + */ + rpc AddInvoice (Invoice) returns (AddInvoiceResponse); + + /* 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. + */ + rpc ListInvoices (ListInvoiceRequest) returns (ListInvoiceResponse); + + /* 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. + */ + rpc LookupInvoice (PaymentHash) returns (Invoice); + + /* + 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, then 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. + */ + rpc SubscribeInvoices (InvoiceSubscription) returns (stream Invoice); + + /* 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. + */ + rpc DecodePayReq (PayReqString) returns (PayReq); + + /* lncli: `listpayments` + ListPayments returns a list of all outgoing payments. + */ + rpc ListPayments (ListPaymentsRequest) returns (ListPaymentsResponse); + + /* lncli: `deletepayments` + DeletePayment deletes an outgoing payment from DB. Note that it will not + attempt to delete an In-Flight payment, since that would be unsafe. + */ + rpc DeletePayment (DeletePaymentRequest) returns (DeletePaymentResponse); + + /* lncli: `deletepayments --all` + DeleteAllPayments deletes all outgoing payments from DB. Note that it will + not attempt to delete In-Flight payments, since that would be unsafe. + */ + rpc DeleteAllPayments (DeleteAllPaymentsRequest) + returns (DeleteAllPaymentsResponse); + + /* 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. + */ + rpc DescribeGraph (ChannelGraphRequest) returns (ChannelGraph); + + /* lncli: `getnodemetrics` + GetNodeMetrics returns node metrics calculated from the graph. Currently + the only supported metric is betweenness centrality of individual nodes. + */ + rpc GetNodeMetrics (NodeMetricsRequest) returns (NodeMetricsResponse); + + /* 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. + */ + rpc GetChanInfo (ChanInfoRequest) returns (ChannelEdge); + + /* lncli: `getnodeinfo` + GetNodeInfo returns the latest advertised, aggregated, and authenticated + channel information for the specified node identified by its public key. + */ + rpc GetNodeInfo (NodeInfoRequest) returns (NodeInfo); + + /* 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 returned 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. + + When using REST, the `dest_custom_records` map type can be set by appending + `&dest_custom_records[]=` + to the URL. Unfortunately this map type doesn't appear in the REST API + documentation because of a bug in the grpc-gateway library. + */ + rpc QueryRoutes (QueryRoutesRequest) returns (QueryRoutesResponse); + + /* lncli: `getnetworkinfo` + GetNetworkInfo returns some basic stats about the known channel graph from + the point of view of the node. + */ + rpc GetNetworkInfo (NetworkInfoRequest) returns (NetworkInfo); + + /* lncli: `stop` + StopDaemon will send a shutdown request to the interrupt handler, triggering + a graceful shutdown of the daemon. + */ + rpc StopDaemon (StopRequest) returns (StopResponse); + + /* + 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. + */ + rpc SubscribeChannelGraph (GraphTopologySubscription) + returns (stream GraphTopologyUpdate); + + /* 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. + */ + rpc DebugLevel (DebugLevelRequest) returns (DebugLevelResponse); + + /* lncli: `feereport` + FeeReport allows the caller to obtain a report detailing the current fee + schedule enforced by the node globally for each channel. + */ + rpc FeeReport (FeeReportRequest) returns (FeeReportResponse); + + /* lncli: `updatechanpolicy` + UpdateChannelPolicy allows the caller to update the fee schedule and + channel policies for all channels globally, or a particular channel. + */ + rpc UpdateChannelPolicy (PolicyUpdateRequest) + returns (PolicyUpdateResponse); + + /* 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, for a maximum number of events. If no maximum number + of events is specified, up to 100 events will be returned. If no time-range + is specified, then events will be returned in the order that they occured. + + 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. + */ + rpc ForwardingHistory (ForwardingHistoryRequest) + returns (ForwardingHistoryResponse); + + /* 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. + */ + rpc ExportChannelBackup (ExportChannelBackupRequest) + returns (ChannelBackup); + + /* + 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. + */ + rpc ExportAllChannelBackups (ChanBackupExportRequest) + returns (ChanBackupSnapshot); + + /* lncli: `verifychanbackup` + 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. + */ + rpc VerifyChanBackup (ChanBackupSnapshot) + returns (VerifyChanBackupResponse); + + /* 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. + */ + rpc RestoreChannelBackups (RestoreChanBackupRequest) + returns (RestoreBackupResponse); + + /* + 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. + */ + rpc SubscribeChannelBackups (ChannelBackupSubscription) + returns (stream ChanBackupSnapshot); + + /* lncli: `bakemacaroon` + BakeMacaroon allows the creation of a new macaroon with custom read and + write permissions. No first-party caveats are added since this can be done + offline. + */ + rpc BakeMacaroon (BakeMacaroonRequest) returns (BakeMacaroonResponse); + + /* lncli: `listmacaroonids` + ListMacaroonIDs returns all root key IDs that are in use. + */ + rpc ListMacaroonIDs (ListMacaroonIDsRequest) + returns (ListMacaroonIDsResponse); + + /* lncli: `deletemacaroonid` + DeleteMacaroonID deletes the specified macaroon ID and invalidates all + macaroons derived from that ID. + */ + rpc DeleteMacaroonID (DeleteMacaroonIDRequest) + returns (DeleteMacaroonIDResponse); + + /* lncli: `listpermissions` + ListPermissions lists all RPC method URIs and their required macaroon + permissions to access them. + */ + rpc ListPermissions (ListPermissionsRequest) + returns (ListPermissionsResponse); + + /* + CheckMacaroonPermissions checks whether a request follows the constraints + imposed on the macaroon and that the macaroon is authorized to follow the + provided permissions. + */ + rpc CheckMacaroonPermissions (CheckMacPermRequest) + returns (CheckMacPermResponse); + + /* + RegisterRPCMiddleware adds a new gRPC middleware to the interceptor chain. A + gRPC middleware is software component external to lnd that aims to add + additional business logic to lnd by observing/intercepting/validating + incoming gRPC client requests and (if needed) replacing/overwriting outgoing + messages before they're sent to the client. When registering the middleware + must identify itself and indicate what custom macaroon caveats it wants to + be responsible for. Only requests that contain a macaroon with that specific + custom caveat are then sent to the middleware for inspection. The other + option is to register for the read-only mode in which all requests/responses + are forwarded for interception to the middleware but the middleware is not + allowed to modify any responses. As a security measure, _no_ middleware can + modify responses for requests made with _unencumbered_ macaroons! + */ + rpc RegisterRPCMiddleware (stream RPCMiddlewareResponse) + returns (stream RPCMiddlewareRequest); + + /* lncli: `sendcustom` + SendCustomMessage sends a custom peer message. + */ + rpc SendCustomMessage (SendCustomMessageRequest) + returns (SendCustomMessageResponse); + + /* lncli: `subscribecustom` + SubscribeCustomMessages subscribes to a stream of incoming custom peer + messages. + + To include messages with type outside of the custom range (>= 32768) lnd + needs to be compiled with the `dev` build tag, and the message type to + override should be specified in lnd's experimental protocol configuration. + */ + rpc SubscribeCustomMessages (SubscribeCustomMessagesRequest) + returns (stream CustomMessage); + + /* lncli: `listaliases` + ListAliases returns the set of all aliases that have ever existed with + their confirmed SCID (if it exists) and/or the base SCID (in the case of + zero conf). + */ + rpc ListAliases (ListAliasesRequest) returns (ListAliasesResponse); + + /* + LookupHtlcResolution retrieves a final htlc resolution from the database. + If the htlc has no final resolution yet, a NotFound grpc status code is + returned. + */ + rpc LookupHtlcResolution (LookupHtlcResolutionRequest) + returns (LookupHtlcResolutionResponse); +} + +message LookupHtlcResolutionRequest { + uint64 chan_id = 1; + + uint64 htlc_index = 2; +} + +message LookupHtlcResolutionResponse { + // Settled is true is the htlc was settled. If false, the htlc was failed. + bool settled = 1; + + // Offchain indicates whether the htlc was resolved off-chain or on-chain. + bool offchain = 2; +} + +message SubscribeCustomMessagesRequest { +} + +message CustomMessage { + // Peer from which the message originates + bytes peer = 1; + + // Message type. This value will be in the custom range (>= 32768). + uint32 type = 2; + + // Raw message data + bytes data = 3; +} + +message SendCustomMessageRequest { + // Peer to send the message to + bytes peer = 1; + + // Message type. This value needs to be in the custom range (>= 32768). + // To send a type < custom range, lnd needs to be compiled with the `dev` + // build tag, and the message type to override should be specified in lnd's + // experimental protocol configuration. + uint32 type = 2; + + // Raw message data. + bytes data = 3; +} + +message SendCustomMessageResponse { +} + +message Utxo { + // The type of address + AddressType address_type = 1; + + // The address + string address = 2; + + // The value of the unspent coin in satoshis + int64 amount_sat = 3; + + // The pkscript in hex + string pk_script = 4; + + // The outpoint in format txid:n + OutPoint outpoint = 5; + + // The number of confirmations for the Utxo + int64 confirmations = 6; +} + +enum OutputScriptType { + SCRIPT_TYPE_PUBKEY_HASH = 0; + SCRIPT_TYPE_SCRIPT_HASH = 1; + SCRIPT_TYPE_WITNESS_V0_PUBKEY_HASH = 2; + SCRIPT_TYPE_WITNESS_V0_SCRIPT_HASH = 3; + SCRIPT_TYPE_PUBKEY = 4; + SCRIPT_TYPE_MULTISIG = 5; + SCRIPT_TYPE_NULLDATA = 6; + SCRIPT_TYPE_NON_STANDARD = 7; + SCRIPT_TYPE_WITNESS_UNKNOWN = 8; + SCRIPT_TYPE_WITNESS_V1_TAPROOT = 9; +} + +message OutputDetail { + // The type of the output + OutputScriptType output_type = 1; + + // The address + string address = 2; + + // The pkscript in hex + string pk_script = 3; + + // The output index used in the raw transaction + int64 output_index = 4; + + // The value of the output coin in satoshis + int64 amount = 5; + + // Denotes if the output is controlled by the internal wallet + bool is_our_address = 6; +} + +message Transaction { + // The transaction hash + string tx_hash = 1; + + // The transaction amount, denominated in satoshis + int64 amount = 2; + + // The number of confirmations + int32 num_confirmations = 3; + + // The hash of the block this transaction was included in + string block_hash = 4; + + // The height of the block this transaction was included in + int32 block_height = 5; + + // Timestamp of this transaction + int64 time_stamp = 6; + + // Fees paid for this transaction + int64 total_fees = 7; + + // Addresses that received funds for this transaction. Deprecated as it is + // now incorporated in the output_details field. + repeated string dest_addresses = 8 [deprecated = true]; + + // Outputs that received funds for this transaction + repeated OutputDetail output_details = 11; + + // The raw transaction hex. + string raw_tx_hex = 9; + + // A label that was optionally set on transaction broadcast. + string label = 10; + + // PreviousOutpoints/Inputs of this transaction. + repeated PreviousOutPoint previous_outpoints = 12; +} + +message GetTransactionsRequest { + /* + The height from which to list transactions, inclusive. If this value is + greater than end_height, transactions will be read in reverse. + */ + int32 start_height = 1; + + /* + The height until which to list transactions, inclusive. To include + unconfirmed transactions, this value should be set to -1, which will + return transactions from start_height until the current chain tip and + unconfirmed transactions. If no end_height is provided, the call will + default to this option. + */ + int32 end_height = 2; + + // An optional filter to only include transactions relevant to an account. + string account = 3; +} + +message TransactionDetails { + // The list of transactions relevant to the wallet. + repeated Transaction transactions = 1; +} + +message FeeLimit { + oneof limit { + /* + The fee limit expressed as a fixed amount of satoshis. + + The fields fixed and fixed_msat are mutually exclusive. + */ + int64 fixed = 1; + + /* + The fee limit expressed as a fixed amount of millisatoshis. + + The fields fixed and fixed_msat are mutually exclusive. + */ + int64 fixed_msat = 3; + + // The fee limit expressed as a percentage of the payment amount. + int64 percent = 2; + } +} + +message SendRequest { + /* + The identity pubkey of the payment recipient. When using REST, this field + must be encoded as base64. + */ + bytes dest = 1; + + /* + The hex-encoded identity pubkey of the payment recipient. Deprecated now + that the REST gateway supports base64 encoding of bytes fields. + */ + string dest_string = 2 [deprecated = true]; + + /* + The amount to send expressed in satoshis. + + The fields amt and amt_msat are mutually exclusive. + */ + int64 amt = 3; + + /* + The amount to send expressed in millisatoshis. + + The fields amt and amt_msat are mutually exclusive. + */ + int64 amt_msat = 12; + + /* + The hash to use within the payment's HTLC. When using REST, this field + must be encoded as base64. + */ + bytes payment_hash = 4; + + /* + The hex-encoded hash to use within the payment's HTLC. Deprecated now + that the REST gateway supports base64 encoding of bytes fields. + */ + string payment_hash_string = 5 [deprecated = true]; + + /* + A bare-bones invoice for a payment within the Lightning Network. With the + details of the invoice, the sender has all the data necessary to send a + payment to the recipient. + */ + string payment_request = 6; + + /* + The CLTV delta from the current height that should be used to set the + timelock for the final hop. + */ + int32 final_cltv_delta = 7; + + /* + The maximum number of satoshis that will be paid as a fee of the payment. + This value can be represented either as a percentage of the amount being + sent, or as a fixed amount of the maximum fee the user is willing the pay to + send the payment. If not specified, lnd will use a default value of 100% + fees for small amounts (<=1k sat) or 5% fees for larger amounts. + */ + FeeLimit fee_limit = 8; + + /* + The channel id of the channel that must be taken to the first hop. If zero, + any channel may be used. + */ + uint64 outgoing_chan_id = 9 [jstype = JS_STRING]; + + /* + The pubkey of the last hop of the route. If empty, any hop may be used. + */ + bytes last_hop_pubkey = 13; + + /* + An optional maximum total time lock for the route. This should not exceed + lnd's `--max-cltv-expiry` setting. If zero, then the value of + `--max-cltv-expiry` is enforced. + */ + uint32 cltv_limit = 10; + + /* + An optional field that can be used to pass an arbitrary set of TLV records + to a peer which understands the new records. This can be used to pass + application specific data during the payment attempt. Record types are + required to be in the custom range >= 65536. When using REST, the values + must be encoded as base64. + */ + map dest_custom_records = 11; + + // If set, circular payments to self are permitted. + bool allow_self_payment = 14; + + /* + Features assumed to be supported by the final node. All transitive feature + dependencies must also be set properly. For a given feature bit pair, either + optional or remote may be set, but not both. If this field is nil or empty, + the router will try to load destination features from the graph as a + fallback. + */ + repeated FeatureBit dest_features = 15; + + /* + The payment address of the generated invoice. This is also called + payment secret in specifications (e.g. BOLT 11). + */ + bytes payment_addr = 16; +} + +message SendResponse { + string payment_error = 1; + bytes payment_preimage = 2; + Route payment_route = 3; + bytes payment_hash = 4; +} + +message SendToRouteRequest { + /* + The payment hash to use for the HTLC. When using REST, this field must be + encoded as base64. + */ + bytes payment_hash = 1; + + /* + An optional hex-encoded payment hash to be used for the HTLC. Deprecated now + that the REST gateway supports base64 encoding of bytes fields. + */ + string payment_hash_string = 2 [deprecated = true]; + + reserved 3; + + // Route that should be used to attempt to complete the payment. + Route route = 4; +} + +message ChannelAcceptRequest { + // The pubkey of the node that wishes to open an inbound channel. + bytes node_pubkey = 1; + + // The hash of the genesis block that the proposed channel resides in. + bytes chain_hash = 2; + + // The pending channel id. + bytes pending_chan_id = 3; + + // The funding amount in satoshis that initiator wishes to use in the + // channel. + uint64 funding_amt = 4; + + // The push amount of the proposed channel in millisatoshis. + uint64 push_amt = 5; + + // The dust limit of the initiator's commitment tx. + uint64 dust_limit = 6; + + // The maximum amount of coins in millisatoshis that can be pending in this + // channel. + uint64 max_value_in_flight = 7; + + // The minimum amount of satoshis the initiator requires us to have at all + // times. + uint64 channel_reserve = 8; + + // The smallest HTLC in millisatoshis that the initiator will accept. + uint64 min_htlc = 9; + + // The initial fee rate that the initiator suggests for both commitment + // transactions. + uint64 fee_per_kw = 10; + + /* + The number of blocks to use for the relative time lock in the pay-to-self + output of both commitment transactions. + */ + uint32 csv_delay = 11; + + // The total number of incoming HTLC's that the initiator will accept. + uint32 max_accepted_htlcs = 12; + + // A bit-field which the initiator uses to specify proposed channel + // behavior. + uint32 channel_flags = 13; + + // The commitment type the initiator wishes to use for the proposed channel. + CommitmentType commitment_type = 14; + + // Whether the initiator wants to open a zero-conf channel via the channel + // type. + bool wants_zero_conf = 15; + + // Whether the initiator wants to use the scid-alias channel type. This is + // separate from the feature bit. + bool wants_scid_alias = 16; +} + +message ChannelAcceptResponse { + // Whether or not the client accepts the channel. + bool accept = 1; + + // The pending channel id to which this response applies. + bytes pending_chan_id = 2; + + /* + An optional error to send the initiating party to indicate why the channel + was rejected. This field *should not* contain sensitive information, it will + be sent to the initiating party. This field should only be set if accept is + false, the channel will be rejected if an error is set with accept=true + because the meaning of this response is ambiguous. Limited to 500 + characters. + */ + string error = 3; + + /* + The upfront shutdown address to use if the initiating peer supports option + upfront shutdown script (see ListPeers for the features supported). Note + that the channel open will fail if this value is set for a peer that does + not support this feature bit. + */ + string upfront_shutdown = 4; + + /* + The csv delay (in blocks) that we require for the remote party. + */ + uint32 csv_delay = 5; + + /* + The reserve amount in satoshis that we require the remote peer to adhere to. + We require that the remote peer always have some reserve amount allocated to + them so that there is always a disincentive to broadcast old state (if they + hold 0 sats on their side of the channel, there is nothing to lose). + */ + uint64 reserve_sat = 6; + + /* + The maximum amount of funds in millisatoshis that we allow the remote peer + to have in outstanding htlcs. + */ + uint64 in_flight_max_msat = 7; + + /* + The maximum number of htlcs that the remote peer can offer us. + */ + uint32 max_htlc_count = 8; + + /* + The minimum value in millisatoshis for incoming htlcs on the channel. + */ + uint64 min_htlc_in = 9; + + /* + The number of confirmations we require before we consider the channel open. + */ + uint32 min_accept_depth = 10; + + /* + Whether the responder wants this to be a zero-conf channel. This will fail + if either side does not have the scid-alias feature bit set. The minimum + depth field must be zero if this is true. + */ + bool zero_conf = 11; +} + +message ChannelPoint { + oneof funding_txid { + /* + Txid of the funding transaction. When using REST, this field must be + encoded as base64. + */ + bytes funding_txid_bytes = 1; + + /* + Hex-encoded string representing the byte-reversed hash of the funding + transaction. + */ + string funding_txid_str = 2; + } + + // The index of the output of the funding transaction + uint32 output_index = 3; +} + +message OutPoint { + // Raw bytes representing the transaction id. + bytes txid_bytes = 1; + + // Reversed, hex-encoded string representing the transaction id. + string txid_str = 2; + + // The index of the output on the transaction. + uint32 output_index = 3; +} + +message PreviousOutPoint { + // The outpoint in format txid:n. + string outpoint = 1; + + // Denotes if the outpoint is controlled by the internal wallet. + // The flag will only detect p2wkh, np2wkh and p2tr inputs as its own. + bool is_our_output = 2; +} + +message LightningAddress { + // The identity pubkey of the Lightning node. + string pubkey = 1; + + // The network location of the lightning node, e.g. `69.69.69.69:1337` or + // `localhost:10011`. + string host = 2; +} + +enum CoinSelectionStrategy { + // Use the coin selection strategy defined in the global configuration + // (lnd.conf). + STRATEGY_USE_GLOBAL_CONFIG = 0; + + // Select the largest available coins first during coin selection. + STRATEGY_LARGEST = 1; + + // Randomly select the available coins during coin selection. + STRATEGY_RANDOM = 2; +} + +message EstimateFeeRequest { + // The map from addresses to amounts for the transaction. + map AddrToAmount = 1; + + // The target number of blocks that this transaction should be confirmed + // by. + int32 target_conf = 2; + + // The minimum number of confirmations each one of your outputs used for + // the transaction must satisfy. + int32 min_confs = 3; + + // Whether unconfirmed outputs should be used as inputs for the transaction. + bool spend_unconfirmed = 4; + + // The strategy to use for selecting coins during fees estimation. + CoinSelectionStrategy coin_selection_strategy = 5; +} + +message EstimateFeeResponse { + // The total fee in satoshis. + int64 fee_sat = 1; + + // Deprecated, use sat_per_vbyte. + // The fee rate in satoshi/vbyte. + int64 feerate_sat_per_byte = 2 [deprecated = true]; + + // The fee rate in satoshi/vbyte. + uint64 sat_per_vbyte = 3; +} + +message SendManyRequest { + // The map from addresses to amounts + map AddrToAmount = 1; + + // The target number of blocks that this transaction should be confirmed + // by. + int32 target_conf = 3; + + // A manual fee rate set in sat/vbyte that should be used when crafting the + // transaction. + uint64 sat_per_vbyte = 4; + + // Deprecated, use sat_per_vbyte. + // A manual fee rate set in sat/vbyte that should be used when crafting the + // transaction. + int64 sat_per_byte = 5 [deprecated = true]; + + // An optional label for the transaction, limited to 500 characters. + string label = 6; + + // The minimum number of confirmations each one of your outputs used for + // the transaction must satisfy. + int32 min_confs = 7; + + // Whether unconfirmed outputs should be used as inputs for the transaction. + bool spend_unconfirmed = 8; + + // The strategy to use for selecting coins during sending many requests. + CoinSelectionStrategy coin_selection_strategy = 9; +} +message SendManyResponse { + // The id of the transaction + string txid = 1; +} + +message SendCoinsRequest { + // The address to send coins to + string addr = 1; + + // The amount in satoshis to send + int64 amount = 2; + + // The target number of blocks that this transaction should be confirmed + // by. + int32 target_conf = 3; + + // A manual fee rate set in sat/vbyte that should be used when crafting the + // transaction. + uint64 sat_per_vbyte = 4; + + // Deprecated, use sat_per_vbyte. + // A manual fee rate set in sat/vbyte that should be used when crafting the + // transaction. + int64 sat_per_byte = 5 [deprecated = true]; + + /* + If set, then the amount field will be ignored, and lnd will attempt to + send all the coins under control of the internal wallet to the specified + address. + */ + bool send_all = 6; + + // An optional label for the transaction, limited to 500 characters. + string label = 7; + + // The minimum number of confirmations each one of your outputs used for + // the transaction must satisfy. + int32 min_confs = 8; + + // Whether unconfirmed outputs should be used as inputs for the transaction. + bool spend_unconfirmed = 9; + + // The strategy to use for selecting coins. + CoinSelectionStrategy coin_selection_strategy = 10; +} +message SendCoinsResponse { + // The transaction ID of the transaction + string txid = 1; +} + +message ListUnspentRequest { + // The minimum number of confirmations to be included. + int32 min_confs = 1; + + // The maximum number of confirmations to be included. + int32 max_confs = 2; + + // An optional filter to only include outputs belonging to an account. + string account = 3; +} +message ListUnspentResponse { + // A list of utxos + repeated Utxo utxos = 1; +} + +/* +`AddressType` has to be one of: + +- `p2wkh`: Pay to witness key hash (`WITNESS_PUBKEY_HASH` = 0) +- `np2wkh`: Pay to nested witness key hash (`NESTED_PUBKEY_HASH` = 1) +- `p2tr`: Pay to taproot pubkey (`TAPROOT_PUBKEY` = 4) +*/ +enum AddressType { + WITNESS_PUBKEY_HASH = 0; + NESTED_PUBKEY_HASH = 1; + UNUSED_WITNESS_PUBKEY_HASH = 2; + UNUSED_NESTED_PUBKEY_HASH = 3; + TAPROOT_PUBKEY = 4; + UNUSED_TAPROOT_PUBKEY = 5; +} + +message NewAddressRequest { + // The type of address to generate. + AddressType type = 1; + + /* + The name of the account to generate a new address for. If empty, the + default wallet account is used. + */ + string account = 2; +} +message NewAddressResponse { + // The newly generated wallet address + string address = 1; +} + +message SignMessageRequest { + /* + The message to be signed. When using REST, this field must be encoded as + base64. + */ + bytes msg = 1; + + /* + Instead of the default double-SHA256 hashing of the message before signing, + only use one round of hashing instead. + */ + bool single_hash = 2; +} +message SignMessageResponse { + // The signature for the given message + string signature = 1; +} + +message VerifyMessageRequest { + /* + The message over which the signature is to be verified. When using REST, + this field must be encoded as base64. + */ + bytes msg = 1; + + // The signature to be verified over the given message + string signature = 2; +} +message VerifyMessageResponse { + // Whether the signature was valid over the given message + bool valid = 1; + + // The pubkey recovered from the signature + string pubkey = 2; +} + +message ConnectPeerRequest { + /* + Lightning address of the peer to connect to. + */ + LightningAddress addr = 1; + + /* + If set, the daemon will attempt to persistently connect to the target + peer. Otherwise, the call will be synchronous. + */ + bool perm = 2; + + /* + The connection timeout value (in seconds) for this request. It won't affect + other requests. + */ + uint64 timeout = 3; +} +message ConnectPeerResponse { +} + +message DisconnectPeerRequest { + // The pubkey of the node to disconnect from + string pub_key = 1; +} +message DisconnectPeerResponse { +} + +message HTLC { + bool incoming = 1; + int64 amount = 2; + bytes hash_lock = 3; + uint32 expiration_height = 4; + + // Index identifying the htlc on the channel. + uint64 htlc_index = 5; + + // If this HTLC is involved in a forwarding operation, this field indicates + // the forwarding channel. For an outgoing htlc, it is the incoming channel. + // For an incoming htlc, it is the outgoing channel. When the htlc + // originates from this node or this node is the final destination, + // forwarding_channel will be zero. The forwarding channel will also be zero + // for htlcs that need to be forwarded but don't have a forwarding decision + // persisted yet. + uint64 forwarding_channel = 6; + + // Index identifying the htlc on the forwarding channel. + uint64 forwarding_htlc_index = 7; +} + +enum CommitmentType { + /* + Returned when the commitment type isn't known or unavailable. + */ + UNKNOWN_COMMITMENT_TYPE = 0; + + /* + A channel using the legacy commitment format having tweaked to_remote + keys. + */ + LEGACY = 1; + + /* + A channel that uses the modern commitment format where the key in the + output of the remote party does not change each state. This makes back + up and recovery easier as when the channel is closed, the funds go + directly to that key. + */ + STATIC_REMOTE_KEY = 2; + + /* + A channel that uses a commitment format that has anchor outputs on the + commitments, allowing fee bumping after a force close transaction has + been broadcast. + */ + ANCHORS = 3; + + /* + A channel that uses a commitment type that builds upon the anchors + commitment format, but in addition requires a CLTV clause to spend outputs + paying to the channel initiator. This is intended for use on leased channels + to guarantee that the channel initiator has no incentives to close a leased + channel before its maturity date. + */ + SCRIPT_ENFORCED_LEASE = 4; + + /* + A channel that uses musig2 for the funding output, and the new tapscript + features where relevant. + */ + // TODO(roasbeef): need script enforce mirror type for the above as well? + SIMPLE_TAPROOT = 5; +} + +message ChannelConstraints { + /* + The CSV delay expressed in relative blocks. If the channel is force closed, + we will need to wait for this many blocks before we can regain our funds. + */ + uint32 csv_delay = 1; + + // The minimum satoshis this node is required to reserve in its balance. + uint64 chan_reserve_sat = 2; + + // The dust limit (in satoshis) of the initiator's commitment tx. + uint64 dust_limit_sat = 3; + + // The maximum amount of coins in millisatoshis that can be pending in this + // channel. + uint64 max_pending_amt_msat = 4; + + // The smallest HTLC in millisatoshis that the initiator will accept. + uint64 min_htlc_msat = 5; + + // The total number of incoming HTLC's that the initiator will accept. + uint32 max_accepted_htlcs = 6; +} + +message Channel { + // Whether this channel is active or not + bool active = 1; + + // The identity pubkey of the remote node + string remote_pubkey = 2; + + /* + The outpoint (txid:index) of the funding transaction. With this value, Bob + will be able to generate a signature for Alice's version of the commitment + transaction. + */ + string channel_point = 3; + + /* + The unique channel ID for the channel. The first 3 bytes are the block + height, the next 3 the index within the block, and the last 2 bytes are the + output index for the channel. + */ + uint64 chan_id = 4 [jstype = JS_STRING]; + + // The total amount of funds held in this channel + int64 capacity = 5; + + // This node's current balance in this channel + int64 local_balance = 6; + + // The counterparty's current balance in this channel + int64 remote_balance = 7; + + /* + The amount calculated to be paid in fees for the current set of commitment + transactions. The fee amount is persisted with the channel in order to + allow the fee amount to be removed and recalculated with each channel state + update, including updates that happen after a system restart. + */ + int64 commit_fee = 8; + + // The weight of the commitment transaction + int64 commit_weight = 9; + + /* + The required number of satoshis per kilo-weight that the requester will pay + at all times, for both the funding transaction and commitment transaction. + This value can later be updated once the channel is open. + */ + int64 fee_per_kw = 10; + + // The unsettled balance in this channel + int64 unsettled_balance = 11; + + /* + The total number of satoshis we've sent within this channel. + */ + int64 total_satoshis_sent = 12; + + /* + The total number of satoshis we've received within this channel. + */ + int64 total_satoshis_received = 13; + + /* + The total number of updates conducted within this channel. + */ + uint64 num_updates = 14; + + /* + The list of active, uncleared HTLCs currently pending within the channel. + */ + repeated HTLC pending_htlcs = 15; + + /* + Deprecated. The CSV delay expressed in relative blocks. If the channel is + force closed, we will need to wait for this many blocks before we can regain + our funds. + */ + uint32 csv_delay = 16 [deprecated = true]; + + // Whether this channel is advertised to the network or not. + bool private = 17; + + // True if we were the ones that created the channel. + bool initiator = 18; + + // A set of flags showing the current state of the channel. + string chan_status_flags = 19; + + // Deprecated. The minimum satoshis this node is required to reserve in its + // balance. + int64 local_chan_reserve_sat = 20 [deprecated = true]; + + /* + Deprecated. The minimum satoshis the other node is required to reserve in + its balance. + */ + int64 remote_chan_reserve_sat = 21 [deprecated = true]; + + // Deprecated. Use commitment_type. + bool static_remote_key = 22 [deprecated = true]; + + // The commitment type used by this channel. + CommitmentType commitment_type = 26; + + /* + The number of seconds that the channel has been monitored by the channel + scoring system. Scores are currently not persisted, so this value may be + less than the lifetime of the channel [EXPERIMENTAL]. + */ + int64 lifetime = 23; + + /* + The number of seconds that the remote peer has been observed as being online + by the channel scoring system over the lifetime of the channel + [EXPERIMENTAL]. + */ + int64 uptime = 24; + + /* + Close address is the address that we will enforce payout to on cooperative + close if the channel was opened utilizing option upfront shutdown. This + value can be set on channel open by setting close_address in an open channel + request. If this value is not set, you can still choose a payout address by + cooperatively closing with the delivery_address field set. + */ + string close_address = 25; + + /* + The amount that the initiator of the channel optionally pushed to the remote + party on channel open. This amount will be zero if the channel initiator did + not push any funds to the remote peer. If the initiator field is true, we + pushed this amount to our peer, if it is false, the remote peer pushed this + amount to us. + */ + uint64 push_amount_sat = 27; + + /* + This uint32 indicates if this channel is to be considered 'frozen'. A + frozen channel doest not allow a cooperative channel close by the + initiator. The thaw_height is the height that this restriction stops + applying to the channel. This field is optional, not setting it or using a + value of zero will mean the channel has no additional restrictions. The + height can be interpreted in two ways: as a relative height if the value is + less than 500,000, or as an absolute height otherwise. + */ + uint32 thaw_height = 28; + + // List constraints for the local node. + ChannelConstraints local_constraints = 29; + + // List constraints for the remote node. + ChannelConstraints remote_constraints = 30; + + /* + This lists out the set of alias short channel ids that exist for a channel. + This may be empty. + */ + repeated uint64 alias_scids = 31; + + // Whether or not this is a zero-conf channel. + bool zero_conf = 32; + + // This is the confirmed / on-chain zero-conf SCID. + uint64 zero_conf_confirmed_scid = 33; + + // The configured alias name of our peer. + string peer_alias = 34; + + // This is the peer SCID alias. + uint64 peer_scid_alias = 35 [jstype = JS_STRING]; + + /* + An optional note-to-self to go along with the channel containing some + useful information. This is only ever stored locally and in no way impacts + the channel's operation. + */ + string memo = 36; +} + +message ListChannelsRequest { + bool active_only = 1; + bool inactive_only = 2; + bool public_only = 3; + bool private_only = 4; + + /* + Filters the response for channels with a target peer's pubkey. If peer is + empty, all channels will be returned. + */ + bytes peer = 5; + + // Informs the server if the peer alias lookup per channel should be + // enabled. It is turned off by default in order to avoid degradation of + // performance for existing clients. + bool peer_alias_lookup = 6; +} +message ListChannelsResponse { + // The list of active channels + repeated Channel channels = 11; +} + +message AliasMap { + /* + For non-zero-conf channels, this is the confirmed SCID. Otherwise, this is + the first assigned "base" alias. + */ + uint64 base_scid = 1; + + // The set of all aliases stored for the base SCID. + repeated uint64 aliases = 2; +} +message ListAliasesRequest { +} +message ListAliasesResponse { + repeated AliasMap alias_maps = 1; +} + +enum Initiator { + INITIATOR_UNKNOWN = 0; + INITIATOR_LOCAL = 1; + INITIATOR_REMOTE = 2; + INITIATOR_BOTH = 3; +} + +message ChannelCloseSummary { + // The outpoint (txid:index) of the funding transaction. + string channel_point = 1; + + // The unique channel ID for the channel. + uint64 chan_id = 2 [jstype = JS_STRING]; + + // The hash of the genesis block that this channel resides within. + string chain_hash = 3; + + // The txid of the transaction which ultimately closed this channel. + string closing_tx_hash = 4; + + // Public key of the remote peer that we formerly had a channel with. + string remote_pubkey = 5; + + // Total capacity of the channel. + int64 capacity = 6; + + // Height at which the funding transaction was spent. + uint32 close_height = 7; + + // Settled balance at the time of channel closure + int64 settled_balance = 8; + + // The sum of all the time-locked outputs at the time of channel closure + int64 time_locked_balance = 9; + + enum ClosureType { + COOPERATIVE_CLOSE = 0; + LOCAL_FORCE_CLOSE = 1; + REMOTE_FORCE_CLOSE = 2; + BREACH_CLOSE = 3; + FUNDING_CANCELED = 4; + ABANDONED = 5; + } + + // Details on how the channel was closed. + ClosureType close_type = 10; + + /* + Open initiator is the party that initiated opening the channel. Note that + this value may be unknown if the channel was closed before we migrated to + store open channel information after close. + */ + Initiator open_initiator = 11; + + /* + Close initiator indicates which party initiated the close. This value will + be unknown for channels that were cooperatively closed before we started + tracking cooperative close initiators. Note that this indicates which party + initiated a close, and it is possible for both to initiate cooperative or + force closes, although only one party's close will be confirmed on chain. + */ + Initiator close_initiator = 12; + + repeated Resolution resolutions = 13; + + /* + This lists out the set of alias short channel ids that existed for the + closed channel. This may be empty. + */ + repeated uint64 alias_scids = 14; + + // The confirmed SCID for a zero-conf channel. + uint64 zero_conf_confirmed_scid = 15 [jstype = JS_STRING]; +} + +enum ResolutionType { + TYPE_UNKNOWN = 0; + + // We resolved an anchor output. + ANCHOR = 1; + + /* + We are resolving an incoming htlc on chain. This if this htlc is + claimed, we swept the incoming htlc with the preimage. If it is timed + out, our peer swept the timeout path. + */ + INCOMING_HTLC = 2; + + /* + We are resolving an outgoing htlc on chain. If this htlc is claimed, + the remote party swept the htlc with the preimage. If it is timed out, + we swept it with the timeout path. + */ + OUTGOING_HTLC = 3; + + // We force closed and need to sweep our time locked commitment output. + COMMIT = 4; +} + +enum ResolutionOutcome { + // Outcome unknown. + OUTCOME_UNKNOWN = 0; + + // An output was claimed on chain. + CLAIMED = 1; + + // An output was left unclaimed on chain. + UNCLAIMED = 2; + + /* + ResolverOutcomeAbandoned indicates that an output that we did not + claim on chain, for example an anchor that we did not sweep and a + third party claimed on chain, or a htlc that we could not decode + so left unclaimed. + */ + ABANDONED = 3; + + /* + If we force closed our channel, our htlcs need to be claimed in two + stages. This outcome represents the broadcast of a timeout or success + transaction for this two stage htlc claim. + */ + FIRST_STAGE = 4; + + // A htlc was timed out on chain. + TIMEOUT = 5; +} + +message Resolution { + // The type of output we are resolving. + ResolutionType resolution_type = 1; + + // The outcome of our on chain action that resolved the outpoint. + ResolutionOutcome outcome = 2; + + // The outpoint that was spent by the resolution. + OutPoint outpoint = 3; + + // The amount that was claimed by the resolution. + uint64 amount_sat = 4; + + // The hex-encoded transaction ID of the sweep transaction that spent the + // output. + string sweep_txid = 5; +} + +message ClosedChannelsRequest { + bool cooperative = 1; + bool local_force = 2; + bool remote_force = 3; + bool breach = 4; + bool funding_canceled = 5; + bool abandoned = 6; +} + +message ClosedChannelsResponse { + repeated ChannelCloseSummary channels = 1; +} + +message Peer { + // The identity pubkey of the peer + string pub_key = 1; + + // Network address of the peer; eg `127.0.0.1:10011` + string address = 3; + + // Bytes of data transmitted to this peer + uint64 bytes_sent = 4; + + // Bytes of data transmitted from this peer + uint64 bytes_recv = 5; + + // Satoshis sent to this peer + int64 sat_sent = 6; + + // Satoshis received from this peer + int64 sat_recv = 7; + + // A channel is inbound if the counterparty initiated the channel + bool inbound = 8; + + // Ping time to this peer + int64 ping_time = 9; + + enum SyncType { + /* + Denotes that we cannot determine the peer's current sync type. + */ + UNKNOWN_SYNC = 0; + + /* + Denotes that we are actively receiving new graph updates from the peer. + */ + ACTIVE_SYNC = 1; + + /* + Denotes that we are not receiving new graph updates from the peer. + */ + PASSIVE_SYNC = 2; + + /* + Denotes that this peer is pinned into an active sync. + */ + PINNED_SYNC = 3; + } + + // The type of sync we are currently performing with this peer. + SyncType sync_type = 10; + + // Features advertised by the remote peer in their init message. + map features = 11; + + /* + The latest errors received from our peer with timestamps, limited to the 10 + most recent errors. These errors are tracked across peer connections, but + are not persisted across lnd restarts. Note that these errors are only + stored for peers that we have channels open with, to prevent peers from + spamming us with errors at no cost. + */ + repeated TimestampedError errors = 12; + + /* + The number of times we have recorded this peer going offline or coming + online, recorded across restarts. Note that this value is decreased over + time if the peer has not recently flapped, so that we can forgive peers + with historically high flap counts. + */ + int32 flap_count = 13; + + /* + The timestamp of the last flap we observed for this peer. If this value is + zero, we have not observed any flaps for this peer. + */ + int64 last_flap_ns = 14; + + /* + The last ping payload the peer has sent to us. + */ + bytes last_ping_payload = 15; +} + +message TimestampedError { + // The unix timestamp in seconds when the error occurred. + uint64 timestamp = 1; + + // The string representation of the error sent by our peer. + string error = 2; +} + +message ListPeersRequest { + /* + If true, only the last error that our peer sent us will be returned with + the peer's information, rather than the full set of historic errors we have + stored. + */ + bool latest_error = 1; +} +message ListPeersResponse { + // The list of currently connected peers + repeated Peer peers = 1; +} + +message PeerEventSubscription { +} + +message PeerEvent { + // The identity pubkey of the peer. + string pub_key = 1; + + enum EventType { + PEER_ONLINE = 0; + PEER_OFFLINE = 1; + } + + EventType type = 2; +} + +message GetInfoRequest { +} +message GetInfoResponse { + // The version of the LND software that the node is running. + string version = 14; + + // The SHA1 commit hash that the daemon is compiled with. + string commit_hash = 20; + + // The identity pubkey of the current node. + string identity_pubkey = 1; + + // If applicable, the alias of the current node, e.g. "bob" + string alias = 2; + + // The color of the current node in hex code format + string color = 17; + + // Number of pending channels + uint32 num_pending_channels = 3; + + // Number of active channels + uint32 num_active_channels = 4; + + // Number of inactive channels + uint32 num_inactive_channels = 15; + + // Number of peers + uint32 num_peers = 5; + + // The node's current view of the height of the best block + uint32 block_height = 6; + + // The node's current view of the hash of the best block + string block_hash = 8; + + // Timestamp of the block best known to the wallet + int64 best_header_timestamp = 13; + + // Whether the wallet's view is synced to the main chain + bool synced_to_chain = 9; + + // Whether we consider ourselves synced with the public channel graph. + bool synced_to_graph = 18; + + /* + Whether the current node is connected to testnet. This field is + deprecated and the network field should be used instead + */ + bool testnet = 10 [deprecated = true]; + + reserved 11; + + /* + A list of active chains the node is connected to. This will only + ever contain a single entry since LND will only ever have a single + chain backend during its lifetime. + */ + repeated Chain chains = 16; + + // The URIs of the current node. + repeated string uris = 12; + + /* + Features that our node has advertised in our init message, node + announcements and invoices. + */ + map features = 19; + + /* + Indicates whether the HTLC interceptor API is in always-on mode. + */ + bool require_htlc_interceptor = 21; + + // Indicates whether final htlc resolutions are stored on disk. + bool store_final_htlc_resolutions = 22; +} + +message GetDebugInfoRequest { +} + +message GetDebugInfoResponse { + map config = 1; + repeated string log = 2; +} + +message GetRecoveryInfoRequest { +} +message GetRecoveryInfoResponse { + // Whether the wallet is in recovery mode + bool recovery_mode = 1; + + // Whether the wallet recovery progress is finished + bool recovery_finished = 2; + + // The recovery progress, ranging from 0 to 1. + double progress = 3; +} + +message Chain { + // Deprecated. The chain is now always assumed to be bitcoin. + // The blockchain the node is on (must be bitcoin) + string chain = 1 [deprecated = true]; + + // The network the node is on (eg regtest, testnet, mainnet) + string network = 2; +} + +message ConfirmationUpdate { + bytes block_sha = 1; + int32 block_height = 2; + + uint32 num_confs_left = 3; +} + +message ChannelOpenUpdate { + ChannelPoint channel_point = 1; +} + +message ChannelCloseUpdate { + bytes closing_txid = 1; + + bool success = 2; +} + +message CloseChannelRequest { + /* + The outpoint (txid:index) of the funding transaction. With this value, Bob + will be able to generate a signature for Alice's version of the commitment + transaction. + */ + ChannelPoint channel_point = 1; + + // If true, then the channel will be closed forcibly. This means the + // current commitment transaction will be signed and broadcast. + bool force = 2; + + // The target number of blocks that the closure transaction should be + // confirmed by. + int32 target_conf = 3; + + // Deprecated, use sat_per_vbyte. + // A manual fee rate set in sat/vbyte that should be used when crafting the + // closure transaction. + int64 sat_per_byte = 4 [deprecated = true]; + + /* + An optional address to send funds to in the case of a cooperative close. + If the channel was opened with an upfront shutdown script and this field + is set, the request to close will fail because the channel must pay out + to the upfront shutdown addresss. + */ + string delivery_address = 5; + + // A manual fee rate set in sat/vbyte that should be used when crafting the + // closure transaction. + uint64 sat_per_vbyte = 6; + + // The maximum fee rate the closer is willing to pay. + // + // NOTE: This field is only respected if we're the initiator of the channel. + uint64 max_fee_per_vbyte = 7; + + // If true, then the rpc call will not block while it awaits a closing txid. + // Consequently this RPC call will not return a closing txid if this value + // is set. + bool no_wait = 8; +} + +message CloseStatusUpdate { + oneof update { + PendingUpdate close_pending = 1; + ChannelCloseUpdate chan_close = 3; + InstantUpdate close_instant = 4; + } +} + +message PendingUpdate { + bytes txid = 1; + uint32 output_index = 2; +} + +message InstantUpdate { +} + +message ReadyForPsbtFunding { + /* + The P2WSH address of the channel funding multisig address that the below + specified amount in satoshis needs to be sent to. + */ + string funding_address = 1; + + /* + The exact amount in satoshis that needs to be sent to the above address to + fund the pending channel. + */ + int64 funding_amount = 2; + + /* + A raw PSBT that contains the pending channel output. If a base PSBT was + provided in the PsbtShim, this is the base PSBT with one additional output. + If no base PSBT was specified, this is an otherwise empty PSBT with exactly + one output. + */ + bytes psbt = 3; +} + +message BatchOpenChannelRequest { + // The list of channels to open. + repeated BatchOpenChannel channels = 1; + + // The target number of blocks that the funding transaction should be + // confirmed by. + int32 target_conf = 2; + + // A manual fee rate set in sat/vByte that should be used when crafting the + // funding transaction. + int64 sat_per_vbyte = 3; + + // The minimum number of confirmations each one of your outputs used for + // the funding transaction must satisfy. + int32 min_confs = 4; + + // Whether unconfirmed outputs should be used as inputs for the funding + // transaction. + bool spend_unconfirmed = 5; + + // An optional label for the batch transaction, limited to 500 characters. + string label = 6; + + // The strategy to use for selecting coins during batch opening channels. + CoinSelectionStrategy coin_selection_strategy = 7; +} + +message BatchOpenChannel { + // The pubkey of the node to open a channel with. When using REST, this + // field must be encoded as base64. + bytes node_pubkey = 1; + + // The number of satoshis the wallet should commit to the channel. + int64 local_funding_amount = 2; + + // The number of satoshis to push to the remote side as part of the initial + // commitment state. + int64 push_sat = 3; + + // Whether this channel should be private, not announced to the greater + // network. + bool private = 4; + + // The minimum value in millisatoshi we will require for incoming HTLCs on + // the channel. + int64 min_htlc_msat = 5; + + // The delay we require on the remote's commitment transaction. If this is + // not set, it will be scaled automatically with the channel size. + uint32 remote_csv_delay = 6; + + /* + Close address is an optional address which specifies the address to which + funds should be paid out to upon cooperative close. This field may only be + set if the peer supports the option upfront feature bit (call listpeers + to check). The remote peer will only accept cooperative closes to this + address if it is set. + + Note: If this value is set on channel creation, you will *not* be able to + cooperatively close out to a different address. + */ + string close_address = 7; + + /* + An optional, unique identifier of 32 random bytes that will be used as the + pending channel ID to identify the channel while it is in the pre-pending + state. + */ + bytes pending_chan_id = 8; + + /* + The explicit commitment type to use. Note this field will only be used if + the remote peer supports explicit channel negotiation. + */ + CommitmentType commitment_type = 9; + + /* + The maximum amount of coins in millisatoshi that can be pending within + the channel. It only applies to the remote party. + */ + uint64 remote_max_value_in_flight_msat = 10; + + /* + The maximum number of concurrent HTLCs we will allow the remote party to add + to the commitment transaction. + */ + uint32 remote_max_htlcs = 11; + + /* + Max local csv is the maximum csv delay we will allow for our own commitment + transaction. + */ + uint32 max_local_csv = 12; + + /* + If this is true, then a zero-conf channel open will be attempted. + */ + bool zero_conf = 13; + + /* + If this is true, then an option-scid-alias channel-type open will be + attempted. + */ + bool scid_alias = 14; + + /* + The base fee charged regardless of the number of milli-satoshis sent. + */ + uint64 base_fee = 15; + + /* + The fee rate in ppm (parts per million) that will be charged in + proportion of the value of each forwarded HTLC. + */ + uint64 fee_rate = 16; + + /* + If use_base_fee is true the open channel announcement will update the + channel base fee with the value specified in base_fee. In the case of + a base_fee of 0 use_base_fee is needed downstream to distinguish whether + to use the default base fee value specified in the config or 0. + */ + bool use_base_fee = 17; + + /* + If use_fee_rate is true the open channel announcement will update the + channel fee rate with the value specified in fee_rate. In the case of + a fee_rate of 0 use_fee_rate is needed downstream to distinguish whether + to use the default fee rate value specified in the config or 0. + */ + bool use_fee_rate = 18; + + /* + The number of satoshis we require the remote peer to reserve. This value, + if specified, must be above the dust limit and below 20% of the channel + capacity. + */ + uint64 remote_chan_reserve_sat = 19; + + /* + An optional note-to-self to go along with the channel containing some + useful information. This is only ever stored locally and in no way impacts + the channel's operation. + */ + string memo = 20; +} + +message BatchOpenChannelResponse { + repeated PendingUpdate pending_channels = 1; +} + +message OpenChannelRequest { + // A manual fee rate set in sat/vbyte that should be used when crafting the + // funding transaction. + uint64 sat_per_vbyte = 1; + + /* + The pubkey of the node to open a channel with. When using REST, this field + must be encoded as base64. + */ + bytes node_pubkey = 2; + + /* + The hex encoded pubkey of the node to open a channel with. Deprecated now + that the REST gateway supports base64 encoding of bytes fields. + */ + string node_pubkey_string = 3 [deprecated = true]; + + // The number of satoshis the wallet should commit to the channel + int64 local_funding_amount = 4; + + // The number of satoshis to push to the remote side as part of the initial + // commitment state + int64 push_sat = 5; + + // The target number of blocks that the funding transaction should be + // confirmed by. + int32 target_conf = 6; + + // Deprecated, use sat_per_vbyte. + // A manual fee rate set in sat/vbyte that should be used when crafting the + // funding transaction. + int64 sat_per_byte = 7 [deprecated = true]; + + // Whether this channel should be private, not announced to the greater + // network. + bool private = 8; + + // The minimum value in millisatoshi we will require for incoming HTLCs on + // the channel. + int64 min_htlc_msat = 9; + + // The delay we require on the remote's commitment transaction. If this is + // not set, it will be scaled automatically with the channel size. + uint32 remote_csv_delay = 10; + + // The minimum number of confirmations each one of your outputs used for + // the funding transaction must satisfy. + int32 min_confs = 11; + + // Whether unconfirmed outputs should be used as inputs for the funding + // transaction. + bool spend_unconfirmed = 12; + + /* + Close address is an optional address which specifies the address to which + funds should be paid out to upon cooperative close. This field may only be + set if the peer supports the option upfront feature bit (call listpeers + to check). The remote peer will only accept cooperative closes to this + address if it is set. + + Note: If this value is set on channel creation, you will *not* be able to + cooperatively close out to a different address. + */ + string close_address = 13; + + /* + Funding shims are an optional argument that allow the caller to intercept + certain funding functionality. For example, a shim can be provided to use a + particular key for the commitment key (ideally cold) rather than use one + that is generated by the wallet as normal, or signal that signing will be + carried out in an interactive manner (PSBT based). + */ + FundingShim funding_shim = 14; + + /* + The maximum amount of coins in millisatoshi that can be pending within + the channel. It only applies to the remote party. + */ + uint64 remote_max_value_in_flight_msat = 15; + + /* + The maximum number of concurrent HTLCs we will allow the remote party to add + to the commitment transaction. + */ + uint32 remote_max_htlcs = 16; + + /* + Max local csv is the maximum csv delay we will allow for our own commitment + transaction. + */ + uint32 max_local_csv = 17; + + /* + The explicit commitment type to use. Note this field will only be used if + the remote peer supports explicit channel negotiation. + */ + CommitmentType commitment_type = 18; + + /* + If this is true, then a zero-conf channel open will be attempted. + */ + bool zero_conf = 19; + + /* + If this is true, then an option-scid-alias channel-type open will be + attempted. + */ + bool scid_alias = 20; + + /* + The base fee charged regardless of the number of milli-satoshis sent. + */ + uint64 base_fee = 21; + + /* + The fee rate in ppm (parts per million) that will be charged in + proportion of the value of each forwarded HTLC. + */ + uint64 fee_rate = 22; + + /* + If use_base_fee is true the open channel announcement will update the + channel base fee with the value specified in base_fee. In the case of + a base_fee of 0 use_base_fee is needed downstream to distinguish whether + to use the default base fee value specified in the config or 0. + */ + bool use_base_fee = 23; + + /* + If use_fee_rate is true the open channel announcement will update the + channel fee rate with the value specified in fee_rate. In the case of + a fee_rate of 0 use_fee_rate is needed downstream to distinguish whether + to use the default fee rate value specified in the config or 0. + */ + bool use_fee_rate = 24; + + /* + The number of satoshis we require the remote peer to reserve. This value, + if specified, must be above the dust limit and below 20% of the channel + capacity. + */ + uint64 remote_chan_reserve_sat = 25; + + /* + If set, then lnd will attempt to commit all the coins under control of the + internal wallet to open the channel, and the LocalFundingAmount field must + be zero and is ignored. + */ + bool fund_max = 26; + + /* + An optional note-to-self to go along with the channel containing some + useful information. This is only ever stored locally and in no way impacts + the channel's operation. + */ + string memo = 27; + + /* + A list of selected outpoints that are allocated for channel funding. + */ + repeated OutPoint outpoints = 28; +} +message OpenStatusUpdate { + oneof update { + /* + Signals that the channel is now fully negotiated and the funding + transaction published. + */ + PendingUpdate chan_pending = 1; + + /* + Signals that the channel's funding transaction has now reached the + required number of confirmations on chain and can be used. + */ + ChannelOpenUpdate chan_open = 3; + + /* + Signals that the funding process has been suspended and the construction + of a PSBT that funds the channel PK script is now required. + */ + ReadyForPsbtFunding psbt_fund = 5; + } + + /* + The pending channel ID of the created channel. This value may be used to + further the funding flow manually via the FundingStateStep method. + */ + bytes pending_chan_id = 4; +} + +message KeyLocator { + // The family of key being identified. + int32 key_family = 1; + + // The precise index of the key being identified. + int32 key_index = 2; +} + +message KeyDescriptor { + /* + The raw bytes of the key being identified. + */ + bytes raw_key_bytes = 1; + + /* + The key locator that identifies which key to use for signing. + */ + KeyLocator key_loc = 2; +} + +message ChanPointShim { + /* + The size of the pre-crafted output to be used as the channel point for this + channel funding. + */ + int64 amt = 1; + + // The target channel point to refrence in created commitment transactions. + ChannelPoint chan_point = 2; + + // Our local key to use when creating the multi-sig output. + KeyDescriptor local_key = 3; + + // The key of the remote party to use when creating the multi-sig output. + bytes remote_key = 4; + + /* + If non-zero, then this will be used as the pending channel ID on the wire + protocol to initate the funding request. This is an optional field, and + should only be set if the responder is already expecting a specific pending + channel ID. + */ + bytes pending_chan_id = 5; + + /* + This uint32 indicates if this channel is to be considered 'frozen'. A frozen + channel does not allow a cooperative channel close by the initiator. The + thaw_height is the height that this restriction stops applying to the + channel. The height can be interpreted in two ways: as a relative height if + the value is less than 500,000, or as an absolute height otherwise. + */ + uint32 thaw_height = 6; + + /* + Indicates that the funding output is using a MuSig2 multi-sig output. + */ + bool musig2 = 7; +} + +message PsbtShim { + /* + A unique identifier of 32 random bytes that will be used as the pending + channel ID to identify the PSBT state machine when interacting with it and + on the wire protocol to initiate the funding request. + */ + bytes pending_chan_id = 1; + + /* + An optional base PSBT the new channel output will be added to. If this is + non-empty, it must be a binary serialized PSBT. + */ + bytes base_psbt = 2; + + /* + If a channel should be part of a batch (multiple channel openings in one + transaction), it can be dangerous if the whole batch transaction is + published too early before all channel opening negotiations are completed. + This flag prevents this particular channel from broadcasting the transaction + after the negotiation with the remote peer. In a batch of channel openings + this flag should be set to true for every channel but the very last. + */ + bool no_publish = 3; +} + +message FundingShim { + oneof shim { + /* + A channel shim where the channel point was fully constructed outside + of lnd's wallet and the transaction might already be published. + */ + ChanPointShim chan_point_shim = 1; + + /* + A channel shim that uses a PSBT to fund and sign the channel funding + transaction. + */ + PsbtShim psbt_shim = 2; + } +} + +message FundingShimCancel { + // The pending channel ID of the channel to cancel the funding shim for. + bytes pending_chan_id = 1; +} + +message FundingPsbtVerify { + /* + The funded but not yet signed PSBT that sends the exact channel capacity + amount to the PK script returned in the open channel message in a previous + step. + */ + bytes funded_psbt = 1; + + // The pending channel ID of the channel to get the PSBT for. + bytes pending_chan_id = 2; + + /* + Can only be used if the no_publish flag was set to true in the OpenChannel + call meaning that the caller is solely responsible for publishing the final + funding transaction. If skip_finalize is set to true then lnd will not wait + for a FundingPsbtFinalize state step and instead assumes that a transaction + with the same TXID as the passed in PSBT will eventually confirm. + IT IS ABSOLUTELY IMPERATIVE that the TXID of the transaction that is + eventually published does have the _same TXID_ as the verified PSBT. That + means no inputs or outputs can change, only signatures can be added. If the + TXID changes between this call and the publish step then the channel will + never be created and the funds will be in limbo. + */ + bool skip_finalize = 3; +} + +message FundingPsbtFinalize { + /* + The funded PSBT that contains all witness data to send the exact channel + capacity amount to the PK script returned in the open channel message in a + previous step. Cannot be set at the same time as final_raw_tx. + */ + bytes signed_psbt = 1; + + // The pending channel ID of the channel to get the PSBT for. + bytes pending_chan_id = 2; + + /* + As an alternative to the signed PSBT with all witness data, the final raw + wire format transaction can also be specified directly. Cannot be set at the + same time as signed_psbt. + */ + bytes final_raw_tx = 3; +} + +message FundingTransitionMsg { + oneof trigger { + /* + The funding shim to register. This should be used before any + channel funding has began by the remote party, as it is intended as a + preparatory step for the full channel funding. + */ + FundingShim shim_register = 1; + + // Used to cancel an existing registered funding shim. + FundingShimCancel shim_cancel = 2; + + /* + Used to continue a funding flow that was initiated to be executed + through a PSBT. This step verifies that the PSBT contains the correct + outputs to fund the channel. + */ + FundingPsbtVerify psbt_verify = 3; + + /* + Used to continue a funding flow that was initiated to be executed + through a PSBT. This step finalizes the funded and signed PSBT, finishes + negotiation with the peer and finally publishes the resulting funding + transaction. + */ + FundingPsbtFinalize psbt_finalize = 4; + } +} + +message FundingStateStepResp { +} + +message PendingHTLC { + // The direction within the channel that the htlc was sent + bool incoming = 1; + + // The total value of the htlc + int64 amount = 2; + + // The final output to be swept back to the user's wallet + string outpoint = 3; + + // The next block height at which we can spend the current stage + uint32 maturity_height = 4; + + /* + The number of blocks remaining until the current stage can be swept. + Negative values indicate how many blocks have passed since becoming + mature. + */ + int32 blocks_til_maturity = 5; + + // Indicates whether the htlc is in its first or second stage of recovery + uint32 stage = 6; +} + +message PendingChannelsRequest { + // Indicates whether to include the raw transaction hex for + // waiting_close_channels. + bool include_raw_tx = 1; +} +message PendingChannelsResponse { + message PendingChannel { + string remote_node_pub = 1; + string channel_point = 2; + + int64 capacity = 3; + + int64 local_balance = 4; + int64 remote_balance = 5; + + // The minimum satoshis this node is required to reserve in its + // balance. + int64 local_chan_reserve_sat = 6; + + /* + The minimum satoshis the other node is required to reserve in its + balance. + */ + int64 remote_chan_reserve_sat = 7; + + // The party that initiated opening the channel. + Initiator initiator = 8; + + // The commitment type used by this channel. + CommitmentType commitment_type = 9; + + // Total number of forwarding packages created in this channel. + int64 num_forwarding_packages = 10; + + // A set of flags showing the current state of the channel. + string chan_status_flags = 11; + + // Whether this channel is advertised to the network or not. + bool private = 12; + + /* + An optional note-to-self to go along with the channel containing some + useful information. This is only ever stored locally and in no way + impacts the channel's operation. + */ + string memo = 13; + } + + message PendingOpenChannel { + // The pending channel + PendingChannel channel = 1; + + /* + The amount calculated to be paid in fees for the current set of + commitment transactions. The fee amount is persisted with the channel + in order to allow the fee amount to be removed and recalculated with + each channel state update, including updates that happen after a system + restart. + */ + int64 commit_fee = 4; + + // The weight of the commitment transaction + int64 commit_weight = 5; + + /* + The required number of satoshis per kilo-weight that the requester will + pay at all times, for both the funding transaction and commitment + transaction. This value can later be updated once the channel is open. + */ + int64 fee_per_kw = 6; + + // Previously used for confirmation_height. Do not reuse. + reserved 2; + + // The number of blocks until the funding transaction is considered + // expired. If this value gets close to zero, there is a risk that the + // channel funding will be canceled by the channel responder. The + // channel should be fee bumped using CPFP (see walletrpc.BumpFee) to + // ensure that the channel confirms in time. Otherwise a force-close + // will be necessary if the channel confirms after the funding + // transaction expires. A negative value means the channel responder has + // very likely canceled the funding and the channel will never become + // fully operational. + int32 funding_expiry_blocks = 3; + } + + message WaitingCloseChannel { + // The pending channel waiting for closing tx to confirm + PendingChannel channel = 1; + + // The balance in satoshis encumbered in this channel + int64 limbo_balance = 2; + + /* + A list of valid commitment transactions. Any of these can confirm at + this point. + */ + Commitments commitments = 3; + + // The transaction id of the closing transaction + string closing_txid = 4; + + // The raw hex encoded bytes of the closing transaction. Included if + // include_raw_tx in the request is true. + string closing_tx_hex = 5; + } + + message Commitments { + // Hash of the local version of the commitment tx. + string local_txid = 1; + + // Hash of the remote version of the commitment tx. + string remote_txid = 2; + + // Hash of the remote pending version of the commitment tx. + string remote_pending_txid = 3; + + /* + The amount in satoshis calculated to be paid in fees for the local + commitment. + */ + uint64 local_commit_fee_sat = 4; + + /* + The amount in satoshis calculated to be paid in fees for the remote + commitment. + */ + uint64 remote_commit_fee_sat = 5; + + /* + The amount in satoshis calculated to be paid in fees for the remote + pending commitment. + */ + uint64 remote_pending_commit_fee_sat = 6; + } + + message ClosedChannel { + // The pending channel to be closed + PendingChannel channel = 1; + + // The transaction id of the closing transaction + string closing_txid = 2; + } + + message ForceClosedChannel { + // The pending channel to be force closed + PendingChannel channel = 1; + + // The transaction id of the closing transaction + string closing_txid = 2; + + // The balance in satoshis encumbered in this pending channel + int64 limbo_balance = 3; + + // The height at which funds can be swept into the wallet + uint32 maturity_height = 4; + + /* + Remaining # of blocks until the commitment output can be swept. + Negative values indicate how many blocks have passed since becoming + mature. + */ + int32 blocks_til_maturity = 5; + + // The total value of funds successfully recovered from this channel + int64 recovered_balance = 6; + + repeated PendingHTLC pending_htlcs = 8; + + /* + There are three resolution states for the anchor: + limbo, lost and recovered. Derive the current state + from the limbo and recovered balances. + */ + enum AnchorState { + // The recovered_balance is zero and limbo_balance is non-zero. + LIMBO = 0; + // The recovered_balance is non-zero. + RECOVERED = 1; + // A state that is neither LIMBO nor RECOVERED. + LOST = 2; + } + + AnchorState anchor = 9; + } + + // The balance in satoshis encumbered in pending channels + int64 total_limbo_balance = 1; + + // Channels pending opening + repeated PendingOpenChannel pending_open_channels = 2; + + /* + Deprecated: Channels pending closing previously contained cooperatively + closed channels with a single confirmation. These channels are now + considered closed from the time we see them on chain. + */ + repeated ClosedChannel pending_closing_channels = 3 [deprecated = true]; + + // Channels pending force closing + repeated ForceClosedChannel pending_force_closing_channels = 4; + + // Channels waiting for closing tx to confirm + repeated WaitingCloseChannel waiting_close_channels = 5; +} + +message ChannelEventSubscription { +} + +message ChannelEventUpdate { + oneof channel { + Channel open_channel = 1; + ChannelCloseSummary closed_channel = 2; + ChannelPoint active_channel = 3; + ChannelPoint inactive_channel = 4; + PendingUpdate pending_open_channel = 6; + ChannelPoint fully_resolved_channel = 7; + } + + enum UpdateType { + OPEN_CHANNEL = 0; + CLOSED_CHANNEL = 1; + ACTIVE_CHANNEL = 2; + INACTIVE_CHANNEL = 3; + PENDING_OPEN_CHANNEL = 4; + FULLY_RESOLVED_CHANNEL = 5; + } + + UpdateType type = 5; +} + +message WalletAccountBalance { + // The confirmed balance of the account (with >= 1 confirmations). + int64 confirmed_balance = 1; + + // The unconfirmed balance of the account (with 0 confirmations). + int64 unconfirmed_balance = 2; +} + +message WalletBalanceRequest { + // The wallet account the balance is shown for. + // If this is not specified, the balance of the "default" account is shown. + string account = 1; + + // The minimum number of confirmations each one of your outputs used for the + // funding transaction must satisfy. If this is not specified, the default + // value of 1 is used. + int32 min_confs = 2; +} + +message WalletBalanceResponse { + // The balance of the wallet + int64 total_balance = 1; + + // The confirmed balance of a wallet(with >= 1 confirmations) + int64 confirmed_balance = 2; + + // The unconfirmed balance of a wallet(with 0 confirmations) + int64 unconfirmed_balance = 3; + + // The total amount of wallet UTXOs held in outputs that are locked for + // other usage. + int64 locked_balance = 5; + + // The amount of reserve required. + int64 reserved_balance_anchor_chan = 6; + + // A mapping of each wallet account's name to its balance. + map account_balance = 4; +} + +message Amount { + // Value denominated in satoshis. + uint64 sat = 1; + + // Value denominated in milli-satoshis. + uint64 msat = 2; +} + +message ChannelBalanceRequest { +} +message ChannelBalanceResponse { + // Deprecated. Sum of channels balances denominated in satoshis + int64 balance = 1 [deprecated = true]; + + // Deprecated. Sum of channels pending balances denominated in satoshis + int64 pending_open_balance = 2 [deprecated = true]; + + // Sum of channels local balances. + Amount local_balance = 3; + + // Sum of channels remote balances. + Amount remote_balance = 4; + + // Sum of channels local unsettled balances. + Amount unsettled_local_balance = 5; + + // Sum of channels remote unsettled balances. + Amount unsettled_remote_balance = 6; + + // Sum of channels pending local balances. + Amount pending_open_local_balance = 7; + + // Sum of channels pending remote balances. + Amount pending_open_remote_balance = 8; +} + +message QueryRoutesRequest { + // The 33-byte hex-encoded public key for the payment destination + string pub_key = 1; + + /* + The amount to send expressed in satoshis. + + The fields amt and amt_msat are mutually exclusive. + */ + int64 amt = 2; + + /* + The amount to send expressed in millisatoshis. + + The fields amt and amt_msat are mutually exclusive. + */ + int64 amt_msat = 12; + + reserved 3; + + /* + An optional CLTV delta from the current height that should be used for the + timelock of the final hop. Note that unlike SendPayment, QueryRoutes does + not add any additional block padding on top of final_ctlv_delta. This + padding of a few blocks needs to be added manually or otherwise failures may + happen when a block comes in while the payment is in flight. + + Note: must not be set if making a payment to a blinded path (delta is + set by the aggregate parameters provided by blinded_payment_paths) + */ + int32 final_cltv_delta = 4; + + /* + The maximum number of satoshis that will be paid as a fee of the payment. + This value can be represented either as a percentage of the amount being + sent, or as a fixed amount of the maximum fee the user is willing the pay to + send the payment. If not specified, lnd will use a default value of 100% + fees for small amounts (<=1k sat) or 5% fees for larger amounts. + */ + FeeLimit fee_limit = 5; + + /* + A list of nodes to ignore during path finding. When using REST, these fields + must be encoded as base64. + */ + repeated bytes ignored_nodes = 6; + + /* + Deprecated. A list of edges to ignore during path finding. + */ + repeated EdgeLocator ignored_edges = 7 [deprecated = true]; + + /* + The source node where the request route should originated from. If empty, + self is assumed. + */ + string source_pub_key = 8; + + /* + If set to true, edge probabilities from mission control will be used to get + the optimal route. + */ + bool use_mission_control = 9; + + /* + A list of directed node pairs that will be ignored during path finding. + */ + repeated NodePair ignored_pairs = 10; + + /* + An optional maximum total time lock for the route. If the source is empty or + ourselves, this should not exceed lnd's `--max-cltv-expiry` setting. If + zero, then the value of `--max-cltv-expiry` is used as the limit. + */ + uint32 cltv_limit = 11; + + /* + An optional field that can be used to pass an arbitrary set of TLV records + to a peer which understands the new records. This can be used to pass + application specific data during the payment attempt. If the destination + does not support the specified records, an error will be returned. + Record types are required to be in the custom range >= 65536. When using + REST, the values must be encoded as base64. + */ + map dest_custom_records = 13; + + /* + The channel id of the channel that must be taken to the first hop. If zero, + any channel may be used. + */ + uint64 outgoing_chan_id = 14 [jstype = JS_STRING]; + + /* + The pubkey of the last hop of the route. If empty, any hop may be used. + */ + bytes last_hop_pubkey = 15; + + /* + Optional route hints to reach the destination through private channels. + */ + repeated lnrpc.RouteHint route_hints = 16; + + /* + An optional blinded path(s) to reach the destination. Note that the + introduction node must be provided as the first hop in the route. + */ + repeated BlindedPaymentPath blinded_payment_paths = 19; + + /* + Features assumed to be supported by the final node. All transitive feature + dependencies must also be set properly. For a given feature bit pair, either + optional or remote may be set, but not both. If this field is nil or empty, + the router will try to load destination features from the graph as a + fallback. + + Note: must not be set if making a payment to a blinded route (features + are provided in blinded_payment_paths). + */ + repeated lnrpc.FeatureBit dest_features = 17; + + /* + The time preference for this payment. Set to -1 to optimize for fees + only, to 1 to optimize for reliability only or a value inbetween for a mix. + */ + double time_pref = 18; +} + +message NodePair { + /* + The sending node of the pair. When using REST, this field must be encoded as + base64. + */ + bytes from = 1; + + /* + The receiving node of the pair. When using REST, this field must be encoded + as base64. + */ + bytes to = 2; +} + +message EdgeLocator { + // The short channel id of this edge. + uint64 channel_id = 1 [jstype = JS_STRING]; + + /* + The direction of this edge. If direction_reverse is false, the direction + of this edge is from the channel endpoint with the lexicographically smaller + pub key to the endpoint with the larger pub key. If direction_reverse is + is true, the edge goes the other way. + */ + bool direction_reverse = 2; +} + +message QueryRoutesResponse { + /* + The route that results from the path finding operation. This is still a + repeated field to retain backwards compatibility. + */ + repeated Route routes = 1; + + /* + The success probability of the returned route based on the current mission + control state. [EXPERIMENTAL] + */ + double success_prob = 2; +} + +message Hop { + /* + The unique channel ID for the channel. The first 3 bytes are the block + height, the next 3 the index within the block, and the last 2 bytes are the + output index for the channel. + */ + uint64 chan_id = 1 [jstype = JS_STRING]; + int64 chan_capacity = 2 [deprecated = true]; + int64 amt_to_forward = 3 [deprecated = true]; + int64 fee = 4 [deprecated = true]; + uint32 expiry = 5; + int64 amt_to_forward_msat = 6; + int64 fee_msat = 7; + + /* + An optional public key of the hop. If the public key is given, the payment + can be executed without relying on a copy of the channel graph. + */ + string pub_key = 8; + + /* + If set to true, then this hop will be encoded using the new variable length + TLV format. Note that if any custom tlv_records below are specified, then + this field MUST be set to true for them to be encoded properly. + */ + bool tlv_payload = 9 [deprecated = true]; + + /* + An optional TLV record that signals the use of an MPP payment. If present, + the receiver will enforce that the same mpp_record is included in the final + hop payload of all non-zero payments in the HTLC set. If empty, a regular + single-shot payment is or was attempted. + */ + MPPRecord mpp_record = 10; + + /* + An optional TLV record that signals the use of an AMP payment. If present, + the receiver will treat all received payments including the same + (payment_addr, set_id) pair as being part of one logical payment. The + payment will be settled by XORing the root_share's together and deriving the + child hashes and preimages according to BOLT XX. Must be used in conjunction + with mpp_record. + */ + AMPRecord amp_record = 12; + + /* + An optional set of key-value TLV records. This is useful within the context + of the SendToRoute call as it allows callers to specify arbitrary K-V pairs + to drop off at each hop within the onion. + */ + map custom_records = 11; + + // The payment metadata to send along with the payment to the payee. + bytes metadata = 13; + + /* + Blinding point is an optional blinding point included for introduction + nodes in blinded paths. This field is mandatory for hops that represents + the introduction point in a blinded path. + */ + bytes blinding_point = 14; + + /* + Encrypted data is a receiver-produced blob of data that provides hops + in a blinded route with forwarding data. As this data is encrypted by + the recipient, we will not be able to parse it - it is essentially an + arbitrary blob of data from our node's perspective. This field is + mandatory for all hops in a blinded path, including the introduction + node. + */ + bytes encrypted_data = 15; + + /* + The total amount that is sent to the recipient (possibly across multiple + HTLCs), as specified by the sender when making a payment to a blinded path. + This value is only set in the final hop payload of a blinded payment. This + value is analogous to the MPPRecord that is used for regular (non-blinded) + MPP payments. + */ + uint64 total_amt_msat = 16; +} + +message MPPRecord { + /* + A unique, random identifier used to authenticate the sender as the intended + payer of a multi-path payment. The payment_addr must be the same for all + subpayments, and match the payment_addr provided in the receiver's invoice. + The same payment_addr must be used on all subpayments. This is also called + payment secret in specifications (e.g. BOLT 11). + */ + bytes payment_addr = 11; + + /* + The total amount in milli-satoshis being sent as part of a larger multi-path + payment. The caller is responsible for ensuring subpayments to the same node + and payment_hash sum exactly to total_amt_msat. The same + total_amt_msat must be used on all subpayments. + */ + int64 total_amt_msat = 10; +} + +message AMPRecord { + bytes root_share = 1; + + bytes set_id = 2; + + uint32 child_index = 3; +} + +/* +A path through the channel graph which runs over one or more channels in +succession. This struct carries all the information required to craft the +Sphinx onion packet, and send the payment along the first hop in the path. A +route is only selected as valid if all the channels have sufficient capacity to +carry the initial payment amount after fees are accounted for. +*/ +message Route { + /* + The cumulative (final) time lock across the entire route. This is the CLTV + value that should be extended to the first hop in the route. All other hops + will decrement the time-lock as advertised, leaving enough time for all + hops to wait for or present the payment preimage to complete the payment. + */ + uint32 total_time_lock = 1; + + /* + The sum of the fees paid at each hop within the final route. In the case + of a one-hop payment, this value will be zero as we don't need to pay a fee + to ourselves. + */ + int64 total_fees = 2 [deprecated = true]; + + /* + The total amount of funds required to complete a payment over this route. + This value includes the cumulative fees at each hop. As a result, the HTLC + extended to the first-hop in the route will need to have at least this many + satoshis, otherwise the route will fail at an intermediate node due to an + insufficient amount of fees. + */ + int64 total_amt = 3 [deprecated = true]; + + /* + Contains details concerning the specific forwarding details at each hop. + */ + repeated Hop hops = 4; + + /* + The total fees in millisatoshis. + */ + int64 total_fees_msat = 5; + + /* + The total amount in millisatoshis. + */ + int64 total_amt_msat = 6; +} + +message NodeInfoRequest { + // The 33-byte hex-encoded compressed public of the target node + string pub_key = 1; + + // If true, will include all known channels associated with the node. + bool include_channels = 2; +} + +message NodeInfo { + /* + An individual vertex/node within the channel graph. A node is + connected to other nodes by one or more channel edges emanating from it. As + the graph is directed, a node will also have an incoming edge attached to + it for each outgoing edge. + */ + LightningNode node = 1; + + // The total number of channels for the node. + uint32 num_channels = 2; + + // The sum of all channels capacity for the node, denominated in satoshis. + int64 total_capacity = 3; + + // A list of all public channels for the node. + repeated ChannelEdge channels = 4; +} + +/* +An individual vertex/node within the channel graph. A node is +connected to other nodes by one or more channel edges emanating from it. As the +graph is directed, a node will also have an incoming edge attached to it for +each outgoing edge. +*/ +message LightningNode { + uint32 last_update = 1; + string pub_key = 2; + string alias = 3; + repeated NodeAddress addresses = 4; + string color = 5; + map features = 6; + + // Custom node announcement tlv records. + map custom_records = 7; +} + +message NodeAddress { + string network = 1; + string addr = 2; +} + +message RoutingPolicy { + uint32 time_lock_delta = 1; + int64 min_htlc = 2; + int64 fee_base_msat = 3; + int64 fee_rate_milli_msat = 4; + bool disabled = 5; + uint64 max_htlc_msat = 6; + uint32 last_update = 7; + + // Custom channel update tlv records. + map custom_records = 8; + + int32 inbound_fee_base_msat = 9; + int32 inbound_fee_rate_milli_msat = 10; +} + +/* +A fully authenticated channel along with all its unique attributes. +Once an authenticated channel announcement has been processed on the network, +then an instance of ChannelEdgeInfo encapsulating the channels attributes is +stored. The other portions relevant to routing policy of a channel are stored +within a ChannelEdgePolicy for each direction of the channel. +*/ +message ChannelEdge { + /* + The unique channel ID for the channel. The first 3 bytes are the block + height, the next 3 the index within the block, and the last 2 bytes are the + output index for the channel. + */ + uint64 channel_id = 1 [jstype = JS_STRING]; + string chan_point = 2; + + uint32 last_update = 3 [deprecated = true]; + + string node1_pub = 4; + string node2_pub = 5; + + int64 capacity = 6; + + RoutingPolicy node1_policy = 7; + RoutingPolicy node2_policy = 8; + + // Custom channel announcement tlv records. + map custom_records = 9; +} + +message ChannelGraphRequest { + /* + Whether unannounced channels are included in the response or not. If set, + unannounced channels are included. Unannounced channels are both private + channels, and public channels that are not yet announced to the network. + */ + bool include_unannounced = 1; +} + +// Returns a new instance of the directed channel graph. +message ChannelGraph { + // The list of `LightningNode`s in this channel graph + repeated LightningNode nodes = 1; + + // The list of `ChannelEdge`s in this channel graph + repeated ChannelEdge edges = 2; +} + +enum NodeMetricType { + UNKNOWN = 0; + BETWEENNESS_CENTRALITY = 1; +} + +message NodeMetricsRequest { + // The requested node metrics. + repeated NodeMetricType types = 1; +} + +message NodeMetricsResponse { + /* + Betweenness centrality is the sum of the ratio of shortest paths that pass + through the node for each pair of nodes in the graph (not counting paths + starting or ending at this node). + Map of node pubkey to betweenness centrality of the node. Normalized + values are in the [0,1] closed interval. + */ + map betweenness_centrality = 1; +} + +message FloatMetric { + // Arbitrary float value. + double value = 1; + + // The value normalized to [0,1] or [-1,1]. + double normalized_value = 2; +} + +message ChanInfoRequest { + /* + The unique channel ID for the channel. The first 3 bytes are the block + height, the next 3 the index within the block, and the last 2 bytes are the + output index for the channel. + */ + uint64 chan_id = 1 [jstype = JS_STRING]; + + // The channel point of the channel in format funding_txid:output_index. If + // chan_id is specified, this field is ignored. + string chan_point = 2; +} + +message NetworkInfoRequest { +} +message NetworkInfo { + uint32 graph_diameter = 1; + double avg_out_degree = 2; + uint32 max_out_degree = 3; + + uint32 num_nodes = 4; + uint32 num_channels = 5; + + int64 total_network_capacity = 6; + + double avg_channel_size = 7; + int64 min_channel_size = 8; + int64 max_channel_size = 9; + int64 median_channel_size_sat = 10; + + // The number of edges marked as zombies. + uint64 num_zombie_chans = 11; + + // TODO(roasbeef): fee rate info, expiry + // * also additional RPC for tracking fee info once in +} + +message StopRequest { +} +message StopResponse { +} + +message GraphTopologySubscription { +} +message GraphTopologyUpdate { + repeated NodeUpdate node_updates = 1; + repeated ChannelEdgeUpdate channel_updates = 2; + repeated ClosedChannelUpdate closed_chans = 3; +} +message NodeUpdate { + /* + Deprecated, use node_addresses. + */ + repeated string addresses = 1 [deprecated = true]; + + string identity_key = 2; + + /* + Deprecated, use features. + */ + bytes global_features = 3 [deprecated = true]; + + string alias = 4; + string color = 5; + repeated NodeAddress node_addresses = 7; + + /* + Features that the node has advertised in the init message, node + announcements and invoices. + */ + map features = 6; +} +message ChannelEdgeUpdate { + /* + The unique channel ID for the channel. The first 3 bytes are the block + height, the next 3 the index within the block, and the last 2 bytes are the + output index for the channel. + */ + uint64 chan_id = 1 [jstype = JS_STRING]; + + ChannelPoint chan_point = 2; + + int64 capacity = 3; + + RoutingPolicy routing_policy = 4; + + string advertising_node = 5; + string connecting_node = 6; +} +message ClosedChannelUpdate { + /* + The unique channel ID for the channel. The first 3 bytes are the block + height, the next 3 the index within the block, and the last 2 bytes are the + output index for the channel. + */ + uint64 chan_id = 1 [jstype = JS_STRING]; + int64 capacity = 2; + uint32 closed_height = 3; + ChannelPoint chan_point = 4; +} + +message HopHint { + // The public key of the node at the start of the channel. + string node_id = 1; + + // The unique identifier of the channel. + uint64 chan_id = 2 [jstype = JS_STRING]; + + // The base fee of the channel denominated in millisatoshis. + uint32 fee_base_msat = 3; + + /* + The fee rate of the channel for sending one satoshi across it denominated in + millionths of a satoshi. + */ + uint32 fee_proportional_millionths = 4; + + // The time-lock delta of the channel. + uint32 cltv_expiry_delta = 5; +} + +message SetID { + bytes set_id = 1; +} + +message RouteHint { + /* + A list of hop hints that when chained together can assist in reaching a + specific destination. + */ + repeated HopHint hop_hints = 1; +} + +message BlindedPaymentPath { + // The blinded path to send the payment to. + BlindedPath blinded_path = 1; + + // The base fee for the blinded path provided, expressed in msat. + uint64 base_fee_msat = 2; + + /* + The proportional fee for the blinded path provided, expressed in parts + per million. + */ + uint32 proportional_fee_rate = 3; + + /* + The total CLTV delta for the blinded path provided, including the + final CLTV delta for the receiving node. + */ + uint32 total_cltv_delta = 4; + + /* + The minimum hltc size that may be sent over the blinded path, expressed + in msat. + */ + uint64 htlc_min_msat = 5; + + /* + The maximum htlc size that may be sent over the blinded path, expressed + in msat. + */ + uint64 htlc_max_msat = 6; + + // The feature bits for the route. + repeated FeatureBit features = 7; +} + +message BlindedPath { + // The unblinded pubkey of the introduction node for the route. + bytes introduction_node = 1; + + // The ephemeral pubkey used by nodes in the blinded route. + bytes blinding_point = 2; + + /* + A set of blinded node keys and data blobs for the blinded portion of the + route. Note that the first hop is expected to be the introduction node, + so the route is always expected to have at least one hop. + */ + repeated BlindedHop blinded_hops = 3; +} + +message BlindedHop { + // The blinded public key of the node. + bytes blinded_node = 1; + + // An encrypted blob of data provided to the blinded node. + bytes encrypted_data = 2; +} + +message AMPInvoiceState { + // The state the HTLCs associated with this setID are in. + InvoiceHTLCState state = 1; + + // The settle index of this HTLC set, if the invoice state is settled. + uint64 settle_index = 2; + + // The time this HTLC set was settled expressed in unix epoch. + int64 settle_time = 3; + + // The total amount paid for the sub-invoice expressed in milli satoshis. + int64 amt_paid_msat = 5; +} + +message Invoice { + /* + An optional memo to attach along with the invoice. Used for record keeping + purposes for the invoice's creator, and will also be set in the description + field of the encoded payment request if the description_hash field is not + being used. + */ + string memo = 1; + + reserved 2; + + /* + The hex-encoded preimage (32 byte) which will allow settling an incoming + HTLC payable to this preimage. When using REST, this field must be encoded + as base64. + */ + bytes r_preimage = 3; + + /* + The hash of the preimage. When using REST, this field must be encoded as + base64. + Note: Output only, don't specify for creating an invoice. + */ + bytes r_hash = 4; + + /* + The value of this invoice in satoshis + + The fields value and value_msat are mutually exclusive. + */ + int64 value = 5; + + /* + The value of this invoice in millisatoshis + + The fields value and value_msat are mutually exclusive. + */ + int64 value_msat = 23; + + /* + Whether this invoice has been fulfilled. + + The field is deprecated. Use the state field instead (compare to SETTLED). + */ + bool settled = 6 [deprecated = true]; + + /* + When this invoice was created. + Measured in seconds since the unix epoch. + Note: Output only, don't specify for creating an invoice. + */ + int64 creation_date = 7; + + /* + When this invoice was settled. + Measured in seconds since the unix epoch. + Note: Output only, don't specify for creating an invoice. + */ + int64 settle_date = 8; + + /* + A bare-bones invoice for a payment within the Lightning Network. With the + details of the invoice, the sender has all the data necessary to send a + payment to the recipient. + Note: Output only, don't specify for creating an invoice. + */ + string payment_request = 9; + + /* + Hash (SHA-256) of a description of the payment. Used if the description of + payment (memo) is too long to naturally fit within the description field + of an encoded payment request. When using REST, this field must be encoded + as base64. + */ + bytes description_hash = 10; + + // Payment request expiry time in seconds. Default is 86400 (24 hours). + int64 expiry = 11; + + // Fallback on-chain address. + string fallback_addr = 12; + + // Delta to use for the time-lock of the CLTV extended to the final hop. + uint64 cltv_expiry = 13; + + /* + Route hints that can each be individually used to assist in reaching the + invoice's destination. + */ + repeated RouteHint route_hints = 14; + + // Whether this invoice should include routing hints for private channels. + // Note: When enabled, if value and value_msat are zero, a large number of + // hints with these channels can be included, which might not be desirable. + bool private = 15; + + /* + The "add" index of this invoice. Each newly created invoice will increment + this index making it monotonically increasing. Callers to the + SubscribeInvoices call can use this to instantly get notified of all added + invoices with an add_index greater than this one. + Note: Output only, don't specify for creating an invoice. + */ + uint64 add_index = 16; + + /* + The "settle" index of this invoice. Each newly settled invoice will + increment this index making it monotonically increasing. Callers to the + SubscribeInvoices call can use this to instantly get notified of all + settled invoices with an settle_index greater than this one. + Note: Output only, don't specify for creating an invoice. + */ + uint64 settle_index = 17; + + // Deprecated, use amt_paid_sat or amt_paid_msat. + int64 amt_paid = 18 [deprecated = true]; + + /* + The amount that was accepted for this invoice, in satoshis. This will ONLY + be set if this invoice has been settled or accepted. We provide this field + as if the invoice was created with a zero value, then we need to record what + amount was ultimately accepted. Additionally, it's possible that the sender + paid MORE that was specified in the original invoice. So we'll record that + here as well. + Note: Output only, don't specify for creating an invoice. + */ + int64 amt_paid_sat = 19; + + /* + The amount that was accepted for this invoice, in millisatoshis. This will + ONLY be set if this invoice has been settled or accepted. We provide this + field as if the invoice was created with a zero value, then we need to + record what amount was ultimately accepted. Additionally, it's possible that + the sender paid MORE that was specified in the original invoice. So we'll + record that here as well. + Note: Output only, don't specify for creating an invoice. + */ + int64 amt_paid_msat = 20; + + enum InvoiceState { + OPEN = 0; + SETTLED = 1; + CANCELED = 2; + ACCEPTED = 3; + } + + /* + The state the invoice is in. + Note: Output only, don't specify for creating an invoice. + */ + InvoiceState state = 21; + + /* + List of HTLCs paying to this invoice [EXPERIMENTAL]. + Note: Output only, don't specify for creating an invoice. + */ + repeated InvoiceHTLC htlcs = 22; + + /* + List of features advertised on the invoice. + Note: Output only, don't specify for creating an invoice. + */ + map features = 24; + + /* + Indicates if this invoice was a spontaneous payment that arrived via keysend + [EXPERIMENTAL]. + Note: Output only, don't specify for creating an invoice. + */ + bool is_keysend = 25; + + /* + The payment address of this invoice. This is also called payment secret in + specifications (e.g. BOLT 11). This value will be used in MPP payments, and + also for newer invoices that always require the MPP payload for added + end-to-end security. + Note: Output only, don't specify for creating an invoice. + */ + bytes payment_addr = 26; + + /* + Signals whether or not this is an AMP invoice. + */ + bool is_amp = 27; + + /* + [EXPERIMENTAL]: + + Maps a 32-byte hex-encoded set ID to the sub-invoice AMP state for the + given set ID. This field is always populated for AMP invoices, and can be + used along side LookupInvoice to obtain the HTLC information related to a + given sub-invoice. + Note: Output only, don't specify for creating an invoice. + */ + map amp_invoice_state = 28; +} + +enum InvoiceHTLCState { + ACCEPTED = 0; + SETTLED = 1; + CANCELED = 2; +} + +// Details of an HTLC that paid to an invoice +message InvoiceHTLC { + // Short channel id over which the htlc was received. + uint64 chan_id = 1 [jstype = JS_STRING]; + + // Index identifying the htlc on the channel. + uint64 htlc_index = 2; + + // The amount of the htlc in msat. + uint64 amt_msat = 3; + + // Block height at which this htlc was accepted. + int32 accept_height = 4; + + // Time at which this htlc was accepted. + int64 accept_time = 5; + + // Time at which this htlc was settled or canceled. + int64 resolve_time = 6; + + // Block height at which this htlc expires. + int32 expiry_height = 7; + + // Current state the htlc is in. + InvoiceHTLCState state = 8; + + // Custom tlv records. + map custom_records = 9; + + // The total amount of the mpp payment in msat. + uint64 mpp_total_amt_msat = 10; + + // Details relevant to AMP HTLCs, only populated if this is an AMP HTLC. + AMP amp = 11; +} + +// Details specific to AMP HTLCs. +message AMP { + // An n-of-n secret share of the root seed from which child payment hashes + // and preimages are derived. + bytes root_share = 1; + + // An identifier for the HTLC set that this HTLC belongs to. + bytes set_id = 2; + + // A nonce used to randomize the child preimage and child hash from a given + // root_share. + uint32 child_index = 3; + + // The payment hash of the AMP HTLC. + bytes hash = 4; + + // The preimage used to settle this AMP htlc. This field will only be + // populated if the invoice is in InvoiceState_ACCEPTED or + // InvoiceState_SETTLED. + bytes preimage = 5; +} + +message AddInvoiceResponse { + bytes r_hash = 1; + + /* + A bare-bones invoice for a payment within the Lightning Network. With the + details of the invoice, the sender has all the data necessary to send a + payment to the recipient. + */ + string payment_request = 2; + + /* + The "add" index of this invoice. Each newly created invoice will increment + this index making it monotonically increasing. Callers to the + SubscribeInvoices call can use this to instantly get notified of all added + invoices with an add_index greater than this one. + */ + uint64 add_index = 16; + + /* + The payment address of the generated invoice. This is also called + payment secret in specifications (e.g. BOLT 11). This value should be used + in all payments for this invoice as we require it for end to end security. + */ + bytes payment_addr = 17; +} +message PaymentHash { + /* + The hex-encoded payment hash of the invoice to be looked up. The passed + payment hash must be exactly 32 bytes, otherwise an error is returned. + Deprecated now that the REST gateway supports base64 encoding of bytes + fields. + */ + string r_hash_str = 1 [deprecated = true]; + + /* + The payment hash of the invoice to be looked up. When using REST, this field + must be encoded as base64. + */ + bytes r_hash = 2; +} + +message ListInvoiceRequest { + /* + If set, only invoices that are not settled and not canceled will be returned + in the response. + */ + bool pending_only = 1; + + /* + The index of an invoice that will be used as either the start or end of a + query to determine which invoices should be returned in the response. + */ + uint64 index_offset = 4; + + // The max number of invoices to return in the response to this query. + uint64 num_max_invoices = 5; + + /* + If set, the invoices returned will result from seeking backwards from the + specified index offset. This can be used to paginate backwards. + */ + bool reversed = 6; + + // If set, returns all invoices with a creation date greater than or equal + // to it. Measured in seconds since the unix epoch. + uint64 creation_date_start = 7; + + // If set, returns all invoices with a creation date less than or equal to + // it. Measured in seconds since the unix epoch. + uint64 creation_date_end = 8; +} + +message ListInvoiceResponse { + /* + A list of invoices from the time slice of the time series specified in the + request. + */ + repeated Invoice invoices = 1; + + /* + The index of the last item in the set of returned invoices. This can be used + to seek further, pagination style. + */ + uint64 last_index_offset = 2; + + /* + The index of the last item in the set of returned invoices. This can be used + to seek backwards, pagination style. + */ + uint64 first_index_offset = 3; +} + +message InvoiceSubscription { + /* + If specified (non-zero), then we'll first start by sending out + notifications for all added indexes with an add_index greater than this + value. This allows callers to catch up on any events they missed while they + weren't connected to the streaming RPC. + */ + uint64 add_index = 1; + + /* + If specified (non-zero), then we'll first start by sending out + notifications for all settled indexes with an settle_index greater than + this value. This allows callers to catch up on any events they missed while + they weren't connected to the streaming RPC. + */ + uint64 settle_index = 2; +} + +enum PaymentFailureReason { + /* + Payment isn't failed (yet). + */ + FAILURE_REASON_NONE = 0; + + /* + There are more routes to try, but the payment timeout was exceeded. + */ + FAILURE_REASON_TIMEOUT = 1; + + /* + All possible routes were tried and failed permanently. Or were no + routes to the destination at all. + */ + FAILURE_REASON_NO_ROUTE = 2; + + /* + A non-recoverable error has occured. + */ + FAILURE_REASON_ERROR = 3; + + /* + Payment details incorrect (unknown hash, invalid amt or + invalid final cltv delta) + */ + FAILURE_REASON_INCORRECT_PAYMENT_DETAILS = 4; + + /* + Insufficient local balance. + */ + FAILURE_REASON_INSUFFICIENT_BALANCE = 5; +} + +message Payment { + // The payment hash + string payment_hash = 1; + + // Deprecated, use value_sat or value_msat. + int64 value = 2 [deprecated = true]; + + // Deprecated, use creation_time_ns + int64 creation_date = 3 [deprecated = true]; + + reserved 4; + + // Deprecated, use fee_sat or fee_msat. + int64 fee = 5 [deprecated = true]; + + // The payment preimage + string payment_preimage = 6; + + // The value of the payment in satoshis + int64 value_sat = 7; + + // The value of the payment in milli-satoshis + int64 value_msat = 8; + + // The optional payment request being fulfilled. + string payment_request = 9; + + enum PaymentStatus { + // Deprecated. This status will never be returned. + UNKNOWN = 0 [deprecated = true]; + + // Payment has inflight HTLCs. + IN_FLIGHT = 1; + + // Payment is settled. + SUCCEEDED = 2; + + // Payment is failed. + FAILED = 3; + + // Payment is created and has not attempted any HTLCs. + INITIATED = 4; + } + + // The status of the payment. + PaymentStatus status = 10; + + // The fee paid for this payment in satoshis + int64 fee_sat = 11; + + // The fee paid for this payment in milli-satoshis + int64 fee_msat = 12; + + // The time in UNIX nanoseconds at which the payment was created. + int64 creation_time_ns = 13; + + // The HTLCs made in attempt to settle the payment. + repeated HTLCAttempt htlcs = 14; + + /* + The creation index of this payment. Each payment can be uniquely identified + by this index, which may not strictly increment by 1 for payments made in + older versions of lnd. + */ + uint64 payment_index = 15; + + PaymentFailureReason failure_reason = 16; +} + +message HTLCAttempt { + // The unique ID that is used for this attempt. + uint64 attempt_id = 7; + + enum HTLCStatus { + IN_FLIGHT = 0; + SUCCEEDED = 1; + FAILED = 2; + } + + // The status of the HTLC. + HTLCStatus status = 1; + + // The route taken by this HTLC. + Route route = 2; + + // The time in UNIX nanoseconds at which this HTLC was sent. + int64 attempt_time_ns = 3; + + /* + The time in UNIX nanoseconds at which this HTLC was settled or failed. + This value will not be set if the HTLC is still IN_FLIGHT. + */ + int64 resolve_time_ns = 4; + + // Detailed htlc failure info. + Failure failure = 5; + + // The preimage that was used to settle the HTLC. + bytes preimage = 6; +} + +message ListPaymentsRequest { + /* + If true, then return payments that have not yet fully completed. This means + that pending payments, as well as failed payments will show up if this + field is set to true. This flag doesn't change the meaning of the indices, + which are tied to individual payments. + */ + bool include_incomplete = 1; + + /* + The index of a payment that will be used as either the start or end of a + query to determine which payments should be returned in the response. The + index_offset is exclusive. In the case of a zero index_offset, the query + will start with the oldest payment when paginating forwards, or will end + with the most recent payment when paginating backwards. + */ + uint64 index_offset = 2; + + // The maximal number of payments returned in the response to this query. + uint64 max_payments = 3; + + /* + If set, the payments returned will result from seeking backwards from the + specified index offset. This can be used to paginate backwards. The order + of the returned payments is always oldest first (ascending index order). + */ + bool reversed = 4; + + /* + If set, all payments (complete and incomplete, independent of the + max_payments parameter) will be counted. Note that setting this to true will + increase the run time of the call significantly on systems that have a lot + of payments, as all of them have to be iterated through to be counted. + */ + bool count_total_payments = 5; + + // If set, returns all payments with a creation date greater than or equal + // to it. Measured in seconds since the unix epoch. + uint64 creation_date_start = 6; + + // If set, returns all payments with a creation date less than or equal to + // it. Measured in seconds since the unix epoch. + uint64 creation_date_end = 7; +} + +message ListPaymentsResponse { + // The list of payments + repeated Payment payments = 1; + + /* + The index of the first item in the set of returned payments. This can be + used as the index_offset to continue seeking backwards in the next request. + */ + uint64 first_index_offset = 2; + + /* + The index of the last item in the set of returned payments. This can be used + as the index_offset to continue seeking forwards in the next request. + */ + uint64 last_index_offset = 3; + + /* + Will only be set if count_total_payments in the request was set. Represents + the total number of payments (complete and incomplete, independent of the + number of payments requested in the query) currently present in the payments + database. + */ + uint64 total_num_payments = 4; +} + +message DeletePaymentRequest { + // Payment hash to delete. + bytes payment_hash = 1; + + /* + Only delete failed HTLCs from the payment, not the payment itself. + */ + bool failed_htlcs_only = 2; +} + +message DeleteAllPaymentsRequest { + // Only delete failed payments. + bool failed_payments_only = 1; + + /* + Only delete failed HTLCs from payments, not the payment itself. + */ + bool failed_htlcs_only = 2; + + // Delete all payments. NOTE: Using this option requires careful + // consideration as it is a destructive operation. + bool all_payments = 3; +} + +message DeletePaymentResponse { +} + +message DeleteAllPaymentsResponse { +} + +message AbandonChannelRequest { + ChannelPoint channel_point = 1; + + bool pending_funding_shim_only = 2; + + /* + Override the requirement for being in dev mode by setting this to true and + confirming the user knows what they are doing and this is a potential foot + gun to lose funds if used on active channels. + */ + bool i_know_what_i_am_doing = 3; +} + +message AbandonChannelResponse { +} + +message DebugLevelRequest { + bool show = 1; + string level_spec = 2; +} +message DebugLevelResponse { + string sub_systems = 1; +} + +message PayReqString { + // The payment request string to be decoded + string pay_req = 1; +} +message PayReq { + string destination = 1; + string payment_hash = 2; + int64 num_satoshis = 3; + int64 timestamp = 4; + int64 expiry = 5; + string description = 6; + string description_hash = 7; + string fallback_addr = 8; + int64 cltv_expiry = 9; + repeated RouteHint route_hints = 10; + bytes payment_addr = 11; + int64 num_msat = 12; + map features = 13; + repeated BlindedPaymentPath blinded_paths = 14; +} + +enum FeatureBit { + DATALOSS_PROTECT_REQ = 0; + DATALOSS_PROTECT_OPT = 1; + INITIAL_ROUING_SYNC = 3; + UPFRONT_SHUTDOWN_SCRIPT_REQ = 4; + UPFRONT_SHUTDOWN_SCRIPT_OPT = 5; + GOSSIP_QUERIES_REQ = 6; + GOSSIP_QUERIES_OPT = 7; + TLV_ONION_REQ = 8; + TLV_ONION_OPT = 9; + EXT_GOSSIP_QUERIES_REQ = 10; + EXT_GOSSIP_QUERIES_OPT = 11; + STATIC_REMOTE_KEY_REQ = 12; + STATIC_REMOTE_KEY_OPT = 13; + PAYMENT_ADDR_REQ = 14; + PAYMENT_ADDR_OPT = 15; + MPP_REQ = 16; + MPP_OPT = 17; + WUMBO_CHANNELS_REQ = 18; + WUMBO_CHANNELS_OPT = 19; + ANCHORS_REQ = 20; + ANCHORS_OPT = 21; + ANCHORS_ZERO_FEE_HTLC_REQ = 22; + ANCHORS_ZERO_FEE_HTLC_OPT = 23; + ROUTE_BLINDING_REQUIRED = 24; + ROUTE_BLINDING_OPTIONAL = 25; + AMP_REQ = 30; + AMP_OPT = 31; +} + +message Feature { + string name = 2; + bool is_required = 3; + bool is_known = 4; +} + +message FeeReportRequest { +} +message ChannelFeeReport { + // The short channel id that this fee report belongs to. + uint64 chan_id = 5 [jstype = JS_STRING]; + + // The channel that this fee report belongs to. + string channel_point = 1; + + // The base fee charged regardless of the number of milli-satoshis sent. + int64 base_fee_msat = 2; + + // The amount charged per milli-satoshis transferred expressed in + // millionths of a satoshi. + int64 fee_per_mil = 3; + + // The effective fee rate in milli-satoshis. Computed by dividing the + // fee_per_mil value by 1 million. + double fee_rate = 4; + + // The base fee charged regardless of the number of milli-satoshis sent. + int32 inbound_base_fee_msat = 6; + + // The amount charged per milli-satoshis transferred expressed in + // millionths of a satoshi. + int32 inbound_fee_per_mil = 7; +} + +message FeeReportResponse { + // An array of channel fee reports which describes the current fee schedule + // for each channel. + repeated ChannelFeeReport channel_fees = 1; + + // The total amount of fee revenue (in satoshis) the switch has collected + // over the past 24 hrs. + uint64 day_fee_sum = 2; + + // The total amount of fee revenue (in satoshis) the switch has collected + // over the past 1 week. + uint64 week_fee_sum = 3; + + // The total amount of fee revenue (in satoshis) the switch has collected + // over the past 1 month. + uint64 month_fee_sum = 4; +} + +message InboundFee { + // The inbound base fee charged regardless of the number of milli-satoshis + // received in the channel. By default, only negative values are accepted. + int32 base_fee_msat = 1; + + // The effective inbound fee rate in micro-satoshis (parts per million). + // By default, only negative values are accepted. + int32 fee_rate_ppm = 2; +} + +message PolicyUpdateRequest { + oneof scope { + // If set, then this update applies to all currently active channels. + bool global = 1; + + // If set, this update will target a specific channel. + ChannelPoint chan_point = 2; + } + + // The base fee charged regardless of the number of milli-satoshis sent. + int64 base_fee_msat = 3; + + // The effective fee rate in milli-satoshis. The precision of this value + // goes up to 6 decimal places, so 1e-6. + double fee_rate = 4; + + // The effective fee rate in micro-satoshis (parts per million). + uint32 fee_rate_ppm = 9; + + // The required timelock delta for HTLCs forwarded over the channel. + uint32 time_lock_delta = 5; + + // If set, the maximum HTLC size in milli-satoshis. If unset, the maximum + // HTLC will be unchanged. + uint64 max_htlc_msat = 6; + + // The minimum HTLC size in milli-satoshis. Only applied if + // min_htlc_msat_specified is true. + uint64 min_htlc_msat = 7; + + // If true, min_htlc_msat is applied. + bool min_htlc_msat_specified = 8; + + // Optional inbound fee. If unset, the previously set value will be + // retained [EXPERIMENTAL]. + InboundFee inbound_fee = 10; +} + +enum UpdateFailure { + UPDATE_FAILURE_UNKNOWN = 0; + UPDATE_FAILURE_PENDING = 1; + UPDATE_FAILURE_NOT_FOUND = 2; + UPDATE_FAILURE_INTERNAL_ERR = 3; + UPDATE_FAILURE_INVALID_PARAMETER = 4; +} + +message FailedUpdate { + // The outpoint in format txid:n + OutPoint outpoint = 1; + + // Reason for the policy update failure. + UpdateFailure reason = 2; + + // A string representation of the policy update error. + string update_error = 3; +} + +message PolicyUpdateResponse { + // List of failed policy updates. + repeated FailedUpdate failed_updates = 1; +} + +message ForwardingHistoryRequest { + // Start time is the starting point of the forwarding history request. All + // records beyond this point will be included, respecting the end time, and + // the index offset. + uint64 start_time = 1; + + // End time is the end point of the forwarding history request. The + // response will carry at most 50k records between the start time and the + // end time. The index offset can be used to implement pagination. + uint64 end_time = 2; + + // Index offset is the offset in the time series to start at. As each + // response can only contain 50k records, callers can use this to skip + // around within a packed time series. + uint32 index_offset = 3; + + // The max number of events to return in the response to this query. + uint32 num_max_events = 4; + + // Informs the server if the peer alias should be looked up for each + // forwarding event. + bool peer_alias_lookup = 5; +} +message ForwardingEvent { + // Timestamp is the time (unix epoch offset) that this circuit was + // completed. Deprecated by timestamp_ns. + uint64 timestamp = 1 [deprecated = true]; + + // The incoming channel ID that carried the HTLC that created the circuit. + uint64 chan_id_in = 2 [jstype = JS_STRING]; + + // The outgoing channel ID that carried the preimage that completed the + // circuit. + uint64 chan_id_out = 4 [jstype = JS_STRING]; + + // The total amount (in satoshis) of the incoming HTLC that created half + // the circuit. + uint64 amt_in = 5; + + // The total amount (in satoshis) of the outgoing HTLC that created the + // second half of the circuit. + uint64 amt_out = 6; + + // The total fee (in satoshis) that this payment circuit carried. + uint64 fee = 7; + + // The total fee (in milli-satoshis) that this payment circuit carried. + uint64 fee_msat = 8; + + // The total amount (in milli-satoshis) of the incoming HTLC that created + // half the circuit. + uint64 amt_in_msat = 9; + + // The total amount (in milli-satoshis) of the outgoing HTLC that created + // the second half of the circuit. + uint64 amt_out_msat = 10; + + // The number of nanoseconds elapsed since January 1, 1970 UTC when this + // circuit was completed. + uint64 timestamp_ns = 11; + + // The peer alias of the incoming channel. + string peer_alias_in = 12; + + // The peer alias of the outgoing channel. + string peer_alias_out = 13; + + // TODO(roasbeef): add settlement latency? + // * use FPE on the chan id? + // * also list failures? +} +message ForwardingHistoryResponse { + // A list of forwarding events from the time slice of the time series + // specified in the request. + repeated ForwardingEvent forwarding_events = 1; + + // The index of the last time in the set of returned forwarding events. Can + // be used to seek further, pagination style. + uint32 last_offset_index = 2; +} + +message ExportChannelBackupRequest { + // The target channel point to obtain a back up for. + ChannelPoint chan_point = 1; +} + +message ChannelBackup { + /* + Identifies the channel that this backup belongs to. + */ + ChannelPoint chan_point = 1; + + /* + Is an encrypted single-chan backup. this can be passed to + RestoreChannelBackups, or the WalletUnlocker Init and Unlock methods in + order to trigger the recovery protocol. When using REST, this field must be + encoded as base64. + */ + bytes chan_backup = 2; +} + +message MultiChanBackup { + /* + Is the set of all channels that are included in this multi-channel backup. + */ + repeated ChannelPoint chan_points = 1; + + /* + A single encrypted blob containing all the static channel backups of the + channel listed above. This can be stored as a single file or blob, and + safely be replaced with any prior/future versions. When using REST, this + field must be encoded as base64. + */ + bytes multi_chan_backup = 2; +} + +message ChanBackupExportRequest { +} +message ChanBackupSnapshot { + /* + The set of new channels that have been added since the last channel backup + snapshot was requested. + */ + ChannelBackups single_chan_backups = 1; + + /* + A multi-channel backup that covers all open channels currently known to + lnd. + */ + MultiChanBackup multi_chan_backup = 2; +} + +message ChannelBackups { + /* + A set of single-chan static channel backups. + */ + repeated ChannelBackup chan_backups = 1; +} + +message RestoreChanBackupRequest { + oneof backup { + /* + The channels to restore as a list of channel/backup pairs. + */ + ChannelBackups chan_backups = 1; + + /* + The channels to restore in the packed multi backup format. When using + REST, this field must be encoded as base64. + */ + bytes multi_chan_backup = 2; + } +} +message RestoreBackupResponse { +} + +message ChannelBackupSubscription { +} + +message VerifyChanBackupResponse { +} + +message MacaroonPermission { + // The entity a permission grants access to. + string entity = 1; + + // The action that is granted. + string action = 2; +} +message BakeMacaroonRequest { + // The list of permissions the new macaroon should grant. + repeated MacaroonPermission permissions = 1; + + // The root key ID used to create the macaroon, must be a positive integer. + uint64 root_key_id = 2; + + /* + Informs the RPC on whether to allow external permissions that LND is not + aware of. + */ + bool allow_external_permissions = 3; +} +message BakeMacaroonResponse { + // The hex encoded macaroon, serialized in binary format. + string macaroon = 1; +} + +message ListMacaroonIDsRequest { +} +message ListMacaroonIDsResponse { + // The list of root key IDs that are in use. + repeated uint64 root_key_ids = 1; +} + +message DeleteMacaroonIDRequest { + // The root key ID to be removed. + uint64 root_key_id = 1; +} +message DeleteMacaroonIDResponse { + // A boolean indicates that the deletion is successful. + bool deleted = 1; +} + +message MacaroonPermissionList { + // A list of macaroon permissions. + repeated MacaroonPermission permissions = 1; +} + +message ListPermissionsRequest { +} +message ListPermissionsResponse { + /* + A map between all RPC method URIs and their required macaroon permissions to + access them. + */ + map method_permissions = 1; +} + +message Failure { + enum FailureCode { + /* + The numbers assigned in this enumeration match the failure codes as + defined in BOLT #4. Because protobuf 3 requires enums to start with 0, + a RESERVED value is added. + */ + RESERVED = 0; + + INCORRECT_OR_UNKNOWN_PAYMENT_DETAILS = 1; + INCORRECT_PAYMENT_AMOUNT = 2; + FINAL_INCORRECT_CLTV_EXPIRY = 3; + FINAL_INCORRECT_HTLC_AMOUNT = 4; + FINAL_EXPIRY_TOO_SOON = 5; + INVALID_REALM = 6; + EXPIRY_TOO_SOON = 7; + INVALID_ONION_VERSION = 8; + INVALID_ONION_HMAC = 9; + INVALID_ONION_KEY = 10; + AMOUNT_BELOW_MINIMUM = 11; + FEE_INSUFFICIENT = 12; + INCORRECT_CLTV_EXPIRY = 13; + CHANNEL_DISABLED = 14; + TEMPORARY_CHANNEL_FAILURE = 15; + REQUIRED_NODE_FEATURE_MISSING = 16; + REQUIRED_CHANNEL_FEATURE_MISSING = 17; + UNKNOWN_NEXT_PEER = 18; + TEMPORARY_NODE_FAILURE = 19; + PERMANENT_NODE_FAILURE = 20; + PERMANENT_CHANNEL_FAILURE = 21; + EXPIRY_TOO_FAR = 22; + MPP_TIMEOUT = 23; + INVALID_ONION_PAYLOAD = 24; + INVALID_ONION_BLINDING = 25; + + /* + An internal error occurred. + */ + INTERNAL_FAILURE = 997; + + /* + The error source is known, but the failure itself couldn't be decoded. + */ + UNKNOWN_FAILURE = 998; + + /* + An unreadable failure result is returned if the received failure message + cannot be decrypted. In that case the error source is unknown. + */ + UNREADABLE_FAILURE = 999; + } + + // Failure code as defined in the Lightning spec + FailureCode code = 1; + + reserved 2; + + // An optional channel update message. + ChannelUpdate channel_update = 3; + + // A failure type-dependent htlc value. + uint64 htlc_msat = 4; + + // The sha256 sum of the onion payload. + bytes onion_sha_256 = 5; + + // A failure type-dependent cltv expiry value. + uint32 cltv_expiry = 6; + + // A failure type-dependent flags value. + uint32 flags = 7; + + /* + The position in the path of the intermediate or final node that generated + the failure message. Position zero is the sender node. + **/ + uint32 failure_source_index = 8; + + // A failure type-dependent block height. + uint32 height = 9; +} + +message ChannelUpdate { + /* + The signature that validates the announced data and proves the ownership + of node id. + */ + bytes signature = 1; + + /* + The target chain that this channel was opened within. This value + should be the genesis hash of the target chain. Along with the short + channel ID, this uniquely identifies the channel globally in a + blockchain. + */ + bytes chain_hash = 2; + + /* + The unique description of the funding transaction. + */ + uint64 chan_id = 3 [jstype = JS_STRING]; + + /* + A timestamp that allows ordering in the case of multiple announcements. + We should ignore the message if timestamp is not greater than the + last-received. + */ + uint32 timestamp = 4; + + /* + The bitfield that describes whether optional fields are present in this + update. Currently, the least-significant bit must be set to 1 if the + optional field MaxHtlc is present. + */ + uint32 message_flags = 10; + + /* + The bitfield that describes additional meta-data concerning how the + update is to be interpreted. Currently, the least-significant bit must be + set to 0 if the creating node corresponds to the first node in the + previously sent channel announcement and 1 otherwise. If the second bit + is set, then the channel is set to be disabled. + */ + uint32 channel_flags = 5; + + /* + The minimum number of blocks this node requires to be added to the expiry + of HTLCs. This is a security parameter determined by the node operator. + This value represents the required gap between the time locks of the + incoming and outgoing HTLC's set to this node. + */ + uint32 time_lock_delta = 6; + + /* + The minimum HTLC value which will be accepted. + */ + uint64 htlc_minimum_msat = 7; + + /* + The base fee that must be used for incoming HTLC's to this particular + channel. This value will be tacked onto the required for a payment + independent of the size of the payment. + */ + uint32 base_fee = 8; + + /* + The fee rate that will be charged per millionth of a satoshi. + */ + uint32 fee_rate = 9; + + /* + The maximum HTLC value which will be accepted. + */ + uint64 htlc_maximum_msat = 11; + + /* + The set of data that was appended to this message, some of which we may + not actually know how to iterate or parse. By holding onto this data, we + ensure that we're able to properly validate the set of signatures that + cover these new fields, and ensure we're able to make upgrades to the + network in a forwards compatible manner. + */ + bytes extra_opaque_data = 12; +} + +message MacaroonId { + bytes nonce = 1; + bytes storageId = 2; + repeated Op ops = 3; +} + +message Op { + string entity = 1; + repeated string actions = 2; +} + +message CheckMacPermRequest { + bytes macaroon = 1; + repeated MacaroonPermission permissions = 2; + string fullMethod = 3; +} + +message CheckMacPermResponse { + bool valid = 1; +} + +message RPCMiddlewareRequest { + /* + The unique ID of the intercepted original gRPC request. Useful for mapping + request to response when implementing full duplex message interception. For + streaming requests, this will be the same ID for all incoming and outgoing + middleware intercept messages of the _same_ stream. + */ + uint64 request_id = 1; + + /* + The raw bytes of the complete macaroon as sent by the gRPC client in the + original request. This might be empty for a request that doesn't require + macaroons such as the wallet unlocker RPCs. + */ + bytes raw_macaroon = 2; + + /* + The parsed condition of the macaroon's custom caveat for convenient access. + This field only contains the value of the custom caveat that the handling + middleware has registered itself for. The condition _must_ be validated for + messages of intercept_type stream_auth and request! + */ + string custom_caveat_condition = 3; + + /* + There are three types of messages that will be sent to the middleware for + inspection and approval: Stream authentication, request and response + interception. The first two can only be accepted (=forward to main RPC + server) or denied (=return error to client). Intercepted responses can also + be replaced/overwritten. + */ + oneof intercept_type { + /* + Intercept stream authentication: each new streaming RPC call that is + initiated against lnd and contains the middleware's custom macaroon + caveat can be approved or denied based upon the macaroon in the stream + header. This message will only be sent for streaming RPCs, unary RPCs + must handle the macaroon authentication in the request interception to + avoid an additional message round trip between lnd and the middleware. + */ + StreamAuth stream_auth = 4; + + /* + Intercept incoming gRPC client request message: all incoming messages, + both on streaming and unary RPCs, are forwarded to the middleware for + inspection. For unary RPC messages the middleware is also expected to + validate the custom macaroon caveat of the request. + */ + RPCMessage request = 5; + + /* + Intercept outgoing gRPC response message: all outgoing messages, both on + streaming and unary RPCs, are forwarded to the middleware for inspection + and amendment. The response in this message is the original response as + it was generated by the main RPC server. It can either be accepted + (=forwarded to the client), replaced/overwritten with a new message of + the same type, or replaced by an error message. + */ + RPCMessage response = 6; + + /* + This is used to indicate to the client that the server has successfully + registered the interceptor. This is only used in the very first message + that the server sends to the client after the client sends the server + the middleware registration message. + */ + bool reg_complete = 8; + } + + /* + The unique message ID of this middleware intercept message. There can be + multiple middleware intercept messages per single gRPC request (one for the + incoming request and one for the outgoing response) or gRPC stream (one for + each incoming message and one for each outgoing response). This message ID + must be referenced when responding (accepting/rejecting/modifying) to an + intercept message. + */ + uint64 msg_id = 7; +} + +message StreamAuth { + /* + The full URI (in the format /./MethodName, for + example /lnrpc.Lightning/GetInfo) of the streaming RPC method that was just + established. + */ + string method_full_uri = 1; +} + +message RPCMessage { + /* + The full URI (in the format /./MethodName, for + example /lnrpc.Lightning/GetInfo) of the RPC method the message was sent + to/from. + */ + string method_full_uri = 1; + + /* + Indicates whether the message was sent over a streaming RPC method or not. + */ + bool stream_rpc = 2; + + /* + The full canonical gRPC name of the message type (in the format + .TypeName, for example lnrpc.GetInfoRequest). In case of an + error being returned from lnd, this simply contains the string "error". + */ + string type_name = 3; + + /* + The full content of the gRPC message, serialized in the binary protobuf + format. + */ + bytes serialized = 4; + + /* + Indicates that the response from lnd was an error, not a gRPC response. If + this is set to true then the type_name contains the string "error" and + serialized contains the error string. + */ + bool is_error = 5; +} + +message RPCMiddlewareResponse { + /* + The request message ID this response refers to. Must always be set when + giving feedback to an intercept but is ignored for the initial registration + message. + */ + uint64 ref_msg_id = 1; + + /* + The middleware can only send two types of messages to lnd: The initial + registration message that identifies the middleware and after that only + feedback messages to requests sent to the middleware. + */ + oneof middleware_message { + /* + The registration message identifies the middleware that's being + registered in lnd. The registration message must be sent immediately + after initiating the RegisterRpcMiddleware stream, otherwise lnd will + time out the attempt and terminate the request. NOTE: The middleware + will only receive interception messages for requests that contain a + macaroon with the custom caveat that the middleware declares it is + responsible for handling in the registration message! As a security + measure, _no_ middleware can intercept requests made with _unencumbered_ + macaroons! + */ + MiddlewareRegistration register = 2; + + /* + The middleware received an interception request and gives feedback to + it. The request_id indicates what message the feedback refers to. + */ + InterceptFeedback feedback = 3; + } +} + +message MiddlewareRegistration { + /* + The name of the middleware to register. The name should be as informative + as possible and is logged on registration. + */ + string middleware_name = 1; + + /* + The name of the custom macaroon caveat that this middleware is responsible + for. Only requests/responses that contain a macaroon with the registered + custom caveat are forwarded for interception to the middleware. The + exception being the read-only mode: All requests/responses are forwarded to + a middleware that requests read-only access but such a middleware won't be + allowed to _alter_ responses. As a security measure, _no_ middleware can + change responses to requests made with _unencumbered_ macaroons! + NOTE: Cannot be used at the same time as read_only_mode. + */ + string custom_macaroon_caveat_name = 2; + + /* + Instead of defining a custom macaroon caveat name a middleware can register + itself for read-only access only. In that mode all requests/responses are + forwarded to the middleware but the middleware isn't allowed to alter any of + the responses. + NOTE: Cannot be used at the same time as custom_macaroon_caveat_name. + */ + bool read_only_mode = 3; +} + +message InterceptFeedback { + /* + The error to return to the user. If this is non-empty, the incoming gRPC + stream/request is aborted and the error is returned to the gRPC client. If + this value is empty, it means the middleware accepts the stream/request/ + response and the processing of it can continue. + */ + string error = 1; + + /* + A boolean indicating that the gRPC message should be replaced/overwritten. + This boolean is needed because in protobuf an empty message is serialized as + a 0-length or nil byte slice and we wouldn't be able to distinguish between + an empty replacement message and the "don't replace anything" case. + */ + bool replace_response = 2; + + /* + If the replace_response field is set to true, this field must contain the + binary serialized gRPC message in the protobuf format. + */ + bytes replacement_serialized = 3; +} diff --git a/cashu/lightning/lnd_grpc/protos/lightning_pb2.py b/cashu/lightning/lnd_grpc/protos/lightning_pb2.py new file mode 100644 index 00000000..2998e7d5 --- /dev/null +++ b/cashu/lightning/lnd_grpc/protos/lightning_pb2.py @@ -0,0 +1,674 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: lightning.proto +# Protobuf Python Version: 5.26.1 +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder + +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x0flightning.proto\x12\x05lnrpc\"B\n\x1bLookupHtlcResolutionRequest\x12\x0f\n\x07\x63han_id\x18\x01 \x01(\x04\x12\x12\n\nhtlc_index\x18\x02 \x01(\x04\"A\n\x1cLookupHtlcResolutionResponse\x12\x0f\n\x07settled\x18\x01 \x01(\x08\x12\x10\n\x08offchain\x18\x02 \x01(\x08\" \n\x1eSubscribeCustomMessagesRequest\"9\n\rCustomMessage\x12\x0c\n\x04peer\x18\x01 \x01(\x0c\x12\x0c\n\x04type\x18\x02 \x01(\r\x12\x0c\n\x04\x64\x61ta\x18\x03 \x01(\x0c\"D\n\x18SendCustomMessageRequest\x12\x0c\n\x04peer\x18\x01 \x01(\x0c\x12\x0c\n\x04type\x18\x02 \x01(\r\x12\x0c\n\x04\x64\x61ta\x18\x03 \x01(\x0c\"\x1b\n\x19SendCustomMessageResponse\"\xa2\x01\n\x04Utxo\x12(\n\x0c\x61\x64\x64ress_type\x18\x01 \x01(\x0e\x32\x12.lnrpc.AddressType\x12\x0f\n\x07\x61\x64\x64ress\x18\x02 \x01(\t\x12\x12\n\namount_sat\x18\x03 \x01(\x03\x12\x11\n\tpk_script\x18\x04 \x01(\t\x12!\n\x08outpoint\x18\x05 \x01(\x0b\x32\x0f.lnrpc.OutPoint\x12\x15\n\rconfirmations\x18\x06 \x01(\x03\"\x9e\x01\n\x0cOutputDetail\x12,\n\x0boutput_type\x18\x01 \x01(\x0e\x32\x17.lnrpc.OutputScriptType\x12\x0f\n\x07\x61\x64\x64ress\x18\x02 \x01(\t\x12\x11\n\tpk_script\x18\x03 \x01(\t\x12\x14\n\x0coutput_index\x18\x04 \x01(\x03\x12\x0e\n\x06\x61mount\x18\x05 \x01(\x03\x12\x16\n\x0eis_our_address\x18\x06 \x01(\x08\"\xbc\x02\n\x0bTransaction\x12\x0f\n\x07tx_hash\x18\x01 \x01(\t\x12\x0e\n\x06\x61mount\x18\x02 \x01(\x03\x12\x19\n\x11num_confirmations\x18\x03 \x01(\x05\x12\x12\n\nblock_hash\x18\x04 \x01(\t\x12\x14\n\x0c\x62lock_height\x18\x05 \x01(\x05\x12\x12\n\ntime_stamp\x18\x06 \x01(\x03\x12\x12\n\ntotal_fees\x18\x07 \x01(\x03\x12\x1a\n\x0e\x64\x65st_addresses\x18\x08 \x03(\tB\x02\x18\x01\x12+\n\x0eoutput_details\x18\x0b \x03(\x0b\x32\x13.lnrpc.OutputDetail\x12\x12\n\nraw_tx_hex\x18\t \x01(\t\x12\r\n\x05label\x18\n \x01(\t\x12\x33\n\x12previous_outpoints\x18\x0c \x03(\x0b\x32\x17.lnrpc.PreviousOutPoint\"S\n\x16GetTransactionsRequest\x12\x14\n\x0cstart_height\x18\x01 \x01(\x05\x12\x12\n\nend_height\x18\x02 \x01(\x05\x12\x0f\n\x07\x61\x63\x63ount\x18\x03 \x01(\t\">\n\x12TransactionDetails\x12(\n\x0ctransactions\x18\x01 \x03(\x0b\x32\x12.lnrpc.Transaction\"M\n\x08\x46\x65\x65Limit\x12\x0f\n\x05\x66ixed\x18\x01 \x01(\x03H\x00\x12\x14\n\nfixed_msat\x18\x03 \x01(\x03H\x00\x12\x11\n\x07percent\x18\x02 \x01(\x03H\x00\x42\x07\n\x05limit\"\x8a\x04\n\x0bSendRequest\x12\x0c\n\x04\x64\x65st\x18\x01 \x01(\x0c\x12\x17\n\x0b\x64\x65st_string\x18\x02 \x01(\tB\x02\x18\x01\x12\x0b\n\x03\x61mt\x18\x03 \x01(\x03\x12\x10\n\x08\x61mt_msat\x18\x0c \x01(\x03\x12\x14\n\x0cpayment_hash\x18\x04 \x01(\x0c\x12\x1f\n\x13payment_hash_string\x18\x05 \x01(\tB\x02\x18\x01\x12\x17\n\x0fpayment_request\x18\x06 \x01(\t\x12\x18\n\x10\x66inal_cltv_delta\x18\x07 \x01(\x05\x12\"\n\tfee_limit\x18\x08 \x01(\x0b\x32\x0f.lnrpc.FeeLimit\x12\x1c\n\x10outgoing_chan_id\x18\t \x01(\x04\x42\x02\x30\x01\x12\x17\n\x0flast_hop_pubkey\x18\r \x01(\x0c\x12\x12\n\ncltv_limit\x18\n \x01(\r\x12\x46\n\x13\x64\x65st_custom_records\x18\x0b \x03(\x0b\x32).lnrpc.SendRequest.DestCustomRecordsEntry\x12\x1a\n\x12\x61llow_self_payment\x18\x0e \x01(\x08\x12(\n\rdest_features\x18\x0f \x03(\x0e\x32\x11.lnrpc.FeatureBit\x12\x14\n\x0cpayment_addr\x18\x10 \x01(\x0c\x1a\x38\n\x16\x44\x65stCustomRecordsEntry\x12\x0b\n\x03key\x18\x01 \x01(\x04\x12\r\n\x05value\x18\x02 \x01(\x0c:\x02\x38\x01\"z\n\x0cSendResponse\x12\x15\n\rpayment_error\x18\x01 \x01(\t\x12\x18\n\x10payment_preimage\x18\x02 \x01(\x0c\x12#\n\rpayment_route\x18\x03 \x01(\x0b\x32\x0c.lnrpc.Route\x12\x14\n\x0cpayment_hash\x18\x04 \x01(\x0c\"n\n\x12SendToRouteRequest\x12\x14\n\x0cpayment_hash\x18\x01 \x01(\x0c\x12\x1f\n\x13payment_hash_string\x18\x02 \x01(\tB\x02\x18\x01\x12\x1b\n\x05route\x18\x04 \x01(\x0b\x32\x0c.lnrpc.RouteJ\x04\x08\x03\x10\x04\"\x98\x03\n\x14\x43hannelAcceptRequest\x12\x13\n\x0bnode_pubkey\x18\x01 \x01(\x0c\x12\x12\n\nchain_hash\x18\x02 \x01(\x0c\x12\x17\n\x0fpending_chan_id\x18\x03 \x01(\x0c\x12\x13\n\x0b\x66unding_amt\x18\x04 \x01(\x04\x12\x10\n\x08push_amt\x18\x05 \x01(\x04\x12\x12\n\ndust_limit\x18\x06 \x01(\x04\x12\x1b\n\x13max_value_in_flight\x18\x07 \x01(\x04\x12\x17\n\x0f\x63hannel_reserve\x18\x08 \x01(\x04\x12\x10\n\x08min_htlc\x18\t \x01(\x04\x12\x12\n\nfee_per_kw\x18\n \x01(\x04\x12\x11\n\tcsv_delay\x18\x0b \x01(\r\x12\x1a\n\x12max_accepted_htlcs\x18\x0c \x01(\r\x12\x15\n\rchannel_flags\x18\r \x01(\r\x12.\n\x0f\x63ommitment_type\x18\x0e \x01(\x0e\x32\x15.lnrpc.CommitmentType\x12\x17\n\x0fwants_zero_conf\x18\x0f \x01(\x08\x12\x18\n\x10wants_scid_alias\x18\x10 \x01(\x08\"\x87\x02\n\x15\x43hannelAcceptResponse\x12\x0e\n\x06\x61\x63\x63\x65pt\x18\x01 \x01(\x08\x12\x17\n\x0fpending_chan_id\x18\x02 \x01(\x0c\x12\r\n\x05\x65rror\x18\x03 \x01(\t\x12\x18\n\x10upfront_shutdown\x18\x04 \x01(\t\x12\x11\n\tcsv_delay\x18\x05 \x01(\r\x12\x13\n\x0breserve_sat\x18\x06 \x01(\x04\x12\x1a\n\x12in_flight_max_msat\x18\x07 \x01(\x04\x12\x16\n\x0emax_htlc_count\x18\x08 \x01(\r\x12\x13\n\x0bmin_htlc_in\x18\t \x01(\x04\x12\x18\n\x10min_accept_depth\x18\n \x01(\r\x12\x11\n\tzero_conf\x18\x0b \x01(\x08\"n\n\x0c\x43hannelPoint\x12\x1c\n\x12\x66unding_txid_bytes\x18\x01 \x01(\x0cH\x00\x12\x1a\n\x10\x66unding_txid_str\x18\x02 \x01(\tH\x00\x12\x14\n\x0coutput_index\x18\x03 \x01(\rB\x0e\n\x0c\x66unding_txid\"F\n\x08OutPoint\x12\x12\n\ntxid_bytes\x18\x01 \x01(\x0c\x12\x10\n\x08txid_str\x18\x02 \x01(\t\x12\x14\n\x0coutput_index\x18\x03 \x01(\r\";\n\x10PreviousOutPoint\x12\x10\n\x08outpoint\x18\x01 \x01(\t\x12\x15\n\ris_our_output\x18\x02 \x01(\x08\"0\n\x10LightningAddress\x12\x0e\n\x06pubkey\x18\x01 \x01(\t\x12\x0c\n\x04host\x18\x02 \x01(\t\"\x8e\x02\n\x12\x45stimateFeeRequest\x12\x41\n\x0c\x41\x64\x64rToAmount\x18\x01 \x03(\x0b\x32+.lnrpc.EstimateFeeRequest.AddrToAmountEntry\x12\x13\n\x0btarget_conf\x18\x02 \x01(\x05\x12\x11\n\tmin_confs\x18\x03 \x01(\x05\x12\x19\n\x11spend_unconfirmed\x18\x04 \x01(\x08\x12=\n\x17\x63oin_selection_strategy\x18\x05 \x01(\x0e\x32\x1c.lnrpc.CoinSelectionStrategy\x1a\x33\n\x11\x41\x64\x64rToAmountEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\x03:\x02\x38\x01\"_\n\x13\x45stimateFeeResponse\x12\x0f\n\x07\x66\x65\x65_sat\x18\x01 \x01(\x03\x12 \n\x14\x66\x65\x65rate_sat_per_byte\x18\x02 \x01(\x03\x42\x02\x18\x01\x12\x15\n\rsat_per_vbyte\x18\x03 \x01(\x04\"\xc8\x02\n\x0fSendManyRequest\x12>\n\x0c\x41\x64\x64rToAmount\x18\x01 \x03(\x0b\x32(.lnrpc.SendManyRequest.AddrToAmountEntry\x12\x13\n\x0btarget_conf\x18\x03 \x01(\x05\x12\x15\n\rsat_per_vbyte\x18\x04 \x01(\x04\x12\x18\n\x0csat_per_byte\x18\x05 \x01(\x03\x42\x02\x18\x01\x12\r\n\x05label\x18\x06 \x01(\t\x12\x11\n\tmin_confs\x18\x07 \x01(\x05\x12\x19\n\x11spend_unconfirmed\x18\x08 \x01(\x08\x12=\n\x17\x63oin_selection_strategy\x18\t \x01(\x0e\x32\x1c.lnrpc.CoinSelectionStrategy\x1a\x33\n\x11\x41\x64\x64rToAmountEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\x03:\x02\x38\x01\" \n\x10SendManyResponse\x12\x0c\n\x04txid\x18\x01 \x01(\t\"\x84\x02\n\x10SendCoinsRequest\x12\x0c\n\x04\x61\x64\x64r\x18\x01 \x01(\t\x12\x0e\n\x06\x61mount\x18\x02 \x01(\x03\x12\x13\n\x0btarget_conf\x18\x03 \x01(\x05\x12\x15\n\rsat_per_vbyte\x18\x04 \x01(\x04\x12\x18\n\x0csat_per_byte\x18\x05 \x01(\x03\x42\x02\x18\x01\x12\x10\n\x08send_all\x18\x06 \x01(\x08\x12\r\n\x05label\x18\x07 \x01(\t\x12\x11\n\tmin_confs\x18\x08 \x01(\x05\x12\x19\n\x11spend_unconfirmed\x18\t \x01(\x08\x12=\n\x17\x63oin_selection_strategy\x18\n \x01(\x0e\x32\x1c.lnrpc.CoinSelectionStrategy\"!\n\x11SendCoinsResponse\x12\x0c\n\x04txid\x18\x01 \x01(\t\"K\n\x12ListUnspentRequest\x12\x11\n\tmin_confs\x18\x01 \x01(\x05\x12\x11\n\tmax_confs\x18\x02 \x01(\x05\x12\x0f\n\x07\x61\x63\x63ount\x18\x03 \x01(\t\"1\n\x13ListUnspentResponse\x12\x1a\n\x05utxos\x18\x01 \x03(\x0b\x32\x0b.lnrpc.Utxo\"F\n\x11NewAddressRequest\x12 \n\x04type\x18\x01 \x01(\x0e\x32\x12.lnrpc.AddressType\x12\x0f\n\x07\x61\x63\x63ount\x18\x02 \x01(\t\"%\n\x12NewAddressResponse\x12\x0f\n\x07\x61\x64\x64ress\x18\x01 \x01(\t\"6\n\x12SignMessageRequest\x12\x0b\n\x03msg\x18\x01 \x01(\x0c\x12\x13\n\x0bsingle_hash\x18\x02 \x01(\x08\"(\n\x13SignMessageResponse\x12\x11\n\tsignature\x18\x01 \x01(\t\"6\n\x14VerifyMessageRequest\x12\x0b\n\x03msg\x18\x01 \x01(\x0c\x12\x11\n\tsignature\x18\x02 \x01(\t\"6\n\x15VerifyMessageResponse\x12\r\n\x05valid\x18\x01 \x01(\x08\x12\x0e\n\x06pubkey\x18\x02 \x01(\t\"Z\n\x12\x43onnectPeerRequest\x12%\n\x04\x61\x64\x64r\x18\x01 \x01(\x0b\x32\x17.lnrpc.LightningAddress\x12\x0c\n\x04perm\x18\x02 \x01(\x08\x12\x0f\n\x07timeout\x18\x03 \x01(\x04\"\x15\n\x13\x43onnectPeerResponse\"(\n\x15\x44isconnectPeerRequest\x12\x0f\n\x07pub_key\x18\x01 \x01(\t\"\x18\n\x16\x44isconnectPeerResponse\"\xa5\x01\n\x04HTLC\x12\x10\n\x08incoming\x18\x01 \x01(\x08\x12\x0e\n\x06\x61mount\x18\x02 \x01(\x03\x12\x11\n\thash_lock\x18\x03 \x01(\x0c\x12\x19\n\x11\x65xpiration_height\x18\x04 \x01(\r\x12\x12\n\nhtlc_index\x18\x05 \x01(\x04\x12\x1a\n\x12\x66orwarding_channel\x18\x06 \x01(\x04\x12\x1d\n\x15\x66orwarding_htlc_index\x18\x07 \x01(\x04\"\xaa\x01\n\x12\x43hannelConstraints\x12\x11\n\tcsv_delay\x18\x01 \x01(\r\x12\x18\n\x10\x63han_reserve_sat\x18\x02 \x01(\x04\x12\x16\n\x0e\x64ust_limit_sat\x18\x03 \x01(\x04\x12\x1c\n\x14max_pending_amt_msat\x18\x04 \x01(\x04\x12\x15\n\rmin_htlc_msat\x18\x05 \x01(\x04\x12\x1a\n\x12max_accepted_htlcs\x18\x06 \x01(\r\"\xb9\x07\n\x07\x43hannel\x12\x0e\n\x06\x61\x63tive\x18\x01 \x01(\x08\x12\x15\n\rremote_pubkey\x18\x02 \x01(\t\x12\x15\n\rchannel_point\x18\x03 \x01(\t\x12\x13\n\x07\x63han_id\x18\x04 \x01(\x04\x42\x02\x30\x01\x12\x10\n\x08\x63\x61pacity\x18\x05 \x01(\x03\x12\x15\n\rlocal_balance\x18\x06 \x01(\x03\x12\x16\n\x0eremote_balance\x18\x07 \x01(\x03\x12\x12\n\ncommit_fee\x18\x08 \x01(\x03\x12\x15\n\rcommit_weight\x18\t \x01(\x03\x12\x12\n\nfee_per_kw\x18\n \x01(\x03\x12\x19\n\x11unsettled_balance\x18\x0b \x01(\x03\x12\x1b\n\x13total_satoshis_sent\x18\x0c \x01(\x03\x12\x1f\n\x17total_satoshis_received\x18\r \x01(\x03\x12\x13\n\x0bnum_updates\x18\x0e \x01(\x04\x12\"\n\rpending_htlcs\x18\x0f \x03(\x0b\x32\x0b.lnrpc.HTLC\x12\x15\n\tcsv_delay\x18\x10 \x01(\rB\x02\x18\x01\x12\x0f\n\x07private\x18\x11 \x01(\x08\x12\x11\n\tinitiator\x18\x12 \x01(\x08\x12\x19\n\x11\x63han_status_flags\x18\x13 \x01(\t\x12\"\n\x16local_chan_reserve_sat\x18\x14 \x01(\x03\x42\x02\x18\x01\x12#\n\x17remote_chan_reserve_sat\x18\x15 \x01(\x03\x42\x02\x18\x01\x12\x1d\n\x11static_remote_key\x18\x16 \x01(\x08\x42\x02\x18\x01\x12.\n\x0f\x63ommitment_type\x18\x1a \x01(\x0e\x32\x15.lnrpc.CommitmentType\x12\x10\n\x08lifetime\x18\x17 \x01(\x03\x12\x0e\n\x06uptime\x18\x18 \x01(\x03\x12\x15\n\rclose_address\x18\x19 \x01(\t\x12\x17\n\x0fpush_amount_sat\x18\x1b \x01(\x04\x12\x13\n\x0bthaw_height\x18\x1c \x01(\r\x12\x34\n\x11local_constraints\x18\x1d \x01(\x0b\x32\x19.lnrpc.ChannelConstraints\x12\x35\n\x12remote_constraints\x18\x1e \x01(\x0b\x32\x19.lnrpc.ChannelConstraints\x12\x13\n\x0b\x61lias_scids\x18\x1f \x03(\x04\x12\x11\n\tzero_conf\x18 \x01(\x08\x12 \n\x18zero_conf_confirmed_scid\x18! \x01(\x04\x12\x12\n\npeer_alias\x18\" \x01(\t\x12\x1b\n\x0fpeer_scid_alias\x18# \x01(\x04\x42\x02\x30\x01\x12\x0c\n\x04memo\x18$ \x01(\t\"\x95\x01\n\x13ListChannelsRequest\x12\x13\n\x0b\x61\x63tive_only\x18\x01 \x01(\x08\x12\x15\n\rinactive_only\x18\x02 \x01(\x08\x12\x13\n\x0bpublic_only\x18\x03 \x01(\x08\x12\x14\n\x0cprivate_only\x18\x04 \x01(\x08\x12\x0c\n\x04peer\x18\x05 \x01(\x0c\x12\x19\n\x11peer_alias_lookup\x18\x06 \x01(\x08\"8\n\x14ListChannelsResponse\x12 \n\x08\x63hannels\x18\x0b \x03(\x0b\x32\x0e.lnrpc.Channel\".\n\x08\x41liasMap\x12\x11\n\tbase_scid\x18\x01 \x01(\x04\x12\x0f\n\x07\x61liases\x18\x02 \x03(\x04\"\x14\n\x12ListAliasesRequest\":\n\x13ListAliasesResponse\x12#\n\nalias_maps\x18\x01 \x03(\x0b\x32\x0f.lnrpc.AliasMap\"\xe4\x04\n\x13\x43hannelCloseSummary\x12\x15\n\rchannel_point\x18\x01 \x01(\t\x12\x13\n\x07\x63han_id\x18\x02 \x01(\x04\x42\x02\x30\x01\x12\x12\n\nchain_hash\x18\x03 \x01(\t\x12\x17\n\x0f\x63losing_tx_hash\x18\x04 \x01(\t\x12\x15\n\rremote_pubkey\x18\x05 \x01(\t\x12\x10\n\x08\x63\x61pacity\x18\x06 \x01(\x03\x12\x14\n\x0c\x63lose_height\x18\x07 \x01(\r\x12\x17\n\x0fsettled_balance\x18\x08 \x01(\x03\x12\x1b\n\x13time_locked_balance\x18\t \x01(\x03\x12:\n\nclose_type\x18\n \x01(\x0e\x32&.lnrpc.ChannelCloseSummary.ClosureType\x12(\n\x0eopen_initiator\x18\x0b \x01(\x0e\x32\x10.lnrpc.Initiator\x12)\n\x0f\x63lose_initiator\x18\x0c \x01(\x0e\x32\x10.lnrpc.Initiator\x12&\n\x0bresolutions\x18\r \x03(\x0b\x32\x11.lnrpc.Resolution\x12\x13\n\x0b\x61lias_scids\x18\x0e \x03(\x04\x12$\n\x18zero_conf_confirmed_scid\x18\x0f \x01(\x04\x42\x02\x30\x01\"\x8a\x01\n\x0b\x43losureType\x12\x15\n\x11\x43OOPERATIVE_CLOSE\x10\x00\x12\x15\n\x11LOCAL_FORCE_CLOSE\x10\x01\x12\x16\n\x12REMOTE_FORCE_CLOSE\x10\x02\x12\x10\n\x0c\x42REACH_CLOSE\x10\x03\x12\x14\n\x10\x46UNDING_CANCELED\x10\x04\x12\r\n\tABANDONED\x10\x05\"\xb2\x01\n\nResolution\x12.\n\x0fresolution_type\x18\x01 \x01(\x0e\x32\x15.lnrpc.ResolutionType\x12)\n\x07outcome\x18\x02 \x01(\x0e\x32\x18.lnrpc.ResolutionOutcome\x12!\n\x08outpoint\x18\x03 \x01(\x0b\x32\x0f.lnrpc.OutPoint\x12\x12\n\namount_sat\x18\x04 \x01(\x04\x12\x12\n\nsweep_txid\x18\x05 \x01(\t\"\x94\x01\n\x15\x43losedChannelsRequest\x12\x13\n\x0b\x63ooperative\x18\x01 \x01(\x08\x12\x13\n\x0blocal_force\x18\x02 \x01(\x08\x12\x14\n\x0cremote_force\x18\x03 \x01(\x08\x12\x0e\n\x06\x62reach\x18\x04 \x01(\x08\x12\x18\n\x10\x66unding_canceled\x18\x05 \x01(\x08\x12\x11\n\tabandoned\x18\x06 \x01(\x08\"F\n\x16\x43losedChannelsResponse\x12,\n\x08\x63hannels\x18\x01 \x03(\x0b\x32\x1a.lnrpc.ChannelCloseSummary\"\xef\x03\n\x04Peer\x12\x0f\n\x07pub_key\x18\x01 \x01(\t\x12\x0f\n\x07\x61\x64\x64ress\x18\x03 \x01(\t\x12\x12\n\nbytes_sent\x18\x04 \x01(\x04\x12\x12\n\nbytes_recv\x18\x05 \x01(\x04\x12\x10\n\x08sat_sent\x18\x06 \x01(\x03\x12\x10\n\x08sat_recv\x18\x07 \x01(\x03\x12\x0f\n\x07inbound\x18\x08 \x01(\x08\x12\x11\n\tping_time\x18\t \x01(\x03\x12\'\n\tsync_type\x18\n \x01(\x0e\x32\x14.lnrpc.Peer.SyncType\x12+\n\x08\x66\x65\x61tures\x18\x0b \x03(\x0b\x32\x19.lnrpc.Peer.FeaturesEntry\x12\'\n\x06\x65rrors\x18\x0c \x03(\x0b\x32\x17.lnrpc.TimestampedError\x12\x12\n\nflap_count\x18\r \x01(\x05\x12\x14\n\x0clast_flap_ns\x18\x0e \x01(\x03\x12\x19\n\x11last_ping_payload\x18\x0f \x01(\x0c\x1a?\n\rFeaturesEntry\x12\x0b\n\x03key\x18\x01 \x01(\r\x12\x1d\n\x05value\x18\x02 \x01(\x0b\x32\x0e.lnrpc.Feature:\x02\x38\x01\"P\n\x08SyncType\x12\x10\n\x0cUNKNOWN_SYNC\x10\x00\x12\x0f\n\x0b\x41\x43TIVE_SYNC\x10\x01\x12\x10\n\x0cPASSIVE_SYNC\x10\x02\x12\x0f\n\x0bPINNED_SYNC\x10\x03\"4\n\x10TimestampedError\x12\x11\n\ttimestamp\x18\x01 \x01(\x04\x12\r\n\x05\x65rror\x18\x02 \x01(\t\"(\n\x10ListPeersRequest\x12\x14\n\x0clatest_error\x18\x01 \x01(\x08\"/\n\x11ListPeersResponse\x12\x1a\n\x05peers\x18\x01 \x03(\x0b\x32\x0b.lnrpc.Peer\"\x17\n\x15PeerEventSubscription\"v\n\tPeerEvent\x12\x0f\n\x07pub_key\x18\x01 \x01(\t\x12(\n\x04type\x18\x02 \x01(\x0e\x32\x1a.lnrpc.PeerEvent.EventType\".\n\tEventType\x12\x0f\n\x0bPEER_ONLINE\x10\x00\x12\x10\n\x0cPEER_OFFLINE\x10\x01\"\x10\n\x0eGetInfoRequest\"\xde\x04\n\x0fGetInfoResponse\x12\x0f\n\x07version\x18\x0e \x01(\t\x12\x13\n\x0b\x63ommit_hash\x18\x14 \x01(\t\x12\x17\n\x0fidentity_pubkey\x18\x01 \x01(\t\x12\r\n\x05\x61lias\x18\x02 \x01(\t\x12\r\n\x05\x63olor\x18\x11 \x01(\t\x12\x1c\n\x14num_pending_channels\x18\x03 \x01(\r\x12\x1b\n\x13num_active_channels\x18\x04 \x01(\r\x12\x1d\n\x15num_inactive_channels\x18\x0f \x01(\r\x12\x11\n\tnum_peers\x18\x05 \x01(\r\x12\x14\n\x0c\x62lock_height\x18\x06 \x01(\r\x12\x12\n\nblock_hash\x18\x08 \x01(\t\x12\x1d\n\x15\x62\x65st_header_timestamp\x18\r \x01(\x03\x12\x17\n\x0fsynced_to_chain\x18\t \x01(\x08\x12\x17\n\x0fsynced_to_graph\x18\x12 \x01(\x08\x12\x13\n\x07testnet\x18\n \x01(\x08\x42\x02\x18\x01\x12\x1c\n\x06\x63hains\x18\x10 \x03(\x0b\x32\x0c.lnrpc.Chain\x12\x0c\n\x04uris\x18\x0c \x03(\t\x12\x36\n\x08\x66\x65\x61tures\x18\x13 \x03(\x0b\x32$.lnrpc.GetInfoResponse.FeaturesEntry\x12 \n\x18require_htlc_interceptor\x18\x15 \x01(\x08\x12$\n\x1cstore_final_htlc_resolutions\x18\x16 \x01(\x08\x1a?\n\rFeaturesEntry\x12\x0b\n\x03key\x18\x01 \x01(\r\x12\x1d\n\x05value\x18\x02 \x01(\x0b\x32\x0e.lnrpc.Feature:\x02\x38\x01J\x04\x08\x0b\x10\x0c\"\x15\n\x13GetDebugInfoRequest\"\x8b\x01\n\x14GetDebugInfoResponse\x12\x37\n\x06\x63onfig\x18\x01 \x03(\x0b\x32\'.lnrpc.GetDebugInfoResponse.ConfigEntry\x12\x0b\n\x03log\x18\x02 \x03(\t\x1a-\n\x0b\x43onfigEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\"\x18\n\x16GetRecoveryInfoRequest\"]\n\x17GetRecoveryInfoResponse\x12\x15\n\rrecovery_mode\x18\x01 \x01(\x08\x12\x19\n\x11recovery_finished\x18\x02 \x01(\x08\x12\x10\n\x08progress\x18\x03 \x01(\x01\"+\n\x05\x43hain\x12\x11\n\x05\x63hain\x18\x01 \x01(\tB\x02\x18\x01\x12\x0f\n\x07network\x18\x02 \x01(\t\"U\n\x12\x43onfirmationUpdate\x12\x11\n\tblock_sha\x18\x01 \x01(\x0c\x12\x14\n\x0c\x62lock_height\x18\x02 \x01(\x05\x12\x16\n\x0enum_confs_left\x18\x03 \x01(\r\"?\n\x11\x43hannelOpenUpdate\x12*\n\rchannel_point\x18\x01 \x01(\x0b\x32\x13.lnrpc.ChannelPoint\";\n\x12\x43hannelCloseUpdate\x12\x14\n\x0c\x63losing_txid\x18\x01 \x01(\x0c\x12\x0f\n\x07success\x18\x02 \x01(\x08\"\xdc\x01\n\x13\x43loseChannelRequest\x12*\n\rchannel_point\x18\x01 \x01(\x0b\x32\x13.lnrpc.ChannelPoint\x12\r\n\x05\x66orce\x18\x02 \x01(\x08\x12\x13\n\x0btarget_conf\x18\x03 \x01(\x05\x12\x18\n\x0csat_per_byte\x18\x04 \x01(\x03\x42\x02\x18\x01\x12\x18\n\x10\x64\x65livery_address\x18\x05 \x01(\t\x12\x15\n\rsat_per_vbyte\x18\x06 \x01(\x04\x12\x19\n\x11max_fee_per_vbyte\x18\x07 \x01(\x04\x12\x0f\n\x07no_wait\x18\x08 \x01(\x08\"\xac\x01\n\x11\x43loseStatusUpdate\x12-\n\rclose_pending\x18\x01 \x01(\x0b\x32\x14.lnrpc.PendingUpdateH\x00\x12/\n\nchan_close\x18\x03 \x01(\x0b\x32\x19.lnrpc.ChannelCloseUpdateH\x00\x12-\n\rclose_instant\x18\x04 \x01(\x0b\x32\x14.lnrpc.InstantUpdateH\x00\x42\x08\n\x06update\"3\n\rPendingUpdate\x12\x0c\n\x04txid\x18\x01 \x01(\x0c\x12\x14\n\x0coutput_index\x18\x02 \x01(\r\"\x0f\n\rInstantUpdate\"T\n\x13ReadyForPsbtFunding\x12\x17\n\x0f\x66unding_address\x18\x01 \x01(\t\x12\x16\n\x0e\x66unding_amount\x18\x02 \x01(\x03\x12\x0c\n\x04psbt\x18\x03 \x01(\x0c\"\xec\x01\n\x17\x42\x61tchOpenChannelRequest\x12)\n\x08\x63hannels\x18\x01 \x03(\x0b\x32\x17.lnrpc.BatchOpenChannel\x12\x13\n\x0btarget_conf\x18\x02 \x01(\x05\x12\x15\n\rsat_per_vbyte\x18\x03 \x01(\x03\x12\x11\n\tmin_confs\x18\x04 \x01(\x05\x12\x19\n\x11spend_unconfirmed\x18\x05 \x01(\x08\x12\r\n\x05label\x18\x06 \x01(\t\x12=\n\x17\x63oin_selection_strategy\x18\x07 \x01(\x0e\x32\x1c.lnrpc.CoinSelectionStrategy\"\xf9\x03\n\x10\x42\x61tchOpenChannel\x12\x13\n\x0bnode_pubkey\x18\x01 \x01(\x0c\x12\x1c\n\x14local_funding_amount\x18\x02 \x01(\x03\x12\x10\n\x08push_sat\x18\x03 \x01(\x03\x12\x0f\n\x07private\x18\x04 \x01(\x08\x12\x15\n\rmin_htlc_msat\x18\x05 \x01(\x03\x12\x18\n\x10remote_csv_delay\x18\x06 \x01(\r\x12\x15\n\rclose_address\x18\x07 \x01(\t\x12\x17\n\x0fpending_chan_id\x18\x08 \x01(\x0c\x12.\n\x0f\x63ommitment_type\x18\t \x01(\x0e\x32\x15.lnrpc.CommitmentType\x12\'\n\x1fremote_max_value_in_flight_msat\x18\n \x01(\x04\x12\x18\n\x10remote_max_htlcs\x18\x0b \x01(\r\x12\x15\n\rmax_local_csv\x18\x0c \x01(\r\x12\x11\n\tzero_conf\x18\r \x01(\x08\x12\x12\n\nscid_alias\x18\x0e \x01(\x08\x12\x10\n\x08\x62\x61se_fee\x18\x0f \x01(\x04\x12\x10\n\x08\x66\x65\x65_rate\x18\x10 \x01(\x04\x12\x14\n\x0cuse_base_fee\x18\x11 \x01(\x08\x12\x14\n\x0cuse_fee_rate\x18\x12 \x01(\x08\x12\x1f\n\x17remote_chan_reserve_sat\x18\x13 \x01(\x04\x12\x0c\n\x04memo\x18\x14 \x01(\t\"J\n\x18\x42\x61tchOpenChannelResponse\x12.\n\x10pending_channels\x18\x01 \x03(\x0b\x32\x14.lnrpc.PendingUpdate\"\xd6\x05\n\x12OpenChannelRequest\x12\x15\n\rsat_per_vbyte\x18\x01 \x01(\x04\x12\x13\n\x0bnode_pubkey\x18\x02 \x01(\x0c\x12\x1e\n\x12node_pubkey_string\x18\x03 \x01(\tB\x02\x18\x01\x12\x1c\n\x14local_funding_amount\x18\x04 \x01(\x03\x12\x10\n\x08push_sat\x18\x05 \x01(\x03\x12\x13\n\x0btarget_conf\x18\x06 \x01(\x05\x12\x18\n\x0csat_per_byte\x18\x07 \x01(\x03\x42\x02\x18\x01\x12\x0f\n\x07private\x18\x08 \x01(\x08\x12\x15\n\rmin_htlc_msat\x18\t \x01(\x03\x12\x18\n\x10remote_csv_delay\x18\n \x01(\r\x12\x11\n\tmin_confs\x18\x0b \x01(\x05\x12\x19\n\x11spend_unconfirmed\x18\x0c \x01(\x08\x12\x15\n\rclose_address\x18\r \x01(\t\x12(\n\x0c\x66unding_shim\x18\x0e \x01(\x0b\x32\x12.lnrpc.FundingShim\x12\'\n\x1fremote_max_value_in_flight_msat\x18\x0f \x01(\x04\x12\x18\n\x10remote_max_htlcs\x18\x10 \x01(\r\x12\x15\n\rmax_local_csv\x18\x11 \x01(\r\x12.\n\x0f\x63ommitment_type\x18\x12 \x01(\x0e\x32\x15.lnrpc.CommitmentType\x12\x11\n\tzero_conf\x18\x13 \x01(\x08\x12\x12\n\nscid_alias\x18\x14 \x01(\x08\x12\x10\n\x08\x62\x61se_fee\x18\x15 \x01(\x04\x12\x10\n\x08\x66\x65\x65_rate\x18\x16 \x01(\x04\x12\x14\n\x0cuse_base_fee\x18\x17 \x01(\x08\x12\x14\n\x0cuse_fee_rate\x18\x18 \x01(\x08\x12\x1f\n\x17remote_chan_reserve_sat\x18\x19 \x01(\x04\x12\x10\n\x08\x66und_max\x18\x1a \x01(\x08\x12\x0c\n\x04memo\x18\x1b \x01(\t\x12\"\n\toutpoints\x18\x1c \x03(\x0b\x32\x0f.lnrpc.OutPoint\"\xc3\x01\n\x10OpenStatusUpdate\x12,\n\x0c\x63han_pending\x18\x01 \x01(\x0b\x32\x14.lnrpc.PendingUpdateH\x00\x12-\n\tchan_open\x18\x03 \x01(\x0b\x32\x18.lnrpc.ChannelOpenUpdateH\x00\x12/\n\tpsbt_fund\x18\x05 \x01(\x0b\x32\x1a.lnrpc.ReadyForPsbtFundingH\x00\x12\x17\n\x0fpending_chan_id\x18\x04 \x01(\x0c\x42\x08\n\x06update\"3\n\nKeyLocator\x12\x12\n\nkey_family\x18\x01 \x01(\x05\x12\x11\n\tkey_index\x18\x02 \x01(\x05\"J\n\rKeyDescriptor\x12\x15\n\rraw_key_bytes\x18\x01 \x01(\x0c\x12\"\n\x07key_loc\x18\x02 \x01(\x0b\x32\x11.lnrpc.KeyLocator\"\xc0\x01\n\rChanPointShim\x12\x0b\n\x03\x61mt\x18\x01 \x01(\x03\x12\'\n\nchan_point\x18\x02 \x01(\x0b\x32\x13.lnrpc.ChannelPoint\x12\'\n\tlocal_key\x18\x03 \x01(\x0b\x32\x14.lnrpc.KeyDescriptor\x12\x12\n\nremote_key\x18\x04 \x01(\x0c\x12\x17\n\x0fpending_chan_id\x18\x05 \x01(\x0c\x12\x13\n\x0bthaw_height\x18\x06 \x01(\r\x12\x0e\n\x06musig2\x18\x07 \x01(\x08\"J\n\x08PsbtShim\x12\x17\n\x0fpending_chan_id\x18\x01 \x01(\x0c\x12\x11\n\tbase_psbt\x18\x02 \x01(\x0c\x12\x12\n\nno_publish\x18\x03 \x01(\x08\"l\n\x0b\x46undingShim\x12/\n\x0f\x63han_point_shim\x18\x01 \x01(\x0b\x32\x14.lnrpc.ChanPointShimH\x00\x12$\n\tpsbt_shim\x18\x02 \x01(\x0b\x32\x0f.lnrpc.PsbtShimH\x00\x42\x06\n\x04shim\",\n\x11\x46undingShimCancel\x12\x17\n\x0fpending_chan_id\x18\x01 \x01(\x0c\"X\n\x11\x46undingPsbtVerify\x12\x13\n\x0b\x66unded_psbt\x18\x01 \x01(\x0c\x12\x17\n\x0fpending_chan_id\x18\x02 \x01(\x0c\x12\x15\n\rskip_finalize\x18\x03 \x01(\x08\"Y\n\x13\x46undingPsbtFinalize\x12\x13\n\x0bsigned_psbt\x18\x01 \x01(\x0c\x12\x17\n\x0fpending_chan_id\x18\x02 \x01(\x0c\x12\x14\n\x0c\x66inal_raw_tx\x18\x03 \x01(\x0c\"\xe5\x01\n\x14\x46undingTransitionMsg\x12+\n\rshim_register\x18\x01 \x01(\x0b\x32\x12.lnrpc.FundingShimH\x00\x12/\n\x0bshim_cancel\x18\x02 \x01(\x0b\x32\x18.lnrpc.FundingShimCancelH\x00\x12/\n\x0bpsbt_verify\x18\x03 \x01(\x0b\x32\x18.lnrpc.FundingPsbtVerifyH\x00\x12\x33\n\rpsbt_finalize\x18\x04 \x01(\x0b\x32\x1a.lnrpc.FundingPsbtFinalizeH\x00\x42\t\n\x07trigger\"\x16\n\x14\x46undingStateStepResp\"\x86\x01\n\x0bPendingHTLC\x12\x10\n\x08incoming\x18\x01 \x01(\x08\x12\x0e\n\x06\x61mount\x18\x02 \x01(\x03\x12\x10\n\x08outpoint\x18\x03 \x01(\t\x12\x17\n\x0fmaturity_height\x18\x04 \x01(\r\x12\x1b\n\x13\x62locks_til_maturity\x18\x05 \x01(\x05\x12\r\n\x05stage\x18\x06 \x01(\r\"0\n\x16PendingChannelsRequest\x12\x16\n\x0einclude_raw_tx\x18\x01 \x01(\x08\"\xbc\x0e\n\x17PendingChannelsResponse\x12\x1b\n\x13total_limbo_balance\x18\x01 \x01(\x03\x12P\n\x15pending_open_channels\x18\x02 \x03(\x0b\x32\x31.lnrpc.PendingChannelsResponse.PendingOpenChannel\x12R\n\x18pending_closing_channels\x18\x03 \x03(\x0b\x32,.lnrpc.PendingChannelsResponse.ClosedChannelB\x02\x18\x01\x12Y\n\x1epending_force_closing_channels\x18\x04 \x03(\x0b\x32\x31.lnrpc.PendingChannelsResponse.ForceClosedChannel\x12R\n\x16waiting_close_channels\x18\x05 \x03(\x0b\x32\x32.lnrpc.PendingChannelsResponse.WaitingCloseChannel\x1a\xf2\x02\n\x0ePendingChannel\x12\x17\n\x0fremote_node_pub\x18\x01 \x01(\t\x12\x15\n\rchannel_point\x18\x02 \x01(\t\x12\x10\n\x08\x63\x61pacity\x18\x03 \x01(\x03\x12\x15\n\rlocal_balance\x18\x04 \x01(\x03\x12\x16\n\x0eremote_balance\x18\x05 \x01(\x03\x12\x1e\n\x16local_chan_reserve_sat\x18\x06 \x01(\x03\x12\x1f\n\x17remote_chan_reserve_sat\x18\x07 \x01(\x03\x12#\n\tinitiator\x18\x08 \x01(\x0e\x32\x10.lnrpc.Initiator\x12.\n\x0f\x63ommitment_type\x18\t \x01(\x0e\x32\x15.lnrpc.CommitmentType\x12\x1f\n\x17num_forwarding_packages\x18\n \x01(\x03\x12\x19\n\x11\x63han_status_flags\x18\x0b \x01(\t\x12\x0f\n\x07private\x18\x0c \x01(\x08\x12\x0c\n\x04memo\x18\r \x01(\t\x1a\xb8\x01\n\x12PendingOpenChannel\x12>\n\x07\x63hannel\x18\x01 \x01(\x0b\x32-.lnrpc.PendingChannelsResponse.PendingChannel\x12\x12\n\ncommit_fee\x18\x04 \x01(\x03\x12\x15\n\rcommit_weight\x18\x05 \x01(\x03\x12\x12\n\nfee_per_kw\x18\x06 \x01(\x03\x12\x1d\n\x15\x66unding_expiry_blocks\x18\x03 \x01(\x05J\x04\x08\x02\x10\x03\x1a\xdb\x01\n\x13WaitingCloseChannel\x12>\n\x07\x63hannel\x18\x01 \x01(\x0b\x32-.lnrpc.PendingChannelsResponse.PendingChannel\x12\x15\n\rlimbo_balance\x18\x02 \x01(\x03\x12?\n\x0b\x63ommitments\x18\x03 \x01(\x0b\x32*.lnrpc.PendingChannelsResponse.Commitments\x12\x14\n\x0c\x63losing_txid\x18\x04 \x01(\t\x12\x16\n\x0e\x63losing_tx_hex\x18\x05 \x01(\t\x1a\xb7\x01\n\x0b\x43ommitments\x12\x12\n\nlocal_txid\x18\x01 \x01(\t\x12\x13\n\x0bremote_txid\x18\x02 \x01(\t\x12\x1b\n\x13remote_pending_txid\x18\x03 \x01(\t\x12\x1c\n\x14local_commit_fee_sat\x18\x04 \x01(\x04\x12\x1d\n\x15remote_commit_fee_sat\x18\x05 \x01(\x04\x12%\n\x1dremote_pending_commit_fee_sat\x18\x06 \x01(\x04\x1a\x65\n\rClosedChannel\x12>\n\x07\x63hannel\x18\x01 \x01(\x0b\x32-.lnrpc.PendingChannelsResponse.PendingChannel\x12\x14\n\x0c\x63losing_txid\x18\x02 \x01(\t\x1a\xff\x02\n\x12\x46orceClosedChannel\x12>\n\x07\x63hannel\x18\x01 \x01(\x0b\x32-.lnrpc.PendingChannelsResponse.PendingChannel\x12\x14\n\x0c\x63losing_txid\x18\x02 \x01(\t\x12\x15\n\rlimbo_balance\x18\x03 \x01(\x03\x12\x17\n\x0fmaturity_height\x18\x04 \x01(\r\x12\x1b\n\x13\x62locks_til_maturity\x18\x05 \x01(\x05\x12\x19\n\x11recovered_balance\x18\x06 \x01(\x03\x12)\n\rpending_htlcs\x18\x08 \x03(\x0b\x32\x12.lnrpc.PendingHTLC\x12M\n\x06\x61nchor\x18\t \x01(\x0e\x32=.lnrpc.PendingChannelsResponse.ForceClosedChannel.AnchorState\"1\n\x0b\x41nchorState\x12\t\n\x05LIMBO\x10\x00\x12\r\n\tRECOVERED\x10\x01\x12\x08\n\x04LOST\x10\x02\"\x1a\n\x18\x43hannelEventSubscription\"\x93\x04\n\x12\x43hannelEventUpdate\x12&\n\x0copen_channel\x18\x01 \x01(\x0b\x32\x0e.lnrpc.ChannelH\x00\x12\x34\n\x0e\x63losed_channel\x18\x02 \x01(\x0b\x32\x1a.lnrpc.ChannelCloseSummaryH\x00\x12-\n\x0e\x61\x63tive_channel\x18\x03 \x01(\x0b\x32\x13.lnrpc.ChannelPointH\x00\x12/\n\x10inactive_channel\x18\x04 \x01(\x0b\x32\x13.lnrpc.ChannelPointH\x00\x12\x34\n\x14pending_open_channel\x18\x06 \x01(\x0b\x32\x14.lnrpc.PendingUpdateH\x00\x12\x35\n\x16\x66ully_resolved_channel\x18\x07 \x01(\x0b\x32\x13.lnrpc.ChannelPointH\x00\x12\x32\n\x04type\x18\x05 \x01(\x0e\x32$.lnrpc.ChannelEventUpdate.UpdateType\"\x92\x01\n\nUpdateType\x12\x10\n\x0cOPEN_CHANNEL\x10\x00\x12\x12\n\x0e\x43LOSED_CHANNEL\x10\x01\x12\x12\n\x0e\x41\x43TIVE_CHANNEL\x10\x02\x12\x14\n\x10INACTIVE_CHANNEL\x10\x03\x12\x18\n\x14PENDING_OPEN_CHANNEL\x10\x04\x12\x1a\n\x16\x46ULLY_RESOLVED_CHANNEL\x10\x05\x42\t\n\x07\x63hannel\"N\n\x14WalletAccountBalance\x12\x19\n\x11\x63onfirmed_balance\x18\x01 \x01(\x03\x12\x1b\n\x13unconfirmed_balance\x18\x02 \x01(\x03\":\n\x14WalletBalanceRequest\x12\x0f\n\x07\x61\x63\x63ount\x18\x01 \x01(\t\x12\x11\n\tmin_confs\x18\x02 \x01(\x05\"\xc3\x02\n\x15WalletBalanceResponse\x12\x15\n\rtotal_balance\x18\x01 \x01(\x03\x12\x19\n\x11\x63onfirmed_balance\x18\x02 \x01(\x03\x12\x1b\n\x13unconfirmed_balance\x18\x03 \x01(\x03\x12\x16\n\x0elocked_balance\x18\x05 \x01(\x03\x12$\n\x1creserved_balance_anchor_chan\x18\x06 \x01(\x03\x12I\n\x0f\x61\x63\x63ount_balance\x18\x04 \x03(\x0b\x32\x30.lnrpc.WalletBalanceResponse.AccountBalanceEntry\x1aR\n\x13\x41\x63\x63ountBalanceEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12*\n\x05value\x18\x02 \x01(\x0b\x32\x1b.lnrpc.WalletAccountBalance:\x02\x38\x01\"#\n\x06\x41mount\x12\x0b\n\x03sat\x18\x01 \x01(\x04\x12\x0c\n\x04msat\x18\x02 \x01(\x04\"\x17\n\x15\x43hannelBalanceRequest\"\xe4\x02\n\x16\x43hannelBalanceResponse\x12\x13\n\x07\x62\x61lance\x18\x01 \x01(\x03\x42\x02\x18\x01\x12 \n\x14pending_open_balance\x18\x02 \x01(\x03\x42\x02\x18\x01\x12$\n\rlocal_balance\x18\x03 \x01(\x0b\x32\r.lnrpc.Amount\x12%\n\x0eremote_balance\x18\x04 \x01(\x0b\x32\r.lnrpc.Amount\x12.\n\x17unsettled_local_balance\x18\x05 \x01(\x0b\x32\r.lnrpc.Amount\x12/\n\x18unsettled_remote_balance\x18\x06 \x01(\x0b\x32\r.lnrpc.Amount\x12\x31\n\x1apending_open_local_balance\x18\x07 \x01(\x0b\x32\r.lnrpc.Amount\x12\x32\n\x1bpending_open_remote_balance\x18\x08 \x01(\x0b\x32\r.lnrpc.Amount\"\x9d\x05\n\x12QueryRoutesRequest\x12\x0f\n\x07pub_key\x18\x01 \x01(\t\x12\x0b\n\x03\x61mt\x18\x02 \x01(\x03\x12\x10\n\x08\x61mt_msat\x18\x0c \x01(\x03\x12\x18\n\x10\x66inal_cltv_delta\x18\x04 \x01(\x05\x12\"\n\tfee_limit\x18\x05 \x01(\x0b\x32\x0f.lnrpc.FeeLimit\x12\x15\n\rignored_nodes\x18\x06 \x03(\x0c\x12-\n\rignored_edges\x18\x07 \x03(\x0b\x32\x12.lnrpc.EdgeLocatorB\x02\x18\x01\x12\x16\n\x0esource_pub_key\x18\x08 \x01(\t\x12\x1b\n\x13use_mission_control\x18\t \x01(\x08\x12&\n\rignored_pairs\x18\n \x03(\x0b\x32\x0f.lnrpc.NodePair\x12\x12\n\ncltv_limit\x18\x0b \x01(\r\x12M\n\x13\x64\x65st_custom_records\x18\r \x03(\x0b\x32\x30.lnrpc.QueryRoutesRequest.DestCustomRecordsEntry\x12\x1c\n\x10outgoing_chan_id\x18\x0e \x01(\x04\x42\x02\x30\x01\x12\x17\n\x0flast_hop_pubkey\x18\x0f \x01(\x0c\x12%\n\x0broute_hints\x18\x10 \x03(\x0b\x32\x10.lnrpc.RouteHint\x12\x38\n\x15\x62linded_payment_paths\x18\x13 \x03(\x0b\x32\x19.lnrpc.BlindedPaymentPath\x12(\n\rdest_features\x18\x11 \x03(\x0e\x32\x11.lnrpc.FeatureBit\x12\x11\n\ttime_pref\x18\x12 \x01(\x01\x1a\x38\n\x16\x44\x65stCustomRecordsEntry\x12\x0b\n\x03key\x18\x01 \x01(\x04\x12\r\n\x05value\x18\x02 \x01(\x0c:\x02\x38\x01J\x04\x08\x03\x10\x04\"$\n\x08NodePair\x12\x0c\n\x04\x66rom\x18\x01 \x01(\x0c\x12\n\n\x02to\x18\x02 \x01(\x0c\"@\n\x0b\x45\x64geLocator\x12\x16\n\nchannel_id\x18\x01 \x01(\x04\x42\x02\x30\x01\x12\x19\n\x11\x64irection_reverse\x18\x02 \x01(\x08\"I\n\x13QueryRoutesResponse\x12\x1c\n\x06routes\x18\x01 \x03(\x0b\x32\x0c.lnrpc.Route\x12\x14\n\x0csuccess_prob\x18\x02 \x01(\x01\"\xde\x03\n\x03Hop\x12\x13\n\x07\x63han_id\x18\x01 \x01(\x04\x42\x02\x30\x01\x12\x19\n\rchan_capacity\x18\x02 \x01(\x03\x42\x02\x18\x01\x12\x1a\n\x0e\x61mt_to_forward\x18\x03 \x01(\x03\x42\x02\x18\x01\x12\x0f\n\x03\x66\x65\x65\x18\x04 \x01(\x03\x42\x02\x18\x01\x12\x0e\n\x06\x65xpiry\x18\x05 \x01(\r\x12\x1b\n\x13\x61mt_to_forward_msat\x18\x06 \x01(\x03\x12\x10\n\x08\x66\x65\x65_msat\x18\x07 \x01(\x03\x12\x0f\n\x07pub_key\x18\x08 \x01(\t\x12\x17\n\x0btlv_payload\x18\t \x01(\x08\x42\x02\x18\x01\x12$\n\nmpp_record\x18\n \x01(\x0b\x32\x10.lnrpc.MPPRecord\x12$\n\namp_record\x18\x0c \x01(\x0b\x32\x10.lnrpc.AMPRecord\x12\x35\n\x0e\x63ustom_records\x18\x0b \x03(\x0b\x32\x1d.lnrpc.Hop.CustomRecordsEntry\x12\x10\n\x08metadata\x18\r \x01(\x0c\x12\x16\n\x0e\x62linding_point\x18\x0e \x01(\x0c\x12\x16\n\x0e\x65ncrypted_data\x18\x0f \x01(\x0c\x12\x16\n\x0etotal_amt_msat\x18\x10 \x01(\x04\x1a\x34\n\x12\x43ustomRecordsEntry\x12\x0b\n\x03key\x18\x01 \x01(\x04\x12\r\n\x05value\x18\x02 \x01(\x0c:\x02\x38\x01\"9\n\tMPPRecord\x12\x14\n\x0cpayment_addr\x18\x0b \x01(\x0c\x12\x16\n\x0etotal_amt_msat\x18\n \x01(\x03\"D\n\tAMPRecord\x12\x12\n\nroot_share\x18\x01 \x01(\x0c\x12\x0e\n\x06set_id\x18\x02 \x01(\x0c\x12\x13\n\x0b\x63hild_index\x18\x03 \x01(\r\"\x9a\x01\n\x05Route\x12\x17\n\x0ftotal_time_lock\x18\x01 \x01(\r\x12\x16\n\ntotal_fees\x18\x02 \x01(\x03\x42\x02\x18\x01\x12\x15\n\ttotal_amt\x18\x03 \x01(\x03\x42\x02\x18\x01\x12\x18\n\x04hops\x18\x04 \x03(\x0b\x32\n.lnrpc.Hop\x12\x17\n\x0ftotal_fees_msat\x18\x05 \x01(\x03\x12\x16\n\x0etotal_amt_msat\x18\x06 \x01(\x03\"<\n\x0fNodeInfoRequest\x12\x0f\n\x07pub_key\x18\x01 \x01(\t\x12\x18\n\x10include_channels\x18\x02 \x01(\x08\"\x82\x01\n\x08NodeInfo\x12\"\n\x04node\x18\x01 \x01(\x0b\x32\x14.lnrpc.LightningNode\x12\x14\n\x0cnum_channels\x18\x02 \x01(\r\x12\x16\n\x0etotal_capacity\x18\x03 \x01(\x03\x12$\n\x08\x63hannels\x18\x04 \x03(\x0b\x32\x12.lnrpc.ChannelEdge\"\xe8\x02\n\rLightningNode\x12\x13\n\x0blast_update\x18\x01 \x01(\r\x12\x0f\n\x07pub_key\x18\x02 \x01(\t\x12\r\n\x05\x61lias\x18\x03 \x01(\t\x12%\n\taddresses\x18\x04 \x03(\x0b\x32\x12.lnrpc.NodeAddress\x12\r\n\x05\x63olor\x18\x05 \x01(\t\x12\x34\n\x08\x66\x65\x61tures\x18\x06 \x03(\x0b\x32\".lnrpc.LightningNode.FeaturesEntry\x12?\n\x0e\x63ustom_records\x18\x07 \x03(\x0b\x32\'.lnrpc.LightningNode.CustomRecordsEntry\x1a?\n\rFeaturesEntry\x12\x0b\n\x03key\x18\x01 \x01(\r\x12\x1d\n\x05value\x18\x02 \x01(\x0b\x32\x0e.lnrpc.Feature:\x02\x38\x01\x1a\x34\n\x12\x43ustomRecordsEntry\x12\x0b\n\x03key\x18\x01 \x01(\x04\x12\r\n\x05value\x18\x02 \x01(\x0c:\x02\x38\x01\",\n\x0bNodeAddress\x12\x0f\n\x07network\x18\x01 \x01(\t\x12\x0c\n\x04\x61\x64\x64r\x18\x02 \x01(\t\"\xe7\x02\n\rRoutingPolicy\x12\x17\n\x0ftime_lock_delta\x18\x01 \x01(\r\x12\x10\n\x08min_htlc\x18\x02 \x01(\x03\x12\x15\n\rfee_base_msat\x18\x03 \x01(\x03\x12\x1b\n\x13\x66\x65\x65_rate_milli_msat\x18\x04 \x01(\x03\x12\x10\n\x08\x64isabled\x18\x05 \x01(\x08\x12\x15\n\rmax_htlc_msat\x18\x06 \x01(\x04\x12\x13\n\x0blast_update\x18\x07 \x01(\r\x12?\n\x0e\x63ustom_records\x18\x08 \x03(\x0b\x32\'.lnrpc.RoutingPolicy.CustomRecordsEntry\x12\x1d\n\x15inbound_fee_base_msat\x18\t \x01(\x05\x12#\n\x1binbound_fee_rate_milli_msat\x18\n \x01(\x05\x1a\x34\n\x12\x43ustomRecordsEntry\x12\x0b\n\x03key\x18\x01 \x01(\x04\x12\r\n\x05value\x18\x02 \x01(\x0c:\x02\x38\x01\"\xd7\x02\n\x0b\x43hannelEdge\x12\x16\n\nchannel_id\x18\x01 \x01(\x04\x42\x02\x30\x01\x12\x12\n\nchan_point\x18\x02 \x01(\t\x12\x17\n\x0blast_update\x18\x03 \x01(\rB\x02\x18\x01\x12\x11\n\tnode1_pub\x18\x04 \x01(\t\x12\x11\n\tnode2_pub\x18\x05 \x01(\t\x12\x10\n\x08\x63\x61pacity\x18\x06 \x01(\x03\x12*\n\x0cnode1_policy\x18\x07 \x01(\x0b\x32\x14.lnrpc.RoutingPolicy\x12*\n\x0cnode2_policy\x18\x08 \x01(\x0b\x32\x14.lnrpc.RoutingPolicy\x12=\n\x0e\x63ustom_records\x18\t \x03(\x0b\x32%.lnrpc.ChannelEdge.CustomRecordsEntry\x1a\x34\n\x12\x43ustomRecordsEntry\x12\x0b\n\x03key\x18\x01 \x01(\x04\x12\r\n\x05value\x18\x02 \x01(\x0c:\x02\x38\x01\"2\n\x13\x43hannelGraphRequest\x12\x1b\n\x13include_unannounced\x18\x01 \x01(\x08\"V\n\x0c\x43hannelGraph\x12#\n\x05nodes\x18\x01 \x03(\x0b\x32\x14.lnrpc.LightningNode\x12!\n\x05\x65\x64ges\x18\x02 \x03(\x0b\x32\x12.lnrpc.ChannelEdge\":\n\x12NodeMetricsRequest\x12$\n\x05types\x18\x01 \x03(\x0e\x32\x15.lnrpc.NodeMetricType\"\xbe\x01\n\x13NodeMetricsResponse\x12U\n\x16\x62\x65tweenness_centrality\x18\x01 \x03(\x0b\x32\x35.lnrpc.NodeMetricsResponse.BetweennessCentralityEntry\x1aP\n\x1a\x42\x65tweennessCentralityEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12!\n\x05value\x18\x02 \x01(\x0b\x32\x12.lnrpc.FloatMetric:\x02\x38\x01\"6\n\x0b\x46loatMetric\x12\r\n\x05value\x18\x01 \x01(\x01\x12\x18\n\x10normalized_value\x18\x02 \x01(\x01\":\n\x0f\x43hanInfoRequest\x12\x13\n\x07\x63han_id\x18\x01 \x01(\x04\x42\x02\x30\x01\x12\x12\n\nchan_point\x18\x02 \x01(\t\"\x14\n\x12NetworkInfoRequest\"\xa7\x02\n\x0bNetworkInfo\x12\x16\n\x0egraph_diameter\x18\x01 \x01(\r\x12\x16\n\x0e\x61vg_out_degree\x18\x02 \x01(\x01\x12\x16\n\x0emax_out_degree\x18\x03 \x01(\r\x12\x11\n\tnum_nodes\x18\x04 \x01(\r\x12\x14\n\x0cnum_channels\x18\x05 \x01(\r\x12\x1e\n\x16total_network_capacity\x18\x06 \x01(\x03\x12\x18\n\x10\x61vg_channel_size\x18\x07 \x01(\x01\x12\x18\n\x10min_channel_size\x18\x08 \x01(\x03\x12\x18\n\x10max_channel_size\x18\t \x01(\x03\x12\x1f\n\x17median_channel_size_sat\x18\n \x01(\x03\x12\x18\n\x10num_zombie_chans\x18\x0b \x01(\x04\"\r\n\x0bStopRequest\"\x0e\n\x0cStopResponse\"\x1b\n\x19GraphTopologySubscription\"\xa3\x01\n\x13GraphTopologyUpdate\x12\'\n\x0cnode_updates\x18\x01 \x03(\x0b\x32\x11.lnrpc.NodeUpdate\x12\x31\n\x0f\x63hannel_updates\x18\x02 \x03(\x0b\x32\x18.lnrpc.ChannelEdgeUpdate\x12\x30\n\x0c\x63losed_chans\x18\x03 \x03(\x0b\x32\x1a.lnrpc.ClosedChannelUpdate\"\x94\x02\n\nNodeUpdate\x12\x15\n\taddresses\x18\x01 \x03(\tB\x02\x18\x01\x12\x14\n\x0cidentity_key\x18\x02 \x01(\t\x12\x1b\n\x0fglobal_features\x18\x03 \x01(\x0c\x42\x02\x18\x01\x12\r\n\x05\x61lias\x18\x04 \x01(\t\x12\r\n\x05\x63olor\x18\x05 \x01(\t\x12*\n\x0enode_addresses\x18\x07 \x03(\x0b\x32\x12.lnrpc.NodeAddress\x12\x31\n\x08\x66\x65\x61tures\x18\x06 \x03(\x0b\x32\x1f.lnrpc.NodeUpdate.FeaturesEntry\x1a?\n\rFeaturesEntry\x12\x0b\n\x03key\x18\x01 \x01(\r\x12\x1d\n\x05value\x18\x02 \x01(\x0b\x32\x0e.lnrpc.Feature:\x02\x38\x01\"\xc4\x01\n\x11\x43hannelEdgeUpdate\x12\x13\n\x07\x63han_id\x18\x01 \x01(\x04\x42\x02\x30\x01\x12\'\n\nchan_point\x18\x02 \x01(\x0b\x32\x13.lnrpc.ChannelPoint\x12\x10\n\x08\x63\x61pacity\x18\x03 \x01(\x03\x12,\n\x0erouting_policy\x18\x04 \x01(\x0b\x32\x14.lnrpc.RoutingPolicy\x12\x18\n\x10\x61\x64vertising_node\x18\x05 \x01(\t\x12\x17\n\x0f\x63onnecting_node\x18\x06 \x01(\t\"|\n\x13\x43losedChannelUpdate\x12\x13\n\x07\x63han_id\x18\x01 \x01(\x04\x42\x02\x30\x01\x12\x10\n\x08\x63\x61pacity\x18\x02 \x01(\x03\x12\x15\n\rclosed_height\x18\x03 \x01(\r\x12\'\n\nchan_point\x18\x04 \x01(\x0b\x32\x13.lnrpc.ChannelPoint\"\x86\x01\n\x07HopHint\x12\x0f\n\x07node_id\x18\x01 \x01(\t\x12\x13\n\x07\x63han_id\x18\x02 \x01(\x04\x42\x02\x30\x01\x12\x15\n\rfee_base_msat\x18\x03 \x01(\r\x12#\n\x1b\x66\x65\x65_proportional_millionths\x18\x04 \x01(\r\x12\x19\n\x11\x63ltv_expiry_delta\x18\x05 \x01(\r\"\x17\n\x05SetID\x12\x0e\n\x06set_id\x18\x01 \x01(\x0c\".\n\tRouteHint\x12!\n\thop_hints\x18\x01 \x03(\x0b\x32\x0e.lnrpc.HopHint\"\xe1\x01\n\x12\x42lindedPaymentPath\x12(\n\x0c\x62linded_path\x18\x01 \x01(\x0b\x32\x12.lnrpc.BlindedPath\x12\x15\n\rbase_fee_msat\x18\x02 \x01(\x04\x12\x1d\n\x15proportional_fee_rate\x18\x03 \x01(\r\x12\x18\n\x10total_cltv_delta\x18\x04 \x01(\r\x12\x15\n\rhtlc_min_msat\x18\x05 \x01(\x04\x12\x15\n\rhtlc_max_msat\x18\x06 \x01(\x04\x12#\n\x08\x66\x65\x61tures\x18\x07 \x03(\x0e\x32\x11.lnrpc.FeatureBit\"i\n\x0b\x42lindedPath\x12\x19\n\x11introduction_node\x18\x01 \x01(\x0c\x12\x16\n\x0e\x62linding_point\x18\x02 \x01(\x0c\x12\'\n\x0c\x62linded_hops\x18\x03 \x03(\x0b\x32\x11.lnrpc.BlindedHop\":\n\nBlindedHop\x12\x14\n\x0c\x62linded_node\x18\x01 \x01(\x0c\x12\x16\n\x0e\x65ncrypted_data\x18\x02 \x01(\x0c\"{\n\x0f\x41MPInvoiceState\x12&\n\x05state\x18\x01 \x01(\x0e\x32\x17.lnrpc.InvoiceHTLCState\x12\x14\n\x0csettle_index\x18\x02 \x01(\x04\x12\x13\n\x0bsettle_time\x18\x03 \x01(\x03\x12\x15\n\ramt_paid_msat\x18\x05 \x01(\x03\"\x85\x07\n\x07Invoice\x12\x0c\n\x04memo\x18\x01 \x01(\t\x12\x12\n\nr_preimage\x18\x03 \x01(\x0c\x12\x0e\n\x06r_hash\x18\x04 \x01(\x0c\x12\r\n\x05value\x18\x05 \x01(\x03\x12\x12\n\nvalue_msat\x18\x17 \x01(\x03\x12\x13\n\x07settled\x18\x06 \x01(\x08\x42\x02\x18\x01\x12\x15\n\rcreation_date\x18\x07 \x01(\x03\x12\x13\n\x0bsettle_date\x18\x08 \x01(\x03\x12\x17\n\x0fpayment_request\x18\t \x01(\t\x12\x18\n\x10\x64\x65scription_hash\x18\n \x01(\x0c\x12\x0e\n\x06\x65xpiry\x18\x0b \x01(\x03\x12\x15\n\rfallback_addr\x18\x0c \x01(\t\x12\x13\n\x0b\x63ltv_expiry\x18\r \x01(\x04\x12%\n\x0broute_hints\x18\x0e \x03(\x0b\x32\x10.lnrpc.RouteHint\x12\x0f\n\x07private\x18\x0f \x01(\x08\x12\x11\n\tadd_index\x18\x10 \x01(\x04\x12\x14\n\x0csettle_index\x18\x11 \x01(\x04\x12\x14\n\x08\x61mt_paid\x18\x12 \x01(\x03\x42\x02\x18\x01\x12\x14\n\x0c\x61mt_paid_sat\x18\x13 \x01(\x03\x12\x15\n\ramt_paid_msat\x18\x14 \x01(\x03\x12*\n\x05state\x18\x15 \x01(\x0e\x32\x1b.lnrpc.Invoice.InvoiceState\x12!\n\x05htlcs\x18\x16 \x03(\x0b\x32\x12.lnrpc.InvoiceHTLC\x12.\n\x08\x66\x65\x61tures\x18\x18 \x03(\x0b\x32\x1c.lnrpc.Invoice.FeaturesEntry\x12\x12\n\nis_keysend\x18\x19 \x01(\x08\x12\x14\n\x0cpayment_addr\x18\x1a \x01(\x0c\x12\x0e\n\x06is_amp\x18\x1b \x01(\x08\x12>\n\x11\x61mp_invoice_state\x18\x1c \x03(\x0b\x32#.lnrpc.Invoice.AmpInvoiceStateEntry\x1a?\n\rFeaturesEntry\x12\x0b\n\x03key\x18\x01 \x01(\r\x12\x1d\n\x05value\x18\x02 \x01(\x0b\x32\x0e.lnrpc.Feature:\x02\x38\x01\x1aN\n\x14\x41mpInvoiceStateEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12%\n\x05value\x18\x02 \x01(\x0b\x32\x16.lnrpc.AMPInvoiceState:\x02\x38\x01\"A\n\x0cInvoiceState\x12\x08\n\x04OPEN\x10\x00\x12\x0b\n\x07SETTLED\x10\x01\x12\x0c\n\x08\x43\x41NCELED\x10\x02\x12\x0c\n\x08\x41\x43\x43\x45PTED\x10\x03J\x04\x08\x02\x10\x03\"\xf3\x02\n\x0bInvoiceHTLC\x12\x13\n\x07\x63han_id\x18\x01 \x01(\x04\x42\x02\x30\x01\x12\x12\n\nhtlc_index\x18\x02 \x01(\x04\x12\x10\n\x08\x61mt_msat\x18\x03 \x01(\x04\x12\x15\n\raccept_height\x18\x04 \x01(\x05\x12\x13\n\x0b\x61\x63\x63\x65pt_time\x18\x05 \x01(\x03\x12\x14\n\x0cresolve_time\x18\x06 \x01(\x03\x12\x15\n\rexpiry_height\x18\x07 \x01(\x05\x12&\n\x05state\x18\x08 \x01(\x0e\x32\x17.lnrpc.InvoiceHTLCState\x12=\n\x0e\x63ustom_records\x18\t \x03(\x0b\x32%.lnrpc.InvoiceHTLC.CustomRecordsEntry\x12\x1a\n\x12mpp_total_amt_msat\x18\n \x01(\x04\x12\x17\n\x03\x61mp\x18\x0b \x01(\x0b\x32\n.lnrpc.AMP\x1a\x34\n\x12\x43ustomRecordsEntry\x12\x0b\n\x03key\x18\x01 \x01(\x04\x12\r\n\x05value\x18\x02 \x01(\x0c:\x02\x38\x01\"^\n\x03\x41MP\x12\x12\n\nroot_share\x18\x01 \x01(\x0c\x12\x0e\n\x06set_id\x18\x02 \x01(\x0c\x12\x13\n\x0b\x63hild_index\x18\x03 \x01(\r\x12\x0c\n\x04hash\x18\x04 \x01(\x0c\x12\x10\n\x08preimage\x18\x05 \x01(\x0c\"f\n\x12\x41\x64\x64InvoiceResponse\x12\x0e\n\x06r_hash\x18\x01 \x01(\x0c\x12\x17\n\x0fpayment_request\x18\x02 \x01(\t\x12\x11\n\tadd_index\x18\x10 \x01(\x04\x12\x14\n\x0cpayment_addr\x18\x11 \x01(\x0c\"5\n\x0bPaymentHash\x12\x16\n\nr_hash_str\x18\x01 \x01(\tB\x02\x18\x01\x12\x0e\n\x06r_hash\x18\x02 \x01(\x0c\"\xa4\x01\n\x12ListInvoiceRequest\x12\x14\n\x0cpending_only\x18\x01 \x01(\x08\x12\x14\n\x0cindex_offset\x18\x04 \x01(\x04\x12\x18\n\x10num_max_invoices\x18\x05 \x01(\x04\x12\x10\n\x08reversed\x18\x06 \x01(\x08\x12\x1b\n\x13\x63reation_date_start\x18\x07 \x01(\x04\x12\x19\n\x11\x63reation_date_end\x18\x08 \x01(\x04\"n\n\x13ListInvoiceResponse\x12 \n\x08invoices\x18\x01 \x03(\x0b\x32\x0e.lnrpc.Invoice\x12\x19\n\x11last_index_offset\x18\x02 \x01(\x04\x12\x1a\n\x12\x66irst_index_offset\x18\x03 \x01(\x04\">\n\x13InvoiceSubscription\x12\x11\n\tadd_index\x18\x01 \x01(\x04\x12\x14\n\x0csettle_index\x18\x02 \x01(\x04\"\xf3\x03\n\x07Payment\x12\x14\n\x0cpayment_hash\x18\x01 \x01(\t\x12\x11\n\x05value\x18\x02 \x01(\x03\x42\x02\x18\x01\x12\x19\n\rcreation_date\x18\x03 \x01(\x03\x42\x02\x18\x01\x12\x0f\n\x03\x66\x65\x65\x18\x05 \x01(\x03\x42\x02\x18\x01\x12\x18\n\x10payment_preimage\x18\x06 \x01(\t\x12\x11\n\tvalue_sat\x18\x07 \x01(\x03\x12\x12\n\nvalue_msat\x18\x08 \x01(\x03\x12\x17\n\x0fpayment_request\x18\t \x01(\t\x12,\n\x06status\x18\n \x01(\x0e\x32\x1c.lnrpc.Payment.PaymentStatus\x12\x0f\n\x07\x66\x65\x65_sat\x18\x0b \x01(\x03\x12\x10\n\x08\x66\x65\x65_msat\x18\x0c \x01(\x03\x12\x18\n\x10\x63reation_time_ns\x18\r \x01(\x03\x12!\n\x05htlcs\x18\x0e \x03(\x0b\x32\x12.lnrpc.HTLCAttempt\x12\x15\n\rpayment_index\x18\x0f \x01(\x04\x12\x33\n\x0e\x66\x61ilure_reason\x18\x10 \x01(\x0e\x32\x1b.lnrpc.PaymentFailureReason\"Y\n\rPaymentStatus\x12\x0f\n\x07UNKNOWN\x10\x00\x1a\x02\x08\x01\x12\r\n\tIN_FLIGHT\x10\x01\x12\r\n\tSUCCEEDED\x10\x02\x12\n\n\x06\x46\x41ILED\x10\x03\x12\r\n\tINITIATED\x10\x04J\x04\x08\x04\x10\x05\"\x8a\x02\n\x0bHTLCAttempt\x12\x12\n\nattempt_id\x18\x07 \x01(\x04\x12-\n\x06status\x18\x01 \x01(\x0e\x32\x1d.lnrpc.HTLCAttempt.HTLCStatus\x12\x1b\n\x05route\x18\x02 \x01(\x0b\x32\x0c.lnrpc.Route\x12\x17\n\x0f\x61ttempt_time_ns\x18\x03 \x01(\x03\x12\x17\n\x0fresolve_time_ns\x18\x04 \x01(\x03\x12\x1f\n\x07\x66\x61ilure\x18\x05 \x01(\x0b\x32\x0e.lnrpc.Failure\x12\x10\n\x08preimage\x18\x06 \x01(\x0c\"6\n\nHTLCStatus\x12\r\n\tIN_FLIGHT\x10\x00\x12\r\n\tSUCCEEDED\x10\x01\x12\n\n\x06\x46\x41ILED\x10\x02\"\xc5\x01\n\x13ListPaymentsRequest\x12\x1a\n\x12include_incomplete\x18\x01 \x01(\x08\x12\x14\n\x0cindex_offset\x18\x02 \x01(\x04\x12\x14\n\x0cmax_payments\x18\x03 \x01(\x04\x12\x10\n\x08reversed\x18\x04 \x01(\x08\x12\x1c\n\x14\x63ount_total_payments\x18\x05 \x01(\x08\x12\x1b\n\x13\x63reation_date_start\x18\x06 \x01(\x04\x12\x19\n\x11\x63reation_date_end\x18\x07 \x01(\x04\"\x8b\x01\n\x14ListPaymentsResponse\x12 \n\x08payments\x18\x01 \x03(\x0b\x32\x0e.lnrpc.Payment\x12\x1a\n\x12\x66irst_index_offset\x18\x02 \x01(\x04\x12\x19\n\x11last_index_offset\x18\x03 \x01(\x04\x12\x1a\n\x12total_num_payments\x18\x04 \x01(\x04\"G\n\x14\x44\x65letePaymentRequest\x12\x14\n\x0cpayment_hash\x18\x01 \x01(\x0c\x12\x19\n\x11\x66\x61iled_htlcs_only\x18\x02 \x01(\x08\"i\n\x18\x44\x65leteAllPaymentsRequest\x12\x1c\n\x14\x66\x61iled_payments_only\x18\x01 \x01(\x08\x12\x19\n\x11\x66\x61iled_htlcs_only\x18\x02 \x01(\x08\x12\x14\n\x0c\x61ll_payments\x18\x03 \x01(\x08\"\x17\n\x15\x44\x65letePaymentResponse\"\x1b\n\x19\x44\x65leteAllPaymentsResponse\"\x86\x01\n\x15\x41\x62\x61ndonChannelRequest\x12*\n\rchannel_point\x18\x01 \x01(\x0b\x32\x13.lnrpc.ChannelPoint\x12!\n\x19pending_funding_shim_only\x18\x02 \x01(\x08\x12\x1e\n\x16i_know_what_i_am_doing\x18\x03 \x01(\x08\"\x18\n\x16\x41\x62\x61ndonChannelResponse\"5\n\x11\x44\x65\x62ugLevelRequest\x12\x0c\n\x04show\x18\x01 \x01(\x08\x12\x12\n\nlevel_spec\x18\x02 \x01(\t\")\n\x12\x44\x65\x62ugLevelResponse\x12\x13\n\x0bsub_systems\x18\x01 \x01(\t\"\x1f\n\x0cPayReqString\x12\x0f\n\x07pay_req\x18\x01 \x01(\t\"\xb8\x03\n\x06PayReq\x12\x13\n\x0b\x64\x65stination\x18\x01 \x01(\t\x12\x14\n\x0cpayment_hash\x18\x02 \x01(\t\x12\x14\n\x0cnum_satoshis\x18\x03 \x01(\x03\x12\x11\n\ttimestamp\x18\x04 \x01(\x03\x12\x0e\n\x06\x65xpiry\x18\x05 \x01(\x03\x12\x13\n\x0b\x64\x65scription\x18\x06 \x01(\t\x12\x18\n\x10\x64\x65scription_hash\x18\x07 \x01(\t\x12\x15\n\rfallback_addr\x18\x08 \x01(\t\x12\x13\n\x0b\x63ltv_expiry\x18\t \x01(\x03\x12%\n\x0broute_hints\x18\n \x03(\x0b\x32\x10.lnrpc.RouteHint\x12\x14\n\x0cpayment_addr\x18\x0b \x01(\x0c\x12\x10\n\x08num_msat\x18\x0c \x01(\x03\x12-\n\x08\x66\x65\x61tures\x18\r \x03(\x0b\x32\x1b.lnrpc.PayReq.FeaturesEntry\x12\x30\n\rblinded_paths\x18\x0e \x03(\x0b\x32\x19.lnrpc.BlindedPaymentPath\x1a?\n\rFeaturesEntry\x12\x0b\n\x03key\x18\x01 \x01(\r\x12\x1d\n\x05value\x18\x02 \x01(\x0b\x32\x0e.lnrpc.Feature:\x02\x38\x01\">\n\x07\x46\x65\x61ture\x12\x0c\n\x04name\x18\x02 \x01(\t\x12\x13\n\x0bis_required\x18\x03 \x01(\x08\x12\x10\n\x08is_known\x18\x04 \x01(\x08\"\x12\n\x10\x46\x65\x65ReportRequest\"\xb8\x01\n\x10\x43hannelFeeReport\x12\x13\n\x07\x63han_id\x18\x05 \x01(\x04\x42\x02\x30\x01\x12\x15\n\rchannel_point\x18\x01 \x01(\t\x12\x15\n\rbase_fee_msat\x18\x02 \x01(\x03\x12\x13\n\x0b\x66\x65\x65_per_mil\x18\x03 \x01(\x03\x12\x10\n\x08\x66\x65\x65_rate\x18\x04 \x01(\x01\x12\x1d\n\x15inbound_base_fee_msat\x18\x06 \x01(\x05\x12\x1b\n\x13inbound_fee_per_mil\x18\x07 \x01(\x05\"\x84\x01\n\x11\x46\x65\x65ReportResponse\x12-\n\x0c\x63hannel_fees\x18\x01 \x03(\x0b\x32\x17.lnrpc.ChannelFeeReport\x12\x13\n\x0b\x64\x61y_fee_sum\x18\x02 \x01(\x04\x12\x14\n\x0cweek_fee_sum\x18\x03 \x01(\x04\x12\x15\n\rmonth_fee_sum\x18\x04 \x01(\x04\"9\n\nInboundFee\x12\x15\n\rbase_fee_msat\x18\x01 \x01(\x05\x12\x14\n\x0c\x66\x65\x65_rate_ppm\x18\x02 \x01(\x05\"\xaa\x02\n\x13PolicyUpdateRequest\x12\x10\n\x06global\x18\x01 \x01(\x08H\x00\x12)\n\nchan_point\x18\x02 \x01(\x0b\x32\x13.lnrpc.ChannelPointH\x00\x12\x15\n\rbase_fee_msat\x18\x03 \x01(\x03\x12\x10\n\x08\x66\x65\x65_rate\x18\x04 \x01(\x01\x12\x14\n\x0c\x66\x65\x65_rate_ppm\x18\t \x01(\r\x12\x17\n\x0ftime_lock_delta\x18\x05 \x01(\r\x12\x15\n\rmax_htlc_msat\x18\x06 \x01(\x04\x12\x15\n\rmin_htlc_msat\x18\x07 \x01(\x04\x12\x1f\n\x17min_htlc_msat_specified\x18\x08 \x01(\x08\x12&\n\x0binbound_fee\x18\n \x01(\x0b\x32\x11.lnrpc.InboundFeeB\x07\n\x05scope\"m\n\x0c\x46\x61iledUpdate\x12!\n\x08outpoint\x18\x01 \x01(\x0b\x32\x0f.lnrpc.OutPoint\x12$\n\x06reason\x18\x02 \x01(\x0e\x32\x14.lnrpc.UpdateFailure\x12\x14\n\x0cupdate_error\x18\x03 \x01(\t\"C\n\x14PolicyUpdateResponse\x12+\n\x0e\x66\x61iled_updates\x18\x01 \x03(\x0b\x32\x13.lnrpc.FailedUpdate\"\x89\x01\n\x18\x46orwardingHistoryRequest\x12\x12\n\nstart_time\x18\x01 \x01(\x04\x12\x10\n\x08\x65nd_time\x18\x02 \x01(\x04\x12\x14\n\x0cindex_offset\x18\x03 \x01(\r\x12\x16\n\x0enum_max_events\x18\x04 \x01(\r\x12\x19\n\x11peer_alias_lookup\x18\x05 \x01(\x08\"\x89\x02\n\x0f\x46orwardingEvent\x12\x15\n\ttimestamp\x18\x01 \x01(\x04\x42\x02\x18\x01\x12\x16\n\nchan_id_in\x18\x02 \x01(\x04\x42\x02\x30\x01\x12\x17\n\x0b\x63han_id_out\x18\x04 \x01(\x04\x42\x02\x30\x01\x12\x0e\n\x06\x61mt_in\x18\x05 \x01(\x04\x12\x0f\n\x07\x61mt_out\x18\x06 \x01(\x04\x12\x0b\n\x03\x66\x65\x65\x18\x07 \x01(\x04\x12\x10\n\x08\x66\x65\x65_msat\x18\x08 \x01(\x04\x12\x13\n\x0b\x61mt_in_msat\x18\t \x01(\x04\x12\x14\n\x0c\x61mt_out_msat\x18\n \x01(\x04\x12\x14\n\x0ctimestamp_ns\x18\x0b \x01(\x04\x12\x15\n\rpeer_alias_in\x18\x0c \x01(\t\x12\x16\n\x0epeer_alias_out\x18\r \x01(\t\"i\n\x19\x46orwardingHistoryResponse\x12\x31\n\x11\x66orwarding_events\x18\x01 \x03(\x0b\x32\x16.lnrpc.ForwardingEvent\x12\x19\n\x11last_offset_index\x18\x02 \x01(\r\"E\n\x1a\x45xportChannelBackupRequest\x12\'\n\nchan_point\x18\x01 \x01(\x0b\x32\x13.lnrpc.ChannelPoint\"M\n\rChannelBackup\x12\'\n\nchan_point\x18\x01 \x01(\x0b\x32\x13.lnrpc.ChannelPoint\x12\x13\n\x0b\x63han_backup\x18\x02 \x01(\x0c\"V\n\x0fMultiChanBackup\x12(\n\x0b\x63han_points\x18\x01 \x03(\x0b\x32\x13.lnrpc.ChannelPoint\x12\x19\n\x11multi_chan_backup\x18\x02 \x01(\x0c\"\x19\n\x17\x43hanBackupExportRequest\"{\n\x12\x43hanBackupSnapshot\x12\x32\n\x13single_chan_backups\x18\x01 \x01(\x0b\x32\x15.lnrpc.ChannelBackups\x12\x31\n\x11multi_chan_backup\x18\x02 \x01(\x0b\x32\x16.lnrpc.MultiChanBackup\"<\n\x0e\x43hannelBackups\x12*\n\x0c\x63han_backups\x18\x01 \x03(\x0b\x32\x14.lnrpc.ChannelBackup\"p\n\x18RestoreChanBackupRequest\x12-\n\x0c\x63han_backups\x18\x01 \x01(\x0b\x32\x15.lnrpc.ChannelBackupsH\x00\x12\x1b\n\x11multi_chan_backup\x18\x02 \x01(\x0cH\x00\x42\x08\n\x06\x62\x61\x63kup\"\x17\n\x15RestoreBackupResponse\"\x1b\n\x19\x43hannelBackupSubscription\"\x1a\n\x18VerifyChanBackupResponse\"4\n\x12MacaroonPermission\x12\x0e\n\x06\x65ntity\x18\x01 \x01(\t\x12\x0e\n\x06\x61\x63tion\x18\x02 \x01(\t\"~\n\x13\x42\x61keMacaroonRequest\x12.\n\x0bpermissions\x18\x01 \x03(\x0b\x32\x19.lnrpc.MacaroonPermission\x12\x13\n\x0broot_key_id\x18\x02 \x01(\x04\x12\"\n\x1a\x61llow_external_permissions\x18\x03 \x01(\x08\"(\n\x14\x42\x61keMacaroonResponse\x12\x10\n\x08macaroon\x18\x01 \x01(\t\"\x18\n\x16ListMacaroonIDsRequest\"/\n\x17ListMacaroonIDsResponse\x12\x14\n\x0croot_key_ids\x18\x01 \x03(\x04\".\n\x17\x44\x65leteMacaroonIDRequest\x12\x13\n\x0broot_key_id\x18\x01 \x01(\x04\"+\n\x18\x44\x65leteMacaroonIDResponse\x12\x0f\n\x07\x64\x65leted\x18\x01 \x01(\x08\"H\n\x16MacaroonPermissionList\x12.\n\x0bpermissions\x18\x01 \x03(\x0b\x32\x19.lnrpc.MacaroonPermission\"\x18\n\x16ListPermissionsRequest\"\xc5\x01\n\x17ListPermissionsResponse\x12Q\n\x12method_permissions\x18\x01 \x03(\x0b\x32\x35.lnrpc.ListPermissionsResponse.MethodPermissionsEntry\x1aW\n\x16MethodPermissionsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12,\n\x05value\x18\x02 \x01(\x0b\x32\x1d.lnrpc.MacaroonPermissionList:\x02\x38\x01\"\xf1\x07\n\x07\x46\x61ilure\x12(\n\x04\x63ode\x18\x01 \x01(\x0e\x32\x1a.lnrpc.Failure.FailureCode\x12,\n\x0e\x63hannel_update\x18\x03 \x01(\x0b\x32\x14.lnrpc.ChannelUpdate\x12\x11\n\thtlc_msat\x18\x04 \x01(\x04\x12\x15\n\ronion_sha_256\x18\x05 \x01(\x0c\x12\x13\n\x0b\x63ltv_expiry\x18\x06 \x01(\r\x12\r\n\x05\x66lags\x18\x07 \x01(\r\x12\x1c\n\x14\x66\x61ilure_source_index\x18\x08 \x01(\r\x12\x0e\n\x06height\x18\t \x01(\r\"\x8b\x06\n\x0b\x46\x61ilureCode\x12\x0c\n\x08RESERVED\x10\x00\x12(\n$INCORRECT_OR_UNKNOWN_PAYMENT_DETAILS\x10\x01\x12\x1c\n\x18INCORRECT_PAYMENT_AMOUNT\x10\x02\x12\x1f\n\x1b\x46INAL_INCORRECT_CLTV_EXPIRY\x10\x03\x12\x1f\n\x1b\x46INAL_INCORRECT_HTLC_AMOUNT\x10\x04\x12\x19\n\x15\x46INAL_EXPIRY_TOO_SOON\x10\x05\x12\x11\n\rINVALID_REALM\x10\x06\x12\x13\n\x0f\x45XPIRY_TOO_SOON\x10\x07\x12\x19\n\x15INVALID_ONION_VERSION\x10\x08\x12\x16\n\x12INVALID_ONION_HMAC\x10\t\x12\x15\n\x11INVALID_ONION_KEY\x10\n\x12\x18\n\x14\x41MOUNT_BELOW_MINIMUM\x10\x0b\x12\x14\n\x10\x46\x45\x45_INSUFFICIENT\x10\x0c\x12\x19\n\x15INCORRECT_CLTV_EXPIRY\x10\r\x12\x14\n\x10\x43HANNEL_DISABLED\x10\x0e\x12\x1d\n\x19TEMPORARY_CHANNEL_FAILURE\x10\x0f\x12!\n\x1dREQUIRED_NODE_FEATURE_MISSING\x10\x10\x12$\n REQUIRED_CHANNEL_FEATURE_MISSING\x10\x11\x12\x15\n\x11UNKNOWN_NEXT_PEER\x10\x12\x12\x1a\n\x16TEMPORARY_NODE_FAILURE\x10\x13\x12\x1a\n\x16PERMANENT_NODE_FAILURE\x10\x14\x12\x1d\n\x19PERMANENT_CHANNEL_FAILURE\x10\x15\x12\x12\n\x0e\x45XPIRY_TOO_FAR\x10\x16\x12\x0f\n\x0bMPP_TIMEOUT\x10\x17\x12\x19\n\x15INVALID_ONION_PAYLOAD\x10\x18\x12\x1a\n\x16INVALID_ONION_BLINDING\x10\x19\x12\x15\n\x10INTERNAL_FAILURE\x10\xe5\x07\x12\x14\n\x0fUNKNOWN_FAILURE\x10\xe6\x07\x12\x17\n\x12UNREADABLE_FAILURE\x10\xe7\x07J\x04\x08\x02\x10\x03\"\x9a\x02\n\rChannelUpdate\x12\x11\n\tsignature\x18\x01 \x01(\x0c\x12\x12\n\nchain_hash\x18\x02 \x01(\x0c\x12\x13\n\x07\x63han_id\x18\x03 \x01(\x04\x42\x02\x30\x01\x12\x11\n\ttimestamp\x18\x04 \x01(\r\x12\x15\n\rmessage_flags\x18\n \x01(\r\x12\x15\n\rchannel_flags\x18\x05 \x01(\r\x12\x17\n\x0ftime_lock_delta\x18\x06 \x01(\r\x12\x19\n\x11htlc_minimum_msat\x18\x07 \x01(\x04\x12\x10\n\x08\x62\x61se_fee\x18\x08 \x01(\r\x12\x10\n\x08\x66\x65\x65_rate\x18\t \x01(\r\x12\x19\n\x11htlc_maximum_msat\x18\x0b \x01(\x04\x12\x19\n\x11\x65xtra_opaque_data\x18\x0c \x01(\x0c\"F\n\nMacaroonId\x12\r\n\x05nonce\x18\x01 \x01(\x0c\x12\x11\n\tstorageId\x18\x02 \x01(\x0c\x12\x16\n\x03ops\x18\x03 \x03(\x0b\x32\t.lnrpc.Op\"%\n\x02Op\x12\x0e\n\x06\x65ntity\x18\x01 \x01(\t\x12\x0f\n\x07\x61\x63tions\x18\x02 \x03(\t\"k\n\x13\x43heckMacPermRequest\x12\x10\n\x08macaroon\x18\x01 \x01(\x0c\x12.\n\x0bpermissions\x18\x02 \x03(\x0b\x32\x19.lnrpc.MacaroonPermission\x12\x12\n\nfullMethod\x18\x03 \x01(\t\"%\n\x14\x43heckMacPermResponse\x12\r\n\x05valid\x18\x01 \x01(\x08\"\x92\x02\n\x14RPCMiddlewareRequest\x12\x12\n\nrequest_id\x18\x01 \x01(\x04\x12\x14\n\x0craw_macaroon\x18\x02 \x01(\x0c\x12\x1f\n\x17\x63ustom_caveat_condition\x18\x03 \x01(\t\x12(\n\x0bstream_auth\x18\x04 \x01(\x0b\x32\x11.lnrpc.StreamAuthH\x00\x12$\n\x07request\x18\x05 \x01(\x0b\x32\x11.lnrpc.RPCMessageH\x00\x12%\n\x08response\x18\x06 \x01(\x0b\x32\x11.lnrpc.RPCMessageH\x00\x12\x16\n\x0creg_complete\x18\x08 \x01(\x08H\x00\x12\x0e\n\x06msg_id\x18\x07 \x01(\x04\x42\x10\n\x0eintercept_type\"%\n\nStreamAuth\x12\x17\n\x0fmethod_full_uri\x18\x01 \x01(\t\"r\n\nRPCMessage\x12\x17\n\x0fmethod_full_uri\x18\x01 \x01(\t\x12\x12\n\nstream_rpc\x18\x02 \x01(\x08\x12\x11\n\ttype_name\x18\x03 \x01(\t\x12\x12\n\nserialized\x18\x04 \x01(\x0c\x12\x10\n\x08is_error\x18\x05 \x01(\x08\"\xa2\x01\n\x15RPCMiddlewareResponse\x12\x12\n\nref_msg_id\x18\x01 \x01(\x04\x12\x31\n\x08register\x18\x02 \x01(\x0b\x32\x1d.lnrpc.MiddlewareRegistrationH\x00\x12,\n\x08\x66\x65\x65\x64\x62\x61\x63k\x18\x03 \x01(\x0b\x32\x18.lnrpc.InterceptFeedbackH\x00\x42\x14\n\x12middleware_message\"n\n\x16MiddlewareRegistration\x12\x17\n\x0fmiddleware_name\x18\x01 \x01(\t\x12#\n\x1b\x63ustom_macaroon_caveat_name\x18\x02 \x01(\t\x12\x16\n\x0eread_only_mode\x18\x03 \x01(\x08\"\\\n\x11InterceptFeedback\x12\r\n\x05\x65rror\x18\x01 \x01(\t\x12\x18\n\x10replace_response\x18\x02 \x01(\x08\x12\x1e\n\x16replacement_serialized\x18\x03 \x01(\x0c*\xcb\x02\n\x10OutputScriptType\x12\x1b\n\x17SCRIPT_TYPE_PUBKEY_HASH\x10\x00\x12\x1b\n\x17SCRIPT_TYPE_SCRIPT_HASH\x10\x01\x12&\n\"SCRIPT_TYPE_WITNESS_V0_PUBKEY_HASH\x10\x02\x12&\n\"SCRIPT_TYPE_WITNESS_V0_SCRIPT_HASH\x10\x03\x12\x16\n\x12SCRIPT_TYPE_PUBKEY\x10\x04\x12\x18\n\x14SCRIPT_TYPE_MULTISIG\x10\x05\x12\x18\n\x14SCRIPT_TYPE_NULLDATA\x10\x06\x12\x1c\n\x18SCRIPT_TYPE_NON_STANDARD\x10\x07\x12\x1f\n\x1bSCRIPT_TYPE_WITNESS_UNKNOWN\x10\x08\x12\"\n\x1eSCRIPT_TYPE_WITNESS_V1_TAPROOT\x10\t*b\n\x15\x43oinSelectionStrategy\x12\x1e\n\x1aSTRATEGY_USE_GLOBAL_CONFIG\x10\x00\x12\x14\n\x10STRATEGY_LARGEST\x10\x01\x12\x13\n\x0fSTRATEGY_RANDOM\x10\x02*\xac\x01\n\x0b\x41\x64\x64ressType\x12\x17\n\x13WITNESS_PUBKEY_HASH\x10\x00\x12\x16\n\x12NESTED_PUBKEY_HASH\x10\x01\x12\x1e\n\x1aUNUSED_WITNESS_PUBKEY_HASH\x10\x02\x12\x1d\n\x19UNUSED_NESTED_PUBKEY_HASH\x10\x03\x12\x12\n\x0eTAPROOT_PUBKEY\x10\x04\x12\x19\n\x15UNUSED_TAPROOT_PUBKEY\x10\x05*\x8c\x01\n\x0e\x43ommitmentType\x12\x1b\n\x17UNKNOWN_COMMITMENT_TYPE\x10\x00\x12\n\n\x06LEGACY\x10\x01\x12\x15\n\x11STATIC_REMOTE_KEY\x10\x02\x12\x0b\n\x07\x41NCHORS\x10\x03\x12\x19\n\x15SCRIPT_ENFORCED_LEASE\x10\x04\x12\x12\n\x0eSIMPLE_TAPROOT\x10\x05*a\n\tInitiator\x12\x15\n\x11INITIATOR_UNKNOWN\x10\x00\x12\x13\n\x0fINITIATOR_LOCAL\x10\x01\x12\x14\n\x10INITIATOR_REMOTE\x10\x02\x12\x12\n\x0eINITIATOR_BOTH\x10\x03*`\n\x0eResolutionType\x12\x10\n\x0cTYPE_UNKNOWN\x10\x00\x12\n\n\x06\x41NCHOR\x10\x01\x12\x11\n\rINCOMING_HTLC\x10\x02\x12\x11\n\rOUTGOING_HTLC\x10\x03\x12\n\n\x06\x43OMMIT\x10\x04*q\n\x11ResolutionOutcome\x12\x13\n\x0fOUTCOME_UNKNOWN\x10\x00\x12\x0b\n\x07\x43LAIMED\x10\x01\x12\r\n\tUNCLAIMED\x10\x02\x12\r\n\tABANDONED\x10\x03\x12\x0f\n\x0b\x46IRST_STAGE\x10\x04\x12\x0b\n\x07TIMEOUT\x10\x05*9\n\x0eNodeMetricType\x12\x0b\n\x07UNKNOWN\x10\x00\x12\x1a\n\x16\x42\x45TWEENNESS_CENTRALITY\x10\x01*;\n\x10InvoiceHTLCState\x12\x0c\n\x08\x41\x43\x43\x45PTED\x10\x00\x12\x0b\n\x07SETTLED\x10\x01\x12\x0c\n\x08\x43\x41NCELED\x10\x02*\xd9\x01\n\x14PaymentFailureReason\x12\x17\n\x13\x46\x41ILURE_REASON_NONE\x10\x00\x12\x1a\n\x16\x46\x41ILURE_REASON_TIMEOUT\x10\x01\x12\x1b\n\x17\x46\x41ILURE_REASON_NO_ROUTE\x10\x02\x12\x18\n\x14\x46\x41ILURE_REASON_ERROR\x10\x03\x12,\n(FAILURE_REASON_INCORRECT_PAYMENT_DETAILS\x10\x04\x12\'\n#FAILURE_REASON_INSUFFICIENT_BALANCE\x10\x05*\x89\x05\n\nFeatureBit\x12\x18\n\x14\x44\x41TALOSS_PROTECT_REQ\x10\x00\x12\x18\n\x14\x44\x41TALOSS_PROTECT_OPT\x10\x01\x12\x17\n\x13INITIAL_ROUING_SYNC\x10\x03\x12\x1f\n\x1bUPFRONT_SHUTDOWN_SCRIPT_REQ\x10\x04\x12\x1f\n\x1bUPFRONT_SHUTDOWN_SCRIPT_OPT\x10\x05\x12\x16\n\x12GOSSIP_QUERIES_REQ\x10\x06\x12\x16\n\x12GOSSIP_QUERIES_OPT\x10\x07\x12\x11\n\rTLV_ONION_REQ\x10\x08\x12\x11\n\rTLV_ONION_OPT\x10\t\x12\x1a\n\x16\x45XT_GOSSIP_QUERIES_REQ\x10\n\x12\x1a\n\x16\x45XT_GOSSIP_QUERIES_OPT\x10\x0b\x12\x19\n\x15STATIC_REMOTE_KEY_REQ\x10\x0c\x12\x19\n\x15STATIC_REMOTE_KEY_OPT\x10\r\x12\x14\n\x10PAYMENT_ADDR_REQ\x10\x0e\x12\x14\n\x10PAYMENT_ADDR_OPT\x10\x0f\x12\x0b\n\x07MPP_REQ\x10\x10\x12\x0b\n\x07MPP_OPT\x10\x11\x12\x16\n\x12WUMBO_CHANNELS_REQ\x10\x12\x12\x16\n\x12WUMBO_CHANNELS_OPT\x10\x13\x12\x0f\n\x0b\x41NCHORS_REQ\x10\x14\x12\x0f\n\x0b\x41NCHORS_OPT\x10\x15\x12\x1d\n\x19\x41NCHORS_ZERO_FEE_HTLC_REQ\x10\x16\x12\x1d\n\x19\x41NCHORS_ZERO_FEE_HTLC_OPT\x10\x17\x12\x1b\n\x17ROUTE_BLINDING_REQUIRED\x10\x18\x12\x1b\n\x17ROUTE_BLINDING_OPTIONAL\x10\x19\x12\x0b\n\x07\x41MP_REQ\x10\x1e\x12\x0b\n\x07\x41MP_OPT\x10\x1f*\xac\x01\n\rUpdateFailure\x12\x1a\n\x16UPDATE_FAILURE_UNKNOWN\x10\x00\x12\x1a\n\x16UPDATE_FAILURE_PENDING\x10\x01\x12\x1c\n\x18UPDATE_FAILURE_NOT_FOUND\x10\x02\x12\x1f\n\x1bUPDATE_FAILURE_INTERNAL_ERR\x10\x03\x12$\n UPDATE_FAILURE_INVALID_PARAMETER\x10\x04\x32\xb9\'\n\tLightning\x12J\n\rWalletBalance\x12\x1b.lnrpc.WalletBalanceRequest\x1a\x1c.lnrpc.WalletBalanceResponse\x12M\n\x0e\x43hannelBalance\x12\x1c.lnrpc.ChannelBalanceRequest\x1a\x1d.lnrpc.ChannelBalanceResponse\x12K\n\x0fGetTransactions\x12\x1d.lnrpc.GetTransactionsRequest\x1a\x19.lnrpc.TransactionDetails\x12\x44\n\x0b\x45stimateFee\x12\x19.lnrpc.EstimateFeeRequest\x1a\x1a.lnrpc.EstimateFeeResponse\x12>\n\tSendCoins\x12\x17.lnrpc.SendCoinsRequest\x1a\x18.lnrpc.SendCoinsResponse\x12\x44\n\x0bListUnspent\x12\x19.lnrpc.ListUnspentRequest\x1a\x1a.lnrpc.ListUnspentResponse\x12L\n\x15SubscribeTransactions\x12\x1d.lnrpc.GetTransactionsRequest\x1a\x12.lnrpc.Transaction0\x01\x12;\n\x08SendMany\x12\x16.lnrpc.SendManyRequest\x1a\x17.lnrpc.SendManyResponse\x12\x41\n\nNewAddress\x12\x18.lnrpc.NewAddressRequest\x1a\x19.lnrpc.NewAddressResponse\x12\x44\n\x0bSignMessage\x12\x19.lnrpc.SignMessageRequest\x1a\x1a.lnrpc.SignMessageResponse\x12J\n\rVerifyMessage\x12\x1b.lnrpc.VerifyMessageRequest\x1a\x1c.lnrpc.VerifyMessageResponse\x12\x44\n\x0b\x43onnectPeer\x12\x19.lnrpc.ConnectPeerRequest\x1a\x1a.lnrpc.ConnectPeerResponse\x12M\n\x0e\x44isconnectPeer\x12\x1c.lnrpc.DisconnectPeerRequest\x1a\x1d.lnrpc.DisconnectPeerResponse\x12>\n\tListPeers\x12\x17.lnrpc.ListPeersRequest\x1a\x18.lnrpc.ListPeersResponse\x12G\n\x13SubscribePeerEvents\x12\x1c.lnrpc.PeerEventSubscription\x1a\x10.lnrpc.PeerEvent0\x01\x12\x38\n\x07GetInfo\x12\x15.lnrpc.GetInfoRequest\x1a\x16.lnrpc.GetInfoResponse\x12G\n\x0cGetDebugInfo\x12\x1a.lnrpc.GetDebugInfoRequest\x1a\x1b.lnrpc.GetDebugInfoResponse\x12P\n\x0fGetRecoveryInfo\x12\x1d.lnrpc.GetRecoveryInfoRequest\x1a\x1e.lnrpc.GetRecoveryInfoResponse\x12P\n\x0fPendingChannels\x12\x1d.lnrpc.PendingChannelsRequest\x1a\x1e.lnrpc.PendingChannelsResponse\x12G\n\x0cListChannels\x12\x1a.lnrpc.ListChannelsRequest\x1a\x1b.lnrpc.ListChannelsResponse\x12V\n\x16SubscribeChannelEvents\x12\x1f.lnrpc.ChannelEventSubscription\x1a\x19.lnrpc.ChannelEventUpdate0\x01\x12M\n\x0e\x43losedChannels\x12\x1c.lnrpc.ClosedChannelsRequest\x1a\x1d.lnrpc.ClosedChannelsResponse\x12\x41\n\x0fOpenChannelSync\x12\x19.lnrpc.OpenChannelRequest\x1a\x13.lnrpc.ChannelPoint\x12\x43\n\x0bOpenChannel\x12\x19.lnrpc.OpenChannelRequest\x1a\x17.lnrpc.OpenStatusUpdate0\x01\x12S\n\x10\x42\x61tchOpenChannel\x12\x1e.lnrpc.BatchOpenChannelRequest\x1a\x1f.lnrpc.BatchOpenChannelResponse\x12L\n\x10\x46undingStateStep\x12\x1b.lnrpc.FundingTransitionMsg\x1a\x1b.lnrpc.FundingStateStepResp\x12P\n\x0f\x43hannelAcceptor\x12\x1c.lnrpc.ChannelAcceptResponse\x1a\x1b.lnrpc.ChannelAcceptRequest(\x01\x30\x01\x12\x46\n\x0c\x43loseChannel\x12\x1a.lnrpc.CloseChannelRequest\x1a\x18.lnrpc.CloseStatusUpdate0\x01\x12M\n\x0e\x41\x62\x61ndonChannel\x12\x1c.lnrpc.AbandonChannelRequest\x1a\x1d.lnrpc.AbandonChannelResponse\x12?\n\x0bSendPayment\x12\x12.lnrpc.SendRequest\x1a\x13.lnrpc.SendResponse\"\x03\x88\x02\x01(\x01\x30\x01\x12:\n\x0fSendPaymentSync\x12\x12.lnrpc.SendRequest\x1a\x13.lnrpc.SendResponse\x12\x46\n\x0bSendToRoute\x12\x19.lnrpc.SendToRouteRequest\x1a\x13.lnrpc.SendResponse\"\x03\x88\x02\x01(\x01\x30\x01\x12\x41\n\x0fSendToRouteSync\x12\x19.lnrpc.SendToRouteRequest\x1a\x13.lnrpc.SendResponse\x12\x37\n\nAddInvoice\x12\x0e.lnrpc.Invoice\x1a\x19.lnrpc.AddInvoiceResponse\x12\x45\n\x0cListInvoices\x12\x19.lnrpc.ListInvoiceRequest\x1a\x1a.lnrpc.ListInvoiceResponse\x12\x33\n\rLookupInvoice\x12\x12.lnrpc.PaymentHash\x1a\x0e.lnrpc.Invoice\x12\x41\n\x11SubscribeInvoices\x12\x1a.lnrpc.InvoiceSubscription\x1a\x0e.lnrpc.Invoice0\x01\x12\x32\n\x0c\x44\x65\x63odePayReq\x12\x13.lnrpc.PayReqString\x1a\r.lnrpc.PayReq\x12G\n\x0cListPayments\x12\x1a.lnrpc.ListPaymentsRequest\x1a\x1b.lnrpc.ListPaymentsResponse\x12J\n\rDeletePayment\x12\x1b.lnrpc.DeletePaymentRequest\x1a\x1c.lnrpc.DeletePaymentResponse\x12V\n\x11\x44\x65leteAllPayments\x12\x1f.lnrpc.DeleteAllPaymentsRequest\x1a .lnrpc.DeleteAllPaymentsResponse\x12@\n\rDescribeGraph\x12\x1a.lnrpc.ChannelGraphRequest\x1a\x13.lnrpc.ChannelGraph\x12G\n\x0eGetNodeMetrics\x12\x19.lnrpc.NodeMetricsRequest\x1a\x1a.lnrpc.NodeMetricsResponse\x12\x39\n\x0bGetChanInfo\x12\x16.lnrpc.ChanInfoRequest\x1a\x12.lnrpc.ChannelEdge\x12\x36\n\x0bGetNodeInfo\x12\x16.lnrpc.NodeInfoRequest\x1a\x0f.lnrpc.NodeInfo\x12\x44\n\x0bQueryRoutes\x12\x19.lnrpc.QueryRoutesRequest\x1a\x1a.lnrpc.QueryRoutesResponse\x12?\n\x0eGetNetworkInfo\x12\x19.lnrpc.NetworkInfoRequest\x1a\x12.lnrpc.NetworkInfo\x12\x35\n\nStopDaemon\x12\x12.lnrpc.StopRequest\x1a\x13.lnrpc.StopResponse\x12W\n\x15SubscribeChannelGraph\x12 .lnrpc.GraphTopologySubscription\x1a\x1a.lnrpc.GraphTopologyUpdate0\x01\x12\x41\n\nDebugLevel\x12\x18.lnrpc.DebugLevelRequest\x1a\x19.lnrpc.DebugLevelResponse\x12>\n\tFeeReport\x12\x17.lnrpc.FeeReportRequest\x1a\x18.lnrpc.FeeReportResponse\x12N\n\x13UpdateChannelPolicy\x12\x1a.lnrpc.PolicyUpdateRequest\x1a\x1b.lnrpc.PolicyUpdateResponse\x12V\n\x11\x46orwardingHistory\x12\x1f.lnrpc.ForwardingHistoryRequest\x1a .lnrpc.ForwardingHistoryResponse\x12N\n\x13\x45xportChannelBackup\x12!.lnrpc.ExportChannelBackupRequest\x1a\x14.lnrpc.ChannelBackup\x12T\n\x17\x45xportAllChannelBackups\x12\x1e.lnrpc.ChanBackupExportRequest\x1a\x19.lnrpc.ChanBackupSnapshot\x12N\n\x10VerifyChanBackup\x12\x19.lnrpc.ChanBackupSnapshot\x1a\x1f.lnrpc.VerifyChanBackupResponse\x12V\n\x15RestoreChannelBackups\x12\x1f.lnrpc.RestoreChanBackupRequest\x1a\x1c.lnrpc.RestoreBackupResponse\x12X\n\x17SubscribeChannelBackups\x12 .lnrpc.ChannelBackupSubscription\x1a\x19.lnrpc.ChanBackupSnapshot0\x01\x12G\n\x0c\x42\x61keMacaroon\x12\x1a.lnrpc.BakeMacaroonRequest\x1a\x1b.lnrpc.BakeMacaroonResponse\x12P\n\x0fListMacaroonIDs\x12\x1d.lnrpc.ListMacaroonIDsRequest\x1a\x1e.lnrpc.ListMacaroonIDsResponse\x12S\n\x10\x44\x65leteMacaroonID\x12\x1e.lnrpc.DeleteMacaroonIDRequest\x1a\x1f.lnrpc.DeleteMacaroonIDResponse\x12P\n\x0fListPermissions\x12\x1d.lnrpc.ListPermissionsRequest\x1a\x1e.lnrpc.ListPermissionsResponse\x12S\n\x18\x43heckMacaroonPermissions\x12\x1a.lnrpc.CheckMacPermRequest\x1a\x1b.lnrpc.CheckMacPermResponse\x12V\n\x15RegisterRPCMiddleware\x12\x1c.lnrpc.RPCMiddlewareResponse\x1a\x1b.lnrpc.RPCMiddlewareRequest(\x01\x30\x01\x12V\n\x11SendCustomMessage\x12\x1f.lnrpc.SendCustomMessageRequest\x1a .lnrpc.SendCustomMessageResponse\x12X\n\x17SubscribeCustomMessages\x12%.lnrpc.SubscribeCustomMessagesRequest\x1a\x14.lnrpc.CustomMessage0\x01\x12\x44\n\x0bListAliases\x12\x19.lnrpc.ListAliasesRequest\x1a\x1a.lnrpc.ListAliasesResponse\x12_\n\x14LookupHtlcResolution\x12\".lnrpc.LookupHtlcResolutionRequest\x1a#.lnrpc.LookupHtlcResolutionResponseB\'Z%github.com/lightningnetwork/lnd/lnrpcb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'cashu.lightning.lnd_grpc.protos.lightning_pb2', _globals) +if not _descriptor._USE_C_DESCRIPTORS: + _globals['DESCRIPTOR']._loaded_options = None + _globals['DESCRIPTOR']._serialized_options = b'Z%github.com/lightningnetwork/lnd/lnrpc' + _globals['_TRANSACTION'].fields_by_name['dest_addresses']._loaded_options = None + _globals['_TRANSACTION'].fields_by_name['dest_addresses']._serialized_options = b'\030\001' + _globals['_SENDREQUEST_DESTCUSTOMRECORDSENTRY']._loaded_options = None + _globals['_SENDREQUEST_DESTCUSTOMRECORDSENTRY']._serialized_options = b'8\001' + _globals['_SENDREQUEST'].fields_by_name['dest_string']._loaded_options = None + _globals['_SENDREQUEST'].fields_by_name['dest_string']._serialized_options = b'\030\001' + _globals['_SENDREQUEST'].fields_by_name['payment_hash_string']._loaded_options = None + _globals['_SENDREQUEST'].fields_by_name['payment_hash_string']._serialized_options = b'\030\001' + _globals['_SENDREQUEST'].fields_by_name['outgoing_chan_id']._loaded_options = None + _globals['_SENDREQUEST'].fields_by_name['outgoing_chan_id']._serialized_options = b'0\001' + _globals['_SENDTOROUTEREQUEST'].fields_by_name['payment_hash_string']._loaded_options = None + _globals['_SENDTOROUTEREQUEST'].fields_by_name['payment_hash_string']._serialized_options = b'\030\001' + _globals['_ESTIMATEFEEREQUEST_ADDRTOAMOUNTENTRY']._loaded_options = None + _globals['_ESTIMATEFEEREQUEST_ADDRTOAMOUNTENTRY']._serialized_options = b'8\001' + _globals['_ESTIMATEFEERESPONSE'].fields_by_name['feerate_sat_per_byte']._loaded_options = None + _globals['_ESTIMATEFEERESPONSE'].fields_by_name['feerate_sat_per_byte']._serialized_options = b'\030\001' + _globals['_SENDMANYREQUEST_ADDRTOAMOUNTENTRY']._loaded_options = None + _globals['_SENDMANYREQUEST_ADDRTOAMOUNTENTRY']._serialized_options = b'8\001' + _globals['_SENDMANYREQUEST'].fields_by_name['sat_per_byte']._loaded_options = None + _globals['_SENDMANYREQUEST'].fields_by_name['sat_per_byte']._serialized_options = b'\030\001' + _globals['_SENDCOINSREQUEST'].fields_by_name['sat_per_byte']._loaded_options = None + _globals['_SENDCOINSREQUEST'].fields_by_name['sat_per_byte']._serialized_options = b'\030\001' + _globals['_CHANNEL'].fields_by_name['chan_id']._loaded_options = None + _globals['_CHANNEL'].fields_by_name['chan_id']._serialized_options = b'0\001' + _globals['_CHANNEL'].fields_by_name['csv_delay']._loaded_options = None + _globals['_CHANNEL'].fields_by_name['csv_delay']._serialized_options = b'\030\001' + _globals['_CHANNEL'].fields_by_name['local_chan_reserve_sat']._loaded_options = None + _globals['_CHANNEL'].fields_by_name['local_chan_reserve_sat']._serialized_options = b'\030\001' + _globals['_CHANNEL'].fields_by_name['remote_chan_reserve_sat']._loaded_options = None + _globals['_CHANNEL'].fields_by_name['remote_chan_reserve_sat']._serialized_options = b'\030\001' + _globals['_CHANNEL'].fields_by_name['static_remote_key']._loaded_options = None + _globals['_CHANNEL'].fields_by_name['static_remote_key']._serialized_options = b'\030\001' + _globals['_CHANNEL'].fields_by_name['peer_scid_alias']._loaded_options = None + _globals['_CHANNEL'].fields_by_name['peer_scid_alias']._serialized_options = b'0\001' + _globals['_CHANNELCLOSESUMMARY'].fields_by_name['chan_id']._loaded_options = None + _globals['_CHANNELCLOSESUMMARY'].fields_by_name['chan_id']._serialized_options = b'0\001' + _globals['_CHANNELCLOSESUMMARY'].fields_by_name['zero_conf_confirmed_scid']._loaded_options = None + _globals['_CHANNELCLOSESUMMARY'].fields_by_name['zero_conf_confirmed_scid']._serialized_options = b'0\001' + _globals['_PEER_FEATURESENTRY']._loaded_options = None + _globals['_PEER_FEATURESENTRY']._serialized_options = b'8\001' + _globals['_GETINFORESPONSE_FEATURESENTRY']._loaded_options = None + _globals['_GETINFORESPONSE_FEATURESENTRY']._serialized_options = b'8\001' + _globals['_GETINFORESPONSE'].fields_by_name['testnet']._loaded_options = None + _globals['_GETINFORESPONSE'].fields_by_name['testnet']._serialized_options = b'\030\001' + _globals['_GETDEBUGINFORESPONSE_CONFIGENTRY']._loaded_options = None + _globals['_GETDEBUGINFORESPONSE_CONFIGENTRY']._serialized_options = b'8\001' + _globals['_CHAIN'].fields_by_name['chain']._loaded_options = None + _globals['_CHAIN'].fields_by_name['chain']._serialized_options = b'\030\001' + _globals['_CLOSECHANNELREQUEST'].fields_by_name['sat_per_byte']._loaded_options = None + _globals['_CLOSECHANNELREQUEST'].fields_by_name['sat_per_byte']._serialized_options = b'\030\001' + _globals['_OPENCHANNELREQUEST'].fields_by_name['node_pubkey_string']._loaded_options = None + _globals['_OPENCHANNELREQUEST'].fields_by_name['node_pubkey_string']._serialized_options = b'\030\001' + _globals['_OPENCHANNELREQUEST'].fields_by_name['sat_per_byte']._loaded_options = None + _globals['_OPENCHANNELREQUEST'].fields_by_name['sat_per_byte']._serialized_options = b'\030\001' + _globals['_PENDINGCHANNELSRESPONSE'].fields_by_name['pending_closing_channels']._loaded_options = None + _globals['_PENDINGCHANNELSRESPONSE'].fields_by_name['pending_closing_channels']._serialized_options = b'\030\001' + _globals['_WALLETBALANCERESPONSE_ACCOUNTBALANCEENTRY']._loaded_options = None + _globals['_WALLETBALANCERESPONSE_ACCOUNTBALANCEENTRY']._serialized_options = b'8\001' + _globals['_CHANNELBALANCERESPONSE'].fields_by_name['balance']._loaded_options = None + _globals['_CHANNELBALANCERESPONSE'].fields_by_name['balance']._serialized_options = b'\030\001' + _globals['_CHANNELBALANCERESPONSE'].fields_by_name['pending_open_balance']._loaded_options = None + _globals['_CHANNELBALANCERESPONSE'].fields_by_name['pending_open_balance']._serialized_options = b'\030\001' + _globals['_QUERYROUTESREQUEST_DESTCUSTOMRECORDSENTRY']._loaded_options = None + _globals['_QUERYROUTESREQUEST_DESTCUSTOMRECORDSENTRY']._serialized_options = b'8\001' + _globals['_QUERYROUTESREQUEST'].fields_by_name['ignored_edges']._loaded_options = None + _globals['_QUERYROUTESREQUEST'].fields_by_name['ignored_edges']._serialized_options = b'\030\001' + _globals['_QUERYROUTESREQUEST'].fields_by_name['outgoing_chan_id']._loaded_options = None + _globals['_QUERYROUTESREQUEST'].fields_by_name['outgoing_chan_id']._serialized_options = b'0\001' + _globals['_EDGELOCATOR'].fields_by_name['channel_id']._loaded_options = None + _globals['_EDGELOCATOR'].fields_by_name['channel_id']._serialized_options = b'0\001' + _globals['_HOP_CUSTOMRECORDSENTRY']._loaded_options = None + _globals['_HOP_CUSTOMRECORDSENTRY']._serialized_options = b'8\001' + _globals['_HOP'].fields_by_name['chan_id']._loaded_options = None + _globals['_HOP'].fields_by_name['chan_id']._serialized_options = b'0\001' + _globals['_HOP'].fields_by_name['chan_capacity']._loaded_options = None + _globals['_HOP'].fields_by_name['chan_capacity']._serialized_options = b'\030\001' + _globals['_HOP'].fields_by_name['amt_to_forward']._loaded_options = None + _globals['_HOP'].fields_by_name['amt_to_forward']._serialized_options = b'\030\001' + _globals['_HOP'].fields_by_name['fee']._loaded_options = None + _globals['_HOP'].fields_by_name['fee']._serialized_options = b'\030\001' + _globals['_HOP'].fields_by_name['tlv_payload']._loaded_options = None + _globals['_HOP'].fields_by_name['tlv_payload']._serialized_options = b'\030\001' + _globals['_ROUTE'].fields_by_name['total_fees']._loaded_options = None + _globals['_ROUTE'].fields_by_name['total_fees']._serialized_options = b'\030\001' + _globals['_ROUTE'].fields_by_name['total_amt']._loaded_options = None + _globals['_ROUTE'].fields_by_name['total_amt']._serialized_options = b'\030\001' + _globals['_LIGHTNINGNODE_FEATURESENTRY']._loaded_options = None + _globals['_LIGHTNINGNODE_FEATURESENTRY']._serialized_options = b'8\001' + _globals['_LIGHTNINGNODE_CUSTOMRECORDSENTRY']._loaded_options = None + _globals['_LIGHTNINGNODE_CUSTOMRECORDSENTRY']._serialized_options = b'8\001' + _globals['_ROUTINGPOLICY_CUSTOMRECORDSENTRY']._loaded_options = None + _globals['_ROUTINGPOLICY_CUSTOMRECORDSENTRY']._serialized_options = b'8\001' + _globals['_CHANNELEDGE_CUSTOMRECORDSENTRY']._loaded_options = None + _globals['_CHANNELEDGE_CUSTOMRECORDSENTRY']._serialized_options = b'8\001' + _globals['_CHANNELEDGE'].fields_by_name['channel_id']._loaded_options = None + _globals['_CHANNELEDGE'].fields_by_name['channel_id']._serialized_options = b'0\001' + _globals['_CHANNELEDGE'].fields_by_name['last_update']._loaded_options = None + _globals['_CHANNELEDGE'].fields_by_name['last_update']._serialized_options = b'\030\001' + _globals['_NODEMETRICSRESPONSE_BETWEENNESSCENTRALITYENTRY']._loaded_options = None + _globals['_NODEMETRICSRESPONSE_BETWEENNESSCENTRALITYENTRY']._serialized_options = b'8\001' + _globals['_CHANINFOREQUEST'].fields_by_name['chan_id']._loaded_options = None + _globals['_CHANINFOREQUEST'].fields_by_name['chan_id']._serialized_options = b'0\001' + _globals['_NODEUPDATE_FEATURESENTRY']._loaded_options = None + _globals['_NODEUPDATE_FEATURESENTRY']._serialized_options = b'8\001' + _globals['_NODEUPDATE'].fields_by_name['addresses']._loaded_options = None + _globals['_NODEUPDATE'].fields_by_name['addresses']._serialized_options = b'\030\001' + _globals['_NODEUPDATE'].fields_by_name['global_features']._loaded_options = None + _globals['_NODEUPDATE'].fields_by_name['global_features']._serialized_options = b'\030\001' + _globals['_CHANNELEDGEUPDATE'].fields_by_name['chan_id']._loaded_options = None + _globals['_CHANNELEDGEUPDATE'].fields_by_name['chan_id']._serialized_options = b'0\001' + _globals['_CLOSEDCHANNELUPDATE'].fields_by_name['chan_id']._loaded_options = None + _globals['_CLOSEDCHANNELUPDATE'].fields_by_name['chan_id']._serialized_options = b'0\001' + _globals['_HOPHINT'].fields_by_name['chan_id']._loaded_options = None + _globals['_HOPHINT'].fields_by_name['chan_id']._serialized_options = b'0\001' + _globals['_INVOICE_FEATURESENTRY']._loaded_options = None + _globals['_INVOICE_FEATURESENTRY']._serialized_options = b'8\001' + _globals['_INVOICE_AMPINVOICESTATEENTRY']._loaded_options = None + _globals['_INVOICE_AMPINVOICESTATEENTRY']._serialized_options = b'8\001' + _globals['_INVOICE'].fields_by_name['settled']._loaded_options = None + _globals['_INVOICE'].fields_by_name['settled']._serialized_options = b'\030\001' + _globals['_INVOICE'].fields_by_name['amt_paid']._loaded_options = None + _globals['_INVOICE'].fields_by_name['amt_paid']._serialized_options = b'\030\001' + _globals['_INVOICEHTLC_CUSTOMRECORDSENTRY']._loaded_options = None + _globals['_INVOICEHTLC_CUSTOMRECORDSENTRY']._serialized_options = b'8\001' + _globals['_INVOICEHTLC'].fields_by_name['chan_id']._loaded_options = None + _globals['_INVOICEHTLC'].fields_by_name['chan_id']._serialized_options = b'0\001' + _globals['_PAYMENTHASH'].fields_by_name['r_hash_str']._loaded_options = None + _globals['_PAYMENTHASH'].fields_by_name['r_hash_str']._serialized_options = b'\030\001' + _globals['_PAYMENT_PAYMENTSTATUS'].values_by_name["UNKNOWN"]._loaded_options = None + _globals['_PAYMENT_PAYMENTSTATUS'].values_by_name["UNKNOWN"]._serialized_options = b'\010\001' + _globals['_PAYMENT'].fields_by_name['value']._loaded_options = None + _globals['_PAYMENT'].fields_by_name['value']._serialized_options = b'\030\001' + _globals['_PAYMENT'].fields_by_name['creation_date']._loaded_options = None + _globals['_PAYMENT'].fields_by_name['creation_date']._serialized_options = b'\030\001' + _globals['_PAYMENT'].fields_by_name['fee']._loaded_options = None + _globals['_PAYMENT'].fields_by_name['fee']._serialized_options = b'\030\001' + _globals['_PAYREQ_FEATURESENTRY']._loaded_options = None + _globals['_PAYREQ_FEATURESENTRY']._serialized_options = b'8\001' + _globals['_CHANNELFEEREPORT'].fields_by_name['chan_id']._loaded_options = None + _globals['_CHANNELFEEREPORT'].fields_by_name['chan_id']._serialized_options = b'0\001' + _globals['_FORWARDINGEVENT'].fields_by_name['timestamp']._loaded_options = None + _globals['_FORWARDINGEVENT'].fields_by_name['timestamp']._serialized_options = b'\030\001' + _globals['_FORWARDINGEVENT'].fields_by_name['chan_id_in']._loaded_options = None + _globals['_FORWARDINGEVENT'].fields_by_name['chan_id_in']._serialized_options = b'0\001' + _globals['_FORWARDINGEVENT'].fields_by_name['chan_id_out']._loaded_options = None + _globals['_FORWARDINGEVENT'].fields_by_name['chan_id_out']._serialized_options = b'0\001' + _globals['_LISTPERMISSIONSRESPONSE_METHODPERMISSIONSENTRY']._loaded_options = None + _globals['_LISTPERMISSIONSRESPONSE_METHODPERMISSIONSENTRY']._serialized_options = b'8\001' + _globals['_CHANNELUPDATE'].fields_by_name['chan_id']._loaded_options = None + _globals['_CHANNELUPDATE'].fields_by_name['chan_id']._serialized_options = b'0\001' + _globals['_LIGHTNING'].methods_by_name['SendPayment']._loaded_options = None + _globals['_LIGHTNING'].methods_by_name['SendPayment']._serialized_options = b'\210\002\001' + _globals['_LIGHTNING'].methods_by_name['SendToRoute']._loaded_options = None + _globals['_LIGHTNING'].methods_by_name['SendToRoute']._serialized_options = b'\210\002\001' + _globals['_OUTPUTSCRIPTTYPE']._serialized_start=30467 + _globals['_OUTPUTSCRIPTTYPE']._serialized_end=30798 + _globals['_COINSELECTIONSTRATEGY']._serialized_start=30800 + _globals['_COINSELECTIONSTRATEGY']._serialized_end=30898 + _globals['_ADDRESSTYPE']._serialized_start=30901 + _globals['_ADDRESSTYPE']._serialized_end=31073 + _globals['_COMMITMENTTYPE']._serialized_start=31076 + _globals['_COMMITMENTTYPE']._serialized_end=31216 + _globals['_INITIATOR']._serialized_start=31218 + _globals['_INITIATOR']._serialized_end=31315 + _globals['_RESOLUTIONTYPE']._serialized_start=31317 + _globals['_RESOLUTIONTYPE']._serialized_end=31413 + _globals['_RESOLUTIONOUTCOME']._serialized_start=31415 + _globals['_RESOLUTIONOUTCOME']._serialized_end=31528 + _globals['_NODEMETRICTYPE']._serialized_start=31530 + _globals['_NODEMETRICTYPE']._serialized_end=31587 + _globals['_INVOICEHTLCSTATE']._serialized_start=31589 + _globals['_INVOICEHTLCSTATE']._serialized_end=31648 + _globals['_PAYMENTFAILUREREASON']._serialized_start=31651 + _globals['_PAYMENTFAILUREREASON']._serialized_end=31868 + _globals['_FEATUREBIT']._serialized_start=31871 + _globals['_FEATUREBIT']._serialized_end=32520 + _globals['_UPDATEFAILURE']._serialized_start=32523 + _globals['_UPDATEFAILURE']._serialized_end=32695 + _globals['_LOOKUPHTLCRESOLUTIONREQUEST']._serialized_start=26 + _globals['_LOOKUPHTLCRESOLUTIONREQUEST']._serialized_end=92 + _globals['_LOOKUPHTLCRESOLUTIONRESPONSE']._serialized_start=94 + _globals['_LOOKUPHTLCRESOLUTIONRESPONSE']._serialized_end=159 + _globals['_SUBSCRIBECUSTOMMESSAGESREQUEST']._serialized_start=161 + _globals['_SUBSCRIBECUSTOMMESSAGESREQUEST']._serialized_end=193 + _globals['_CUSTOMMESSAGE']._serialized_start=195 + _globals['_CUSTOMMESSAGE']._serialized_end=252 + _globals['_SENDCUSTOMMESSAGEREQUEST']._serialized_start=254 + _globals['_SENDCUSTOMMESSAGEREQUEST']._serialized_end=322 + _globals['_SENDCUSTOMMESSAGERESPONSE']._serialized_start=324 + _globals['_SENDCUSTOMMESSAGERESPONSE']._serialized_end=351 + _globals['_UTXO']._serialized_start=354 + _globals['_UTXO']._serialized_end=516 + _globals['_OUTPUTDETAIL']._serialized_start=519 + _globals['_OUTPUTDETAIL']._serialized_end=677 + _globals['_TRANSACTION']._serialized_start=680 + _globals['_TRANSACTION']._serialized_end=996 + _globals['_GETTRANSACTIONSREQUEST']._serialized_start=998 + _globals['_GETTRANSACTIONSREQUEST']._serialized_end=1081 + _globals['_TRANSACTIONDETAILS']._serialized_start=1083 + _globals['_TRANSACTIONDETAILS']._serialized_end=1145 + _globals['_FEELIMIT']._serialized_start=1147 + _globals['_FEELIMIT']._serialized_end=1224 + _globals['_SENDREQUEST']._serialized_start=1227 + _globals['_SENDREQUEST']._serialized_end=1749 + _globals['_SENDREQUEST_DESTCUSTOMRECORDSENTRY']._serialized_start=1693 + _globals['_SENDREQUEST_DESTCUSTOMRECORDSENTRY']._serialized_end=1749 + _globals['_SENDRESPONSE']._serialized_start=1751 + _globals['_SENDRESPONSE']._serialized_end=1873 + _globals['_SENDTOROUTEREQUEST']._serialized_start=1875 + _globals['_SENDTOROUTEREQUEST']._serialized_end=1985 + _globals['_CHANNELACCEPTREQUEST']._serialized_start=1988 + _globals['_CHANNELACCEPTREQUEST']._serialized_end=2396 + _globals['_CHANNELACCEPTRESPONSE']._serialized_start=2399 + _globals['_CHANNELACCEPTRESPONSE']._serialized_end=2662 + _globals['_CHANNELPOINT']._serialized_start=2664 + _globals['_CHANNELPOINT']._serialized_end=2774 + _globals['_OUTPOINT']._serialized_start=2776 + _globals['_OUTPOINT']._serialized_end=2846 + _globals['_PREVIOUSOUTPOINT']._serialized_start=2848 + _globals['_PREVIOUSOUTPOINT']._serialized_end=2907 + _globals['_LIGHTNINGADDRESS']._serialized_start=2909 + _globals['_LIGHTNINGADDRESS']._serialized_end=2957 + _globals['_ESTIMATEFEEREQUEST']._serialized_start=2960 + _globals['_ESTIMATEFEEREQUEST']._serialized_end=3230 + _globals['_ESTIMATEFEEREQUEST_ADDRTOAMOUNTENTRY']._serialized_start=3179 + _globals['_ESTIMATEFEEREQUEST_ADDRTOAMOUNTENTRY']._serialized_end=3230 + _globals['_ESTIMATEFEERESPONSE']._serialized_start=3232 + _globals['_ESTIMATEFEERESPONSE']._serialized_end=3327 + _globals['_SENDMANYREQUEST']._serialized_start=3330 + _globals['_SENDMANYREQUEST']._serialized_end=3658 + _globals['_SENDMANYREQUEST_ADDRTOAMOUNTENTRY']._serialized_start=3179 + _globals['_SENDMANYREQUEST_ADDRTOAMOUNTENTRY']._serialized_end=3230 + _globals['_SENDMANYRESPONSE']._serialized_start=3660 + _globals['_SENDMANYRESPONSE']._serialized_end=3692 + _globals['_SENDCOINSREQUEST']._serialized_start=3695 + _globals['_SENDCOINSREQUEST']._serialized_end=3955 + _globals['_SENDCOINSRESPONSE']._serialized_start=3957 + _globals['_SENDCOINSRESPONSE']._serialized_end=3990 + _globals['_LISTUNSPENTREQUEST']._serialized_start=3992 + _globals['_LISTUNSPENTREQUEST']._serialized_end=4067 + _globals['_LISTUNSPENTRESPONSE']._serialized_start=4069 + _globals['_LISTUNSPENTRESPONSE']._serialized_end=4118 + _globals['_NEWADDRESSREQUEST']._serialized_start=4120 + _globals['_NEWADDRESSREQUEST']._serialized_end=4190 + _globals['_NEWADDRESSRESPONSE']._serialized_start=4192 + _globals['_NEWADDRESSRESPONSE']._serialized_end=4229 + _globals['_SIGNMESSAGEREQUEST']._serialized_start=4231 + _globals['_SIGNMESSAGEREQUEST']._serialized_end=4285 + _globals['_SIGNMESSAGERESPONSE']._serialized_start=4287 + _globals['_SIGNMESSAGERESPONSE']._serialized_end=4327 + _globals['_VERIFYMESSAGEREQUEST']._serialized_start=4329 + _globals['_VERIFYMESSAGEREQUEST']._serialized_end=4383 + _globals['_VERIFYMESSAGERESPONSE']._serialized_start=4385 + _globals['_VERIFYMESSAGERESPONSE']._serialized_end=4439 + _globals['_CONNECTPEERREQUEST']._serialized_start=4441 + _globals['_CONNECTPEERREQUEST']._serialized_end=4531 + _globals['_CONNECTPEERRESPONSE']._serialized_start=4533 + _globals['_CONNECTPEERRESPONSE']._serialized_end=4554 + _globals['_DISCONNECTPEERREQUEST']._serialized_start=4556 + _globals['_DISCONNECTPEERREQUEST']._serialized_end=4596 + _globals['_DISCONNECTPEERRESPONSE']._serialized_start=4598 + _globals['_DISCONNECTPEERRESPONSE']._serialized_end=4622 + _globals['_HTLC']._serialized_start=4625 + _globals['_HTLC']._serialized_end=4790 + _globals['_CHANNELCONSTRAINTS']._serialized_start=4793 + _globals['_CHANNELCONSTRAINTS']._serialized_end=4963 + _globals['_CHANNEL']._serialized_start=4966 + _globals['_CHANNEL']._serialized_end=5919 + _globals['_LISTCHANNELSREQUEST']._serialized_start=5922 + _globals['_LISTCHANNELSREQUEST']._serialized_end=6071 + _globals['_LISTCHANNELSRESPONSE']._serialized_start=6073 + _globals['_LISTCHANNELSRESPONSE']._serialized_end=6129 + _globals['_ALIASMAP']._serialized_start=6131 + _globals['_ALIASMAP']._serialized_end=6177 + _globals['_LISTALIASESREQUEST']._serialized_start=6179 + _globals['_LISTALIASESREQUEST']._serialized_end=6199 + _globals['_LISTALIASESRESPONSE']._serialized_start=6201 + _globals['_LISTALIASESRESPONSE']._serialized_end=6259 + _globals['_CHANNELCLOSESUMMARY']._serialized_start=6262 + _globals['_CHANNELCLOSESUMMARY']._serialized_end=6874 + _globals['_CHANNELCLOSESUMMARY_CLOSURETYPE']._serialized_start=6736 + _globals['_CHANNELCLOSESUMMARY_CLOSURETYPE']._serialized_end=6874 + _globals['_RESOLUTION']._serialized_start=6877 + _globals['_RESOLUTION']._serialized_end=7055 + _globals['_CLOSEDCHANNELSREQUEST']._serialized_start=7058 + _globals['_CLOSEDCHANNELSREQUEST']._serialized_end=7206 + _globals['_CLOSEDCHANNELSRESPONSE']._serialized_start=7208 + _globals['_CLOSEDCHANNELSRESPONSE']._serialized_end=7278 + _globals['_PEER']._serialized_start=7281 + _globals['_PEER']._serialized_end=7776 + _globals['_PEER_FEATURESENTRY']._serialized_start=7631 + _globals['_PEER_FEATURESENTRY']._serialized_end=7694 + _globals['_PEER_SYNCTYPE']._serialized_start=7696 + _globals['_PEER_SYNCTYPE']._serialized_end=7776 + _globals['_TIMESTAMPEDERROR']._serialized_start=7778 + _globals['_TIMESTAMPEDERROR']._serialized_end=7830 + _globals['_LISTPEERSREQUEST']._serialized_start=7832 + _globals['_LISTPEERSREQUEST']._serialized_end=7872 + _globals['_LISTPEERSRESPONSE']._serialized_start=7874 + _globals['_LISTPEERSRESPONSE']._serialized_end=7921 + _globals['_PEEREVENTSUBSCRIPTION']._serialized_start=7923 + _globals['_PEEREVENTSUBSCRIPTION']._serialized_end=7946 + _globals['_PEEREVENT']._serialized_start=7948 + _globals['_PEEREVENT']._serialized_end=8066 + _globals['_PEEREVENT_EVENTTYPE']._serialized_start=8020 + _globals['_PEEREVENT_EVENTTYPE']._serialized_end=8066 + _globals['_GETINFOREQUEST']._serialized_start=8068 + _globals['_GETINFOREQUEST']._serialized_end=8084 + _globals['_GETINFORESPONSE']._serialized_start=8087 + _globals['_GETINFORESPONSE']._serialized_end=8693 + _globals['_GETINFORESPONSE_FEATURESENTRY']._serialized_start=7631 + _globals['_GETINFORESPONSE_FEATURESENTRY']._serialized_end=7694 + _globals['_GETDEBUGINFOREQUEST']._serialized_start=8695 + _globals['_GETDEBUGINFOREQUEST']._serialized_end=8716 + _globals['_GETDEBUGINFORESPONSE']._serialized_start=8719 + _globals['_GETDEBUGINFORESPONSE']._serialized_end=8858 + _globals['_GETDEBUGINFORESPONSE_CONFIGENTRY']._serialized_start=8813 + _globals['_GETDEBUGINFORESPONSE_CONFIGENTRY']._serialized_end=8858 + _globals['_GETRECOVERYINFOREQUEST']._serialized_start=8860 + _globals['_GETRECOVERYINFOREQUEST']._serialized_end=8884 + _globals['_GETRECOVERYINFORESPONSE']._serialized_start=8886 + _globals['_GETRECOVERYINFORESPONSE']._serialized_end=8979 + _globals['_CHAIN']._serialized_start=8981 + _globals['_CHAIN']._serialized_end=9024 + _globals['_CONFIRMATIONUPDATE']._serialized_start=9026 + _globals['_CONFIRMATIONUPDATE']._serialized_end=9111 + _globals['_CHANNELOPENUPDATE']._serialized_start=9113 + _globals['_CHANNELOPENUPDATE']._serialized_end=9176 + _globals['_CHANNELCLOSEUPDATE']._serialized_start=9178 + _globals['_CHANNELCLOSEUPDATE']._serialized_end=9237 + _globals['_CLOSECHANNELREQUEST']._serialized_start=9240 + _globals['_CLOSECHANNELREQUEST']._serialized_end=9460 + _globals['_CLOSESTATUSUPDATE']._serialized_start=9463 + _globals['_CLOSESTATUSUPDATE']._serialized_end=9635 + _globals['_PENDINGUPDATE']._serialized_start=9637 + _globals['_PENDINGUPDATE']._serialized_end=9688 + _globals['_INSTANTUPDATE']._serialized_start=9690 + _globals['_INSTANTUPDATE']._serialized_end=9705 + _globals['_READYFORPSBTFUNDING']._serialized_start=9707 + _globals['_READYFORPSBTFUNDING']._serialized_end=9791 + _globals['_BATCHOPENCHANNELREQUEST']._serialized_start=9794 + _globals['_BATCHOPENCHANNELREQUEST']._serialized_end=10030 + _globals['_BATCHOPENCHANNEL']._serialized_start=10033 + _globals['_BATCHOPENCHANNEL']._serialized_end=10538 + _globals['_BATCHOPENCHANNELRESPONSE']._serialized_start=10540 + _globals['_BATCHOPENCHANNELRESPONSE']._serialized_end=10614 + _globals['_OPENCHANNELREQUEST']._serialized_start=10617 + _globals['_OPENCHANNELREQUEST']._serialized_end=11343 + _globals['_OPENSTATUSUPDATE']._serialized_start=11346 + _globals['_OPENSTATUSUPDATE']._serialized_end=11541 + _globals['_KEYLOCATOR']._serialized_start=11543 + _globals['_KEYLOCATOR']._serialized_end=11594 + _globals['_KEYDESCRIPTOR']._serialized_start=11596 + _globals['_KEYDESCRIPTOR']._serialized_end=11670 + _globals['_CHANPOINTSHIM']._serialized_start=11673 + _globals['_CHANPOINTSHIM']._serialized_end=11865 + _globals['_PSBTSHIM']._serialized_start=11867 + _globals['_PSBTSHIM']._serialized_end=11941 + _globals['_FUNDINGSHIM']._serialized_start=11943 + _globals['_FUNDINGSHIM']._serialized_end=12051 + _globals['_FUNDINGSHIMCANCEL']._serialized_start=12053 + _globals['_FUNDINGSHIMCANCEL']._serialized_end=12097 + _globals['_FUNDINGPSBTVERIFY']._serialized_start=12099 + _globals['_FUNDINGPSBTVERIFY']._serialized_end=12187 + _globals['_FUNDINGPSBTFINALIZE']._serialized_start=12189 + _globals['_FUNDINGPSBTFINALIZE']._serialized_end=12278 + _globals['_FUNDINGTRANSITIONMSG']._serialized_start=12281 + _globals['_FUNDINGTRANSITIONMSG']._serialized_end=12510 + _globals['_FUNDINGSTATESTEPRESP']._serialized_start=12512 + _globals['_FUNDINGSTATESTEPRESP']._serialized_end=12534 + _globals['_PENDINGHTLC']._serialized_start=12537 + _globals['_PENDINGHTLC']._serialized_end=12671 + _globals['_PENDINGCHANNELSREQUEST']._serialized_start=12673 + _globals['_PENDINGCHANNELSREQUEST']._serialized_end=12721 + _globals['_PENDINGCHANNELSRESPONSE']._serialized_start=12724 + _globals['_PENDINGCHANNELSRESPONSE']._serialized_end=14576 + _globals['_PENDINGCHANNELSRESPONSE_PENDINGCHANNEL']._serialized_start=13122 + _globals['_PENDINGCHANNELSRESPONSE_PENDINGCHANNEL']._serialized_end=13492 + _globals['_PENDINGCHANNELSRESPONSE_PENDINGOPENCHANNEL']._serialized_start=13495 + _globals['_PENDINGCHANNELSRESPONSE_PENDINGOPENCHANNEL']._serialized_end=13679 + _globals['_PENDINGCHANNELSRESPONSE_WAITINGCLOSECHANNEL']._serialized_start=13682 + _globals['_PENDINGCHANNELSRESPONSE_WAITINGCLOSECHANNEL']._serialized_end=13901 + _globals['_PENDINGCHANNELSRESPONSE_COMMITMENTS']._serialized_start=13904 + _globals['_PENDINGCHANNELSRESPONSE_COMMITMENTS']._serialized_end=14087 + _globals['_PENDINGCHANNELSRESPONSE_CLOSEDCHANNEL']._serialized_start=14089 + _globals['_PENDINGCHANNELSRESPONSE_CLOSEDCHANNEL']._serialized_end=14190 + _globals['_PENDINGCHANNELSRESPONSE_FORCECLOSEDCHANNEL']._serialized_start=14193 + _globals['_PENDINGCHANNELSRESPONSE_FORCECLOSEDCHANNEL']._serialized_end=14576 + _globals['_PENDINGCHANNELSRESPONSE_FORCECLOSEDCHANNEL_ANCHORSTATE']._serialized_start=14527 + _globals['_PENDINGCHANNELSRESPONSE_FORCECLOSEDCHANNEL_ANCHORSTATE']._serialized_end=14576 + _globals['_CHANNELEVENTSUBSCRIPTION']._serialized_start=14578 + _globals['_CHANNELEVENTSUBSCRIPTION']._serialized_end=14604 + _globals['_CHANNELEVENTUPDATE']._serialized_start=14607 + _globals['_CHANNELEVENTUPDATE']._serialized_end=15138 + _globals['_CHANNELEVENTUPDATE_UPDATETYPE']._serialized_start=14981 + _globals['_CHANNELEVENTUPDATE_UPDATETYPE']._serialized_end=15127 + _globals['_WALLETACCOUNTBALANCE']._serialized_start=15140 + _globals['_WALLETACCOUNTBALANCE']._serialized_end=15218 + _globals['_WALLETBALANCEREQUEST']._serialized_start=15220 + _globals['_WALLETBALANCEREQUEST']._serialized_end=15278 + _globals['_WALLETBALANCERESPONSE']._serialized_start=15281 + _globals['_WALLETBALANCERESPONSE']._serialized_end=15604 + _globals['_WALLETBALANCERESPONSE_ACCOUNTBALANCEENTRY']._serialized_start=15522 + _globals['_WALLETBALANCERESPONSE_ACCOUNTBALANCEENTRY']._serialized_end=15604 + _globals['_AMOUNT']._serialized_start=15606 + _globals['_AMOUNT']._serialized_end=15641 + _globals['_CHANNELBALANCEREQUEST']._serialized_start=15643 + _globals['_CHANNELBALANCEREQUEST']._serialized_end=15666 + _globals['_CHANNELBALANCERESPONSE']._serialized_start=15669 + _globals['_CHANNELBALANCERESPONSE']._serialized_end=16025 + _globals['_QUERYROUTESREQUEST']._serialized_start=16028 + _globals['_QUERYROUTESREQUEST']._serialized_end=16697 + _globals['_QUERYROUTESREQUEST_DESTCUSTOMRECORDSENTRY']._serialized_start=1693 + _globals['_QUERYROUTESREQUEST_DESTCUSTOMRECORDSENTRY']._serialized_end=1749 + _globals['_NODEPAIR']._serialized_start=16699 + _globals['_NODEPAIR']._serialized_end=16735 + _globals['_EDGELOCATOR']._serialized_start=16737 + _globals['_EDGELOCATOR']._serialized_end=16801 + _globals['_QUERYROUTESRESPONSE']._serialized_start=16803 + _globals['_QUERYROUTESRESPONSE']._serialized_end=16876 + _globals['_HOP']._serialized_start=16879 + _globals['_HOP']._serialized_end=17357 + _globals['_HOP_CUSTOMRECORDSENTRY']._serialized_start=17305 + _globals['_HOP_CUSTOMRECORDSENTRY']._serialized_end=17357 + _globals['_MPPRECORD']._serialized_start=17359 + _globals['_MPPRECORD']._serialized_end=17416 + _globals['_AMPRECORD']._serialized_start=17418 + _globals['_AMPRECORD']._serialized_end=17486 + _globals['_ROUTE']._serialized_start=17489 + _globals['_ROUTE']._serialized_end=17643 + _globals['_NODEINFOREQUEST']._serialized_start=17645 + _globals['_NODEINFOREQUEST']._serialized_end=17705 + _globals['_NODEINFO']._serialized_start=17708 + _globals['_NODEINFO']._serialized_end=17838 + _globals['_LIGHTNINGNODE']._serialized_start=17841 + _globals['_LIGHTNINGNODE']._serialized_end=18201 + _globals['_LIGHTNINGNODE_FEATURESENTRY']._serialized_start=7631 + _globals['_LIGHTNINGNODE_FEATURESENTRY']._serialized_end=7694 + _globals['_LIGHTNINGNODE_CUSTOMRECORDSENTRY']._serialized_start=17305 + _globals['_LIGHTNINGNODE_CUSTOMRECORDSENTRY']._serialized_end=17357 + _globals['_NODEADDRESS']._serialized_start=18203 + _globals['_NODEADDRESS']._serialized_end=18247 + _globals['_ROUTINGPOLICY']._serialized_start=18250 + _globals['_ROUTINGPOLICY']._serialized_end=18609 + _globals['_ROUTINGPOLICY_CUSTOMRECORDSENTRY']._serialized_start=17305 + _globals['_ROUTINGPOLICY_CUSTOMRECORDSENTRY']._serialized_end=17357 + _globals['_CHANNELEDGE']._serialized_start=18612 + _globals['_CHANNELEDGE']._serialized_end=18955 + _globals['_CHANNELEDGE_CUSTOMRECORDSENTRY']._serialized_start=17305 + _globals['_CHANNELEDGE_CUSTOMRECORDSENTRY']._serialized_end=17357 + _globals['_CHANNELGRAPHREQUEST']._serialized_start=18957 + _globals['_CHANNELGRAPHREQUEST']._serialized_end=19007 + _globals['_CHANNELGRAPH']._serialized_start=19009 + _globals['_CHANNELGRAPH']._serialized_end=19095 + _globals['_NODEMETRICSREQUEST']._serialized_start=19097 + _globals['_NODEMETRICSREQUEST']._serialized_end=19155 + _globals['_NODEMETRICSRESPONSE']._serialized_start=19158 + _globals['_NODEMETRICSRESPONSE']._serialized_end=19348 + _globals['_NODEMETRICSRESPONSE_BETWEENNESSCENTRALITYENTRY']._serialized_start=19268 + _globals['_NODEMETRICSRESPONSE_BETWEENNESSCENTRALITYENTRY']._serialized_end=19348 + _globals['_FLOATMETRIC']._serialized_start=19350 + _globals['_FLOATMETRIC']._serialized_end=19404 + _globals['_CHANINFOREQUEST']._serialized_start=19406 + _globals['_CHANINFOREQUEST']._serialized_end=19464 + _globals['_NETWORKINFOREQUEST']._serialized_start=19466 + _globals['_NETWORKINFOREQUEST']._serialized_end=19486 + _globals['_NETWORKINFO']._serialized_start=19489 + _globals['_NETWORKINFO']._serialized_end=19784 + _globals['_STOPREQUEST']._serialized_start=19786 + _globals['_STOPREQUEST']._serialized_end=19799 + _globals['_STOPRESPONSE']._serialized_start=19801 + _globals['_STOPRESPONSE']._serialized_end=19815 + _globals['_GRAPHTOPOLOGYSUBSCRIPTION']._serialized_start=19817 + _globals['_GRAPHTOPOLOGYSUBSCRIPTION']._serialized_end=19844 + _globals['_GRAPHTOPOLOGYUPDATE']._serialized_start=19847 + _globals['_GRAPHTOPOLOGYUPDATE']._serialized_end=20010 + _globals['_NODEUPDATE']._serialized_start=20013 + _globals['_NODEUPDATE']._serialized_end=20289 + _globals['_NODEUPDATE_FEATURESENTRY']._serialized_start=7631 + _globals['_NODEUPDATE_FEATURESENTRY']._serialized_end=7694 + _globals['_CHANNELEDGEUPDATE']._serialized_start=20292 + _globals['_CHANNELEDGEUPDATE']._serialized_end=20488 + _globals['_CLOSEDCHANNELUPDATE']._serialized_start=20490 + _globals['_CLOSEDCHANNELUPDATE']._serialized_end=20614 + _globals['_HOPHINT']._serialized_start=20617 + _globals['_HOPHINT']._serialized_end=20751 + _globals['_SETID']._serialized_start=20753 + _globals['_SETID']._serialized_end=20776 + _globals['_ROUTEHINT']._serialized_start=20778 + _globals['_ROUTEHINT']._serialized_end=20824 + _globals['_BLINDEDPAYMENTPATH']._serialized_start=20827 + _globals['_BLINDEDPAYMENTPATH']._serialized_end=21052 + _globals['_BLINDEDPATH']._serialized_start=21054 + _globals['_BLINDEDPATH']._serialized_end=21159 + _globals['_BLINDEDHOP']._serialized_start=21161 + _globals['_BLINDEDHOP']._serialized_end=21219 + _globals['_AMPINVOICESTATE']._serialized_start=21221 + _globals['_AMPINVOICESTATE']._serialized_end=21344 + _globals['_INVOICE']._serialized_start=21347 + _globals['_INVOICE']._serialized_end=22248 + _globals['_INVOICE_FEATURESENTRY']._serialized_start=7631 + _globals['_INVOICE_FEATURESENTRY']._serialized_end=7694 + _globals['_INVOICE_AMPINVOICESTATEENTRY']._serialized_start=22097 + _globals['_INVOICE_AMPINVOICESTATEENTRY']._serialized_end=22175 + _globals['_INVOICE_INVOICESTATE']._serialized_start=22177 + _globals['_INVOICE_INVOICESTATE']._serialized_end=22242 + _globals['_INVOICEHTLC']._serialized_start=22251 + _globals['_INVOICEHTLC']._serialized_end=22622 + _globals['_INVOICEHTLC_CUSTOMRECORDSENTRY']._serialized_start=17305 + _globals['_INVOICEHTLC_CUSTOMRECORDSENTRY']._serialized_end=17357 + _globals['_AMP']._serialized_start=22624 + _globals['_AMP']._serialized_end=22718 + _globals['_ADDINVOICERESPONSE']._serialized_start=22720 + _globals['_ADDINVOICERESPONSE']._serialized_end=22822 + _globals['_PAYMENTHASH']._serialized_start=22824 + _globals['_PAYMENTHASH']._serialized_end=22877 + _globals['_LISTINVOICEREQUEST']._serialized_start=22880 + _globals['_LISTINVOICEREQUEST']._serialized_end=23044 + _globals['_LISTINVOICERESPONSE']._serialized_start=23046 + _globals['_LISTINVOICERESPONSE']._serialized_end=23156 + _globals['_INVOICESUBSCRIPTION']._serialized_start=23158 + _globals['_INVOICESUBSCRIPTION']._serialized_end=23220 + _globals['_PAYMENT']._serialized_start=23223 + _globals['_PAYMENT']._serialized_end=23722 + _globals['_PAYMENT_PAYMENTSTATUS']._serialized_start=23627 + _globals['_PAYMENT_PAYMENTSTATUS']._serialized_end=23716 + _globals['_HTLCATTEMPT']._serialized_start=23725 + _globals['_HTLCATTEMPT']._serialized_end=23991 + _globals['_HTLCATTEMPT_HTLCSTATUS']._serialized_start=23937 + _globals['_HTLCATTEMPT_HTLCSTATUS']._serialized_end=23991 + _globals['_LISTPAYMENTSREQUEST']._serialized_start=23994 + _globals['_LISTPAYMENTSREQUEST']._serialized_end=24191 + _globals['_LISTPAYMENTSRESPONSE']._serialized_start=24194 + _globals['_LISTPAYMENTSRESPONSE']._serialized_end=24333 + _globals['_DELETEPAYMENTREQUEST']._serialized_start=24335 + _globals['_DELETEPAYMENTREQUEST']._serialized_end=24406 + _globals['_DELETEALLPAYMENTSREQUEST']._serialized_start=24408 + _globals['_DELETEALLPAYMENTSREQUEST']._serialized_end=24513 + _globals['_DELETEPAYMENTRESPONSE']._serialized_start=24515 + _globals['_DELETEPAYMENTRESPONSE']._serialized_end=24538 + _globals['_DELETEALLPAYMENTSRESPONSE']._serialized_start=24540 + _globals['_DELETEALLPAYMENTSRESPONSE']._serialized_end=24567 + _globals['_ABANDONCHANNELREQUEST']._serialized_start=24570 + _globals['_ABANDONCHANNELREQUEST']._serialized_end=24704 + _globals['_ABANDONCHANNELRESPONSE']._serialized_start=24706 + _globals['_ABANDONCHANNELRESPONSE']._serialized_end=24730 + _globals['_DEBUGLEVELREQUEST']._serialized_start=24732 + _globals['_DEBUGLEVELREQUEST']._serialized_end=24785 + _globals['_DEBUGLEVELRESPONSE']._serialized_start=24787 + _globals['_DEBUGLEVELRESPONSE']._serialized_end=24828 + _globals['_PAYREQSTRING']._serialized_start=24830 + _globals['_PAYREQSTRING']._serialized_end=24861 + _globals['_PAYREQ']._serialized_start=24864 + _globals['_PAYREQ']._serialized_end=25304 + _globals['_PAYREQ_FEATURESENTRY']._serialized_start=7631 + _globals['_PAYREQ_FEATURESENTRY']._serialized_end=7694 + _globals['_FEATURE']._serialized_start=25306 + _globals['_FEATURE']._serialized_end=25368 + _globals['_FEEREPORTREQUEST']._serialized_start=25370 + _globals['_FEEREPORTREQUEST']._serialized_end=25388 + _globals['_CHANNELFEEREPORT']._serialized_start=25391 + _globals['_CHANNELFEEREPORT']._serialized_end=25575 + _globals['_FEEREPORTRESPONSE']._serialized_start=25578 + _globals['_FEEREPORTRESPONSE']._serialized_end=25710 + _globals['_INBOUNDFEE']._serialized_start=25712 + _globals['_INBOUNDFEE']._serialized_end=25769 + _globals['_POLICYUPDATEREQUEST']._serialized_start=25772 + _globals['_POLICYUPDATEREQUEST']._serialized_end=26070 + _globals['_FAILEDUPDATE']._serialized_start=26072 + _globals['_FAILEDUPDATE']._serialized_end=26181 + _globals['_POLICYUPDATERESPONSE']._serialized_start=26183 + _globals['_POLICYUPDATERESPONSE']._serialized_end=26250 + _globals['_FORWARDINGHISTORYREQUEST']._serialized_start=26253 + _globals['_FORWARDINGHISTORYREQUEST']._serialized_end=26390 + _globals['_FORWARDINGEVENT']._serialized_start=26393 + _globals['_FORWARDINGEVENT']._serialized_end=26658 + _globals['_FORWARDINGHISTORYRESPONSE']._serialized_start=26660 + _globals['_FORWARDINGHISTORYRESPONSE']._serialized_end=26765 + _globals['_EXPORTCHANNELBACKUPREQUEST']._serialized_start=26767 + _globals['_EXPORTCHANNELBACKUPREQUEST']._serialized_end=26836 + _globals['_CHANNELBACKUP']._serialized_start=26838 + _globals['_CHANNELBACKUP']._serialized_end=26915 + _globals['_MULTICHANBACKUP']._serialized_start=26917 + _globals['_MULTICHANBACKUP']._serialized_end=27003 + _globals['_CHANBACKUPEXPORTREQUEST']._serialized_start=27005 + _globals['_CHANBACKUPEXPORTREQUEST']._serialized_end=27030 + _globals['_CHANBACKUPSNAPSHOT']._serialized_start=27032 + _globals['_CHANBACKUPSNAPSHOT']._serialized_end=27155 + _globals['_CHANNELBACKUPS']._serialized_start=27157 + _globals['_CHANNELBACKUPS']._serialized_end=27217 + _globals['_RESTORECHANBACKUPREQUEST']._serialized_start=27219 + _globals['_RESTORECHANBACKUPREQUEST']._serialized_end=27331 + _globals['_RESTOREBACKUPRESPONSE']._serialized_start=27333 + _globals['_RESTOREBACKUPRESPONSE']._serialized_end=27356 + _globals['_CHANNELBACKUPSUBSCRIPTION']._serialized_start=27358 + _globals['_CHANNELBACKUPSUBSCRIPTION']._serialized_end=27385 + _globals['_VERIFYCHANBACKUPRESPONSE']._serialized_start=27387 + _globals['_VERIFYCHANBACKUPRESPONSE']._serialized_end=27413 + _globals['_MACAROONPERMISSION']._serialized_start=27415 + _globals['_MACAROONPERMISSION']._serialized_end=27467 + _globals['_BAKEMACAROONREQUEST']._serialized_start=27469 + _globals['_BAKEMACAROONREQUEST']._serialized_end=27595 + _globals['_BAKEMACAROONRESPONSE']._serialized_start=27597 + _globals['_BAKEMACAROONRESPONSE']._serialized_end=27637 + _globals['_LISTMACAROONIDSREQUEST']._serialized_start=27639 + _globals['_LISTMACAROONIDSREQUEST']._serialized_end=27663 + _globals['_LISTMACAROONIDSRESPONSE']._serialized_start=27665 + _globals['_LISTMACAROONIDSRESPONSE']._serialized_end=27712 + _globals['_DELETEMACAROONIDREQUEST']._serialized_start=27714 + _globals['_DELETEMACAROONIDREQUEST']._serialized_end=27760 + _globals['_DELETEMACAROONIDRESPONSE']._serialized_start=27762 + _globals['_DELETEMACAROONIDRESPONSE']._serialized_end=27805 + _globals['_MACAROONPERMISSIONLIST']._serialized_start=27807 + _globals['_MACAROONPERMISSIONLIST']._serialized_end=27879 + _globals['_LISTPERMISSIONSREQUEST']._serialized_start=27881 + _globals['_LISTPERMISSIONSREQUEST']._serialized_end=27905 + _globals['_LISTPERMISSIONSRESPONSE']._serialized_start=27908 + _globals['_LISTPERMISSIONSRESPONSE']._serialized_end=28105 + _globals['_LISTPERMISSIONSRESPONSE_METHODPERMISSIONSENTRY']._serialized_start=28018 + _globals['_LISTPERMISSIONSRESPONSE_METHODPERMISSIONSENTRY']._serialized_end=28105 + _globals['_FAILURE']._serialized_start=28108 + _globals['_FAILURE']._serialized_end=29117 + _globals['_FAILURE_FAILURECODE']._serialized_start=28332 + _globals['_FAILURE_FAILURECODE']._serialized_end=29111 + _globals['_CHANNELUPDATE']._serialized_start=29120 + _globals['_CHANNELUPDATE']._serialized_end=29402 + _globals['_MACAROONID']._serialized_start=29404 + _globals['_MACAROONID']._serialized_end=29474 + _globals['_OP']._serialized_start=29476 + _globals['_OP']._serialized_end=29513 + _globals['_CHECKMACPERMREQUEST']._serialized_start=29515 + _globals['_CHECKMACPERMREQUEST']._serialized_end=29622 + _globals['_CHECKMACPERMRESPONSE']._serialized_start=29624 + _globals['_CHECKMACPERMRESPONSE']._serialized_end=29661 + _globals['_RPCMIDDLEWAREREQUEST']._serialized_start=29664 + _globals['_RPCMIDDLEWAREREQUEST']._serialized_end=29938 + _globals['_STREAMAUTH']._serialized_start=29940 + _globals['_STREAMAUTH']._serialized_end=29977 + _globals['_RPCMESSAGE']._serialized_start=29979 + _globals['_RPCMESSAGE']._serialized_end=30093 + _globals['_RPCMIDDLEWARERESPONSE']._serialized_start=30096 + _globals['_RPCMIDDLEWARERESPONSE']._serialized_end=30258 + _globals['_MIDDLEWAREREGISTRATION']._serialized_start=30260 + _globals['_MIDDLEWAREREGISTRATION']._serialized_end=30370 + _globals['_INTERCEPTFEEDBACK']._serialized_start=30372 + _globals['_INTERCEPTFEEDBACK']._serialized_end=30464 + _globals['_LIGHTNING']._serialized_start=32698 + _globals['_LIGHTNING']._serialized_end=37747 +# @@protoc_insertion_point(module_scope) diff --git a/cashu/lightning/lnd_grpc/protos/lightning_pb2.pyi b/cashu/lightning/lnd_grpc/protos/lightning_pb2.pyi new file mode 100644 index 00000000..2fa0469c --- /dev/null +++ b/cashu/lightning/lnd_grpc/protos/lightning_pb2.pyi @@ -0,0 +1,8506 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import builtins +import collections.abc +import sys +import typing + +import google.protobuf.descriptor +import google.protobuf.internal.containers +import google.protobuf.internal.enum_type_wrapper +import google.protobuf.message + +if sys.version_info >= (3, 10): + import typing as typing_extensions +else: + import typing_extensions + +DESCRIPTOR: google.protobuf.descriptor.FileDescriptor + +class _OutputScriptType: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + +class _OutputScriptTypeEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_OutputScriptType.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + SCRIPT_TYPE_PUBKEY_HASH: _OutputScriptType.ValueType # 0 + SCRIPT_TYPE_SCRIPT_HASH: _OutputScriptType.ValueType # 1 + SCRIPT_TYPE_WITNESS_V0_PUBKEY_HASH: _OutputScriptType.ValueType # 2 + SCRIPT_TYPE_WITNESS_V0_SCRIPT_HASH: _OutputScriptType.ValueType # 3 + SCRIPT_TYPE_PUBKEY: _OutputScriptType.ValueType # 4 + SCRIPT_TYPE_MULTISIG: _OutputScriptType.ValueType # 5 + SCRIPT_TYPE_NULLDATA: _OutputScriptType.ValueType # 6 + SCRIPT_TYPE_NON_STANDARD: _OutputScriptType.ValueType # 7 + SCRIPT_TYPE_WITNESS_UNKNOWN: _OutputScriptType.ValueType # 8 + SCRIPT_TYPE_WITNESS_V1_TAPROOT: _OutputScriptType.ValueType # 9 + +class OutputScriptType(_OutputScriptType, metaclass=_OutputScriptTypeEnumTypeWrapper): ... + +SCRIPT_TYPE_PUBKEY_HASH: OutputScriptType.ValueType # 0 +SCRIPT_TYPE_SCRIPT_HASH: OutputScriptType.ValueType # 1 +SCRIPT_TYPE_WITNESS_V0_PUBKEY_HASH: OutputScriptType.ValueType # 2 +SCRIPT_TYPE_WITNESS_V0_SCRIPT_HASH: OutputScriptType.ValueType # 3 +SCRIPT_TYPE_PUBKEY: OutputScriptType.ValueType # 4 +SCRIPT_TYPE_MULTISIG: OutputScriptType.ValueType # 5 +SCRIPT_TYPE_NULLDATA: OutputScriptType.ValueType # 6 +SCRIPT_TYPE_NON_STANDARD: OutputScriptType.ValueType # 7 +SCRIPT_TYPE_WITNESS_UNKNOWN: OutputScriptType.ValueType # 8 +SCRIPT_TYPE_WITNESS_V1_TAPROOT: OutputScriptType.ValueType # 9 +global___OutputScriptType = OutputScriptType + +class _CoinSelectionStrategy: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + +class _CoinSelectionStrategyEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_CoinSelectionStrategy.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + STRATEGY_USE_GLOBAL_CONFIG: _CoinSelectionStrategy.ValueType # 0 + """Use the coin selection strategy defined in the global configuration + (lnd.conf). + """ + STRATEGY_LARGEST: _CoinSelectionStrategy.ValueType # 1 + """Select the largest available coins first during coin selection.""" + STRATEGY_RANDOM: _CoinSelectionStrategy.ValueType # 2 + """Randomly select the available coins during coin selection.""" + +class CoinSelectionStrategy(_CoinSelectionStrategy, metaclass=_CoinSelectionStrategyEnumTypeWrapper): ... + +STRATEGY_USE_GLOBAL_CONFIG: CoinSelectionStrategy.ValueType # 0 +"""Use the coin selection strategy defined in the global configuration +(lnd.conf). +""" +STRATEGY_LARGEST: CoinSelectionStrategy.ValueType # 1 +"""Select the largest available coins first during coin selection.""" +STRATEGY_RANDOM: CoinSelectionStrategy.ValueType # 2 +"""Randomly select the available coins during coin selection.""" +global___CoinSelectionStrategy = CoinSelectionStrategy + +class _AddressType: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + +class _AddressTypeEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_AddressType.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + WITNESS_PUBKEY_HASH: _AddressType.ValueType # 0 + NESTED_PUBKEY_HASH: _AddressType.ValueType # 1 + UNUSED_WITNESS_PUBKEY_HASH: _AddressType.ValueType # 2 + UNUSED_NESTED_PUBKEY_HASH: _AddressType.ValueType # 3 + TAPROOT_PUBKEY: _AddressType.ValueType # 4 + UNUSED_TAPROOT_PUBKEY: _AddressType.ValueType # 5 + +class AddressType(_AddressType, metaclass=_AddressTypeEnumTypeWrapper): + """ + `AddressType` has to be one of: + + - `p2wkh`: Pay to witness key hash (`WITNESS_PUBKEY_HASH` = 0) + - `np2wkh`: Pay to nested witness key hash (`NESTED_PUBKEY_HASH` = 1) + - `p2tr`: Pay to taproot pubkey (`TAPROOT_PUBKEY` = 4) + """ + +WITNESS_PUBKEY_HASH: AddressType.ValueType # 0 +NESTED_PUBKEY_HASH: AddressType.ValueType # 1 +UNUSED_WITNESS_PUBKEY_HASH: AddressType.ValueType # 2 +UNUSED_NESTED_PUBKEY_HASH: AddressType.ValueType # 3 +TAPROOT_PUBKEY: AddressType.ValueType # 4 +UNUSED_TAPROOT_PUBKEY: AddressType.ValueType # 5 +global___AddressType = AddressType + +class _CommitmentType: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + +class _CommitmentTypeEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_CommitmentType.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + UNKNOWN_COMMITMENT_TYPE: _CommitmentType.ValueType # 0 + """ + Returned when the commitment type isn't known or unavailable. + """ + LEGACY: _CommitmentType.ValueType # 1 + """ + A channel using the legacy commitment format having tweaked to_remote + keys. + """ + STATIC_REMOTE_KEY: _CommitmentType.ValueType # 2 + """ + A channel that uses the modern commitment format where the key in the + output of the remote party does not change each state. This makes back + up and recovery easier as when the channel is closed, the funds go + directly to that key. + """ + ANCHORS: _CommitmentType.ValueType # 3 + """ + A channel that uses a commitment format that has anchor outputs on the + commitments, allowing fee bumping after a force close transaction has + been broadcast. + """ + SCRIPT_ENFORCED_LEASE: _CommitmentType.ValueType # 4 + """ + A channel that uses a commitment type that builds upon the anchors + commitment format, but in addition requires a CLTV clause to spend outputs + paying to the channel initiator. This is intended for use on leased channels + to guarantee that the channel initiator has no incentives to close a leased + channel before its maturity date. + """ + SIMPLE_TAPROOT: _CommitmentType.ValueType # 5 + """ + A channel that uses musig2 for the funding output, and the new tapscript + features where relevant. + + TODO(roasbeef): need script enforce mirror type for the above as well? + """ + +class CommitmentType(_CommitmentType, metaclass=_CommitmentTypeEnumTypeWrapper): ... + +UNKNOWN_COMMITMENT_TYPE: CommitmentType.ValueType # 0 +""" +Returned when the commitment type isn't known or unavailable. +""" +LEGACY: CommitmentType.ValueType # 1 +""" +A channel using the legacy commitment format having tweaked to_remote +keys. +""" +STATIC_REMOTE_KEY: CommitmentType.ValueType # 2 +""" +A channel that uses the modern commitment format where the key in the +output of the remote party does not change each state. This makes back +up and recovery easier as when the channel is closed, the funds go +directly to that key. +""" +ANCHORS: CommitmentType.ValueType # 3 +""" +A channel that uses a commitment format that has anchor outputs on the +commitments, allowing fee bumping after a force close transaction has +been broadcast. +""" +SCRIPT_ENFORCED_LEASE: CommitmentType.ValueType # 4 +""" +A channel that uses a commitment type that builds upon the anchors +commitment format, but in addition requires a CLTV clause to spend outputs +paying to the channel initiator. This is intended for use on leased channels +to guarantee that the channel initiator has no incentives to close a leased +channel before its maturity date. +""" +SIMPLE_TAPROOT: CommitmentType.ValueType # 5 +""" +A channel that uses musig2 for the funding output, and the new tapscript +features where relevant. + +TODO(roasbeef): need script enforce mirror type for the above as well? +""" +global___CommitmentType = CommitmentType + +class _Initiator: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + +class _InitiatorEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_Initiator.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + INITIATOR_UNKNOWN: _Initiator.ValueType # 0 + INITIATOR_LOCAL: _Initiator.ValueType # 1 + INITIATOR_REMOTE: _Initiator.ValueType # 2 + INITIATOR_BOTH: _Initiator.ValueType # 3 + +class Initiator(_Initiator, metaclass=_InitiatorEnumTypeWrapper): ... + +INITIATOR_UNKNOWN: Initiator.ValueType # 0 +INITIATOR_LOCAL: Initiator.ValueType # 1 +INITIATOR_REMOTE: Initiator.ValueType # 2 +INITIATOR_BOTH: Initiator.ValueType # 3 +global___Initiator = Initiator + +class _ResolutionType: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + +class _ResolutionTypeEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_ResolutionType.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + TYPE_UNKNOWN: _ResolutionType.ValueType # 0 + ANCHOR: _ResolutionType.ValueType # 1 + """We resolved an anchor output.""" + INCOMING_HTLC: _ResolutionType.ValueType # 2 + """ + We are resolving an incoming htlc on chain. This if this htlc is + claimed, we swept the incoming htlc with the preimage. If it is timed + out, our peer swept the timeout path. + """ + OUTGOING_HTLC: _ResolutionType.ValueType # 3 + """ + We are resolving an outgoing htlc on chain. If this htlc is claimed, + the remote party swept the htlc with the preimage. If it is timed out, + we swept it with the timeout path. + """ + COMMIT: _ResolutionType.ValueType # 4 + """We force closed and need to sweep our time locked commitment output.""" + +class ResolutionType(_ResolutionType, metaclass=_ResolutionTypeEnumTypeWrapper): ... + +TYPE_UNKNOWN: ResolutionType.ValueType # 0 +ANCHOR: ResolutionType.ValueType # 1 +"""We resolved an anchor output.""" +INCOMING_HTLC: ResolutionType.ValueType # 2 +""" +We are resolving an incoming htlc on chain. This if this htlc is +claimed, we swept the incoming htlc with the preimage. If it is timed +out, our peer swept the timeout path. +""" +OUTGOING_HTLC: ResolutionType.ValueType # 3 +""" +We are resolving an outgoing htlc on chain. If this htlc is claimed, +the remote party swept the htlc with the preimage. If it is timed out, +we swept it with the timeout path. +""" +COMMIT: ResolutionType.ValueType # 4 +"""We force closed and need to sweep our time locked commitment output.""" +global___ResolutionType = ResolutionType + +class _ResolutionOutcome: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + +class _ResolutionOutcomeEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_ResolutionOutcome.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + OUTCOME_UNKNOWN: _ResolutionOutcome.ValueType # 0 + """Outcome unknown.""" + CLAIMED: _ResolutionOutcome.ValueType # 1 + """An output was claimed on chain.""" + UNCLAIMED: _ResolutionOutcome.ValueType # 2 + """An output was left unclaimed on chain.""" + ABANDONED: _ResolutionOutcome.ValueType # 3 + """ + ResolverOutcomeAbandoned indicates that an output that we did not + claim on chain, for example an anchor that we did not sweep and a + third party claimed on chain, or a htlc that we could not decode + so left unclaimed. + """ + FIRST_STAGE: _ResolutionOutcome.ValueType # 4 + """ + If we force closed our channel, our htlcs need to be claimed in two + stages. This outcome represents the broadcast of a timeout or success + transaction for this two stage htlc claim. + """ + TIMEOUT: _ResolutionOutcome.ValueType # 5 + """A htlc was timed out on chain.""" + +class ResolutionOutcome(_ResolutionOutcome, metaclass=_ResolutionOutcomeEnumTypeWrapper): ... + +OUTCOME_UNKNOWN: ResolutionOutcome.ValueType # 0 +"""Outcome unknown.""" +CLAIMED: ResolutionOutcome.ValueType # 1 +"""An output was claimed on chain.""" +UNCLAIMED: ResolutionOutcome.ValueType # 2 +"""An output was left unclaimed on chain.""" +ABANDONED: ResolutionOutcome.ValueType # 3 +""" +ResolverOutcomeAbandoned indicates that an output that we did not +claim on chain, for example an anchor that we did not sweep and a +third party claimed on chain, or a htlc that we could not decode +so left unclaimed. +""" +FIRST_STAGE: ResolutionOutcome.ValueType # 4 +""" +If we force closed our channel, our htlcs need to be claimed in two +stages. This outcome represents the broadcast of a timeout or success +transaction for this two stage htlc claim. +""" +TIMEOUT: ResolutionOutcome.ValueType # 5 +"""A htlc was timed out on chain.""" +global___ResolutionOutcome = ResolutionOutcome + +class _NodeMetricType: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + +class _NodeMetricTypeEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_NodeMetricType.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + UNKNOWN: _NodeMetricType.ValueType # 0 + BETWEENNESS_CENTRALITY: _NodeMetricType.ValueType # 1 + +class NodeMetricType(_NodeMetricType, metaclass=_NodeMetricTypeEnumTypeWrapper): ... + +UNKNOWN: NodeMetricType.ValueType # 0 +BETWEENNESS_CENTRALITY: NodeMetricType.ValueType # 1 +global___NodeMetricType = NodeMetricType + +class _InvoiceHTLCState: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + +class _InvoiceHTLCStateEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_InvoiceHTLCState.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + ACCEPTED: _InvoiceHTLCState.ValueType # 0 + SETTLED: _InvoiceHTLCState.ValueType # 1 + CANCELED: _InvoiceHTLCState.ValueType # 2 + +class InvoiceHTLCState(_InvoiceHTLCState, metaclass=_InvoiceHTLCStateEnumTypeWrapper): ... + +ACCEPTED: InvoiceHTLCState.ValueType # 0 +SETTLED: InvoiceHTLCState.ValueType # 1 +CANCELED: InvoiceHTLCState.ValueType # 2 +global___InvoiceHTLCState = InvoiceHTLCState + +class _PaymentFailureReason: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + +class _PaymentFailureReasonEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_PaymentFailureReason.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + FAILURE_REASON_NONE: _PaymentFailureReason.ValueType # 0 + """ + Payment isn't failed (yet). + """ + FAILURE_REASON_TIMEOUT: _PaymentFailureReason.ValueType # 1 + """ + There are more routes to try, but the payment timeout was exceeded. + """ + FAILURE_REASON_NO_ROUTE: _PaymentFailureReason.ValueType # 2 + """ + All possible routes were tried and failed permanently. Or were no + routes to the destination at all. + """ + FAILURE_REASON_ERROR: _PaymentFailureReason.ValueType # 3 + """ + A non-recoverable error has occured. + """ + FAILURE_REASON_INCORRECT_PAYMENT_DETAILS: _PaymentFailureReason.ValueType # 4 + """ + Payment details incorrect (unknown hash, invalid amt or + invalid final cltv delta) + """ + FAILURE_REASON_INSUFFICIENT_BALANCE: _PaymentFailureReason.ValueType # 5 + """ + Insufficient local balance. + """ + +class PaymentFailureReason(_PaymentFailureReason, metaclass=_PaymentFailureReasonEnumTypeWrapper): ... + +FAILURE_REASON_NONE: PaymentFailureReason.ValueType # 0 +""" +Payment isn't failed (yet). +""" +FAILURE_REASON_TIMEOUT: PaymentFailureReason.ValueType # 1 +""" +There are more routes to try, but the payment timeout was exceeded. +""" +FAILURE_REASON_NO_ROUTE: PaymentFailureReason.ValueType # 2 +""" +All possible routes were tried and failed permanently. Or were no +routes to the destination at all. +""" +FAILURE_REASON_ERROR: PaymentFailureReason.ValueType # 3 +""" +A non-recoverable error has occured. +""" +FAILURE_REASON_INCORRECT_PAYMENT_DETAILS: PaymentFailureReason.ValueType # 4 +""" +Payment details incorrect (unknown hash, invalid amt or +invalid final cltv delta) +""" +FAILURE_REASON_INSUFFICIENT_BALANCE: PaymentFailureReason.ValueType # 5 +""" +Insufficient local balance. +""" +global___PaymentFailureReason = PaymentFailureReason + +class _FeatureBit: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + +class _FeatureBitEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_FeatureBit.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + DATALOSS_PROTECT_REQ: _FeatureBit.ValueType # 0 + DATALOSS_PROTECT_OPT: _FeatureBit.ValueType # 1 + INITIAL_ROUING_SYNC: _FeatureBit.ValueType # 3 + UPFRONT_SHUTDOWN_SCRIPT_REQ: _FeatureBit.ValueType # 4 + UPFRONT_SHUTDOWN_SCRIPT_OPT: _FeatureBit.ValueType # 5 + GOSSIP_QUERIES_REQ: _FeatureBit.ValueType # 6 + GOSSIP_QUERIES_OPT: _FeatureBit.ValueType # 7 + TLV_ONION_REQ: _FeatureBit.ValueType # 8 + TLV_ONION_OPT: _FeatureBit.ValueType # 9 + EXT_GOSSIP_QUERIES_REQ: _FeatureBit.ValueType # 10 + EXT_GOSSIP_QUERIES_OPT: _FeatureBit.ValueType # 11 + STATIC_REMOTE_KEY_REQ: _FeatureBit.ValueType # 12 + STATIC_REMOTE_KEY_OPT: _FeatureBit.ValueType # 13 + PAYMENT_ADDR_REQ: _FeatureBit.ValueType # 14 + PAYMENT_ADDR_OPT: _FeatureBit.ValueType # 15 + MPP_REQ: _FeatureBit.ValueType # 16 + MPP_OPT: _FeatureBit.ValueType # 17 + WUMBO_CHANNELS_REQ: _FeatureBit.ValueType # 18 + WUMBO_CHANNELS_OPT: _FeatureBit.ValueType # 19 + ANCHORS_REQ: _FeatureBit.ValueType # 20 + ANCHORS_OPT: _FeatureBit.ValueType # 21 + ANCHORS_ZERO_FEE_HTLC_REQ: _FeatureBit.ValueType # 22 + ANCHORS_ZERO_FEE_HTLC_OPT: _FeatureBit.ValueType # 23 + ROUTE_BLINDING_REQUIRED: _FeatureBit.ValueType # 24 + ROUTE_BLINDING_OPTIONAL: _FeatureBit.ValueType # 25 + AMP_REQ: _FeatureBit.ValueType # 30 + AMP_OPT: _FeatureBit.ValueType # 31 + +class FeatureBit(_FeatureBit, metaclass=_FeatureBitEnumTypeWrapper): ... + +DATALOSS_PROTECT_REQ: FeatureBit.ValueType # 0 +DATALOSS_PROTECT_OPT: FeatureBit.ValueType # 1 +INITIAL_ROUING_SYNC: FeatureBit.ValueType # 3 +UPFRONT_SHUTDOWN_SCRIPT_REQ: FeatureBit.ValueType # 4 +UPFRONT_SHUTDOWN_SCRIPT_OPT: FeatureBit.ValueType # 5 +GOSSIP_QUERIES_REQ: FeatureBit.ValueType # 6 +GOSSIP_QUERIES_OPT: FeatureBit.ValueType # 7 +TLV_ONION_REQ: FeatureBit.ValueType # 8 +TLV_ONION_OPT: FeatureBit.ValueType # 9 +EXT_GOSSIP_QUERIES_REQ: FeatureBit.ValueType # 10 +EXT_GOSSIP_QUERIES_OPT: FeatureBit.ValueType # 11 +STATIC_REMOTE_KEY_REQ: FeatureBit.ValueType # 12 +STATIC_REMOTE_KEY_OPT: FeatureBit.ValueType # 13 +PAYMENT_ADDR_REQ: FeatureBit.ValueType # 14 +PAYMENT_ADDR_OPT: FeatureBit.ValueType # 15 +MPP_REQ: FeatureBit.ValueType # 16 +MPP_OPT: FeatureBit.ValueType # 17 +WUMBO_CHANNELS_REQ: FeatureBit.ValueType # 18 +WUMBO_CHANNELS_OPT: FeatureBit.ValueType # 19 +ANCHORS_REQ: FeatureBit.ValueType # 20 +ANCHORS_OPT: FeatureBit.ValueType # 21 +ANCHORS_ZERO_FEE_HTLC_REQ: FeatureBit.ValueType # 22 +ANCHORS_ZERO_FEE_HTLC_OPT: FeatureBit.ValueType # 23 +ROUTE_BLINDING_REQUIRED: FeatureBit.ValueType # 24 +ROUTE_BLINDING_OPTIONAL: FeatureBit.ValueType # 25 +AMP_REQ: FeatureBit.ValueType # 30 +AMP_OPT: FeatureBit.ValueType # 31 +global___FeatureBit = FeatureBit + +class _UpdateFailure: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + +class _UpdateFailureEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_UpdateFailure.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + UPDATE_FAILURE_UNKNOWN: _UpdateFailure.ValueType # 0 + UPDATE_FAILURE_PENDING: _UpdateFailure.ValueType # 1 + UPDATE_FAILURE_NOT_FOUND: _UpdateFailure.ValueType # 2 + UPDATE_FAILURE_INTERNAL_ERR: _UpdateFailure.ValueType # 3 + UPDATE_FAILURE_INVALID_PARAMETER: _UpdateFailure.ValueType # 4 + +class UpdateFailure(_UpdateFailure, metaclass=_UpdateFailureEnumTypeWrapper): ... + +UPDATE_FAILURE_UNKNOWN: UpdateFailure.ValueType # 0 +UPDATE_FAILURE_PENDING: UpdateFailure.ValueType # 1 +UPDATE_FAILURE_NOT_FOUND: UpdateFailure.ValueType # 2 +UPDATE_FAILURE_INTERNAL_ERR: UpdateFailure.ValueType # 3 +UPDATE_FAILURE_INVALID_PARAMETER: UpdateFailure.ValueType # 4 +global___UpdateFailure = UpdateFailure + +@typing.final +class LookupHtlcResolutionRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + CHAN_ID_FIELD_NUMBER: builtins.int + HTLC_INDEX_FIELD_NUMBER: builtins.int + chan_id: builtins.int + htlc_index: builtins.int + def __init__( + self, + *, + chan_id: builtins.int = ..., + htlc_index: builtins.int = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["chan_id", b"chan_id", "htlc_index", b"htlc_index"]) -> None: ... + +global___LookupHtlcResolutionRequest = LookupHtlcResolutionRequest + +@typing.final +class LookupHtlcResolutionResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + SETTLED_FIELD_NUMBER: builtins.int + OFFCHAIN_FIELD_NUMBER: builtins.int + settled: builtins.bool + """Settled is true is the htlc was settled. If false, the htlc was failed.""" + offchain: builtins.bool + """Offchain indicates whether the htlc was resolved off-chain or on-chain.""" + def __init__( + self, + *, + settled: builtins.bool = ..., + offchain: builtins.bool = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["offchain", b"offchain", "settled", b"settled"]) -> None: ... + +global___LookupHtlcResolutionResponse = LookupHtlcResolutionResponse + +@typing.final +class SubscribeCustomMessagesRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +global___SubscribeCustomMessagesRequest = SubscribeCustomMessagesRequest + +@typing.final +class CustomMessage(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + PEER_FIELD_NUMBER: builtins.int + TYPE_FIELD_NUMBER: builtins.int + DATA_FIELD_NUMBER: builtins.int + peer: builtins.bytes + """Peer from which the message originates""" + type: builtins.int + """Message type. This value will be in the custom range (>= 32768).""" + data: builtins.bytes + """Raw message data""" + def __init__( + self, + *, + peer: builtins.bytes = ..., + type: builtins.int = ..., + data: builtins.bytes = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["data", b"data", "peer", b"peer", "type", b"type"]) -> None: ... + +global___CustomMessage = CustomMessage + +@typing.final +class SendCustomMessageRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + PEER_FIELD_NUMBER: builtins.int + TYPE_FIELD_NUMBER: builtins.int + DATA_FIELD_NUMBER: builtins.int + peer: builtins.bytes + """Peer to send the message to""" + type: builtins.int + """Message type. This value needs to be in the custom range (>= 32768). + To send a type < custom range, lnd needs to be compiled with the `dev` + build tag, and the message type to override should be specified in lnd's + experimental protocol configuration. + """ + data: builtins.bytes + """Raw message data.""" + def __init__( + self, + *, + peer: builtins.bytes = ..., + type: builtins.int = ..., + data: builtins.bytes = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["data", b"data", "peer", b"peer", "type", b"type"]) -> None: ... + +global___SendCustomMessageRequest = SendCustomMessageRequest + +@typing.final +class SendCustomMessageResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +global___SendCustomMessageResponse = SendCustomMessageResponse + +@typing.final +class Utxo(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + ADDRESS_TYPE_FIELD_NUMBER: builtins.int + ADDRESS_FIELD_NUMBER: builtins.int + AMOUNT_SAT_FIELD_NUMBER: builtins.int + PK_SCRIPT_FIELD_NUMBER: builtins.int + OUTPOINT_FIELD_NUMBER: builtins.int + CONFIRMATIONS_FIELD_NUMBER: builtins.int + address_type: global___AddressType.ValueType + """The type of address""" + address: builtins.str + """The address""" + amount_sat: builtins.int + """The value of the unspent coin in satoshis""" + pk_script: builtins.str + """The pkscript in hex""" + confirmations: builtins.int + """The number of confirmations for the Utxo""" + @property + def outpoint(self) -> global___OutPoint: + """The outpoint in format txid:n""" + + def __init__( + self, + *, + address_type: global___AddressType.ValueType = ..., + address: builtins.str = ..., + amount_sat: builtins.int = ..., + pk_script: builtins.str = ..., + outpoint: global___OutPoint | None = ..., + confirmations: builtins.int = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["outpoint", b"outpoint"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["address", b"address", "address_type", b"address_type", "amount_sat", b"amount_sat", "confirmations", b"confirmations", "outpoint", b"outpoint", "pk_script", b"pk_script"]) -> None: ... + +global___Utxo = Utxo + +@typing.final +class OutputDetail(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + OUTPUT_TYPE_FIELD_NUMBER: builtins.int + ADDRESS_FIELD_NUMBER: builtins.int + PK_SCRIPT_FIELD_NUMBER: builtins.int + OUTPUT_INDEX_FIELD_NUMBER: builtins.int + AMOUNT_FIELD_NUMBER: builtins.int + IS_OUR_ADDRESS_FIELD_NUMBER: builtins.int + output_type: global___OutputScriptType.ValueType + """The type of the output""" + address: builtins.str + """The address""" + pk_script: builtins.str + """The pkscript in hex""" + output_index: builtins.int + """The output index used in the raw transaction""" + amount: builtins.int + """The value of the output coin in satoshis""" + is_our_address: builtins.bool + """Denotes if the output is controlled by the internal wallet""" + def __init__( + self, + *, + output_type: global___OutputScriptType.ValueType = ..., + address: builtins.str = ..., + pk_script: builtins.str = ..., + output_index: builtins.int = ..., + amount: builtins.int = ..., + is_our_address: builtins.bool = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["address", b"address", "amount", b"amount", "is_our_address", b"is_our_address", "output_index", b"output_index", "output_type", b"output_type", "pk_script", b"pk_script"]) -> None: ... + +global___OutputDetail = OutputDetail + +@typing.final +class Transaction(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + TX_HASH_FIELD_NUMBER: builtins.int + AMOUNT_FIELD_NUMBER: builtins.int + NUM_CONFIRMATIONS_FIELD_NUMBER: builtins.int + BLOCK_HASH_FIELD_NUMBER: builtins.int + BLOCK_HEIGHT_FIELD_NUMBER: builtins.int + TIME_STAMP_FIELD_NUMBER: builtins.int + TOTAL_FEES_FIELD_NUMBER: builtins.int + DEST_ADDRESSES_FIELD_NUMBER: builtins.int + OUTPUT_DETAILS_FIELD_NUMBER: builtins.int + RAW_TX_HEX_FIELD_NUMBER: builtins.int + LABEL_FIELD_NUMBER: builtins.int + PREVIOUS_OUTPOINTS_FIELD_NUMBER: builtins.int + tx_hash: builtins.str + """The transaction hash""" + amount: builtins.int + """The transaction amount, denominated in satoshis""" + num_confirmations: builtins.int + """The number of confirmations""" + block_hash: builtins.str + """The hash of the block this transaction was included in""" + block_height: builtins.int + """The height of the block this transaction was included in""" + time_stamp: builtins.int + """Timestamp of this transaction""" + total_fees: builtins.int + """Fees paid for this transaction""" + raw_tx_hex: builtins.str + """The raw transaction hex.""" + label: builtins.str + """A label that was optionally set on transaction broadcast.""" + @property + def dest_addresses(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.str]: + """Addresses that received funds for this transaction. Deprecated as it is + now incorporated in the output_details field. + """ + + @property + def output_details(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___OutputDetail]: + """Outputs that received funds for this transaction""" + + @property + def previous_outpoints(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___PreviousOutPoint]: + """PreviousOutpoints/Inputs of this transaction.""" + + def __init__( + self, + *, + tx_hash: builtins.str = ..., + amount: builtins.int = ..., + num_confirmations: builtins.int = ..., + block_hash: builtins.str = ..., + block_height: builtins.int = ..., + time_stamp: builtins.int = ..., + total_fees: builtins.int = ..., + dest_addresses: collections.abc.Iterable[builtins.str] | None = ..., + output_details: collections.abc.Iterable[global___OutputDetail] | None = ..., + raw_tx_hex: builtins.str = ..., + label: builtins.str = ..., + previous_outpoints: collections.abc.Iterable[global___PreviousOutPoint] | None = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["amount", b"amount", "block_hash", b"block_hash", "block_height", b"block_height", "dest_addresses", b"dest_addresses", "label", b"label", "num_confirmations", b"num_confirmations", "output_details", b"output_details", "previous_outpoints", b"previous_outpoints", "raw_tx_hex", b"raw_tx_hex", "time_stamp", b"time_stamp", "total_fees", b"total_fees", "tx_hash", b"tx_hash"]) -> None: ... + +global___Transaction = Transaction + +@typing.final +class GetTransactionsRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + START_HEIGHT_FIELD_NUMBER: builtins.int + END_HEIGHT_FIELD_NUMBER: builtins.int + ACCOUNT_FIELD_NUMBER: builtins.int + start_height: builtins.int + """ + The height from which to list transactions, inclusive. If this value is + greater than end_height, transactions will be read in reverse. + """ + end_height: builtins.int + """ + The height until which to list transactions, inclusive. To include + unconfirmed transactions, this value should be set to -1, which will + return transactions from start_height until the current chain tip and + unconfirmed transactions. If no end_height is provided, the call will + default to this option. + """ + account: builtins.str + """An optional filter to only include transactions relevant to an account.""" + def __init__( + self, + *, + start_height: builtins.int = ..., + end_height: builtins.int = ..., + account: builtins.str = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["account", b"account", "end_height", b"end_height", "start_height", b"start_height"]) -> None: ... + +global___GetTransactionsRequest = GetTransactionsRequest + +@typing.final +class TransactionDetails(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + TRANSACTIONS_FIELD_NUMBER: builtins.int + @property + def transactions(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___Transaction]: + """The list of transactions relevant to the wallet.""" + + def __init__( + self, + *, + transactions: collections.abc.Iterable[global___Transaction] | None = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["transactions", b"transactions"]) -> None: ... + +global___TransactionDetails = TransactionDetails + +@typing.final +class FeeLimit(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + FIXED_FIELD_NUMBER: builtins.int + FIXED_MSAT_FIELD_NUMBER: builtins.int + PERCENT_FIELD_NUMBER: builtins.int + fixed: builtins.int + """ + The fee limit expressed as a fixed amount of satoshis. + + The fields fixed and fixed_msat are mutually exclusive. + """ + fixed_msat: builtins.int + """ + The fee limit expressed as a fixed amount of millisatoshis. + + The fields fixed and fixed_msat are mutually exclusive. + """ + percent: builtins.int + """The fee limit expressed as a percentage of the payment amount.""" + def __init__( + self, + *, + fixed: builtins.int = ..., + fixed_msat: builtins.int = ..., + percent: builtins.int = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["fixed", b"fixed", "fixed_msat", b"fixed_msat", "limit", b"limit", "percent", b"percent"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["fixed", b"fixed", "fixed_msat", b"fixed_msat", "limit", b"limit", "percent", b"percent"]) -> None: ... + def WhichOneof(self, oneof_group: typing.Literal["limit", b"limit"]) -> typing.Literal["fixed", "fixed_msat", "percent"] | None: ... + +global___FeeLimit = FeeLimit + +@typing.final +class SendRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + @typing.final + class DestCustomRecordsEntry(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + KEY_FIELD_NUMBER: builtins.int + VALUE_FIELD_NUMBER: builtins.int + key: builtins.int + value: builtins.bytes + def __init__( + self, + *, + key: builtins.int = ..., + value: builtins.bytes = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["key", b"key", "value", b"value"]) -> None: ... + + DEST_FIELD_NUMBER: builtins.int + DEST_STRING_FIELD_NUMBER: builtins.int + AMT_FIELD_NUMBER: builtins.int + AMT_MSAT_FIELD_NUMBER: builtins.int + PAYMENT_HASH_FIELD_NUMBER: builtins.int + PAYMENT_HASH_STRING_FIELD_NUMBER: builtins.int + PAYMENT_REQUEST_FIELD_NUMBER: builtins.int + FINAL_CLTV_DELTA_FIELD_NUMBER: builtins.int + FEE_LIMIT_FIELD_NUMBER: builtins.int + OUTGOING_CHAN_ID_FIELD_NUMBER: builtins.int + LAST_HOP_PUBKEY_FIELD_NUMBER: builtins.int + CLTV_LIMIT_FIELD_NUMBER: builtins.int + DEST_CUSTOM_RECORDS_FIELD_NUMBER: builtins.int + ALLOW_SELF_PAYMENT_FIELD_NUMBER: builtins.int + DEST_FEATURES_FIELD_NUMBER: builtins.int + PAYMENT_ADDR_FIELD_NUMBER: builtins.int + dest: builtins.bytes + """ + The identity pubkey of the payment recipient. When using REST, this field + must be encoded as base64. + """ + dest_string: builtins.str + """ + The hex-encoded identity pubkey of the payment recipient. Deprecated now + that the REST gateway supports base64 encoding of bytes fields. + """ + amt: builtins.int + """ + The amount to send expressed in satoshis. + + The fields amt and amt_msat are mutually exclusive. + """ + amt_msat: builtins.int + """ + The amount to send expressed in millisatoshis. + + The fields amt and amt_msat are mutually exclusive. + """ + payment_hash: builtins.bytes + """ + The hash to use within the payment's HTLC. When using REST, this field + must be encoded as base64. + """ + payment_hash_string: builtins.str + """ + The hex-encoded hash to use within the payment's HTLC. Deprecated now + that the REST gateway supports base64 encoding of bytes fields. + """ + payment_request: builtins.str + """ + A bare-bones invoice for a payment within the Lightning Network. With the + details of the invoice, the sender has all the data necessary to send a + payment to the recipient. + """ + final_cltv_delta: builtins.int + """ + The CLTV delta from the current height that should be used to set the + timelock for the final hop. + """ + outgoing_chan_id: builtins.int + """ + The channel id of the channel that must be taken to the first hop. If zero, + any channel may be used. + """ + last_hop_pubkey: builtins.bytes + """ + The pubkey of the last hop of the route. If empty, any hop may be used. + """ + cltv_limit: builtins.int + """ + An optional maximum total time lock for the route. This should not exceed + lnd's `--max-cltv-expiry` setting. If zero, then the value of + `--max-cltv-expiry` is enforced. + """ + allow_self_payment: builtins.bool + """If set, circular payments to self are permitted.""" + payment_addr: builtins.bytes + """ + The payment address of the generated invoice. This is also called + payment secret in specifications (e.g. BOLT 11). + """ + @property + def fee_limit(self) -> global___FeeLimit: + """ + The maximum number of satoshis that will be paid as a fee of the payment. + This value can be represented either as a percentage of the amount being + sent, or as a fixed amount of the maximum fee the user is willing the pay to + send the payment. If not specified, lnd will use a default value of 100% + fees for small amounts (<=1k sat) or 5% fees for larger amounts. + """ + + @property + def dest_custom_records(self) -> google.protobuf.internal.containers.ScalarMap[builtins.int, builtins.bytes]: + """ + An optional field that can be used to pass an arbitrary set of TLV records + to a peer which understands the new records. This can be used to pass + application specific data during the payment attempt. Record types are + required to be in the custom range >= 65536. When using REST, the values + must be encoded as base64. + """ + + @property + def dest_features(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[global___FeatureBit.ValueType]: + """ + Features assumed to be supported by the final node. All transitive feature + dependencies must also be set properly. For a given feature bit pair, either + optional or remote may be set, but not both. If this field is nil or empty, + the router will try to load destination features from the graph as a + fallback. + """ + + def __init__( + self, + *, + dest: builtins.bytes = ..., + dest_string: builtins.str = ..., + amt: builtins.int = ..., + amt_msat: builtins.int = ..., + payment_hash: builtins.bytes = ..., + payment_hash_string: builtins.str = ..., + payment_request: builtins.str = ..., + final_cltv_delta: builtins.int = ..., + fee_limit: global___FeeLimit | None = ..., + outgoing_chan_id: builtins.int = ..., + last_hop_pubkey: builtins.bytes = ..., + cltv_limit: builtins.int = ..., + dest_custom_records: collections.abc.Mapping[builtins.int, builtins.bytes] | None = ..., + allow_self_payment: builtins.bool = ..., + dest_features: collections.abc.Iterable[global___FeatureBit.ValueType] | None = ..., + payment_addr: builtins.bytes = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["fee_limit", b"fee_limit"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["allow_self_payment", b"allow_self_payment", "amt", b"amt", "amt_msat", b"amt_msat", "cltv_limit", b"cltv_limit", "dest", b"dest", "dest_custom_records", b"dest_custom_records", "dest_features", b"dest_features", "dest_string", b"dest_string", "fee_limit", b"fee_limit", "final_cltv_delta", b"final_cltv_delta", "last_hop_pubkey", b"last_hop_pubkey", "outgoing_chan_id", b"outgoing_chan_id", "payment_addr", b"payment_addr", "payment_hash", b"payment_hash", "payment_hash_string", b"payment_hash_string", "payment_request", b"payment_request"]) -> None: ... + +global___SendRequest = SendRequest + +@typing.final +class SendResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + PAYMENT_ERROR_FIELD_NUMBER: builtins.int + PAYMENT_PREIMAGE_FIELD_NUMBER: builtins.int + PAYMENT_ROUTE_FIELD_NUMBER: builtins.int + PAYMENT_HASH_FIELD_NUMBER: builtins.int + payment_error: builtins.str + payment_preimage: builtins.bytes + payment_hash: builtins.bytes + @property + def payment_route(self) -> global___Route: ... + def __init__( + self, + *, + payment_error: builtins.str = ..., + payment_preimage: builtins.bytes = ..., + payment_route: global___Route | None = ..., + payment_hash: builtins.bytes = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["payment_route", b"payment_route"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["payment_error", b"payment_error", "payment_hash", b"payment_hash", "payment_preimage", b"payment_preimage", "payment_route", b"payment_route"]) -> None: ... + +global___SendResponse = SendResponse + +@typing.final +class SendToRouteRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + PAYMENT_HASH_FIELD_NUMBER: builtins.int + PAYMENT_HASH_STRING_FIELD_NUMBER: builtins.int + ROUTE_FIELD_NUMBER: builtins.int + payment_hash: builtins.bytes + """ + The payment hash to use for the HTLC. When using REST, this field must be + encoded as base64. + """ + payment_hash_string: builtins.str + """ + An optional hex-encoded payment hash to be used for the HTLC. Deprecated now + that the REST gateway supports base64 encoding of bytes fields. + """ + @property + def route(self) -> global___Route: + """Route that should be used to attempt to complete the payment.""" + + def __init__( + self, + *, + payment_hash: builtins.bytes = ..., + payment_hash_string: builtins.str = ..., + route: global___Route | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["route", b"route"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["payment_hash", b"payment_hash", "payment_hash_string", b"payment_hash_string", "route", b"route"]) -> None: ... + +global___SendToRouteRequest = SendToRouteRequest + +@typing.final +class ChannelAcceptRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + NODE_PUBKEY_FIELD_NUMBER: builtins.int + CHAIN_HASH_FIELD_NUMBER: builtins.int + PENDING_CHAN_ID_FIELD_NUMBER: builtins.int + FUNDING_AMT_FIELD_NUMBER: builtins.int + PUSH_AMT_FIELD_NUMBER: builtins.int + DUST_LIMIT_FIELD_NUMBER: builtins.int + MAX_VALUE_IN_FLIGHT_FIELD_NUMBER: builtins.int + CHANNEL_RESERVE_FIELD_NUMBER: builtins.int + MIN_HTLC_FIELD_NUMBER: builtins.int + FEE_PER_KW_FIELD_NUMBER: builtins.int + CSV_DELAY_FIELD_NUMBER: builtins.int + MAX_ACCEPTED_HTLCS_FIELD_NUMBER: builtins.int + CHANNEL_FLAGS_FIELD_NUMBER: builtins.int + COMMITMENT_TYPE_FIELD_NUMBER: builtins.int + WANTS_ZERO_CONF_FIELD_NUMBER: builtins.int + WANTS_SCID_ALIAS_FIELD_NUMBER: builtins.int + node_pubkey: builtins.bytes + """The pubkey of the node that wishes to open an inbound channel.""" + chain_hash: builtins.bytes + """The hash of the genesis block that the proposed channel resides in.""" + pending_chan_id: builtins.bytes + """The pending channel id.""" + funding_amt: builtins.int + """The funding amount in satoshis that initiator wishes to use in the + channel. + """ + push_amt: builtins.int + """The push amount of the proposed channel in millisatoshis.""" + dust_limit: builtins.int + """The dust limit of the initiator's commitment tx.""" + max_value_in_flight: builtins.int + """The maximum amount of coins in millisatoshis that can be pending in this + channel. + """ + channel_reserve: builtins.int + """The minimum amount of satoshis the initiator requires us to have at all + times. + """ + min_htlc: builtins.int + """The smallest HTLC in millisatoshis that the initiator will accept.""" + fee_per_kw: builtins.int + """The initial fee rate that the initiator suggests for both commitment + transactions. + """ + csv_delay: builtins.int + """ + The number of blocks to use for the relative time lock in the pay-to-self + output of both commitment transactions. + """ + max_accepted_htlcs: builtins.int + """The total number of incoming HTLC's that the initiator will accept.""" + channel_flags: builtins.int + """A bit-field which the initiator uses to specify proposed channel + behavior. + """ + commitment_type: global___CommitmentType.ValueType + """The commitment type the initiator wishes to use for the proposed channel.""" + wants_zero_conf: builtins.bool + """Whether the initiator wants to open a zero-conf channel via the channel + type. + """ + wants_scid_alias: builtins.bool + """Whether the initiator wants to use the scid-alias channel type. This is + separate from the feature bit. + """ + def __init__( + self, + *, + node_pubkey: builtins.bytes = ..., + chain_hash: builtins.bytes = ..., + pending_chan_id: builtins.bytes = ..., + funding_amt: builtins.int = ..., + push_amt: builtins.int = ..., + dust_limit: builtins.int = ..., + max_value_in_flight: builtins.int = ..., + channel_reserve: builtins.int = ..., + min_htlc: builtins.int = ..., + fee_per_kw: builtins.int = ..., + csv_delay: builtins.int = ..., + max_accepted_htlcs: builtins.int = ..., + channel_flags: builtins.int = ..., + commitment_type: global___CommitmentType.ValueType = ..., + wants_zero_conf: builtins.bool = ..., + wants_scid_alias: builtins.bool = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["chain_hash", b"chain_hash", "channel_flags", b"channel_flags", "channel_reserve", b"channel_reserve", "commitment_type", b"commitment_type", "csv_delay", b"csv_delay", "dust_limit", b"dust_limit", "fee_per_kw", b"fee_per_kw", "funding_amt", b"funding_amt", "max_accepted_htlcs", b"max_accepted_htlcs", "max_value_in_flight", b"max_value_in_flight", "min_htlc", b"min_htlc", "node_pubkey", b"node_pubkey", "pending_chan_id", b"pending_chan_id", "push_amt", b"push_amt", "wants_scid_alias", b"wants_scid_alias", "wants_zero_conf", b"wants_zero_conf"]) -> None: ... + +global___ChannelAcceptRequest = ChannelAcceptRequest + +@typing.final +class ChannelAcceptResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + ACCEPT_FIELD_NUMBER: builtins.int + PENDING_CHAN_ID_FIELD_NUMBER: builtins.int + ERROR_FIELD_NUMBER: builtins.int + UPFRONT_SHUTDOWN_FIELD_NUMBER: builtins.int + CSV_DELAY_FIELD_NUMBER: builtins.int + RESERVE_SAT_FIELD_NUMBER: builtins.int + IN_FLIGHT_MAX_MSAT_FIELD_NUMBER: builtins.int + MAX_HTLC_COUNT_FIELD_NUMBER: builtins.int + MIN_HTLC_IN_FIELD_NUMBER: builtins.int + MIN_ACCEPT_DEPTH_FIELD_NUMBER: builtins.int + ZERO_CONF_FIELD_NUMBER: builtins.int + accept: builtins.bool + """Whether or not the client accepts the channel.""" + pending_chan_id: builtins.bytes + """The pending channel id to which this response applies.""" + error: builtins.str + """ + An optional error to send the initiating party to indicate why the channel + was rejected. This field *should not* contain sensitive information, it will + be sent to the initiating party. This field should only be set if accept is + false, the channel will be rejected if an error is set with accept=true + because the meaning of this response is ambiguous. Limited to 500 + characters. + """ + upfront_shutdown: builtins.str + """ + The upfront shutdown address to use if the initiating peer supports option + upfront shutdown script (see ListPeers for the features supported). Note + that the channel open will fail if this value is set for a peer that does + not support this feature bit. + """ + csv_delay: builtins.int + """ + The csv delay (in blocks) that we require for the remote party. + """ + reserve_sat: builtins.int + """ + The reserve amount in satoshis that we require the remote peer to adhere to. + We require that the remote peer always have some reserve amount allocated to + them so that there is always a disincentive to broadcast old state (if they + hold 0 sats on their side of the channel, there is nothing to lose). + """ + in_flight_max_msat: builtins.int + """ + The maximum amount of funds in millisatoshis that we allow the remote peer + to have in outstanding htlcs. + """ + max_htlc_count: builtins.int + """ + The maximum number of htlcs that the remote peer can offer us. + """ + min_htlc_in: builtins.int + """ + The minimum value in millisatoshis for incoming htlcs on the channel. + """ + min_accept_depth: builtins.int + """ + The number of confirmations we require before we consider the channel open. + """ + zero_conf: builtins.bool + """ + Whether the responder wants this to be a zero-conf channel. This will fail + if either side does not have the scid-alias feature bit set. The minimum + depth field must be zero if this is true. + """ + def __init__( + self, + *, + accept: builtins.bool = ..., + pending_chan_id: builtins.bytes = ..., + error: builtins.str = ..., + upfront_shutdown: builtins.str = ..., + csv_delay: builtins.int = ..., + reserve_sat: builtins.int = ..., + in_flight_max_msat: builtins.int = ..., + max_htlc_count: builtins.int = ..., + min_htlc_in: builtins.int = ..., + min_accept_depth: builtins.int = ..., + zero_conf: builtins.bool = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["accept", b"accept", "csv_delay", b"csv_delay", "error", b"error", "in_flight_max_msat", b"in_flight_max_msat", "max_htlc_count", b"max_htlc_count", "min_accept_depth", b"min_accept_depth", "min_htlc_in", b"min_htlc_in", "pending_chan_id", b"pending_chan_id", "reserve_sat", b"reserve_sat", "upfront_shutdown", b"upfront_shutdown", "zero_conf", b"zero_conf"]) -> None: ... + +global___ChannelAcceptResponse = ChannelAcceptResponse + +@typing.final +class ChannelPoint(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + FUNDING_TXID_BYTES_FIELD_NUMBER: builtins.int + FUNDING_TXID_STR_FIELD_NUMBER: builtins.int + OUTPUT_INDEX_FIELD_NUMBER: builtins.int + funding_txid_bytes: builtins.bytes + """ + Txid of the funding transaction. When using REST, this field must be + encoded as base64. + """ + funding_txid_str: builtins.str + """ + Hex-encoded string representing the byte-reversed hash of the funding + transaction. + """ + output_index: builtins.int + """The index of the output of the funding transaction""" + def __init__( + self, + *, + funding_txid_bytes: builtins.bytes = ..., + funding_txid_str: builtins.str = ..., + output_index: builtins.int = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["funding_txid", b"funding_txid", "funding_txid_bytes", b"funding_txid_bytes", "funding_txid_str", b"funding_txid_str"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["funding_txid", b"funding_txid", "funding_txid_bytes", b"funding_txid_bytes", "funding_txid_str", b"funding_txid_str", "output_index", b"output_index"]) -> None: ... + def WhichOneof(self, oneof_group: typing.Literal["funding_txid", b"funding_txid"]) -> typing.Literal["funding_txid_bytes", "funding_txid_str"] | None: ... + +global___ChannelPoint = ChannelPoint + +@typing.final +class OutPoint(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + TXID_BYTES_FIELD_NUMBER: builtins.int + TXID_STR_FIELD_NUMBER: builtins.int + OUTPUT_INDEX_FIELD_NUMBER: builtins.int + txid_bytes: builtins.bytes + """Raw bytes representing the transaction id.""" + txid_str: builtins.str + """Reversed, hex-encoded string representing the transaction id.""" + output_index: builtins.int + """The index of the output on the transaction.""" + def __init__( + self, + *, + txid_bytes: builtins.bytes = ..., + txid_str: builtins.str = ..., + output_index: builtins.int = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["output_index", b"output_index", "txid_bytes", b"txid_bytes", "txid_str", b"txid_str"]) -> None: ... + +global___OutPoint = OutPoint + +@typing.final +class PreviousOutPoint(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + OUTPOINT_FIELD_NUMBER: builtins.int + IS_OUR_OUTPUT_FIELD_NUMBER: builtins.int + outpoint: builtins.str + """The outpoint in format txid:n.""" + is_our_output: builtins.bool + """Denotes if the outpoint is controlled by the internal wallet. + The flag will only detect p2wkh, np2wkh and p2tr inputs as its own. + """ + def __init__( + self, + *, + outpoint: builtins.str = ..., + is_our_output: builtins.bool = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["is_our_output", b"is_our_output", "outpoint", b"outpoint"]) -> None: ... + +global___PreviousOutPoint = PreviousOutPoint + +@typing.final +class LightningAddress(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + PUBKEY_FIELD_NUMBER: builtins.int + HOST_FIELD_NUMBER: builtins.int + pubkey: builtins.str + """The identity pubkey of the Lightning node.""" + host: builtins.str + """The network location of the lightning node, e.g. `69.69.69.69:1337` or + `localhost:10011`. + """ + def __init__( + self, + *, + pubkey: builtins.str = ..., + host: builtins.str = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["host", b"host", "pubkey", b"pubkey"]) -> None: ... + +global___LightningAddress = LightningAddress + +@typing.final +class EstimateFeeRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + @typing.final + class AddrToAmountEntry(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + KEY_FIELD_NUMBER: builtins.int + VALUE_FIELD_NUMBER: builtins.int + key: builtins.str + value: builtins.int + def __init__( + self, + *, + key: builtins.str = ..., + value: builtins.int = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["key", b"key", "value", b"value"]) -> None: ... + + ADDRTOAMOUNT_FIELD_NUMBER: builtins.int + TARGET_CONF_FIELD_NUMBER: builtins.int + MIN_CONFS_FIELD_NUMBER: builtins.int + SPEND_UNCONFIRMED_FIELD_NUMBER: builtins.int + COIN_SELECTION_STRATEGY_FIELD_NUMBER: builtins.int + target_conf: builtins.int + """The target number of blocks that this transaction should be confirmed + by. + """ + min_confs: builtins.int + """The minimum number of confirmations each one of your outputs used for + the transaction must satisfy. + """ + spend_unconfirmed: builtins.bool + """Whether unconfirmed outputs should be used as inputs for the transaction.""" + coin_selection_strategy: global___CoinSelectionStrategy.ValueType + """The strategy to use for selecting coins during fees estimation.""" + @property + def AddrToAmount(self) -> google.protobuf.internal.containers.ScalarMap[builtins.str, builtins.int]: + """The map from addresses to amounts for the transaction.""" + + def __init__( + self, + *, + AddrToAmount: collections.abc.Mapping[builtins.str, builtins.int] | None = ..., + target_conf: builtins.int = ..., + min_confs: builtins.int = ..., + spend_unconfirmed: builtins.bool = ..., + coin_selection_strategy: global___CoinSelectionStrategy.ValueType = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["AddrToAmount", b"AddrToAmount", "coin_selection_strategy", b"coin_selection_strategy", "min_confs", b"min_confs", "spend_unconfirmed", b"spend_unconfirmed", "target_conf", b"target_conf"]) -> None: ... + +global___EstimateFeeRequest = EstimateFeeRequest + +@typing.final +class EstimateFeeResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + FEE_SAT_FIELD_NUMBER: builtins.int + FEERATE_SAT_PER_BYTE_FIELD_NUMBER: builtins.int + SAT_PER_VBYTE_FIELD_NUMBER: builtins.int + fee_sat: builtins.int + """The total fee in satoshis.""" + feerate_sat_per_byte: builtins.int + """Deprecated, use sat_per_vbyte. + The fee rate in satoshi/vbyte. + """ + sat_per_vbyte: builtins.int + """The fee rate in satoshi/vbyte.""" + def __init__( + self, + *, + fee_sat: builtins.int = ..., + feerate_sat_per_byte: builtins.int = ..., + sat_per_vbyte: builtins.int = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["fee_sat", b"fee_sat", "feerate_sat_per_byte", b"feerate_sat_per_byte", "sat_per_vbyte", b"sat_per_vbyte"]) -> None: ... + +global___EstimateFeeResponse = EstimateFeeResponse + +@typing.final +class SendManyRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + @typing.final + class AddrToAmountEntry(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + KEY_FIELD_NUMBER: builtins.int + VALUE_FIELD_NUMBER: builtins.int + key: builtins.str + value: builtins.int + def __init__( + self, + *, + key: builtins.str = ..., + value: builtins.int = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["key", b"key", "value", b"value"]) -> None: ... + + ADDRTOAMOUNT_FIELD_NUMBER: builtins.int + TARGET_CONF_FIELD_NUMBER: builtins.int + SAT_PER_VBYTE_FIELD_NUMBER: builtins.int + SAT_PER_BYTE_FIELD_NUMBER: builtins.int + LABEL_FIELD_NUMBER: builtins.int + MIN_CONFS_FIELD_NUMBER: builtins.int + SPEND_UNCONFIRMED_FIELD_NUMBER: builtins.int + COIN_SELECTION_STRATEGY_FIELD_NUMBER: builtins.int + target_conf: builtins.int + """The target number of blocks that this transaction should be confirmed + by. + """ + sat_per_vbyte: builtins.int + """A manual fee rate set in sat/vbyte that should be used when crafting the + transaction. + """ + sat_per_byte: builtins.int + """Deprecated, use sat_per_vbyte. + A manual fee rate set in sat/vbyte that should be used when crafting the + transaction. + """ + label: builtins.str + """An optional label for the transaction, limited to 500 characters.""" + min_confs: builtins.int + """The minimum number of confirmations each one of your outputs used for + the transaction must satisfy. + """ + spend_unconfirmed: builtins.bool + """Whether unconfirmed outputs should be used as inputs for the transaction.""" + coin_selection_strategy: global___CoinSelectionStrategy.ValueType + """The strategy to use for selecting coins during sending many requests.""" + @property + def AddrToAmount(self) -> google.protobuf.internal.containers.ScalarMap[builtins.str, builtins.int]: + """The map from addresses to amounts""" + + def __init__( + self, + *, + AddrToAmount: collections.abc.Mapping[builtins.str, builtins.int] | None = ..., + target_conf: builtins.int = ..., + sat_per_vbyte: builtins.int = ..., + sat_per_byte: builtins.int = ..., + label: builtins.str = ..., + min_confs: builtins.int = ..., + spend_unconfirmed: builtins.bool = ..., + coin_selection_strategy: global___CoinSelectionStrategy.ValueType = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["AddrToAmount", b"AddrToAmount", "coin_selection_strategy", b"coin_selection_strategy", "label", b"label", "min_confs", b"min_confs", "sat_per_byte", b"sat_per_byte", "sat_per_vbyte", b"sat_per_vbyte", "spend_unconfirmed", b"spend_unconfirmed", "target_conf", b"target_conf"]) -> None: ... + +global___SendManyRequest = SendManyRequest + +@typing.final +class SendManyResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + TXID_FIELD_NUMBER: builtins.int + txid: builtins.str + """The id of the transaction""" + def __init__( + self, + *, + txid: builtins.str = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["txid", b"txid"]) -> None: ... + +global___SendManyResponse = SendManyResponse + +@typing.final +class SendCoinsRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + ADDR_FIELD_NUMBER: builtins.int + AMOUNT_FIELD_NUMBER: builtins.int + TARGET_CONF_FIELD_NUMBER: builtins.int + SAT_PER_VBYTE_FIELD_NUMBER: builtins.int + SAT_PER_BYTE_FIELD_NUMBER: builtins.int + SEND_ALL_FIELD_NUMBER: builtins.int + LABEL_FIELD_NUMBER: builtins.int + MIN_CONFS_FIELD_NUMBER: builtins.int + SPEND_UNCONFIRMED_FIELD_NUMBER: builtins.int + COIN_SELECTION_STRATEGY_FIELD_NUMBER: builtins.int + addr: builtins.str + """The address to send coins to""" + amount: builtins.int + """The amount in satoshis to send""" + target_conf: builtins.int + """The target number of blocks that this transaction should be confirmed + by. + """ + sat_per_vbyte: builtins.int + """A manual fee rate set in sat/vbyte that should be used when crafting the + transaction. + """ + sat_per_byte: builtins.int + """Deprecated, use sat_per_vbyte. + A manual fee rate set in sat/vbyte that should be used when crafting the + transaction. + """ + send_all: builtins.bool + """ + If set, then the amount field will be ignored, and lnd will attempt to + send all the coins under control of the internal wallet to the specified + address. + """ + label: builtins.str + """An optional label for the transaction, limited to 500 characters.""" + min_confs: builtins.int + """The minimum number of confirmations each one of your outputs used for + the transaction must satisfy. + """ + spend_unconfirmed: builtins.bool + """Whether unconfirmed outputs should be used as inputs for the transaction.""" + coin_selection_strategy: global___CoinSelectionStrategy.ValueType + """The strategy to use for selecting coins.""" + def __init__( + self, + *, + addr: builtins.str = ..., + amount: builtins.int = ..., + target_conf: builtins.int = ..., + sat_per_vbyte: builtins.int = ..., + sat_per_byte: builtins.int = ..., + send_all: builtins.bool = ..., + label: builtins.str = ..., + min_confs: builtins.int = ..., + spend_unconfirmed: builtins.bool = ..., + coin_selection_strategy: global___CoinSelectionStrategy.ValueType = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["addr", b"addr", "amount", b"amount", "coin_selection_strategy", b"coin_selection_strategy", "label", b"label", "min_confs", b"min_confs", "sat_per_byte", b"sat_per_byte", "sat_per_vbyte", b"sat_per_vbyte", "send_all", b"send_all", "spend_unconfirmed", b"spend_unconfirmed", "target_conf", b"target_conf"]) -> None: ... + +global___SendCoinsRequest = SendCoinsRequest + +@typing.final +class SendCoinsResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + TXID_FIELD_NUMBER: builtins.int + txid: builtins.str + """The transaction ID of the transaction""" + def __init__( + self, + *, + txid: builtins.str = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["txid", b"txid"]) -> None: ... + +global___SendCoinsResponse = SendCoinsResponse + +@typing.final +class ListUnspentRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + MIN_CONFS_FIELD_NUMBER: builtins.int + MAX_CONFS_FIELD_NUMBER: builtins.int + ACCOUNT_FIELD_NUMBER: builtins.int + min_confs: builtins.int + """The minimum number of confirmations to be included.""" + max_confs: builtins.int + """The maximum number of confirmations to be included.""" + account: builtins.str + """An optional filter to only include outputs belonging to an account.""" + def __init__( + self, + *, + min_confs: builtins.int = ..., + max_confs: builtins.int = ..., + account: builtins.str = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["account", b"account", "max_confs", b"max_confs", "min_confs", b"min_confs"]) -> None: ... + +global___ListUnspentRequest = ListUnspentRequest + +@typing.final +class ListUnspentResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + UTXOS_FIELD_NUMBER: builtins.int + @property + def utxos(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___Utxo]: + """A list of utxos""" + + def __init__( + self, + *, + utxos: collections.abc.Iterable[global___Utxo] | None = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["utxos", b"utxos"]) -> None: ... + +global___ListUnspentResponse = ListUnspentResponse + +@typing.final +class NewAddressRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + TYPE_FIELD_NUMBER: builtins.int + ACCOUNT_FIELD_NUMBER: builtins.int + type: global___AddressType.ValueType + """The type of address to generate.""" + account: builtins.str + """ + The name of the account to generate a new address for. If empty, the + default wallet account is used. + """ + def __init__( + self, + *, + type: global___AddressType.ValueType = ..., + account: builtins.str = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["account", b"account", "type", b"type"]) -> None: ... + +global___NewAddressRequest = NewAddressRequest + +@typing.final +class NewAddressResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + ADDRESS_FIELD_NUMBER: builtins.int + address: builtins.str + """The newly generated wallet address""" + def __init__( + self, + *, + address: builtins.str = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["address", b"address"]) -> None: ... + +global___NewAddressResponse = NewAddressResponse + +@typing.final +class SignMessageRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + MSG_FIELD_NUMBER: builtins.int + SINGLE_HASH_FIELD_NUMBER: builtins.int + msg: builtins.bytes + """ + The message to be signed. When using REST, this field must be encoded as + base64. + """ + single_hash: builtins.bool + """ + Instead of the default double-SHA256 hashing of the message before signing, + only use one round of hashing instead. + """ + def __init__( + self, + *, + msg: builtins.bytes = ..., + single_hash: builtins.bool = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["msg", b"msg", "single_hash", b"single_hash"]) -> None: ... + +global___SignMessageRequest = SignMessageRequest + +@typing.final +class SignMessageResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + SIGNATURE_FIELD_NUMBER: builtins.int + signature: builtins.str + """The signature for the given message""" + def __init__( + self, + *, + signature: builtins.str = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["signature", b"signature"]) -> None: ... + +global___SignMessageResponse = SignMessageResponse + +@typing.final +class VerifyMessageRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + MSG_FIELD_NUMBER: builtins.int + SIGNATURE_FIELD_NUMBER: builtins.int + msg: builtins.bytes + """ + The message over which the signature is to be verified. When using REST, + this field must be encoded as base64. + """ + signature: builtins.str + """The signature to be verified over the given message""" + def __init__( + self, + *, + msg: builtins.bytes = ..., + signature: builtins.str = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["msg", b"msg", "signature", b"signature"]) -> None: ... + +global___VerifyMessageRequest = VerifyMessageRequest + +@typing.final +class VerifyMessageResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + VALID_FIELD_NUMBER: builtins.int + PUBKEY_FIELD_NUMBER: builtins.int + valid: builtins.bool + """Whether the signature was valid over the given message""" + pubkey: builtins.str + """The pubkey recovered from the signature""" + def __init__( + self, + *, + valid: builtins.bool = ..., + pubkey: builtins.str = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["pubkey", b"pubkey", "valid", b"valid"]) -> None: ... + +global___VerifyMessageResponse = VerifyMessageResponse + +@typing.final +class ConnectPeerRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + ADDR_FIELD_NUMBER: builtins.int + PERM_FIELD_NUMBER: builtins.int + TIMEOUT_FIELD_NUMBER: builtins.int + perm: builtins.bool + """ + If set, the daemon will attempt to persistently connect to the target + peer. Otherwise, the call will be synchronous. + """ + timeout: builtins.int + """ + The connection timeout value (in seconds) for this request. It won't affect + other requests. + """ + @property + def addr(self) -> global___LightningAddress: + """ + Lightning address of the peer to connect to. + """ + + def __init__( + self, + *, + addr: global___LightningAddress | None = ..., + perm: builtins.bool = ..., + timeout: builtins.int = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["addr", b"addr"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["addr", b"addr", "perm", b"perm", "timeout", b"timeout"]) -> None: ... + +global___ConnectPeerRequest = ConnectPeerRequest + +@typing.final +class ConnectPeerResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +global___ConnectPeerResponse = ConnectPeerResponse + +@typing.final +class DisconnectPeerRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + PUB_KEY_FIELD_NUMBER: builtins.int + pub_key: builtins.str + """The pubkey of the node to disconnect from""" + def __init__( + self, + *, + pub_key: builtins.str = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["pub_key", b"pub_key"]) -> None: ... + +global___DisconnectPeerRequest = DisconnectPeerRequest + +@typing.final +class DisconnectPeerResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +global___DisconnectPeerResponse = DisconnectPeerResponse + +@typing.final +class HTLC(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + INCOMING_FIELD_NUMBER: builtins.int + AMOUNT_FIELD_NUMBER: builtins.int + HASH_LOCK_FIELD_NUMBER: builtins.int + EXPIRATION_HEIGHT_FIELD_NUMBER: builtins.int + HTLC_INDEX_FIELD_NUMBER: builtins.int + FORWARDING_CHANNEL_FIELD_NUMBER: builtins.int + FORWARDING_HTLC_INDEX_FIELD_NUMBER: builtins.int + incoming: builtins.bool + amount: builtins.int + hash_lock: builtins.bytes + expiration_height: builtins.int + htlc_index: builtins.int + """Index identifying the htlc on the channel.""" + forwarding_channel: builtins.int + """If this HTLC is involved in a forwarding operation, this field indicates + the forwarding channel. For an outgoing htlc, it is the incoming channel. + For an incoming htlc, it is the outgoing channel. When the htlc + originates from this node or this node is the final destination, + forwarding_channel will be zero. The forwarding channel will also be zero + for htlcs that need to be forwarded but don't have a forwarding decision + persisted yet. + """ + forwarding_htlc_index: builtins.int + """Index identifying the htlc on the forwarding channel.""" + def __init__( + self, + *, + incoming: builtins.bool = ..., + amount: builtins.int = ..., + hash_lock: builtins.bytes = ..., + expiration_height: builtins.int = ..., + htlc_index: builtins.int = ..., + forwarding_channel: builtins.int = ..., + forwarding_htlc_index: builtins.int = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["amount", b"amount", "expiration_height", b"expiration_height", "forwarding_channel", b"forwarding_channel", "forwarding_htlc_index", b"forwarding_htlc_index", "hash_lock", b"hash_lock", "htlc_index", b"htlc_index", "incoming", b"incoming"]) -> None: ... + +global___HTLC = HTLC + +@typing.final +class ChannelConstraints(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + CSV_DELAY_FIELD_NUMBER: builtins.int + CHAN_RESERVE_SAT_FIELD_NUMBER: builtins.int + DUST_LIMIT_SAT_FIELD_NUMBER: builtins.int + MAX_PENDING_AMT_MSAT_FIELD_NUMBER: builtins.int + MIN_HTLC_MSAT_FIELD_NUMBER: builtins.int + MAX_ACCEPTED_HTLCS_FIELD_NUMBER: builtins.int + csv_delay: builtins.int + """ + The CSV delay expressed in relative blocks. If the channel is force closed, + we will need to wait for this many blocks before we can regain our funds. + """ + chan_reserve_sat: builtins.int + """The minimum satoshis this node is required to reserve in its balance.""" + dust_limit_sat: builtins.int + """The dust limit (in satoshis) of the initiator's commitment tx.""" + max_pending_amt_msat: builtins.int + """The maximum amount of coins in millisatoshis that can be pending in this + channel. + """ + min_htlc_msat: builtins.int + """The smallest HTLC in millisatoshis that the initiator will accept.""" + max_accepted_htlcs: builtins.int + """The total number of incoming HTLC's that the initiator will accept.""" + def __init__( + self, + *, + csv_delay: builtins.int = ..., + chan_reserve_sat: builtins.int = ..., + dust_limit_sat: builtins.int = ..., + max_pending_amt_msat: builtins.int = ..., + min_htlc_msat: builtins.int = ..., + max_accepted_htlcs: builtins.int = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["chan_reserve_sat", b"chan_reserve_sat", "csv_delay", b"csv_delay", "dust_limit_sat", b"dust_limit_sat", "max_accepted_htlcs", b"max_accepted_htlcs", "max_pending_amt_msat", b"max_pending_amt_msat", "min_htlc_msat", b"min_htlc_msat"]) -> None: ... + +global___ChannelConstraints = ChannelConstraints + +@typing.final +class Channel(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + ACTIVE_FIELD_NUMBER: builtins.int + REMOTE_PUBKEY_FIELD_NUMBER: builtins.int + CHANNEL_POINT_FIELD_NUMBER: builtins.int + CHAN_ID_FIELD_NUMBER: builtins.int + CAPACITY_FIELD_NUMBER: builtins.int + LOCAL_BALANCE_FIELD_NUMBER: builtins.int + REMOTE_BALANCE_FIELD_NUMBER: builtins.int + COMMIT_FEE_FIELD_NUMBER: builtins.int + COMMIT_WEIGHT_FIELD_NUMBER: builtins.int + FEE_PER_KW_FIELD_NUMBER: builtins.int + UNSETTLED_BALANCE_FIELD_NUMBER: builtins.int + TOTAL_SATOSHIS_SENT_FIELD_NUMBER: builtins.int + TOTAL_SATOSHIS_RECEIVED_FIELD_NUMBER: builtins.int + NUM_UPDATES_FIELD_NUMBER: builtins.int + PENDING_HTLCS_FIELD_NUMBER: builtins.int + CSV_DELAY_FIELD_NUMBER: builtins.int + PRIVATE_FIELD_NUMBER: builtins.int + INITIATOR_FIELD_NUMBER: builtins.int + CHAN_STATUS_FLAGS_FIELD_NUMBER: builtins.int + LOCAL_CHAN_RESERVE_SAT_FIELD_NUMBER: builtins.int + REMOTE_CHAN_RESERVE_SAT_FIELD_NUMBER: builtins.int + STATIC_REMOTE_KEY_FIELD_NUMBER: builtins.int + COMMITMENT_TYPE_FIELD_NUMBER: builtins.int + LIFETIME_FIELD_NUMBER: builtins.int + UPTIME_FIELD_NUMBER: builtins.int + CLOSE_ADDRESS_FIELD_NUMBER: builtins.int + PUSH_AMOUNT_SAT_FIELD_NUMBER: builtins.int + THAW_HEIGHT_FIELD_NUMBER: builtins.int + LOCAL_CONSTRAINTS_FIELD_NUMBER: builtins.int + REMOTE_CONSTRAINTS_FIELD_NUMBER: builtins.int + ALIAS_SCIDS_FIELD_NUMBER: builtins.int + ZERO_CONF_FIELD_NUMBER: builtins.int + ZERO_CONF_CONFIRMED_SCID_FIELD_NUMBER: builtins.int + PEER_ALIAS_FIELD_NUMBER: builtins.int + PEER_SCID_ALIAS_FIELD_NUMBER: builtins.int + MEMO_FIELD_NUMBER: builtins.int + active: builtins.bool + """Whether this channel is active or not""" + remote_pubkey: builtins.str + """The identity pubkey of the remote node""" + channel_point: builtins.str + """ + The outpoint (txid:index) of the funding transaction. With this value, Bob + will be able to generate a signature for Alice's version of the commitment + transaction. + """ + chan_id: builtins.int + """ + The unique channel ID for the channel. The first 3 bytes are the block + height, the next 3 the index within the block, and the last 2 bytes are the + output index for the channel. + """ + capacity: builtins.int + """The total amount of funds held in this channel""" + local_balance: builtins.int + """This node's current balance in this channel""" + remote_balance: builtins.int + """The counterparty's current balance in this channel""" + commit_fee: builtins.int + """ + The amount calculated to be paid in fees for the current set of commitment + transactions. The fee amount is persisted with the channel in order to + allow the fee amount to be removed and recalculated with each channel state + update, including updates that happen after a system restart. + """ + commit_weight: builtins.int + """The weight of the commitment transaction""" + fee_per_kw: builtins.int + """ + The required number of satoshis per kilo-weight that the requester will pay + at all times, for both the funding transaction and commitment transaction. + This value can later be updated once the channel is open. + """ + unsettled_balance: builtins.int + """The unsettled balance in this channel""" + total_satoshis_sent: builtins.int + """ + The total number of satoshis we've sent within this channel. + """ + total_satoshis_received: builtins.int + """ + The total number of satoshis we've received within this channel. + """ + num_updates: builtins.int + """ + The total number of updates conducted within this channel. + """ + csv_delay: builtins.int + """ + Deprecated. The CSV delay expressed in relative blocks. If the channel is + force closed, we will need to wait for this many blocks before we can regain + our funds. + """ + private: builtins.bool + """Whether this channel is advertised to the network or not.""" + initiator: builtins.bool + """True if we were the ones that created the channel.""" + chan_status_flags: builtins.str + """A set of flags showing the current state of the channel.""" + local_chan_reserve_sat: builtins.int + """Deprecated. The minimum satoshis this node is required to reserve in its + balance. + """ + remote_chan_reserve_sat: builtins.int + """ + Deprecated. The minimum satoshis the other node is required to reserve in + its balance. + """ + static_remote_key: builtins.bool + """Deprecated. Use commitment_type.""" + commitment_type: global___CommitmentType.ValueType + """The commitment type used by this channel.""" + lifetime: builtins.int + """ + The number of seconds that the channel has been monitored by the channel + scoring system. Scores are currently not persisted, so this value may be + less than the lifetime of the channel [EXPERIMENTAL]. + """ + uptime: builtins.int + """ + The number of seconds that the remote peer has been observed as being online + by the channel scoring system over the lifetime of the channel + [EXPERIMENTAL]. + """ + close_address: builtins.str + """ + Close address is the address that we will enforce payout to on cooperative + close if the channel was opened utilizing option upfront shutdown. This + value can be set on channel open by setting close_address in an open channel + request. If this value is not set, you can still choose a payout address by + cooperatively closing with the delivery_address field set. + """ + push_amount_sat: builtins.int + """ + The amount that the initiator of the channel optionally pushed to the remote + party on channel open. This amount will be zero if the channel initiator did + not push any funds to the remote peer. If the initiator field is true, we + pushed this amount to our peer, if it is false, the remote peer pushed this + amount to us. + """ + thaw_height: builtins.int + """ + This uint32 indicates if this channel is to be considered 'frozen'. A + frozen channel doest not allow a cooperative channel close by the + initiator. The thaw_height is the height that this restriction stops + applying to the channel. This field is optional, not setting it or using a + value of zero will mean the channel has no additional restrictions. The + height can be interpreted in two ways: as a relative height if the value is + less than 500,000, or as an absolute height otherwise. + """ + zero_conf: builtins.bool + """Whether or not this is a zero-conf channel.""" + zero_conf_confirmed_scid: builtins.int + """This is the confirmed / on-chain zero-conf SCID.""" + peer_alias: builtins.str + """The configured alias name of our peer.""" + peer_scid_alias: builtins.int + """This is the peer SCID alias.""" + memo: builtins.str + """ + An optional note-to-self to go along with the channel containing some + useful information. This is only ever stored locally and in no way impacts + the channel's operation. + """ + @property + def pending_htlcs(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___HTLC]: + """ + The list of active, uncleared HTLCs currently pending within the channel. + """ + + @property + def local_constraints(self) -> global___ChannelConstraints: + """List constraints for the local node.""" + + @property + def remote_constraints(self) -> global___ChannelConstraints: + """List constraints for the remote node.""" + + @property + def alias_scids(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.int]: + """ + This lists out the set of alias short channel ids that exist for a channel. + This may be empty. + """ + + def __init__( + self, + *, + active: builtins.bool = ..., + remote_pubkey: builtins.str = ..., + channel_point: builtins.str = ..., + chan_id: builtins.int = ..., + capacity: builtins.int = ..., + local_balance: builtins.int = ..., + remote_balance: builtins.int = ..., + commit_fee: builtins.int = ..., + commit_weight: builtins.int = ..., + fee_per_kw: builtins.int = ..., + unsettled_balance: builtins.int = ..., + total_satoshis_sent: builtins.int = ..., + total_satoshis_received: builtins.int = ..., + num_updates: builtins.int = ..., + pending_htlcs: collections.abc.Iterable[global___HTLC] | None = ..., + csv_delay: builtins.int = ..., + private: builtins.bool = ..., + initiator: builtins.bool = ..., + chan_status_flags: builtins.str = ..., + local_chan_reserve_sat: builtins.int = ..., + remote_chan_reserve_sat: builtins.int = ..., + static_remote_key: builtins.bool = ..., + commitment_type: global___CommitmentType.ValueType = ..., + lifetime: builtins.int = ..., + uptime: builtins.int = ..., + close_address: builtins.str = ..., + push_amount_sat: builtins.int = ..., + thaw_height: builtins.int = ..., + local_constraints: global___ChannelConstraints | None = ..., + remote_constraints: global___ChannelConstraints | None = ..., + alias_scids: collections.abc.Iterable[builtins.int] | None = ..., + zero_conf: builtins.bool = ..., + zero_conf_confirmed_scid: builtins.int = ..., + peer_alias: builtins.str = ..., + peer_scid_alias: builtins.int = ..., + memo: builtins.str = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["local_constraints", b"local_constraints", "remote_constraints", b"remote_constraints"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["active", b"active", "alias_scids", b"alias_scids", "capacity", b"capacity", "chan_id", b"chan_id", "chan_status_flags", b"chan_status_flags", "channel_point", b"channel_point", "close_address", b"close_address", "commit_fee", b"commit_fee", "commit_weight", b"commit_weight", "commitment_type", b"commitment_type", "csv_delay", b"csv_delay", "fee_per_kw", b"fee_per_kw", "initiator", b"initiator", "lifetime", b"lifetime", "local_balance", b"local_balance", "local_chan_reserve_sat", b"local_chan_reserve_sat", "local_constraints", b"local_constraints", "memo", b"memo", "num_updates", b"num_updates", "peer_alias", b"peer_alias", "peer_scid_alias", b"peer_scid_alias", "pending_htlcs", b"pending_htlcs", "private", b"private", "push_amount_sat", b"push_amount_sat", "remote_balance", b"remote_balance", "remote_chan_reserve_sat", b"remote_chan_reserve_sat", "remote_constraints", b"remote_constraints", "remote_pubkey", b"remote_pubkey", "static_remote_key", b"static_remote_key", "thaw_height", b"thaw_height", "total_satoshis_received", b"total_satoshis_received", "total_satoshis_sent", b"total_satoshis_sent", "unsettled_balance", b"unsettled_balance", "uptime", b"uptime", "zero_conf", b"zero_conf", "zero_conf_confirmed_scid", b"zero_conf_confirmed_scid"]) -> None: ... + +global___Channel = Channel + +@typing.final +class ListChannelsRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + ACTIVE_ONLY_FIELD_NUMBER: builtins.int + INACTIVE_ONLY_FIELD_NUMBER: builtins.int + PUBLIC_ONLY_FIELD_NUMBER: builtins.int + PRIVATE_ONLY_FIELD_NUMBER: builtins.int + PEER_FIELD_NUMBER: builtins.int + PEER_ALIAS_LOOKUP_FIELD_NUMBER: builtins.int + active_only: builtins.bool + inactive_only: builtins.bool + public_only: builtins.bool + private_only: builtins.bool + peer: builtins.bytes + """ + Filters the response for channels with a target peer's pubkey. If peer is + empty, all channels will be returned. + """ + peer_alias_lookup: builtins.bool + """Informs the server if the peer alias lookup per channel should be + enabled. It is turned off by default in order to avoid degradation of + performance for existing clients. + """ + def __init__( + self, + *, + active_only: builtins.bool = ..., + inactive_only: builtins.bool = ..., + public_only: builtins.bool = ..., + private_only: builtins.bool = ..., + peer: builtins.bytes = ..., + peer_alias_lookup: builtins.bool = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["active_only", b"active_only", "inactive_only", b"inactive_only", "peer", b"peer", "peer_alias_lookup", b"peer_alias_lookup", "private_only", b"private_only", "public_only", b"public_only"]) -> None: ... + +global___ListChannelsRequest = ListChannelsRequest + +@typing.final +class ListChannelsResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + CHANNELS_FIELD_NUMBER: builtins.int + @property + def channels(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___Channel]: + """The list of active channels""" + + def __init__( + self, + *, + channels: collections.abc.Iterable[global___Channel] | None = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["channels", b"channels"]) -> None: ... + +global___ListChannelsResponse = ListChannelsResponse + +@typing.final +class AliasMap(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + BASE_SCID_FIELD_NUMBER: builtins.int + ALIASES_FIELD_NUMBER: builtins.int + base_scid: builtins.int + """ + For non-zero-conf channels, this is the confirmed SCID. Otherwise, this is + the first assigned "base" alias. + """ + @property + def aliases(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.int]: + """The set of all aliases stored for the base SCID.""" + + def __init__( + self, + *, + base_scid: builtins.int = ..., + aliases: collections.abc.Iterable[builtins.int] | None = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["aliases", b"aliases", "base_scid", b"base_scid"]) -> None: ... + +global___AliasMap = AliasMap + +@typing.final +class ListAliasesRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +global___ListAliasesRequest = ListAliasesRequest + +@typing.final +class ListAliasesResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + ALIAS_MAPS_FIELD_NUMBER: builtins.int + @property + def alias_maps(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___AliasMap]: ... + def __init__( + self, + *, + alias_maps: collections.abc.Iterable[global___AliasMap] | None = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["alias_maps", b"alias_maps"]) -> None: ... + +global___ListAliasesResponse = ListAliasesResponse + +@typing.final +class ChannelCloseSummary(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + class _ClosureType: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + + class _ClosureTypeEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[ChannelCloseSummary._ClosureType.ValueType], builtins.type): # noqa: F821 + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + COOPERATIVE_CLOSE: ChannelCloseSummary._ClosureType.ValueType # 0 + LOCAL_FORCE_CLOSE: ChannelCloseSummary._ClosureType.ValueType # 1 + REMOTE_FORCE_CLOSE: ChannelCloseSummary._ClosureType.ValueType # 2 + BREACH_CLOSE: ChannelCloseSummary._ClosureType.ValueType # 3 + FUNDING_CANCELED: ChannelCloseSummary._ClosureType.ValueType # 4 + ABANDONED: ChannelCloseSummary._ClosureType.ValueType # 5 + + class ClosureType(_ClosureType, metaclass=_ClosureTypeEnumTypeWrapper): ... + COOPERATIVE_CLOSE: ChannelCloseSummary.ClosureType.ValueType # 0 + LOCAL_FORCE_CLOSE: ChannelCloseSummary.ClosureType.ValueType # 1 + REMOTE_FORCE_CLOSE: ChannelCloseSummary.ClosureType.ValueType # 2 + BREACH_CLOSE: ChannelCloseSummary.ClosureType.ValueType # 3 + FUNDING_CANCELED: ChannelCloseSummary.ClosureType.ValueType # 4 + ABANDONED: ChannelCloseSummary.ClosureType.ValueType # 5 + + CHANNEL_POINT_FIELD_NUMBER: builtins.int + CHAN_ID_FIELD_NUMBER: builtins.int + CHAIN_HASH_FIELD_NUMBER: builtins.int + CLOSING_TX_HASH_FIELD_NUMBER: builtins.int + REMOTE_PUBKEY_FIELD_NUMBER: builtins.int + CAPACITY_FIELD_NUMBER: builtins.int + CLOSE_HEIGHT_FIELD_NUMBER: builtins.int + SETTLED_BALANCE_FIELD_NUMBER: builtins.int + TIME_LOCKED_BALANCE_FIELD_NUMBER: builtins.int + CLOSE_TYPE_FIELD_NUMBER: builtins.int + OPEN_INITIATOR_FIELD_NUMBER: builtins.int + CLOSE_INITIATOR_FIELD_NUMBER: builtins.int + RESOLUTIONS_FIELD_NUMBER: builtins.int + ALIAS_SCIDS_FIELD_NUMBER: builtins.int + ZERO_CONF_CONFIRMED_SCID_FIELD_NUMBER: builtins.int + channel_point: builtins.str + """The outpoint (txid:index) of the funding transaction.""" + chan_id: builtins.int + """ The unique channel ID for the channel.""" + chain_hash: builtins.str + """The hash of the genesis block that this channel resides within.""" + closing_tx_hash: builtins.str + """The txid of the transaction which ultimately closed this channel.""" + remote_pubkey: builtins.str + """Public key of the remote peer that we formerly had a channel with.""" + capacity: builtins.int + """Total capacity of the channel.""" + close_height: builtins.int + """Height at which the funding transaction was spent.""" + settled_balance: builtins.int + """Settled balance at the time of channel closure""" + time_locked_balance: builtins.int + """The sum of all the time-locked outputs at the time of channel closure""" + close_type: global___ChannelCloseSummary.ClosureType.ValueType + """Details on how the channel was closed.""" + open_initiator: global___Initiator.ValueType + """ + Open initiator is the party that initiated opening the channel. Note that + this value may be unknown if the channel was closed before we migrated to + store open channel information after close. + """ + close_initiator: global___Initiator.ValueType + """ + Close initiator indicates which party initiated the close. This value will + be unknown for channels that were cooperatively closed before we started + tracking cooperative close initiators. Note that this indicates which party + initiated a close, and it is possible for both to initiate cooperative or + force closes, although only one party's close will be confirmed on chain. + """ + zero_conf_confirmed_scid: builtins.int + """ The confirmed SCID for a zero-conf channel.""" + @property + def resolutions(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___Resolution]: ... + @property + def alias_scids(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.int]: + """ + This lists out the set of alias short channel ids that existed for the + closed channel. This may be empty. + """ + + def __init__( + self, + *, + channel_point: builtins.str = ..., + chan_id: builtins.int = ..., + chain_hash: builtins.str = ..., + closing_tx_hash: builtins.str = ..., + remote_pubkey: builtins.str = ..., + capacity: builtins.int = ..., + close_height: builtins.int = ..., + settled_balance: builtins.int = ..., + time_locked_balance: builtins.int = ..., + close_type: global___ChannelCloseSummary.ClosureType.ValueType = ..., + open_initiator: global___Initiator.ValueType = ..., + close_initiator: global___Initiator.ValueType = ..., + resolutions: collections.abc.Iterable[global___Resolution] | None = ..., + alias_scids: collections.abc.Iterable[builtins.int] | None = ..., + zero_conf_confirmed_scid: builtins.int = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["alias_scids", b"alias_scids", "capacity", b"capacity", "chain_hash", b"chain_hash", "chan_id", b"chan_id", "channel_point", b"channel_point", "close_height", b"close_height", "close_initiator", b"close_initiator", "close_type", b"close_type", "closing_tx_hash", b"closing_tx_hash", "open_initiator", b"open_initiator", "remote_pubkey", b"remote_pubkey", "resolutions", b"resolutions", "settled_balance", b"settled_balance", "time_locked_balance", b"time_locked_balance", "zero_conf_confirmed_scid", b"zero_conf_confirmed_scid"]) -> None: ... + +global___ChannelCloseSummary = ChannelCloseSummary + +@typing.final +class Resolution(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + RESOLUTION_TYPE_FIELD_NUMBER: builtins.int + OUTCOME_FIELD_NUMBER: builtins.int + OUTPOINT_FIELD_NUMBER: builtins.int + AMOUNT_SAT_FIELD_NUMBER: builtins.int + SWEEP_TXID_FIELD_NUMBER: builtins.int + resolution_type: global___ResolutionType.ValueType + """The type of output we are resolving.""" + outcome: global___ResolutionOutcome.ValueType + """The outcome of our on chain action that resolved the outpoint.""" + amount_sat: builtins.int + """The amount that was claimed by the resolution.""" + sweep_txid: builtins.str + """The hex-encoded transaction ID of the sweep transaction that spent the + output. + """ + @property + def outpoint(self) -> global___OutPoint: + """The outpoint that was spent by the resolution.""" + + def __init__( + self, + *, + resolution_type: global___ResolutionType.ValueType = ..., + outcome: global___ResolutionOutcome.ValueType = ..., + outpoint: global___OutPoint | None = ..., + amount_sat: builtins.int = ..., + sweep_txid: builtins.str = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["outpoint", b"outpoint"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["amount_sat", b"amount_sat", "outcome", b"outcome", "outpoint", b"outpoint", "resolution_type", b"resolution_type", "sweep_txid", b"sweep_txid"]) -> None: ... + +global___Resolution = Resolution + +@typing.final +class ClosedChannelsRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + COOPERATIVE_FIELD_NUMBER: builtins.int + LOCAL_FORCE_FIELD_NUMBER: builtins.int + REMOTE_FORCE_FIELD_NUMBER: builtins.int + BREACH_FIELD_NUMBER: builtins.int + FUNDING_CANCELED_FIELD_NUMBER: builtins.int + ABANDONED_FIELD_NUMBER: builtins.int + cooperative: builtins.bool + local_force: builtins.bool + remote_force: builtins.bool + breach: builtins.bool + funding_canceled: builtins.bool + abandoned: builtins.bool + def __init__( + self, + *, + cooperative: builtins.bool = ..., + local_force: builtins.bool = ..., + remote_force: builtins.bool = ..., + breach: builtins.bool = ..., + funding_canceled: builtins.bool = ..., + abandoned: builtins.bool = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["abandoned", b"abandoned", "breach", b"breach", "cooperative", b"cooperative", "funding_canceled", b"funding_canceled", "local_force", b"local_force", "remote_force", b"remote_force"]) -> None: ... + +global___ClosedChannelsRequest = ClosedChannelsRequest + +@typing.final +class ClosedChannelsResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + CHANNELS_FIELD_NUMBER: builtins.int + @property + def channels(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___ChannelCloseSummary]: ... + def __init__( + self, + *, + channels: collections.abc.Iterable[global___ChannelCloseSummary] | None = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["channels", b"channels"]) -> None: ... + +global___ClosedChannelsResponse = ClosedChannelsResponse + +@typing.final +class Peer(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + class _SyncType: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + + class _SyncTypeEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[Peer._SyncType.ValueType], builtins.type): # noqa: F821 + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + UNKNOWN_SYNC: Peer._SyncType.ValueType # 0 + """ + Denotes that we cannot determine the peer's current sync type. + """ + ACTIVE_SYNC: Peer._SyncType.ValueType # 1 + """ + Denotes that we are actively receiving new graph updates from the peer. + """ + PASSIVE_SYNC: Peer._SyncType.ValueType # 2 + """ + Denotes that we are not receiving new graph updates from the peer. + """ + PINNED_SYNC: Peer._SyncType.ValueType # 3 + """ + Denotes that this peer is pinned into an active sync. + """ + + class SyncType(_SyncType, metaclass=_SyncTypeEnumTypeWrapper): ... + UNKNOWN_SYNC: Peer.SyncType.ValueType # 0 + """ + Denotes that we cannot determine the peer's current sync type. + """ + ACTIVE_SYNC: Peer.SyncType.ValueType # 1 + """ + Denotes that we are actively receiving new graph updates from the peer. + """ + PASSIVE_SYNC: Peer.SyncType.ValueType # 2 + """ + Denotes that we are not receiving new graph updates from the peer. + """ + PINNED_SYNC: Peer.SyncType.ValueType # 3 + """ + Denotes that this peer is pinned into an active sync. + """ + + @typing.final + class FeaturesEntry(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + KEY_FIELD_NUMBER: builtins.int + VALUE_FIELD_NUMBER: builtins.int + key: builtins.int + @property + def value(self) -> global___Feature: ... + def __init__( + self, + *, + key: builtins.int = ..., + value: global___Feature | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["value", b"value"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["key", b"key", "value", b"value"]) -> None: ... + + PUB_KEY_FIELD_NUMBER: builtins.int + ADDRESS_FIELD_NUMBER: builtins.int + BYTES_SENT_FIELD_NUMBER: builtins.int + BYTES_RECV_FIELD_NUMBER: builtins.int + SAT_SENT_FIELD_NUMBER: builtins.int + SAT_RECV_FIELD_NUMBER: builtins.int + INBOUND_FIELD_NUMBER: builtins.int + PING_TIME_FIELD_NUMBER: builtins.int + SYNC_TYPE_FIELD_NUMBER: builtins.int + FEATURES_FIELD_NUMBER: builtins.int + ERRORS_FIELD_NUMBER: builtins.int + FLAP_COUNT_FIELD_NUMBER: builtins.int + LAST_FLAP_NS_FIELD_NUMBER: builtins.int + LAST_PING_PAYLOAD_FIELD_NUMBER: builtins.int + pub_key: builtins.str + """The identity pubkey of the peer""" + address: builtins.str + """Network address of the peer; eg `127.0.0.1:10011`""" + bytes_sent: builtins.int + """Bytes of data transmitted to this peer""" + bytes_recv: builtins.int + """Bytes of data transmitted from this peer""" + sat_sent: builtins.int + """Satoshis sent to this peer""" + sat_recv: builtins.int + """Satoshis received from this peer""" + inbound: builtins.bool + """A channel is inbound if the counterparty initiated the channel""" + ping_time: builtins.int + """Ping time to this peer""" + sync_type: global___Peer.SyncType.ValueType + """The type of sync we are currently performing with this peer.""" + flap_count: builtins.int + """ + The number of times we have recorded this peer going offline or coming + online, recorded across restarts. Note that this value is decreased over + time if the peer has not recently flapped, so that we can forgive peers + with historically high flap counts. + """ + last_flap_ns: builtins.int + """ + The timestamp of the last flap we observed for this peer. If this value is + zero, we have not observed any flaps for this peer. + """ + last_ping_payload: builtins.bytes + """ + The last ping payload the peer has sent to us. + """ + @property + def features(self) -> google.protobuf.internal.containers.MessageMap[builtins.int, global___Feature]: + """Features advertised by the remote peer in their init message.""" + + @property + def errors(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___TimestampedError]: + """ + The latest errors received from our peer with timestamps, limited to the 10 + most recent errors. These errors are tracked across peer connections, but + are not persisted across lnd restarts. Note that these errors are only + stored for peers that we have channels open with, to prevent peers from + spamming us with errors at no cost. + """ + + def __init__( + self, + *, + pub_key: builtins.str = ..., + address: builtins.str = ..., + bytes_sent: builtins.int = ..., + bytes_recv: builtins.int = ..., + sat_sent: builtins.int = ..., + sat_recv: builtins.int = ..., + inbound: builtins.bool = ..., + ping_time: builtins.int = ..., + sync_type: global___Peer.SyncType.ValueType = ..., + features: collections.abc.Mapping[builtins.int, global___Feature] | None = ..., + errors: collections.abc.Iterable[global___TimestampedError] | None = ..., + flap_count: builtins.int = ..., + last_flap_ns: builtins.int = ..., + last_ping_payload: builtins.bytes = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["address", b"address", "bytes_recv", b"bytes_recv", "bytes_sent", b"bytes_sent", "errors", b"errors", "features", b"features", "flap_count", b"flap_count", "inbound", b"inbound", "last_flap_ns", b"last_flap_ns", "last_ping_payload", b"last_ping_payload", "ping_time", b"ping_time", "pub_key", b"pub_key", "sat_recv", b"sat_recv", "sat_sent", b"sat_sent", "sync_type", b"sync_type"]) -> None: ... + +global___Peer = Peer + +@typing.final +class TimestampedError(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + TIMESTAMP_FIELD_NUMBER: builtins.int + ERROR_FIELD_NUMBER: builtins.int + timestamp: builtins.int + """The unix timestamp in seconds when the error occurred.""" + error: builtins.str + """The string representation of the error sent by our peer.""" + def __init__( + self, + *, + timestamp: builtins.int = ..., + error: builtins.str = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["error", b"error", "timestamp", b"timestamp"]) -> None: ... + +global___TimestampedError = TimestampedError + +@typing.final +class ListPeersRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + LATEST_ERROR_FIELD_NUMBER: builtins.int + latest_error: builtins.bool + """ + If true, only the last error that our peer sent us will be returned with + the peer's information, rather than the full set of historic errors we have + stored. + """ + def __init__( + self, + *, + latest_error: builtins.bool = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["latest_error", b"latest_error"]) -> None: ... + +global___ListPeersRequest = ListPeersRequest + +@typing.final +class ListPeersResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + PEERS_FIELD_NUMBER: builtins.int + @property + def peers(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___Peer]: + """The list of currently connected peers""" + + def __init__( + self, + *, + peers: collections.abc.Iterable[global___Peer] | None = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["peers", b"peers"]) -> None: ... + +global___ListPeersResponse = ListPeersResponse + +@typing.final +class PeerEventSubscription(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +global___PeerEventSubscription = PeerEventSubscription + +@typing.final +class PeerEvent(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + class _EventType: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + + class _EventTypeEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[PeerEvent._EventType.ValueType], builtins.type): # noqa: F821 + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + PEER_ONLINE: PeerEvent._EventType.ValueType # 0 + PEER_OFFLINE: PeerEvent._EventType.ValueType # 1 + + class EventType(_EventType, metaclass=_EventTypeEnumTypeWrapper): ... + PEER_ONLINE: PeerEvent.EventType.ValueType # 0 + PEER_OFFLINE: PeerEvent.EventType.ValueType # 1 + + PUB_KEY_FIELD_NUMBER: builtins.int + TYPE_FIELD_NUMBER: builtins.int + pub_key: builtins.str + """The identity pubkey of the peer.""" + type: global___PeerEvent.EventType.ValueType + def __init__( + self, + *, + pub_key: builtins.str = ..., + type: global___PeerEvent.EventType.ValueType = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["pub_key", b"pub_key", "type", b"type"]) -> None: ... + +global___PeerEvent = PeerEvent + +@typing.final +class GetInfoRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +global___GetInfoRequest = GetInfoRequest + +@typing.final +class GetInfoResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + @typing.final + class FeaturesEntry(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + KEY_FIELD_NUMBER: builtins.int + VALUE_FIELD_NUMBER: builtins.int + key: builtins.int + @property + def value(self) -> global___Feature: ... + def __init__( + self, + *, + key: builtins.int = ..., + value: global___Feature | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["value", b"value"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["key", b"key", "value", b"value"]) -> None: ... + + VERSION_FIELD_NUMBER: builtins.int + COMMIT_HASH_FIELD_NUMBER: builtins.int + IDENTITY_PUBKEY_FIELD_NUMBER: builtins.int + ALIAS_FIELD_NUMBER: builtins.int + COLOR_FIELD_NUMBER: builtins.int + NUM_PENDING_CHANNELS_FIELD_NUMBER: builtins.int + NUM_ACTIVE_CHANNELS_FIELD_NUMBER: builtins.int + NUM_INACTIVE_CHANNELS_FIELD_NUMBER: builtins.int + NUM_PEERS_FIELD_NUMBER: builtins.int + BLOCK_HEIGHT_FIELD_NUMBER: builtins.int + BLOCK_HASH_FIELD_NUMBER: builtins.int + BEST_HEADER_TIMESTAMP_FIELD_NUMBER: builtins.int + SYNCED_TO_CHAIN_FIELD_NUMBER: builtins.int + SYNCED_TO_GRAPH_FIELD_NUMBER: builtins.int + TESTNET_FIELD_NUMBER: builtins.int + CHAINS_FIELD_NUMBER: builtins.int + URIS_FIELD_NUMBER: builtins.int + FEATURES_FIELD_NUMBER: builtins.int + REQUIRE_HTLC_INTERCEPTOR_FIELD_NUMBER: builtins.int + STORE_FINAL_HTLC_RESOLUTIONS_FIELD_NUMBER: builtins.int + version: builtins.str + """The version of the LND software that the node is running.""" + commit_hash: builtins.str + """The SHA1 commit hash that the daemon is compiled with.""" + identity_pubkey: builtins.str + """The identity pubkey of the current node.""" + alias: builtins.str + """If applicable, the alias of the current node, e.g. "bob" """ + color: builtins.str + """The color of the current node in hex code format""" + num_pending_channels: builtins.int + """Number of pending channels""" + num_active_channels: builtins.int + """Number of active channels""" + num_inactive_channels: builtins.int + """Number of inactive channels""" + num_peers: builtins.int + """Number of peers""" + block_height: builtins.int + """The node's current view of the height of the best block""" + block_hash: builtins.str + """The node's current view of the hash of the best block""" + best_header_timestamp: builtins.int + """Timestamp of the block best known to the wallet""" + synced_to_chain: builtins.bool + """Whether the wallet's view is synced to the main chain""" + synced_to_graph: builtins.bool + """Whether we consider ourselves synced with the public channel graph.""" + testnet: builtins.bool + """ + Whether the current node is connected to testnet. This field is + deprecated and the network field should be used instead + """ + require_htlc_interceptor: builtins.bool + """ + Indicates whether the HTLC interceptor API is in always-on mode. + """ + store_final_htlc_resolutions: builtins.bool + """Indicates whether final htlc resolutions are stored on disk.""" + @property + def chains(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___Chain]: + """ + A list of active chains the node is connected to. This will only + ever contain a single entry since LND will only ever have a single + chain backend during its lifetime. + """ + + @property + def uris(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.str]: + """The URIs of the current node.""" + + @property + def features(self) -> google.protobuf.internal.containers.MessageMap[builtins.int, global___Feature]: + """ + Features that our node has advertised in our init message, node + announcements and invoices. + """ + + def __init__( + self, + *, + version: builtins.str = ..., + commit_hash: builtins.str = ..., + identity_pubkey: builtins.str = ..., + alias: builtins.str = ..., + color: builtins.str = ..., + num_pending_channels: builtins.int = ..., + num_active_channels: builtins.int = ..., + num_inactive_channels: builtins.int = ..., + num_peers: builtins.int = ..., + block_height: builtins.int = ..., + block_hash: builtins.str = ..., + best_header_timestamp: builtins.int = ..., + synced_to_chain: builtins.bool = ..., + synced_to_graph: builtins.bool = ..., + testnet: builtins.bool = ..., + chains: collections.abc.Iterable[global___Chain] | None = ..., + uris: collections.abc.Iterable[builtins.str] | None = ..., + features: collections.abc.Mapping[builtins.int, global___Feature] | None = ..., + require_htlc_interceptor: builtins.bool = ..., + store_final_htlc_resolutions: builtins.bool = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["alias", b"alias", "best_header_timestamp", b"best_header_timestamp", "block_hash", b"block_hash", "block_height", b"block_height", "chains", b"chains", "color", b"color", "commit_hash", b"commit_hash", "features", b"features", "identity_pubkey", b"identity_pubkey", "num_active_channels", b"num_active_channels", "num_inactive_channels", b"num_inactive_channels", "num_peers", b"num_peers", "num_pending_channels", b"num_pending_channels", "require_htlc_interceptor", b"require_htlc_interceptor", "store_final_htlc_resolutions", b"store_final_htlc_resolutions", "synced_to_chain", b"synced_to_chain", "synced_to_graph", b"synced_to_graph", "testnet", b"testnet", "uris", b"uris", "version", b"version"]) -> None: ... + +global___GetInfoResponse = GetInfoResponse + +@typing.final +class GetDebugInfoRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +global___GetDebugInfoRequest = GetDebugInfoRequest + +@typing.final +class GetDebugInfoResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + @typing.final + class ConfigEntry(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + KEY_FIELD_NUMBER: builtins.int + VALUE_FIELD_NUMBER: builtins.int + key: builtins.str + value: builtins.str + def __init__( + self, + *, + key: builtins.str = ..., + value: builtins.str = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["key", b"key", "value", b"value"]) -> None: ... + + CONFIG_FIELD_NUMBER: builtins.int + LOG_FIELD_NUMBER: builtins.int + @property + def config(self) -> google.protobuf.internal.containers.ScalarMap[builtins.str, builtins.str]: ... + @property + def log(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.str]: ... + def __init__( + self, + *, + config: collections.abc.Mapping[builtins.str, builtins.str] | None = ..., + log: collections.abc.Iterable[builtins.str] | None = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["config", b"config", "log", b"log"]) -> None: ... + +global___GetDebugInfoResponse = GetDebugInfoResponse + +@typing.final +class GetRecoveryInfoRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +global___GetRecoveryInfoRequest = GetRecoveryInfoRequest + +@typing.final +class GetRecoveryInfoResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + RECOVERY_MODE_FIELD_NUMBER: builtins.int + RECOVERY_FINISHED_FIELD_NUMBER: builtins.int + PROGRESS_FIELD_NUMBER: builtins.int + recovery_mode: builtins.bool + """Whether the wallet is in recovery mode""" + recovery_finished: builtins.bool + """Whether the wallet recovery progress is finished""" + progress: builtins.float + """The recovery progress, ranging from 0 to 1.""" + def __init__( + self, + *, + recovery_mode: builtins.bool = ..., + recovery_finished: builtins.bool = ..., + progress: builtins.float = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["progress", b"progress", "recovery_finished", b"recovery_finished", "recovery_mode", b"recovery_mode"]) -> None: ... + +global___GetRecoveryInfoResponse = GetRecoveryInfoResponse + +@typing.final +class Chain(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + CHAIN_FIELD_NUMBER: builtins.int + NETWORK_FIELD_NUMBER: builtins.int + chain: builtins.str + """Deprecated. The chain is now always assumed to be bitcoin. + The blockchain the node is on (must be bitcoin) + """ + network: builtins.str + """The network the node is on (eg regtest, testnet, mainnet)""" + def __init__( + self, + *, + chain: builtins.str = ..., + network: builtins.str = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["chain", b"chain", "network", b"network"]) -> None: ... + +global___Chain = Chain + +@typing.final +class ConfirmationUpdate(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + BLOCK_SHA_FIELD_NUMBER: builtins.int + BLOCK_HEIGHT_FIELD_NUMBER: builtins.int + NUM_CONFS_LEFT_FIELD_NUMBER: builtins.int + block_sha: builtins.bytes + block_height: builtins.int + num_confs_left: builtins.int + def __init__( + self, + *, + block_sha: builtins.bytes = ..., + block_height: builtins.int = ..., + num_confs_left: builtins.int = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["block_height", b"block_height", "block_sha", b"block_sha", "num_confs_left", b"num_confs_left"]) -> None: ... + +global___ConfirmationUpdate = ConfirmationUpdate + +@typing.final +class ChannelOpenUpdate(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + CHANNEL_POINT_FIELD_NUMBER: builtins.int + @property + def channel_point(self) -> global___ChannelPoint: ... + def __init__( + self, + *, + channel_point: global___ChannelPoint | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["channel_point", b"channel_point"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["channel_point", b"channel_point"]) -> None: ... + +global___ChannelOpenUpdate = ChannelOpenUpdate + +@typing.final +class ChannelCloseUpdate(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + CLOSING_TXID_FIELD_NUMBER: builtins.int + SUCCESS_FIELD_NUMBER: builtins.int + closing_txid: builtins.bytes + success: builtins.bool + def __init__( + self, + *, + closing_txid: builtins.bytes = ..., + success: builtins.bool = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["closing_txid", b"closing_txid", "success", b"success"]) -> None: ... + +global___ChannelCloseUpdate = ChannelCloseUpdate + +@typing.final +class CloseChannelRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + CHANNEL_POINT_FIELD_NUMBER: builtins.int + FORCE_FIELD_NUMBER: builtins.int + TARGET_CONF_FIELD_NUMBER: builtins.int + SAT_PER_BYTE_FIELD_NUMBER: builtins.int + DELIVERY_ADDRESS_FIELD_NUMBER: builtins.int + SAT_PER_VBYTE_FIELD_NUMBER: builtins.int + MAX_FEE_PER_VBYTE_FIELD_NUMBER: builtins.int + NO_WAIT_FIELD_NUMBER: builtins.int + force: builtins.bool + """If true, then the channel will be closed forcibly. This means the + current commitment transaction will be signed and broadcast. + """ + target_conf: builtins.int + """The target number of blocks that the closure transaction should be + confirmed by. + """ + sat_per_byte: builtins.int + """Deprecated, use sat_per_vbyte. + A manual fee rate set in sat/vbyte that should be used when crafting the + closure transaction. + """ + delivery_address: builtins.str + """ + An optional address to send funds to in the case of a cooperative close. + If the channel was opened with an upfront shutdown script and this field + is set, the request to close will fail because the channel must pay out + to the upfront shutdown addresss. + """ + sat_per_vbyte: builtins.int + """A manual fee rate set in sat/vbyte that should be used when crafting the + closure transaction. + """ + max_fee_per_vbyte: builtins.int + """The maximum fee rate the closer is willing to pay. + + NOTE: This field is only respected if we're the initiator of the channel. + """ + no_wait: builtins.bool + """If true, then the rpc call will not block while it awaits a closing txid. + Consequently this RPC call will not return a closing txid if this value + is set. + """ + @property + def channel_point(self) -> global___ChannelPoint: + """ + The outpoint (txid:index) of the funding transaction. With this value, Bob + will be able to generate a signature for Alice's version of the commitment + transaction. + """ + + def __init__( + self, + *, + channel_point: global___ChannelPoint | None = ..., + force: builtins.bool = ..., + target_conf: builtins.int = ..., + sat_per_byte: builtins.int = ..., + delivery_address: builtins.str = ..., + sat_per_vbyte: builtins.int = ..., + max_fee_per_vbyte: builtins.int = ..., + no_wait: builtins.bool = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["channel_point", b"channel_point"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["channel_point", b"channel_point", "delivery_address", b"delivery_address", "force", b"force", "max_fee_per_vbyte", b"max_fee_per_vbyte", "no_wait", b"no_wait", "sat_per_byte", b"sat_per_byte", "sat_per_vbyte", b"sat_per_vbyte", "target_conf", b"target_conf"]) -> None: ... + +global___CloseChannelRequest = CloseChannelRequest + +@typing.final +class CloseStatusUpdate(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + CLOSE_PENDING_FIELD_NUMBER: builtins.int + CHAN_CLOSE_FIELD_NUMBER: builtins.int + CLOSE_INSTANT_FIELD_NUMBER: builtins.int + @property + def close_pending(self) -> global___PendingUpdate: ... + @property + def chan_close(self) -> global___ChannelCloseUpdate: ... + @property + def close_instant(self) -> global___InstantUpdate: ... + def __init__( + self, + *, + close_pending: global___PendingUpdate | None = ..., + chan_close: global___ChannelCloseUpdate | None = ..., + close_instant: global___InstantUpdate | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["chan_close", b"chan_close", "close_instant", b"close_instant", "close_pending", b"close_pending", "update", b"update"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["chan_close", b"chan_close", "close_instant", b"close_instant", "close_pending", b"close_pending", "update", b"update"]) -> None: ... + def WhichOneof(self, oneof_group: typing.Literal["update", b"update"]) -> typing.Literal["close_pending", "chan_close", "close_instant"] | None: ... + +global___CloseStatusUpdate = CloseStatusUpdate + +@typing.final +class PendingUpdate(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + TXID_FIELD_NUMBER: builtins.int + OUTPUT_INDEX_FIELD_NUMBER: builtins.int + txid: builtins.bytes + output_index: builtins.int + def __init__( + self, + *, + txid: builtins.bytes = ..., + output_index: builtins.int = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["output_index", b"output_index", "txid", b"txid"]) -> None: ... + +global___PendingUpdate = PendingUpdate + +@typing.final +class InstantUpdate(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +global___InstantUpdate = InstantUpdate + +@typing.final +class ReadyForPsbtFunding(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + FUNDING_ADDRESS_FIELD_NUMBER: builtins.int + FUNDING_AMOUNT_FIELD_NUMBER: builtins.int + PSBT_FIELD_NUMBER: builtins.int + funding_address: builtins.str + """ + The P2WSH address of the channel funding multisig address that the below + specified amount in satoshis needs to be sent to. + """ + funding_amount: builtins.int + """ + The exact amount in satoshis that needs to be sent to the above address to + fund the pending channel. + """ + psbt: builtins.bytes + """ + A raw PSBT that contains the pending channel output. If a base PSBT was + provided in the PsbtShim, this is the base PSBT with one additional output. + If no base PSBT was specified, this is an otherwise empty PSBT with exactly + one output. + """ + def __init__( + self, + *, + funding_address: builtins.str = ..., + funding_amount: builtins.int = ..., + psbt: builtins.bytes = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["funding_address", b"funding_address", "funding_amount", b"funding_amount", "psbt", b"psbt"]) -> None: ... + +global___ReadyForPsbtFunding = ReadyForPsbtFunding + +@typing.final +class BatchOpenChannelRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + CHANNELS_FIELD_NUMBER: builtins.int + TARGET_CONF_FIELD_NUMBER: builtins.int + SAT_PER_VBYTE_FIELD_NUMBER: builtins.int + MIN_CONFS_FIELD_NUMBER: builtins.int + SPEND_UNCONFIRMED_FIELD_NUMBER: builtins.int + LABEL_FIELD_NUMBER: builtins.int + COIN_SELECTION_STRATEGY_FIELD_NUMBER: builtins.int + target_conf: builtins.int + """The target number of blocks that the funding transaction should be + confirmed by. + """ + sat_per_vbyte: builtins.int + """A manual fee rate set in sat/vByte that should be used when crafting the + funding transaction. + """ + min_confs: builtins.int + """The minimum number of confirmations each one of your outputs used for + the funding transaction must satisfy. + """ + spend_unconfirmed: builtins.bool + """Whether unconfirmed outputs should be used as inputs for the funding + transaction. + """ + label: builtins.str + """An optional label for the batch transaction, limited to 500 characters.""" + coin_selection_strategy: global___CoinSelectionStrategy.ValueType + """The strategy to use for selecting coins during batch opening channels.""" + @property + def channels(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___BatchOpenChannel]: + """The list of channels to open.""" + + def __init__( + self, + *, + channels: collections.abc.Iterable[global___BatchOpenChannel] | None = ..., + target_conf: builtins.int = ..., + sat_per_vbyte: builtins.int = ..., + min_confs: builtins.int = ..., + spend_unconfirmed: builtins.bool = ..., + label: builtins.str = ..., + coin_selection_strategy: global___CoinSelectionStrategy.ValueType = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["channels", b"channels", "coin_selection_strategy", b"coin_selection_strategy", "label", b"label", "min_confs", b"min_confs", "sat_per_vbyte", b"sat_per_vbyte", "spend_unconfirmed", b"spend_unconfirmed", "target_conf", b"target_conf"]) -> None: ... + +global___BatchOpenChannelRequest = BatchOpenChannelRequest + +@typing.final +class BatchOpenChannel(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + NODE_PUBKEY_FIELD_NUMBER: builtins.int + LOCAL_FUNDING_AMOUNT_FIELD_NUMBER: builtins.int + PUSH_SAT_FIELD_NUMBER: builtins.int + PRIVATE_FIELD_NUMBER: builtins.int + MIN_HTLC_MSAT_FIELD_NUMBER: builtins.int + REMOTE_CSV_DELAY_FIELD_NUMBER: builtins.int + CLOSE_ADDRESS_FIELD_NUMBER: builtins.int + PENDING_CHAN_ID_FIELD_NUMBER: builtins.int + COMMITMENT_TYPE_FIELD_NUMBER: builtins.int + REMOTE_MAX_VALUE_IN_FLIGHT_MSAT_FIELD_NUMBER: builtins.int + REMOTE_MAX_HTLCS_FIELD_NUMBER: builtins.int + MAX_LOCAL_CSV_FIELD_NUMBER: builtins.int + ZERO_CONF_FIELD_NUMBER: builtins.int + SCID_ALIAS_FIELD_NUMBER: builtins.int + BASE_FEE_FIELD_NUMBER: builtins.int + FEE_RATE_FIELD_NUMBER: builtins.int + USE_BASE_FEE_FIELD_NUMBER: builtins.int + USE_FEE_RATE_FIELD_NUMBER: builtins.int + REMOTE_CHAN_RESERVE_SAT_FIELD_NUMBER: builtins.int + MEMO_FIELD_NUMBER: builtins.int + node_pubkey: builtins.bytes + """The pubkey of the node to open a channel with. When using REST, this + field must be encoded as base64. + """ + local_funding_amount: builtins.int + """The number of satoshis the wallet should commit to the channel.""" + push_sat: builtins.int + """The number of satoshis to push to the remote side as part of the initial + commitment state. + """ + private: builtins.bool + """Whether this channel should be private, not announced to the greater + network. + """ + min_htlc_msat: builtins.int + """The minimum value in millisatoshi we will require for incoming HTLCs on + the channel. + """ + remote_csv_delay: builtins.int + """The delay we require on the remote's commitment transaction. If this is + not set, it will be scaled automatically with the channel size. + """ + close_address: builtins.str + """ + Close address is an optional address which specifies the address to which + funds should be paid out to upon cooperative close. This field may only be + set if the peer supports the option upfront feature bit (call listpeers + to check). The remote peer will only accept cooperative closes to this + address if it is set. + + Note: If this value is set on channel creation, you will *not* be able to + cooperatively close out to a different address. + """ + pending_chan_id: builtins.bytes + """ + An optional, unique identifier of 32 random bytes that will be used as the + pending channel ID to identify the channel while it is in the pre-pending + state. + """ + commitment_type: global___CommitmentType.ValueType + """ + The explicit commitment type to use. Note this field will only be used if + the remote peer supports explicit channel negotiation. + """ + remote_max_value_in_flight_msat: builtins.int + """ + The maximum amount of coins in millisatoshi that can be pending within + the channel. It only applies to the remote party. + """ + remote_max_htlcs: builtins.int + """ + The maximum number of concurrent HTLCs we will allow the remote party to add + to the commitment transaction. + """ + max_local_csv: builtins.int + """ + Max local csv is the maximum csv delay we will allow for our own commitment + transaction. + """ + zero_conf: builtins.bool + """ + If this is true, then a zero-conf channel open will be attempted. + """ + scid_alias: builtins.bool + """ + If this is true, then an option-scid-alias channel-type open will be + attempted. + """ + base_fee: builtins.int + """ + The base fee charged regardless of the number of milli-satoshis sent. + """ + fee_rate: builtins.int + """ + The fee rate in ppm (parts per million) that will be charged in + proportion of the value of each forwarded HTLC. + """ + use_base_fee: builtins.bool + """ + If use_base_fee is true the open channel announcement will update the + channel base fee with the value specified in base_fee. In the case of + a base_fee of 0 use_base_fee is needed downstream to distinguish whether + to use the default base fee value specified in the config or 0. + """ + use_fee_rate: builtins.bool + """ + If use_fee_rate is true the open channel announcement will update the + channel fee rate with the value specified in fee_rate. In the case of + a fee_rate of 0 use_fee_rate is needed downstream to distinguish whether + to use the default fee rate value specified in the config or 0. + """ + remote_chan_reserve_sat: builtins.int + """ + The number of satoshis we require the remote peer to reserve. This value, + if specified, must be above the dust limit and below 20% of the channel + capacity. + """ + memo: builtins.str + """ + An optional note-to-self to go along with the channel containing some + useful information. This is only ever stored locally and in no way impacts + the channel's operation. + """ + def __init__( + self, + *, + node_pubkey: builtins.bytes = ..., + local_funding_amount: builtins.int = ..., + push_sat: builtins.int = ..., + private: builtins.bool = ..., + min_htlc_msat: builtins.int = ..., + remote_csv_delay: builtins.int = ..., + close_address: builtins.str = ..., + pending_chan_id: builtins.bytes = ..., + commitment_type: global___CommitmentType.ValueType = ..., + remote_max_value_in_flight_msat: builtins.int = ..., + remote_max_htlcs: builtins.int = ..., + max_local_csv: builtins.int = ..., + zero_conf: builtins.bool = ..., + scid_alias: builtins.bool = ..., + base_fee: builtins.int = ..., + fee_rate: builtins.int = ..., + use_base_fee: builtins.bool = ..., + use_fee_rate: builtins.bool = ..., + remote_chan_reserve_sat: builtins.int = ..., + memo: builtins.str = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["base_fee", b"base_fee", "close_address", b"close_address", "commitment_type", b"commitment_type", "fee_rate", b"fee_rate", "local_funding_amount", b"local_funding_amount", "max_local_csv", b"max_local_csv", "memo", b"memo", "min_htlc_msat", b"min_htlc_msat", "node_pubkey", b"node_pubkey", "pending_chan_id", b"pending_chan_id", "private", b"private", "push_sat", b"push_sat", "remote_chan_reserve_sat", b"remote_chan_reserve_sat", "remote_csv_delay", b"remote_csv_delay", "remote_max_htlcs", b"remote_max_htlcs", "remote_max_value_in_flight_msat", b"remote_max_value_in_flight_msat", "scid_alias", b"scid_alias", "use_base_fee", b"use_base_fee", "use_fee_rate", b"use_fee_rate", "zero_conf", b"zero_conf"]) -> None: ... + +global___BatchOpenChannel = BatchOpenChannel + +@typing.final +class BatchOpenChannelResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + PENDING_CHANNELS_FIELD_NUMBER: builtins.int + @property + def pending_channels(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___PendingUpdate]: ... + def __init__( + self, + *, + pending_channels: collections.abc.Iterable[global___PendingUpdate] | None = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["pending_channels", b"pending_channels"]) -> None: ... + +global___BatchOpenChannelResponse = BatchOpenChannelResponse + +@typing.final +class OpenChannelRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + SAT_PER_VBYTE_FIELD_NUMBER: builtins.int + NODE_PUBKEY_FIELD_NUMBER: builtins.int + NODE_PUBKEY_STRING_FIELD_NUMBER: builtins.int + LOCAL_FUNDING_AMOUNT_FIELD_NUMBER: builtins.int + PUSH_SAT_FIELD_NUMBER: builtins.int + TARGET_CONF_FIELD_NUMBER: builtins.int + SAT_PER_BYTE_FIELD_NUMBER: builtins.int + PRIVATE_FIELD_NUMBER: builtins.int + MIN_HTLC_MSAT_FIELD_NUMBER: builtins.int + REMOTE_CSV_DELAY_FIELD_NUMBER: builtins.int + MIN_CONFS_FIELD_NUMBER: builtins.int + SPEND_UNCONFIRMED_FIELD_NUMBER: builtins.int + CLOSE_ADDRESS_FIELD_NUMBER: builtins.int + FUNDING_SHIM_FIELD_NUMBER: builtins.int + REMOTE_MAX_VALUE_IN_FLIGHT_MSAT_FIELD_NUMBER: builtins.int + REMOTE_MAX_HTLCS_FIELD_NUMBER: builtins.int + MAX_LOCAL_CSV_FIELD_NUMBER: builtins.int + COMMITMENT_TYPE_FIELD_NUMBER: builtins.int + ZERO_CONF_FIELD_NUMBER: builtins.int + SCID_ALIAS_FIELD_NUMBER: builtins.int + BASE_FEE_FIELD_NUMBER: builtins.int + FEE_RATE_FIELD_NUMBER: builtins.int + USE_BASE_FEE_FIELD_NUMBER: builtins.int + USE_FEE_RATE_FIELD_NUMBER: builtins.int + REMOTE_CHAN_RESERVE_SAT_FIELD_NUMBER: builtins.int + FUND_MAX_FIELD_NUMBER: builtins.int + MEMO_FIELD_NUMBER: builtins.int + OUTPOINTS_FIELD_NUMBER: builtins.int + sat_per_vbyte: builtins.int + """A manual fee rate set in sat/vbyte that should be used when crafting the + funding transaction. + """ + node_pubkey: builtins.bytes + """ + The pubkey of the node to open a channel with. When using REST, this field + must be encoded as base64. + """ + node_pubkey_string: builtins.str + """ + The hex encoded pubkey of the node to open a channel with. Deprecated now + that the REST gateway supports base64 encoding of bytes fields. + """ + local_funding_amount: builtins.int + """The number of satoshis the wallet should commit to the channel""" + push_sat: builtins.int + """The number of satoshis to push to the remote side as part of the initial + commitment state + """ + target_conf: builtins.int + """The target number of blocks that the funding transaction should be + confirmed by. + """ + sat_per_byte: builtins.int + """Deprecated, use sat_per_vbyte. + A manual fee rate set in sat/vbyte that should be used when crafting the + funding transaction. + """ + private: builtins.bool + """Whether this channel should be private, not announced to the greater + network. + """ + min_htlc_msat: builtins.int + """The minimum value in millisatoshi we will require for incoming HTLCs on + the channel. + """ + remote_csv_delay: builtins.int + """The delay we require on the remote's commitment transaction. If this is + not set, it will be scaled automatically with the channel size. + """ + min_confs: builtins.int + """The minimum number of confirmations each one of your outputs used for + the funding transaction must satisfy. + """ + spend_unconfirmed: builtins.bool + """Whether unconfirmed outputs should be used as inputs for the funding + transaction. + """ + close_address: builtins.str + """ + Close address is an optional address which specifies the address to which + funds should be paid out to upon cooperative close. This field may only be + set if the peer supports the option upfront feature bit (call listpeers + to check). The remote peer will only accept cooperative closes to this + address if it is set. + + Note: If this value is set on channel creation, you will *not* be able to + cooperatively close out to a different address. + """ + remote_max_value_in_flight_msat: builtins.int + """ + The maximum amount of coins in millisatoshi that can be pending within + the channel. It only applies to the remote party. + """ + remote_max_htlcs: builtins.int + """ + The maximum number of concurrent HTLCs we will allow the remote party to add + to the commitment transaction. + """ + max_local_csv: builtins.int + """ + Max local csv is the maximum csv delay we will allow for our own commitment + transaction. + """ + commitment_type: global___CommitmentType.ValueType + """ + The explicit commitment type to use. Note this field will only be used if + the remote peer supports explicit channel negotiation. + """ + zero_conf: builtins.bool + """ + If this is true, then a zero-conf channel open will be attempted. + """ + scid_alias: builtins.bool + """ + If this is true, then an option-scid-alias channel-type open will be + attempted. + """ + base_fee: builtins.int + """ + The base fee charged regardless of the number of milli-satoshis sent. + """ + fee_rate: builtins.int + """ + The fee rate in ppm (parts per million) that will be charged in + proportion of the value of each forwarded HTLC. + """ + use_base_fee: builtins.bool + """ + If use_base_fee is true the open channel announcement will update the + channel base fee with the value specified in base_fee. In the case of + a base_fee of 0 use_base_fee is needed downstream to distinguish whether + to use the default base fee value specified in the config or 0. + """ + use_fee_rate: builtins.bool + """ + If use_fee_rate is true the open channel announcement will update the + channel fee rate with the value specified in fee_rate. In the case of + a fee_rate of 0 use_fee_rate is needed downstream to distinguish whether + to use the default fee rate value specified in the config or 0. + """ + remote_chan_reserve_sat: builtins.int + """ + The number of satoshis we require the remote peer to reserve. This value, + if specified, must be above the dust limit and below 20% of the channel + capacity. + """ + fund_max: builtins.bool + """ + If set, then lnd will attempt to commit all the coins under control of the + internal wallet to open the channel, and the LocalFundingAmount field must + be zero and is ignored. + """ + memo: builtins.str + """ + An optional note-to-self to go along with the channel containing some + useful information. This is only ever stored locally and in no way impacts + the channel's operation. + """ + @property + def funding_shim(self) -> global___FundingShim: + """ + Funding shims are an optional argument that allow the caller to intercept + certain funding functionality. For example, a shim can be provided to use a + particular key for the commitment key (ideally cold) rather than use one + that is generated by the wallet as normal, or signal that signing will be + carried out in an interactive manner (PSBT based). + """ + + @property + def outpoints(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___OutPoint]: + """ + A list of selected outpoints that are allocated for channel funding. + """ + + def __init__( + self, + *, + sat_per_vbyte: builtins.int = ..., + node_pubkey: builtins.bytes = ..., + node_pubkey_string: builtins.str = ..., + local_funding_amount: builtins.int = ..., + push_sat: builtins.int = ..., + target_conf: builtins.int = ..., + sat_per_byte: builtins.int = ..., + private: builtins.bool = ..., + min_htlc_msat: builtins.int = ..., + remote_csv_delay: builtins.int = ..., + min_confs: builtins.int = ..., + spend_unconfirmed: builtins.bool = ..., + close_address: builtins.str = ..., + funding_shim: global___FundingShim | None = ..., + remote_max_value_in_flight_msat: builtins.int = ..., + remote_max_htlcs: builtins.int = ..., + max_local_csv: builtins.int = ..., + commitment_type: global___CommitmentType.ValueType = ..., + zero_conf: builtins.bool = ..., + scid_alias: builtins.bool = ..., + base_fee: builtins.int = ..., + fee_rate: builtins.int = ..., + use_base_fee: builtins.bool = ..., + use_fee_rate: builtins.bool = ..., + remote_chan_reserve_sat: builtins.int = ..., + fund_max: builtins.bool = ..., + memo: builtins.str = ..., + outpoints: collections.abc.Iterable[global___OutPoint] | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["funding_shim", b"funding_shim"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["base_fee", b"base_fee", "close_address", b"close_address", "commitment_type", b"commitment_type", "fee_rate", b"fee_rate", "fund_max", b"fund_max", "funding_shim", b"funding_shim", "local_funding_amount", b"local_funding_amount", "max_local_csv", b"max_local_csv", "memo", b"memo", "min_confs", b"min_confs", "min_htlc_msat", b"min_htlc_msat", "node_pubkey", b"node_pubkey", "node_pubkey_string", b"node_pubkey_string", "outpoints", b"outpoints", "private", b"private", "push_sat", b"push_sat", "remote_chan_reserve_sat", b"remote_chan_reserve_sat", "remote_csv_delay", b"remote_csv_delay", "remote_max_htlcs", b"remote_max_htlcs", "remote_max_value_in_flight_msat", b"remote_max_value_in_flight_msat", "sat_per_byte", b"sat_per_byte", "sat_per_vbyte", b"sat_per_vbyte", "scid_alias", b"scid_alias", "spend_unconfirmed", b"spend_unconfirmed", "target_conf", b"target_conf", "use_base_fee", b"use_base_fee", "use_fee_rate", b"use_fee_rate", "zero_conf", b"zero_conf"]) -> None: ... + +global___OpenChannelRequest = OpenChannelRequest + +@typing.final +class OpenStatusUpdate(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + CHAN_PENDING_FIELD_NUMBER: builtins.int + CHAN_OPEN_FIELD_NUMBER: builtins.int + PSBT_FUND_FIELD_NUMBER: builtins.int + PENDING_CHAN_ID_FIELD_NUMBER: builtins.int + pending_chan_id: builtins.bytes + """ + The pending channel ID of the created channel. This value may be used to + further the funding flow manually via the FundingStateStep method. + """ + @property + def chan_pending(self) -> global___PendingUpdate: + """ + Signals that the channel is now fully negotiated and the funding + transaction published. + """ + + @property + def chan_open(self) -> global___ChannelOpenUpdate: + """ + Signals that the channel's funding transaction has now reached the + required number of confirmations on chain and can be used. + """ + + @property + def psbt_fund(self) -> global___ReadyForPsbtFunding: + """ + Signals that the funding process has been suspended and the construction + of a PSBT that funds the channel PK script is now required. + """ + + def __init__( + self, + *, + chan_pending: global___PendingUpdate | None = ..., + chan_open: global___ChannelOpenUpdate | None = ..., + psbt_fund: global___ReadyForPsbtFunding | None = ..., + pending_chan_id: builtins.bytes = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["chan_open", b"chan_open", "chan_pending", b"chan_pending", "psbt_fund", b"psbt_fund", "update", b"update"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["chan_open", b"chan_open", "chan_pending", b"chan_pending", "pending_chan_id", b"pending_chan_id", "psbt_fund", b"psbt_fund", "update", b"update"]) -> None: ... + def WhichOneof(self, oneof_group: typing.Literal["update", b"update"]) -> typing.Literal["chan_pending", "chan_open", "psbt_fund"] | None: ... + +global___OpenStatusUpdate = OpenStatusUpdate + +@typing.final +class KeyLocator(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + KEY_FAMILY_FIELD_NUMBER: builtins.int + KEY_INDEX_FIELD_NUMBER: builtins.int + key_family: builtins.int + """The family of key being identified.""" + key_index: builtins.int + """The precise index of the key being identified.""" + def __init__( + self, + *, + key_family: builtins.int = ..., + key_index: builtins.int = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["key_family", b"key_family", "key_index", b"key_index"]) -> None: ... + +global___KeyLocator = KeyLocator + +@typing.final +class KeyDescriptor(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + RAW_KEY_BYTES_FIELD_NUMBER: builtins.int + KEY_LOC_FIELD_NUMBER: builtins.int + raw_key_bytes: builtins.bytes + """ + The raw bytes of the key being identified. + """ + @property + def key_loc(self) -> global___KeyLocator: + """ + The key locator that identifies which key to use for signing. + """ + + def __init__( + self, + *, + raw_key_bytes: builtins.bytes = ..., + key_loc: global___KeyLocator | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["key_loc", b"key_loc"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["key_loc", b"key_loc", "raw_key_bytes", b"raw_key_bytes"]) -> None: ... + +global___KeyDescriptor = KeyDescriptor + +@typing.final +class ChanPointShim(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + AMT_FIELD_NUMBER: builtins.int + CHAN_POINT_FIELD_NUMBER: builtins.int + LOCAL_KEY_FIELD_NUMBER: builtins.int + REMOTE_KEY_FIELD_NUMBER: builtins.int + PENDING_CHAN_ID_FIELD_NUMBER: builtins.int + THAW_HEIGHT_FIELD_NUMBER: builtins.int + MUSIG2_FIELD_NUMBER: builtins.int + amt: builtins.int + """ + The size of the pre-crafted output to be used as the channel point for this + channel funding. + """ + remote_key: builtins.bytes + """The key of the remote party to use when creating the multi-sig output.""" + pending_chan_id: builtins.bytes + """ + If non-zero, then this will be used as the pending channel ID on the wire + protocol to initate the funding request. This is an optional field, and + should only be set if the responder is already expecting a specific pending + channel ID. + """ + thaw_height: builtins.int + """ + This uint32 indicates if this channel is to be considered 'frozen'. A frozen + channel does not allow a cooperative channel close by the initiator. The + thaw_height is the height that this restriction stops applying to the + channel. The height can be interpreted in two ways: as a relative height if + the value is less than 500,000, or as an absolute height otherwise. + """ + musig2: builtins.bool + """ + Indicates that the funding output is using a MuSig2 multi-sig output. + """ + @property + def chan_point(self) -> global___ChannelPoint: + """The target channel point to refrence in created commitment transactions.""" + + @property + def local_key(self) -> global___KeyDescriptor: + """Our local key to use when creating the multi-sig output.""" + + def __init__( + self, + *, + amt: builtins.int = ..., + chan_point: global___ChannelPoint | None = ..., + local_key: global___KeyDescriptor | None = ..., + remote_key: builtins.bytes = ..., + pending_chan_id: builtins.bytes = ..., + thaw_height: builtins.int = ..., + musig2: builtins.bool = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["chan_point", b"chan_point", "local_key", b"local_key"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["amt", b"amt", "chan_point", b"chan_point", "local_key", b"local_key", "musig2", b"musig2", "pending_chan_id", b"pending_chan_id", "remote_key", b"remote_key", "thaw_height", b"thaw_height"]) -> None: ... + +global___ChanPointShim = ChanPointShim + +@typing.final +class PsbtShim(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + PENDING_CHAN_ID_FIELD_NUMBER: builtins.int + BASE_PSBT_FIELD_NUMBER: builtins.int + NO_PUBLISH_FIELD_NUMBER: builtins.int + pending_chan_id: builtins.bytes + """ + A unique identifier of 32 random bytes that will be used as the pending + channel ID to identify the PSBT state machine when interacting with it and + on the wire protocol to initiate the funding request. + """ + base_psbt: builtins.bytes + """ + An optional base PSBT the new channel output will be added to. If this is + non-empty, it must be a binary serialized PSBT. + """ + no_publish: builtins.bool + """ + If a channel should be part of a batch (multiple channel openings in one + transaction), it can be dangerous if the whole batch transaction is + published too early before all channel opening negotiations are completed. + This flag prevents this particular channel from broadcasting the transaction + after the negotiation with the remote peer. In a batch of channel openings + this flag should be set to true for every channel but the very last. + """ + def __init__( + self, + *, + pending_chan_id: builtins.bytes = ..., + base_psbt: builtins.bytes = ..., + no_publish: builtins.bool = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["base_psbt", b"base_psbt", "no_publish", b"no_publish", "pending_chan_id", b"pending_chan_id"]) -> None: ... + +global___PsbtShim = PsbtShim + +@typing.final +class FundingShim(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + CHAN_POINT_SHIM_FIELD_NUMBER: builtins.int + PSBT_SHIM_FIELD_NUMBER: builtins.int + @property + def chan_point_shim(self) -> global___ChanPointShim: + """ + A channel shim where the channel point was fully constructed outside + of lnd's wallet and the transaction might already be published. + """ + + @property + def psbt_shim(self) -> global___PsbtShim: + """ + A channel shim that uses a PSBT to fund and sign the channel funding + transaction. + """ + + def __init__( + self, + *, + chan_point_shim: global___ChanPointShim | None = ..., + psbt_shim: global___PsbtShim | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["chan_point_shim", b"chan_point_shim", "psbt_shim", b"psbt_shim", "shim", b"shim"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["chan_point_shim", b"chan_point_shim", "psbt_shim", b"psbt_shim", "shim", b"shim"]) -> None: ... + def WhichOneof(self, oneof_group: typing.Literal["shim", b"shim"]) -> typing.Literal["chan_point_shim", "psbt_shim"] | None: ... + +global___FundingShim = FundingShim + +@typing.final +class FundingShimCancel(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + PENDING_CHAN_ID_FIELD_NUMBER: builtins.int + pending_chan_id: builtins.bytes + """The pending channel ID of the channel to cancel the funding shim for.""" + def __init__( + self, + *, + pending_chan_id: builtins.bytes = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["pending_chan_id", b"pending_chan_id"]) -> None: ... + +global___FundingShimCancel = FundingShimCancel + +@typing.final +class FundingPsbtVerify(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + FUNDED_PSBT_FIELD_NUMBER: builtins.int + PENDING_CHAN_ID_FIELD_NUMBER: builtins.int + SKIP_FINALIZE_FIELD_NUMBER: builtins.int + funded_psbt: builtins.bytes + """ + The funded but not yet signed PSBT that sends the exact channel capacity + amount to the PK script returned in the open channel message in a previous + step. + """ + pending_chan_id: builtins.bytes + """The pending channel ID of the channel to get the PSBT for.""" + skip_finalize: builtins.bool + """ + Can only be used if the no_publish flag was set to true in the OpenChannel + call meaning that the caller is solely responsible for publishing the final + funding transaction. If skip_finalize is set to true then lnd will not wait + for a FundingPsbtFinalize state step and instead assumes that a transaction + with the same TXID as the passed in PSBT will eventually confirm. + IT IS ABSOLUTELY IMPERATIVE that the TXID of the transaction that is + eventually published does have the _same TXID_ as the verified PSBT. That + means no inputs or outputs can change, only signatures can be added. If the + TXID changes between this call and the publish step then the channel will + never be created and the funds will be in limbo. + """ + def __init__( + self, + *, + funded_psbt: builtins.bytes = ..., + pending_chan_id: builtins.bytes = ..., + skip_finalize: builtins.bool = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["funded_psbt", b"funded_psbt", "pending_chan_id", b"pending_chan_id", "skip_finalize", b"skip_finalize"]) -> None: ... + +global___FundingPsbtVerify = FundingPsbtVerify + +@typing.final +class FundingPsbtFinalize(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + SIGNED_PSBT_FIELD_NUMBER: builtins.int + PENDING_CHAN_ID_FIELD_NUMBER: builtins.int + FINAL_RAW_TX_FIELD_NUMBER: builtins.int + signed_psbt: builtins.bytes + """ + The funded PSBT that contains all witness data to send the exact channel + capacity amount to the PK script returned in the open channel message in a + previous step. Cannot be set at the same time as final_raw_tx. + """ + pending_chan_id: builtins.bytes + """The pending channel ID of the channel to get the PSBT for.""" + final_raw_tx: builtins.bytes + """ + As an alternative to the signed PSBT with all witness data, the final raw + wire format transaction can also be specified directly. Cannot be set at the + same time as signed_psbt. + """ + def __init__( + self, + *, + signed_psbt: builtins.bytes = ..., + pending_chan_id: builtins.bytes = ..., + final_raw_tx: builtins.bytes = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["final_raw_tx", b"final_raw_tx", "pending_chan_id", b"pending_chan_id", "signed_psbt", b"signed_psbt"]) -> None: ... + +global___FundingPsbtFinalize = FundingPsbtFinalize + +@typing.final +class FundingTransitionMsg(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + SHIM_REGISTER_FIELD_NUMBER: builtins.int + SHIM_CANCEL_FIELD_NUMBER: builtins.int + PSBT_VERIFY_FIELD_NUMBER: builtins.int + PSBT_FINALIZE_FIELD_NUMBER: builtins.int + @property + def shim_register(self) -> global___FundingShim: + """ + The funding shim to register. This should be used before any + channel funding has began by the remote party, as it is intended as a + preparatory step for the full channel funding. + """ + + @property + def shim_cancel(self) -> global___FundingShimCancel: + """Used to cancel an existing registered funding shim.""" + + @property + def psbt_verify(self) -> global___FundingPsbtVerify: + """ + Used to continue a funding flow that was initiated to be executed + through a PSBT. This step verifies that the PSBT contains the correct + outputs to fund the channel. + """ + + @property + def psbt_finalize(self) -> global___FundingPsbtFinalize: + """ + Used to continue a funding flow that was initiated to be executed + through a PSBT. This step finalizes the funded and signed PSBT, finishes + negotiation with the peer and finally publishes the resulting funding + transaction. + """ + + def __init__( + self, + *, + shim_register: global___FundingShim | None = ..., + shim_cancel: global___FundingShimCancel | None = ..., + psbt_verify: global___FundingPsbtVerify | None = ..., + psbt_finalize: global___FundingPsbtFinalize | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["psbt_finalize", b"psbt_finalize", "psbt_verify", b"psbt_verify", "shim_cancel", b"shim_cancel", "shim_register", b"shim_register", "trigger", b"trigger"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["psbt_finalize", b"psbt_finalize", "psbt_verify", b"psbt_verify", "shim_cancel", b"shim_cancel", "shim_register", b"shim_register", "trigger", b"trigger"]) -> None: ... + def WhichOneof(self, oneof_group: typing.Literal["trigger", b"trigger"]) -> typing.Literal["shim_register", "shim_cancel", "psbt_verify", "psbt_finalize"] | None: ... + +global___FundingTransitionMsg = FundingTransitionMsg + +@typing.final +class FundingStateStepResp(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +global___FundingStateStepResp = FundingStateStepResp + +@typing.final +class PendingHTLC(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + INCOMING_FIELD_NUMBER: builtins.int + AMOUNT_FIELD_NUMBER: builtins.int + OUTPOINT_FIELD_NUMBER: builtins.int + MATURITY_HEIGHT_FIELD_NUMBER: builtins.int + BLOCKS_TIL_MATURITY_FIELD_NUMBER: builtins.int + STAGE_FIELD_NUMBER: builtins.int + incoming: builtins.bool + """The direction within the channel that the htlc was sent""" + amount: builtins.int + """The total value of the htlc""" + outpoint: builtins.str + """The final output to be swept back to the user's wallet""" + maturity_height: builtins.int + """The next block height at which we can spend the current stage""" + blocks_til_maturity: builtins.int + """ + The number of blocks remaining until the current stage can be swept. + Negative values indicate how many blocks have passed since becoming + mature. + """ + stage: builtins.int + """Indicates whether the htlc is in its first or second stage of recovery""" + def __init__( + self, + *, + incoming: builtins.bool = ..., + amount: builtins.int = ..., + outpoint: builtins.str = ..., + maturity_height: builtins.int = ..., + blocks_til_maturity: builtins.int = ..., + stage: builtins.int = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["amount", b"amount", "blocks_til_maturity", b"blocks_til_maturity", "incoming", b"incoming", "maturity_height", b"maturity_height", "outpoint", b"outpoint", "stage", b"stage"]) -> None: ... + +global___PendingHTLC = PendingHTLC + +@typing.final +class PendingChannelsRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + INCLUDE_RAW_TX_FIELD_NUMBER: builtins.int + include_raw_tx: builtins.bool + """Indicates whether to include the raw transaction hex for + waiting_close_channels. + """ + def __init__( + self, + *, + include_raw_tx: builtins.bool = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["include_raw_tx", b"include_raw_tx"]) -> None: ... + +global___PendingChannelsRequest = PendingChannelsRequest + +@typing.final +class PendingChannelsResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + @typing.final + class PendingChannel(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + REMOTE_NODE_PUB_FIELD_NUMBER: builtins.int + CHANNEL_POINT_FIELD_NUMBER: builtins.int + CAPACITY_FIELD_NUMBER: builtins.int + LOCAL_BALANCE_FIELD_NUMBER: builtins.int + REMOTE_BALANCE_FIELD_NUMBER: builtins.int + LOCAL_CHAN_RESERVE_SAT_FIELD_NUMBER: builtins.int + REMOTE_CHAN_RESERVE_SAT_FIELD_NUMBER: builtins.int + INITIATOR_FIELD_NUMBER: builtins.int + COMMITMENT_TYPE_FIELD_NUMBER: builtins.int + NUM_FORWARDING_PACKAGES_FIELD_NUMBER: builtins.int + CHAN_STATUS_FLAGS_FIELD_NUMBER: builtins.int + PRIVATE_FIELD_NUMBER: builtins.int + MEMO_FIELD_NUMBER: builtins.int + remote_node_pub: builtins.str + channel_point: builtins.str + capacity: builtins.int + local_balance: builtins.int + remote_balance: builtins.int + local_chan_reserve_sat: builtins.int + """The minimum satoshis this node is required to reserve in its + balance. + """ + remote_chan_reserve_sat: builtins.int + """ + The minimum satoshis the other node is required to reserve in its + balance. + """ + initiator: global___Initiator.ValueType + """The party that initiated opening the channel.""" + commitment_type: global___CommitmentType.ValueType + """The commitment type used by this channel.""" + num_forwarding_packages: builtins.int + """Total number of forwarding packages created in this channel.""" + chan_status_flags: builtins.str + """A set of flags showing the current state of the channel.""" + private: builtins.bool + """Whether this channel is advertised to the network or not.""" + memo: builtins.str + """ + An optional note-to-self to go along with the channel containing some + useful information. This is only ever stored locally and in no way + impacts the channel's operation. + """ + def __init__( + self, + *, + remote_node_pub: builtins.str = ..., + channel_point: builtins.str = ..., + capacity: builtins.int = ..., + local_balance: builtins.int = ..., + remote_balance: builtins.int = ..., + local_chan_reserve_sat: builtins.int = ..., + remote_chan_reserve_sat: builtins.int = ..., + initiator: global___Initiator.ValueType = ..., + commitment_type: global___CommitmentType.ValueType = ..., + num_forwarding_packages: builtins.int = ..., + chan_status_flags: builtins.str = ..., + private: builtins.bool = ..., + memo: builtins.str = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["capacity", b"capacity", "chan_status_flags", b"chan_status_flags", "channel_point", b"channel_point", "commitment_type", b"commitment_type", "initiator", b"initiator", "local_balance", b"local_balance", "local_chan_reserve_sat", b"local_chan_reserve_sat", "memo", b"memo", "num_forwarding_packages", b"num_forwarding_packages", "private", b"private", "remote_balance", b"remote_balance", "remote_chan_reserve_sat", b"remote_chan_reserve_sat", "remote_node_pub", b"remote_node_pub"]) -> None: ... + + @typing.final + class PendingOpenChannel(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + CHANNEL_FIELD_NUMBER: builtins.int + COMMIT_FEE_FIELD_NUMBER: builtins.int + COMMIT_WEIGHT_FIELD_NUMBER: builtins.int + FEE_PER_KW_FIELD_NUMBER: builtins.int + FUNDING_EXPIRY_BLOCKS_FIELD_NUMBER: builtins.int + commit_fee: builtins.int + """ + The amount calculated to be paid in fees for the current set of + commitment transactions. The fee amount is persisted with the channel + in order to allow the fee amount to be removed and recalculated with + each channel state update, including updates that happen after a system + restart. + """ + commit_weight: builtins.int + """The weight of the commitment transaction""" + fee_per_kw: builtins.int + """ + The required number of satoshis per kilo-weight that the requester will + pay at all times, for both the funding transaction and commitment + transaction. This value can later be updated once the channel is open. + """ + funding_expiry_blocks: builtins.int + """The number of blocks until the funding transaction is considered + expired. If this value gets close to zero, there is a risk that the + channel funding will be canceled by the channel responder. The + channel should be fee bumped using CPFP (see walletrpc.BumpFee) to + ensure that the channel confirms in time. Otherwise a force-close + will be necessary if the channel confirms after the funding + transaction expires. A negative value means the channel responder has + very likely canceled the funding and the channel will never become + fully operational. + """ + @property + def channel(self) -> global___PendingChannelsResponse.PendingChannel: + """The pending channel""" + + def __init__( + self, + *, + channel: global___PendingChannelsResponse.PendingChannel | None = ..., + commit_fee: builtins.int = ..., + commit_weight: builtins.int = ..., + fee_per_kw: builtins.int = ..., + funding_expiry_blocks: builtins.int = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["channel", b"channel"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["channel", b"channel", "commit_fee", b"commit_fee", "commit_weight", b"commit_weight", "fee_per_kw", b"fee_per_kw", "funding_expiry_blocks", b"funding_expiry_blocks"]) -> None: ... + + @typing.final + class WaitingCloseChannel(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + CHANNEL_FIELD_NUMBER: builtins.int + LIMBO_BALANCE_FIELD_NUMBER: builtins.int + COMMITMENTS_FIELD_NUMBER: builtins.int + CLOSING_TXID_FIELD_NUMBER: builtins.int + CLOSING_TX_HEX_FIELD_NUMBER: builtins.int + limbo_balance: builtins.int + """The balance in satoshis encumbered in this channel""" + closing_txid: builtins.str + """The transaction id of the closing transaction""" + closing_tx_hex: builtins.str + """The raw hex encoded bytes of the closing transaction. Included if + include_raw_tx in the request is true. + """ + @property + def channel(self) -> global___PendingChannelsResponse.PendingChannel: + """The pending channel waiting for closing tx to confirm""" + + @property + def commitments(self) -> global___PendingChannelsResponse.Commitments: + """ + A list of valid commitment transactions. Any of these can confirm at + this point. + """ + + def __init__( + self, + *, + channel: global___PendingChannelsResponse.PendingChannel | None = ..., + limbo_balance: builtins.int = ..., + commitments: global___PendingChannelsResponse.Commitments | None = ..., + closing_txid: builtins.str = ..., + closing_tx_hex: builtins.str = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["channel", b"channel", "commitments", b"commitments"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["channel", b"channel", "closing_tx_hex", b"closing_tx_hex", "closing_txid", b"closing_txid", "commitments", b"commitments", "limbo_balance", b"limbo_balance"]) -> None: ... + + @typing.final + class Commitments(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + LOCAL_TXID_FIELD_NUMBER: builtins.int + REMOTE_TXID_FIELD_NUMBER: builtins.int + REMOTE_PENDING_TXID_FIELD_NUMBER: builtins.int + LOCAL_COMMIT_FEE_SAT_FIELD_NUMBER: builtins.int + REMOTE_COMMIT_FEE_SAT_FIELD_NUMBER: builtins.int + REMOTE_PENDING_COMMIT_FEE_SAT_FIELD_NUMBER: builtins.int + local_txid: builtins.str + """Hash of the local version of the commitment tx.""" + remote_txid: builtins.str + """Hash of the remote version of the commitment tx.""" + remote_pending_txid: builtins.str + """Hash of the remote pending version of the commitment tx.""" + local_commit_fee_sat: builtins.int + """ + The amount in satoshis calculated to be paid in fees for the local + commitment. + """ + remote_commit_fee_sat: builtins.int + """ + The amount in satoshis calculated to be paid in fees for the remote + commitment. + """ + remote_pending_commit_fee_sat: builtins.int + """ + The amount in satoshis calculated to be paid in fees for the remote + pending commitment. + """ + def __init__( + self, + *, + local_txid: builtins.str = ..., + remote_txid: builtins.str = ..., + remote_pending_txid: builtins.str = ..., + local_commit_fee_sat: builtins.int = ..., + remote_commit_fee_sat: builtins.int = ..., + remote_pending_commit_fee_sat: builtins.int = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["local_commit_fee_sat", b"local_commit_fee_sat", "local_txid", b"local_txid", "remote_commit_fee_sat", b"remote_commit_fee_sat", "remote_pending_commit_fee_sat", b"remote_pending_commit_fee_sat", "remote_pending_txid", b"remote_pending_txid", "remote_txid", b"remote_txid"]) -> None: ... + + @typing.final + class ClosedChannel(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + CHANNEL_FIELD_NUMBER: builtins.int + CLOSING_TXID_FIELD_NUMBER: builtins.int + closing_txid: builtins.str + """The transaction id of the closing transaction""" + @property + def channel(self) -> global___PendingChannelsResponse.PendingChannel: + """The pending channel to be closed""" + + def __init__( + self, + *, + channel: global___PendingChannelsResponse.PendingChannel | None = ..., + closing_txid: builtins.str = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["channel", b"channel"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["channel", b"channel", "closing_txid", b"closing_txid"]) -> None: ... + + @typing.final + class ForceClosedChannel(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + class _AnchorState: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + + class _AnchorStateEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[PendingChannelsResponse.ForceClosedChannel._AnchorState.ValueType], builtins.type): # noqa: F821 + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + LIMBO: PendingChannelsResponse.ForceClosedChannel._AnchorState.ValueType # 0 + """The recovered_balance is zero and limbo_balance is non-zero.""" + RECOVERED: PendingChannelsResponse.ForceClosedChannel._AnchorState.ValueType # 1 + """The recovered_balance is non-zero.""" + LOST: PendingChannelsResponse.ForceClosedChannel._AnchorState.ValueType # 2 + """A state that is neither LIMBO nor RECOVERED.""" + + class AnchorState(_AnchorState, metaclass=_AnchorStateEnumTypeWrapper): + """ + There are three resolution states for the anchor: + limbo, lost and recovered. Derive the current state + from the limbo and recovered balances. + """ + + LIMBO: PendingChannelsResponse.ForceClosedChannel.AnchorState.ValueType # 0 + """The recovered_balance is zero and limbo_balance is non-zero.""" + RECOVERED: PendingChannelsResponse.ForceClosedChannel.AnchorState.ValueType # 1 + """The recovered_balance is non-zero.""" + LOST: PendingChannelsResponse.ForceClosedChannel.AnchorState.ValueType # 2 + """A state that is neither LIMBO nor RECOVERED.""" + + CHANNEL_FIELD_NUMBER: builtins.int + CLOSING_TXID_FIELD_NUMBER: builtins.int + LIMBO_BALANCE_FIELD_NUMBER: builtins.int + MATURITY_HEIGHT_FIELD_NUMBER: builtins.int + BLOCKS_TIL_MATURITY_FIELD_NUMBER: builtins.int + RECOVERED_BALANCE_FIELD_NUMBER: builtins.int + PENDING_HTLCS_FIELD_NUMBER: builtins.int + ANCHOR_FIELD_NUMBER: builtins.int + closing_txid: builtins.str + """The transaction id of the closing transaction""" + limbo_balance: builtins.int + """The balance in satoshis encumbered in this pending channel""" + maturity_height: builtins.int + """The height at which funds can be swept into the wallet""" + blocks_til_maturity: builtins.int + """ + Remaining # of blocks until the commitment output can be swept. + Negative values indicate how many blocks have passed since becoming + mature. + """ + recovered_balance: builtins.int + """The total value of funds successfully recovered from this channel""" + anchor: global___PendingChannelsResponse.ForceClosedChannel.AnchorState.ValueType + @property + def channel(self) -> global___PendingChannelsResponse.PendingChannel: + """The pending channel to be force closed""" + + @property + def pending_htlcs(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___PendingHTLC]: ... + def __init__( + self, + *, + channel: global___PendingChannelsResponse.PendingChannel | None = ..., + closing_txid: builtins.str = ..., + limbo_balance: builtins.int = ..., + maturity_height: builtins.int = ..., + blocks_til_maturity: builtins.int = ..., + recovered_balance: builtins.int = ..., + pending_htlcs: collections.abc.Iterable[global___PendingHTLC] | None = ..., + anchor: global___PendingChannelsResponse.ForceClosedChannel.AnchorState.ValueType = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["channel", b"channel"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["anchor", b"anchor", "blocks_til_maturity", b"blocks_til_maturity", "channel", b"channel", "closing_txid", b"closing_txid", "limbo_balance", b"limbo_balance", "maturity_height", b"maturity_height", "pending_htlcs", b"pending_htlcs", "recovered_balance", b"recovered_balance"]) -> None: ... + + TOTAL_LIMBO_BALANCE_FIELD_NUMBER: builtins.int + PENDING_OPEN_CHANNELS_FIELD_NUMBER: builtins.int + PENDING_CLOSING_CHANNELS_FIELD_NUMBER: builtins.int + PENDING_FORCE_CLOSING_CHANNELS_FIELD_NUMBER: builtins.int + WAITING_CLOSE_CHANNELS_FIELD_NUMBER: builtins.int + total_limbo_balance: builtins.int + """The balance in satoshis encumbered in pending channels""" + @property + def pending_open_channels(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___PendingChannelsResponse.PendingOpenChannel]: + """Channels pending opening""" + + @property + def pending_closing_channels(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___PendingChannelsResponse.ClosedChannel]: + """ + Deprecated: Channels pending closing previously contained cooperatively + closed channels with a single confirmation. These channels are now + considered closed from the time we see them on chain. + """ + + @property + def pending_force_closing_channels(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___PendingChannelsResponse.ForceClosedChannel]: + """Channels pending force closing""" + + @property + def waiting_close_channels(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___PendingChannelsResponse.WaitingCloseChannel]: + """Channels waiting for closing tx to confirm""" + + def __init__( + self, + *, + total_limbo_balance: builtins.int = ..., + pending_open_channels: collections.abc.Iterable[global___PendingChannelsResponse.PendingOpenChannel] | None = ..., + pending_closing_channels: collections.abc.Iterable[global___PendingChannelsResponse.ClosedChannel] | None = ..., + pending_force_closing_channels: collections.abc.Iterable[global___PendingChannelsResponse.ForceClosedChannel] | None = ..., + waiting_close_channels: collections.abc.Iterable[global___PendingChannelsResponse.WaitingCloseChannel] | None = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["pending_closing_channels", b"pending_closing_channels", "pending_force_closing_channels", b"pending_force_closing_channels", "pending_open_channels", b"pending_open_channels", "total_limbo_balance", b"total_limbo_balance", "waiting_close_channels", b"waiting_close_channels"]) -> None: ... + +global___PendingChannelsResponse = PendingChannelsResponse + +@typing.final +class ChannelEventSubscription(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +global___ChannelEventSubscription = ChannelEventSubscription + +@typing.final +class ChannelEventUpdate(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + class _UpdateType: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + + class _UpdateTypeEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[ChannelEventUpdate._UpdateType.ValueType], builtins.type): # noqa: F821 + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + OPEN_CHANNEL: ChannelEventUpdate._UpdateType.ValueType # 0 + CLOSED_CHANNEL: ChannelEventUpdate._UpdateType.ValueType # 1 + ACTIVE_CHANNEL: ChannelEventUpdate._UpdateType.ValueType # 2 + INACTIVE_CHANNEL: ChannelEventUpdate._UpdateType.ValueType # 3 + PENDING_OPEN_CHANNEL: ChannelEventUpdate._UpdateType.ValueType # 4 + FULLY_RESOLVED_CHANNEL: ChannelEventUpdate._UpdateType.ValueType # 5 + + class UpdateType(_UpdateType, metaclass=_UpdateTypeEnumTypeWrapper): ... + OPEN_CHANNEL: ChannelEventUpdate.UpdateType.ValueType # 0 + CLOSED_CHANNEL: ChannelEventUpdate.UpdateType.ValueType # 1 + ACTIVE_CHANNEL: ChannelEventUpdate.UpdateType.ValueType # 2 + INACTIVE_CHANNEL: ChannelEventUpdate.UpdateType.ValueType # 3 + PENDING_OPEN_CHANNEL: ChannelEventUpdate.UpdateType.ValueType # 4 + FULLY_RESOLVED_CHANNEL: ChannelEventUpdate.UpdateType.ValueType # 5 + + OPEN_CHANNEL_FIELD_NUMBER: builtins.int + CLOSED_CHANNEL_FIELD_NUMBER: builtins.int + ACTIVE_CHANNEL_FIELD_NUMBER: builtins.int + INACTIVE_CHANNEL_FIELD_NUMBER: builtins.int + PENDING_OPEN_CHANNEL_FIELD_NUMBER: builtins.int + FULLY_RESOLVED_CHANNEL_FIELD_NUMBER: builtins.int + TYPE_FIELD_NUMBER: builtins.int + type: global___ChannelEventUpdate.UpdateType.ValueType + @property + def open_channel(self) -> global___Channel: ... + @property + def closed_channel(self) -> global___ChannelCloseSummary: ... + @property + def active_channel(self) -> global___ChannelPoint: ... + @property + def inactive_channel(self) -> global___ChannelPoint: ... + @property + def pending_open_channel(self) -> global___PendingUpdate: ... + @property + def fully_resolved_channel(self) -> global___ChannelPoint: ... + def __init__( + self, + *, + open_channel: global___Channel | None = ..., + closed_channel: global___ChannelCloseSummary | None = ..., + active_channel: global___ChannelPoint | None = ..., + inactive_channel: global___ChannelPoint | None = ..., + pending_open_channel: global___PendingUpdate | None = ..., + fully_resolved_channel: global___ChannelPoint | None = ..., + type: global___ChannelEventUpdate.UpdateType.ValueType = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["active_channel", b"active_channel", "channel", b"channel", "closed_channel", b"closed_channel", "fully_resolved_channel", b"fully_resolved_channel", "inactive_channel", b"inactive_channel", "open_channel", b"open_channel", "pending_open_channel", b"pending_open_channel"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["active_channel", b"active_channel", "channel", b"channel", "closed_channel", b"closed_channel", "fully_resolved_channel", b"fully_resolved_channel", "inactive_channel", b"inactive_channel", "open_channel", b"open_channel", "pending_open_channel", b"pending_open_channel", "type", b"type"]) -> None: ... + def WhichOneof(self, oneof_group: typing.Literal["channel", b"channel"]) -> typing.Literal["open_channel", "closed_channel", "active_channel", "inactive_channel", "pending_open_channel", "fully_resolved_channel"] | None: ... + +global___ChannelEventUpdate = ChannelEventUpdate + +@typing.final +class WalletAccountBalance(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + CONFIRMED_BALANCE_FIELD_NUMBER: builtins.int + UNCONFIRMED_BALANCE_FIELD_NUMBER: builtins.int + confirmed_balance: builtins.int + """The confirmed balance of the account (with >= 1 confirmations).""" + unconfirmed_balance: builtins.int + """The unconfirmed balance of the account (with 0 confirmations).""" + def __init__( + self, + *, + confirmed_balance: builtins.int = ..., + unconfirmed_balance: builtins.int = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["confirmed_balance", b"confirmed_balance", "unconfirmed_balance", b"unconfirmed_balance"]) -> None: ... + +global___WalletAccountBalance = WalletAccountBalance + +@typing.final +class WalletBalanceRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + ACCOUNT_FIELD_NUMBER: builtins.int + MIN_CONFS_FIELD_NUMBER: builtins.int + account: builtins.str + """The wallet account the balance is shown for. + If this is not specified, the balance of the "default" account is shown. + """ + min_confs: builtins.int + """The minimum number of confirmations each one of your outputs used for the + funding transaction must satisfy. If this is not specified, the default + value of 1 is used. + """ + def __init__( + self, + *, + account: builtins.str = ..., + min_confs: builtins.int = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["account", b"account", "min_confs", b"min_confs"]) -> None: ... + +global___WalletBalanceRequest = WalletBalanceRequest + +@typing.final +class WalletBalanceResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + @typing.final + class AccountBalanceEntry(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + KEY_FIELD_NUMBER: builtins.int + VALUE_FIELD_NUMBER: builtins.int + key: builtins.str + @property + def value(self) -> global___WalletAccountBalance: ... + def __init__( + self, + *, + key: builtins.str = ..., + value: global___WalletAccountBalance | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["value", b"value"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["key", b"key", "value", b"value"]) -> None: ... + + TOTAL_BALANCE_FIELD_NUMBER: builtins.int + CONFIRMED_BALANCE_FIELD_NUMBER: builtins.int + UNCONFIRMED_BALANCE_FIELD_NUMBER: builtins.int + LOCKED_BALANCE_FIELD_NUMBER: builtins.int + RESERVED_BALANCE_ANCHOR_CHAN_FIELD_NUMBER: builtins.int + ACCOUNT_BALANCE_FIELD_NUMBER: builtins.int + total_balance: builtins.int + """The balance of the wallet""" + confirmed_balance: builtins.int + """The confirmed balance of a wallet(with >= 1 confirmations)""" + unconfirmed_balance: builtins.int + """The unconfirmed balance of a wallet(with 0 confirmations)""" + locked_balance: builtins.int + """The total amount of wallet UTXOs held in outputs that are locked for + other usage. + """ + reserved_balance_anchor_chan: builtins.int + """The amount of reserve required.""" + @property + def account_balance(self) -> google.protobuf.internal.containers.MessageMap[builtins.str, global___WalletAccountBalance]: + """A mapping of each wallet account's name to its balance.""" + + def __init__( + self, + *, + total_balance: builtins.int = ..., + confirmed_balance: builtins.int = ..., + unconfirmed_balance: builtins.int = ..., + locked_balance: builtins.int = ..., + reserved_balance_anchor_chan: builtins.int = ..., + account_balance: collections.abc.Mapping[builtins.str, global___WalletAccountBalance] | None = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["account_balance", b"account_balance", "confirmed_balance", b"confirmed_balance", "locked_balance", b"locked_balance", "reserved_balance_anchor_chan", b"reserved_balance_anchor_chan", "total_balance", b"total_balance", "unconfirmed_balance", b"unconfirmed_balance"]) -> None: ... + +global___WalletBalanceResponse = WalletBalanceResponse + +@typing.final +class Amount(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + SAT_FIELD_NUMBER: builtins.int + MSAT_FIELD_NUMBER: builtins.int + sat: builtins.int + """Value denominated in satoshis.""" + msat: builtins.int + """Value denominated in milli-satoshis.""" + def __init__( + self, + *, + sat: builtins.int = ..., + msat: builtins.int = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["msat", b"msat", "sat", b"sat"]) -> None: ... + +global___Amount = Amount + +@typing.final +class ChannelBalanceRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +global___ChannelBalanceRequest = ChannelBalanceRequest + +@typing.final +class ChannelBalanceResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + BALANCE_FIELD_NUMBER: builtins.int + PENDING_OPEN_BALANCE_FIELD_NUMBER: builtins.int + LOCAL_BALANCE_FIELD_NUMBER: builtins.int + REMOTE_BALANCE_FIELD_NUMBER: builtins.int + UNSETTLED_LOCAL_BALANCE_FIELD_NUMBER: builtins.int + UNSETTLED_REMOTE_BALANCE_FIELD_NUMBER: builtins.int + PENDING_OPEN_LOCAL_BALANCE_FIELD_NUMBER: builtins.int + PENDING_OPEN_REMOTE_BALANCE_FIELD_NUMBER: builtins.int + balance: builtins.int + """Deprecated. Sum of channels balances denominated in satoshis""" + pending_open_balance: builtins.int + """Deprecated. Sum of channels pending balances denominated in satoshis""" + @property + def local_balance(self) -> global___Amount: + """Sum of channels local balances.""" + + @property + def remote_balance(self) -> global___Amount: + """Sum of channels remote balances.""" + + @property + def unsettled_local_balance(self) -> global___Amount: + """Sum of channels local unsettled balances.""" + + @property + def unsettled_remote_balance(self) -> global___Amount: + """Sum of channels remote unsettled balances.""" + + @property + def pending_open_local_balance(self) -> global___Amount: + """Sum of channels pending local balances.""" + + @property + def pending_open_remote_balance(self) -> global___Amount: + """Sum of channels pending remote balances.""" + + def __init__( + self, + *, + balance: builtins.int = ..., + pending_open_balance: builtins.int = ..., + local_balance: global___Amount | None = ..., + remote_balance: global___Amount | None = ..., + unsettled_local_balance: global___Amount | None = ..., + unsettled_remote_balance: global___Amount | None = ..., + pending_open_local_balance: global___Amount | None = ..., + pending_open_remote_balance: global___Amount | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["local_balance", b"local_balance", "pending_open_local_balance", b"pending_open_local_balance", "pending_open_remote_balance", b"pending_open_remote_balance", "remote_balance", b"remote_balance", "unsettled_local_balance", b"unsettled_local_balance", "unsettled_remote_balance", b"unsettled_remote_balance"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["balance", b"balance", "local_balance", b"local_balance", "pending_open_balance", b"pending_open_balance", "pending_open_local_balance", b"pending_open_local_balance", "pending_open_remote_balance", b"pending_open_remote_balance", "remote_balance", b"remote_balance", "unsettled_local_balance", b"unsettled_local_balance", "unsettled_remote_balance", b"unsettled_remote_balance"]) -> None: ... + +global___ChannelBalanceResponse = ChannelBalanceResponse + +@typing.final +class QueryRoutesRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + @typing.final + class DestCustomRecordsEntry(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + KEY_FIELD_NUMBER: builtins.int + VALUE_FIELD_NUMBER: builtins.int + key: builtins.int + value: builtins.bytes + def __init__( + self, + *, + key: builtins.int = ..., + value: builtins.bytes = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["key", b"key", "value", b"value"]) -> None: ... + + PUB_KEY_FIELD_NUMBER: builtins.int + AMT_FIELD_NUMBER: builtins.int + AMT_MSAT_FIELD_NUMBER: builtins.int + FINAL_CLTV_DELTA_FIELD_NUMBER: builtins.int + FEE_LIMIT_FIELD_NUMBER: builtins.int + IGNORED_NODES_FIELD_NUMBER: builtins.int + IGNORED_EDGES_FIELD_NUMBER: builtins.int + SOURCE_PUB_KEY_FIELD_NUMBER: builtins.int + USE_MISSION_CONTROL_FIELD_NUMBER: builtins.int + IGNORED_PAIRS_FIELD_NUMBER: builtins.int + CLTV_LIMIT_FIELD_NUMBER: builtins.int + DEST_CUSTOM_RECORDS_FIELD_NUMBER: builtins.int + OUTGOING_CHAN_ID_FIELD_NUMBER: builtins.int + LAST_HOP_PUBKEY_FIELD_NUMBER: builtins.int + ROUTE_HINTS_FIELD_NUMBER: builtins.int + BLINDED_PAYMENT_PATHS_FIELD_NUMBER: builtins.int + DEST_FEATURES_FIELD_NUMBER: builtins.int + TIME_PREF_FIELD_NUMBER: builtins.int + pub_key: builtins.str + """The 33-byte hex-encoded public key for the payment destination""" + amt: builtins.int + """ + The amount to send expressed in satoshis. + + The fields amt and amt_msat are mutually exclusive. + """ + amt_msat: builtins.int + """ + The amount to send expressed in millisatoshis. + + The fields amt and amt_msat are mutually exclusive. + """ + final_cltv_delta: builtins.int + """ + An optional CLTV delta from the current height that should be used for the + timelock of the final hop. Note that unlike SendPayment, QueryRoutes does + not add any additional block padding on top of final_ctlv_delta. This + padding of a few blocks needs to be added manually or otherwise failures may + happen when a block comes in while the payment is in flight. + + Note: must not be set if making a payment to a blinded path (delta is + set by the aggregate parameters provided by blinded_payment_paths) + """ + source_pub_key: builtins.str + """ + The source node where the request route should originated from. If empty, + self is assumed. + """ + use_mission_control: builtins.bool + """ + If set to true, edge probabilities from mission control will be used to get + the optimal route. + """ + cltv_limit: builtins.int + """ + An optional maximum total time lock for the route. If the source is empty or + ourselves, this should not exceed lnd's `--max-cltv-expiry` setting. If + zero, then the value of `--max-cltv-expiry` is used as the limit. + """ + outgoing_chan_id: builtins.int + """ + The channel id of the channel that must be taken to the first hop. If zero, + any channel may be used. + """ + last_hop_pubkey: builtins.bytes + """ + The pubkey of the last hop of the route. If empty, any hop may be used. + """ + time_pref: builtins.float + """ + The time preference for this payment. Set to -1 to optimize for fees + only, to 1 to optimize for reliability only or a value inbetween for a mix. + """ + @property + def fee_limit(self) -> global___FeeLimit: + """ + The maximum number of satoshis that will be paid as a fee of the payment. + This value can be represented either as a percentage of the amount being + sent, or as a fixed amount of the maximum fee the user is willing the pay to + send the payment. If not specified, lnd will use a default value of 100% + fees for small amounts (<=1k sat) or 5% fees for larger amounts. + """ + + @property + def ignored_nodes(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.bytes]: + """ + A list of nodes to ignore during path finding. When using REST, these fields + must be encoded as base64. + """ + + @property + def ignored_edges(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___EdgeLocator]: + """ + Deprecated. A list of edges to ignore during path finding. + """ + + @property + def ignored_pairs(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___NodePair]: + """ + A list of directed node pairs that will be ignored during path finding. + """ + + @property + def dest_custom_records(self) -> google.protobuf.internal.containers.ScalarMap[builtins.int, builtins.bytes]: + """ + An optional field that can be used to pass an arbitrary set of TLV records + to a peer which understands the new records. This can be used to pass + application specific data during the payment attempt. If the destination + does not support the specified records, an error will be returned. + Record types are required to be in the custom range >= 65536. When using + REST, the values must be encoded as base64. + """ + + @property + def route_hints(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___RouteHint]: + """ + Optional route hints to reach the destination through private channels. + """ + + @property + def blinded_payment_paths(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___BlindedPaymentPath]: + """ + An optional blinded path(s) to reach the destination. Note that the + introduction node must be provided as the first hop in the route. + """ + + @property + def dest_features(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[global___FeatureBit.ValueType]: + """ + Features assumed to be supported by the final node. All transitive feature + dependencies must also be set properly. For a given feature bit pair, either + optional or remote may be set, but not both. If this field is nil or empty, + the router will try to load destination features from the graph as a + fallback. + + Note: must not be set if making a payment to a blinded route (features + are provided in blinded_payment_paths). + """ + + def __init__( + self, + *, + pub_key: builtins.str = ..., + amt: builtins.int = ..., + amt_msat: builtins.int = ..., + final_cltv_delta: builtins.int = ..., + fee_limit: global___FeeLimit | None = ..., + ignored_nodes: collections.abc.Iterable[builtins.bytes] | None = ..., + ignored_edges: collections.abc.Iterable[global___EdgeLocator] | None = ..., + source_pub_key: builtins.str = ..., + use_mission_control: builtins.bool = ..., + ignored_pairs: collections.abc.Iterable[global___NodePair] | None = ..., + cltv_limit: builtins.int = ..., + dest_custom_records: collections.abc.Mapping[builtins.int, builtins.bytes] | None = ..., + outgoing_chan_id: builtins.int = ..., + last_hop_pubkey: builtins.bytes = ..., + route_hints: collections.abc.Iterable[global___RouteHint] | None = ..., + blinded_payment_paths: collections.abc.Iterable[global___BlindedPaymentPath] | None = ..., + dest_features: collections.abc.Iterable[global___FeatureBit.ValueType] | None = ..., + time_pref: builtins.float = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["fee_limit", b"fee_limit"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["amt", b"amt", "amt_msat", b"amt_msat", "blinded_payment_paths", b"blinded_payment_paths", "cltv_limit", b"cltv_limit", "dest_custom_records", b"dest_custom_records", "dest_features", b"dest_features", "fee_limit", b"fee_limit", "final_cltv_delta", b"final_cltv_delta", "ignored_edges", b"ignored_edges", "ignored_nodes", b"ignored_nodes", "ignored_pairs", b"ignored_pairs", "last_hop_pubkey", b"last_hop_pubkey", "outgoing_chan_id", b"outgoing_chan_id", "pub_key", b"pub_key", "route_hints", b"route_hints", "source_pub_key", b"source_pub_key", "time_pref", b"time_pref", "use_mission_control", b"use_mission_control"]) -> None: ... + +global___QueryRoutesRequest = QueryRoutesRequest + +@typing.final +class NodePair(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + FROM_FIELD_NUMBER: builtins.int + TO_FIELD_NUMBER: builtins.int + to: builtins.bytes + """ + The receiving node of the pair. When using REST, this field must be encoded + as base64. + """ + def __init__( + self, + *, + to: builtins.bytes = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["from", b"from", "to", b"to"]) -> None: ... + +global___NodePair = NodePair + +@typing.final +class EdgeLocator(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + CHANNEL_ID_FIELD_NUMBER: builtins.int + DIRECTION_REVERSE_FIELD_NUMBER: builtins.int + channel_id: builtins.int + """The short channel id of this edge.""" + direction_reverse: builtins.bool + """ + The direction of this edge. If direction_reverse is false, the direction + of this edge is from the channel endpoint with the lexicographically smaller + pub key to the endpoint with the larger pub key. If direction_reverse is + is true, the edge goes the other way. + """ + def __init__( + self, + *, + channel_id: builtins.int = ..., + direction_reverse: builtins.bool = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["channel_id", b"channel_id", "direction_reverse", b"direction_reverse"]) -> None: ... + +global___EdgeLocator = EdgeLocator + +@typing.final +class QueryRoutesResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + ROUTES_FIELD_NUMBER: builtins.int + SUCCESS_PROB_FIELD_NUMBER: builtins.int + success_prob: builtins.float + """ + The success probability of the returned route based on the current mission + control state. [EXPERIMENTAL] + """ + @property + def routes(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___Route]: + """ + The route that results from the path finding operation. This is still a + repeated field to retain backwards compatibility. + """ + + def __init__( + self, + *, + routes: collections.abc.Iterable[global___Route] | None = ..., + success_prob: builtins.float = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["routes", b"routes", "success_prob", b"success_prob"]) -> None: ... + +global___QueryRoutesResponse = QueryRoutesResponse + +@typing.final +class Hop(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + @typing.final + class CustomRecordsEntry(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + KEY_FIELD_NUMBER: builtins.int + VALUE_FIELD_NUMBER: builtins.int + key: builtins.int + value: builtins.bytes + def __init__( + self, + *, + key: builtins.int = ..., + value: builtins.bytes = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["key", b"key", "value", b"value"]) -> None: ... + + CHAN_ID_FIELD_NUMBER: builtins.int + CHAN_CAPACITY_FIELD_NUMBER: builtins.int + AMT_TO_FORWARD_FIELD_NUMBER: builtins.int + FEE_FIELD_NUMBER: builtins.int + EXPIRY_FIELD_NUMBER: builtins.int + AMT_TO_FORWARD_MSAT_FIELD_NUMBER: builtins.int + FEE_MSAT_FIELD_NUMBER: builtins.int + PUB_KEY_FIELD_NUMBER: builtins.int + TLV_PAYLOAD_FIELD_NUMBER: builtins.int + MPP_RECORD_FIELD_NUMBER: builtins.int + AMP_RECORD_FIELD_NUMBER: builtins.int + CUSTOM_RECORDS_FIELD_NUMBER: builtins.int + METADATA_FIELD_NUMBER: builtins.int + BLINDING_POINT_FIELD_NUMBER: builtins.int + ENCRYPTED_DATA_FIELD_NUMBER: builtins.int + TOTAL_AMT_MSAT_FIELD_NUMBER: builtins.int + chan_id: builtins.int + """ + The unique channel ID for the channel. The first 3 bytes are the block + height, the next 3 the index within the block, and the last 2 bytes are the + output index for the channel. + """ + chan_capacity: builtins.int + amt_to_forward: builtins.int + fee: builtins.int + expiry: builtins.int + amt_to_forward_msat: builtins.int + fee_msat: builtins.int + pub_key: builtins.str + """ + An optional public key of the hop. If the public key is given, the payment + can be executed without relying on a copy of the channel graph. + """ + tlv_payload: builtins.bool + """ + If set to true, then this hop will be encoded using the new variable length + TLV format. Note that if any custom tlv_records below are specified, then + this field MUST be set to true for them to be encoded properly. + """ + metadata: builtins.bytes + """The payment metadata to send along with the payment to the payee.""" + blinding_point: builtins.bytes + """ + Blinding point is an optional blinding point included for introduction + nodes in blinded paths. This field is mandatory for hops that represents + the introduction point in a blinded path. + """ + encrypted_data: builtins.bytes + """ + Encrypted data is a receiver-produced blob of data that provides hops + in a blinded route with forwarding data. As this data is encrypted by + the recipient, we will not be able to parse it - it is essentially an + arbitrary blob of data from our node's perspective. This field is + mandatory for all hops in a blinded path, including the introduction + node. + """ + total_amt_msat: builtins.int + """ + The total amount that is sent to the recipient (possibly across multiple + HTLCs), as specified by the sender when making a payment to a blinded path. + This value is only set in the final hop payload of a blinded payment. This + value is analogous to the MPPRecord that is used for regular (non-blinded) + MPP payments. + """ + @property + def mpp_record(self) -> global___MPPRecord: + """ + An optional TLV record that signals the use of an MPP payment. If present, + the receiver will enforce that the same mpp_record is included in the final + hop payload of all non-zero payments in the HTLC set. If empty, a regular + single-shot payment is or was attempted. + """ + + @property + def amp_record(self) -> global___AMPRecord: + """ + An optional TLV record that signals the use of an AMP payment. If present, + the receiver will treat all received payments including the same + (payment_addr, set_id) pair as being part of one logical payment. The + payment will be settled by XORing the root_share's together and deriving the + child hashes and preimages according to BOLT XX. Must be used in conjunction + with mpp_record. + """ + + @property + def custom_records(self) -> google.protobuf.internal.containers.ScalarMap[builtins.int, builtins.bytes]: + """ + An optional set of key-value TLV records. This is useful within the context + of the SendToRoute call as it allows callers to specify arbitrary K-V pairs + to drop off at each hop within the onion. + """ + + def __init__( + self, + *, + chan_id: builtins.int = ..., + chan_capacity: builtins.int = ..., + amt_to_forward: builtins.int = ..., + fee: builtins.int = ..., + expiry: builtins.int = ..., + amt_to_forward_msat: builtins.int = ..., + fee_msat: builtins.int = ..., + pub_key: builtins.str = ..., + tlv_payload: builtins.bool = ..., + mpp_record: global___MPPRecord | None = ..., + amp_record: global___AMPRecord | None = ..., + custom_records: collections.abc.Mapping[builtins.int, builtins.bytes] | None = ..., + metadata: builtins.bytes = ..., + blinding_point: builtins.bytes = ..., + encrypted_data: builtins.bytes = ..., + total_amt_msat: builtins.int = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["amp_record", b"amp_record", "mpp_record", b"mpp_record"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["amp_record", b"amp_record", "amt_to_forward", b"amt_to_forward", "amt_to_forward_msat", b"amt_to_forward_msat", "blinding_point", b"blinding_point", "chan_capacity", b"chan_capacity", "chan_id", b"chan_id", "custom_records", b"custom_records", "encrypted_data", b"encrypted_data", "expiry", b"expiry", "fee", b"fee", "fee_msat", b"fee_msat", "metadata", b"metadata", "mpp_record", b"mpp_record", "pub_key", b"pub_key", "tlv_payload", b"tlv_payload", "total_amt_msat", b"total_amt_msat"]) -> None: ... + +global___Hop = Hop + +@typing.final +class MPPRecord(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + PAYMENT_ADDR_FIELD_NUMBER: builtins.int + TOTAL_AMT_MSAT_FIELD_NUMBER: builtins.int + payment_addr: builtins.bytes + """ + A unique, random identifier used to authenticate the sender as the intended + payer of a multi-path payment. The payment_addr must be the same for all + subpayments, and match the payment_addr provided in the receiver's invoice. + The same payment_addr must be used on all subpayments. This is also called + payment secret in specifications (e.g. BOLT 11). + """ + total_amt_msat: builtins.int + """ + The total amount in milli-satoshis being sent as part of a larger multi-path + payment. The caller is responsible for ensuring subpayments to the same node + and payment_hash sum exactly to total_amt_msat. The same + total_amt_msat must be used on all subpayments. + """ + def __init__( + self, + *, + payment_addr: builtins.bytes = ..., + total_amt_msat: builtins.int = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["payment_addr", b"payment_addr", "total_amt_msat", b"total_amt_msat"]) -> None: ... + +global___MPPRecord = MPPRecord + +@typing.final +class AMPRecord(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + ROOT_SHARE_FIELD_NUMBER: builtins.int + SET_ID_FIELD_NUMBER: builtins.int + CHILD_INDEX_FIELD_NUMBER: builtins.int + root_share: builtins.bytes + set_id: builtins.bytes + child_index: builtins.int + def __init__( + self, + *, + root_share: builtins.bytes = ..., + set_id: builtins.bytes = ..., + child_index: builtins.int = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["child_index", b"child_index", "root_share", b"root_share", "set_id", b"set_id"]) -> None: ... + +global___AMPRecord = AMPRecord + +@typing.final +class Route(google.protobuf.message.Message): + """ + A path through the channel graph which runs over one or more channels in + succession. This struct carries all the information required to craft the + Sphinx onion packet, and send the payment along the first hop in the path. A + route is only selected as valid if all the channels have sufficient capacity to + carry the initial payment amount after fees are accounted for. + """ + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + TOTAL_TIME_LOCK_FIELD_NUMBER: builtins.int + TOTAL_FEES_FIELD_NUMBER: builtins.int + TOTAL_AMT_FIELD_NUMBER: builtins.int + HOPS_FIELD_NUMBER: builtins.int + TOTAL_FEES_MSAT_FIELD_NUMBER: builtins.int + TOTAL_AMT_MSAT_FIELD_NUMBER: builtins.int + total_time_lock: builtins.int + """ + The cumulative (final) time lock across the entire route. This is the CLTV + value that should be extended to the first hop in the route. All other hops + will decrement the time-lock as advertised, leaving enough time for all + hops to wait for or present the payment preimage to complete the payment. + """ + total_fees: builtins.int + """ + The sum of the fees paid at each hop within the final route. In the case + of a one-hop payment, this value will be zero as we don't need to pay a fee + to ourselves. + """ + total_amt: builtins.int + """ + The total amount of funds required to complete a payment over this route. + This value includes the cumulative fees at each hop. As a result, the HTLC + extended to the first-hop in the route will need to have at least this many + satoshis, otherwise the route will fail at an intermediate node due to an + insufficient amount of fees. + """ + total_fees_msat: builtins.int + """ + The total fees in millisatoshis. + """ + total_amt_msat: builtins.int + """ + The total amount in millisatoshis. + """ + @property + def hops(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___Hop]: + """ + Contains details concerning the specific forwarding details at each hop. + """ + + def __init__( + self, + *, + total_time_lock: builtins.int = ..., + total_fees: builtins.int = ..., + total_amt: builtins.int = ..., + hops: collections.abc.Iterable[global___Hop] | None = ..., + total_fees_msat: builtins.int = ..., + total_amt_msat: builtins.int = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["hops", b"hops", "total_amt", b"total_amt", "total_amt_msat", b"total_amt_msat", "total_fees", b"total_fees", "total_fees_msat", b"total_fees_msat", "total_time_lock", b"total_time_lock"]) -> None: ... + +global___Route = Route + +@typing.final +class NodeInfoRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + PUB_KEY_FIELD_NUMBER: builtins.int + INCLUDE_CHANNELS_FIELD_NUMBER: builtins.int + pub_key: builtins.str + """The 33-byte hex-encoded compressed public of the target node""" + include_channels: builtins.bool + """If true, will include all known channels associated with the node.""" + def __init__( + self, + *, + pub_key: builtins.str = ..., + include_channels: builtins.bool = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["include_channels", b"include_channels", "pub_key", b"pub_key"]) -> None: ... + +global___NodeInfoRequest = NodeInfoRequest + +@typing.final +class NodeInfo(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + NODE_FIELD_NUMBER: builtins.int + NUM_CHANNELS_FIELD_NUMBER: builtins.int + TOTAL_CAPACITY_FIELD_NUMBER: builtins.int + CHANNELS_FIELD_NUMBER: builtins.int + num_channels: builtins.int + """The total number of channels for the node.""" + total_capacity: builtins.int + """The sum of all channels capacity for the node, denominated in satoshis.""" + @property + def node(self) -> global___LightningNode: + """ + An individual vertex/node within the channel graph. A node is + connected to other nodes by one or more channel edges emanating from it. As + the graph is directed, a node will also have an incoming edge attached to + it for each outgoing edge. + """ + + @property + def channels(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___ChannelEdge]: + """A list of all public channels for the node.""" + + def __init__( + self, + *, + node: global___LightningNode | None = ..., + num_channels: builtins.int = ..., + total_capacity: builtins.int = ..., + channels: collections.abc.Iterable[global___ChannelEdge] | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["node", b"node"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["channels", b"channels", "node", b"node", "num_channels", b"num_channels", "total_capacity", b"total_capacity"]) -> None: ... + +global___NodeInfo = NodeInfo + +@typing.final +class LightningNode(google.protobuf.message.Message): + """ + An individual vertex/node within the channel graph. A node is + connected to other nodes by one or more channel edges emanating from it. As the + graph is directed, a node will also have an incoming edge attached to it for + each outgoing edge. + """ + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + @typing.final + class FeaturesEntry(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + KEY_FIELD_NUMBER: builtins.int + VALUE_FIELD_NUMBER: builtins.int + key: builtins.int + @property + def value(self) -> global___Feature: ... + def __init__( + self, + *, + key: builtins.int = ..., + value: global___Feature | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["value", b"value"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["key", b"key", "value", b"value"]) -> None: ... + + @typing.final + class CustomRecordsEntry(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + KEY_FIELD_NUMBER: builtins.int + VALUE_FIELD_NUMBER: builtins.int + key: builtins.int + value: builtins.bytes + def __init__( + self, + *, + key: builtins.int = ..., + value: builtins.bytes = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["key", b"key", "value", b"value"]) -> None: ... + + LAST_UPDATE_FIELD_NUMBER: builtins.int + PUB_KEY_FIELD_NUMBER: builtins.int + ALIAS_FIELD_NUMBER: builtins.int + ADDRESSES_FIELD_NUMBER: builtins.int + COLOR_FIELD_NUMBER: builtins.int + FEATURES_FIELD_NUMBER: builtins.int + CUSTOM_RECORDS_FIELD_NUMBER: builtins.int + last_update: builtins.int + pub_key: builtins.str + alias: builtins.str + color: builtins.str + @property + def addresses(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___NodeAddress]: ... + @property + def features(self) -> google.protobuf.internal.containers.MessageMap[builtins.int, global___Feature]: ... + @property + def custom_records(self) -> google.protobuf.internal.containers.ScalarMap[builtins.int, builtins.bytes]: + """Custom node announcement tlv records.""" + + def __init__( + self, + *, + last_update: builtins.int = ..., + pub_key: builtins.str = ..., + alias: builtins.str = ..., + addresses: collections.abc.Iterable[global___NodeAddress] | None = ..., + color: builtins.str = ..., + features: collections.abc.Mapping[builtins.int, global___Feature] | None = ..., + custom_records: collections.abc.Mapping[builtins.int, builtins.bytes] | None = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["addresses", b"addresses", "alias", b"alias", "color", b"color", "custom_records", b"custom_records", "features", b"features", "last_update", b"last_update", "pub_key", b"pub_key"]) -> None: ... + +global___LightningNode = LightningNode + +@typing.final +class NodeAddress(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + NETWORK_FIELD_NUMBER: builtins.int + ADDR_FIELD_NUMBER: builtins.int + network: builtins.str + addr: builtins.str + def __init__( + self, + *, + network: builtins.str = ..., + addr: builtins.str = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["addr", b"addr", "network", b"network"]) -> None: ... + +global___NodeAddress = NodeAddress + +@typing.final +class RoutingPolicy(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + @typing.final + class CustomRecordsEntry(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + KEY_FIELD_NUMBER: builtins.int + VALUE_FIELD_NUMBER: builtins.int + key: builtins.int + value: builtins.bytes + def __init__( + self, + *, + key: builtins.int = ..., + value: builtins.bytes = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["key", b"key", "value", b"value"]) -> None: ... + + TIME_LOCK_DELTA_FIELD_NUMBER: builtins.int + MIN_HTLC_FIELD_NUMBER: builtins.int + FEE_BASE_MSAT_FIELD_NUMBER: builtins.int + FEE_RATE_MILLI_MSAT_FIELD_NUMBER: builtins.int + DISABLED_FIELD_NUMBER: builtins.int + MAX_HTLC_MSAT_FIELD_NUMBER: builtins.int + LAST_UPDATE_FIELD_NUMBER: builtins.int + CUSTOM_RECORDS_FIELD_NUMBER: builtins.int + INBOUND_FEE_BASE_MSAT_FIELD_NUMBER: builtins.int + INBOUND_FEE_RATE_MILLI_MSAT_FIELD_NUMBER: builtins.int + time_lock_delta: builtins.int + min_htlc: builtins.int + fee_base_msat: builtins.int + fee_rate_milli_msat: builtins.int + disabled: builtins.bool + max_htlc_msat: builtins.int + last_update: builtins.int + inbound_fee_base_msat: builtins.int + inbound_fee_rate_milli_msat: builtins.int + @property + def custom_records(self) -> google.protobuf.internal.containers.ScalarMap[builtins.int, builtins.bytes]: + """Custom channel update tlv records.""" + + def __init__( + self, + *, + time_lock_delta: builtins.int = ..., + min_htlc: builtins.int = ..., + fee_base_msat: builtins.int = ..., + fee_rate_milli_msat: builtins.int = ..., + disabled: builtins.bool = ..., + max_htlc_msat: builtins.int = ..., + last_update: builtins.int = ..., + custom_records: collections.abc.Mapping[builtins.int, builtins.bytes] | None = ..., + inbound_fee_base_msat: builtins.int = ..., + inbound_fee_rate_milli_msat: builtins.int = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["custom_records", b"custom_records", "disabled", b"disabled", "fee_base_msat", b"fee_base_msat", "fee_rate_milli_msat", b"fee_rate_milli_msat", "inbound_fee_base_msat", b"inbound_fee_base_msat", "inbound_fee_rate_milli_msat", b"inbound_fee_rate_milli_msat", "last_update", b"last_update", "max_htlc_msat", b"max_htlc_msat", "min_htlc", b"min_htlc", "time_lock_delta", b"time_lock_delta"]) -> None: ... + +global___RoutingPolicy = RoutingPolicy + +@typing.final +class ChannelEdge(google.protobuf.message.Message): + """ + A fully authenticated channel along with all its unique attributes. + Once an authenticated channel announcement has been processed on the network, + then an instance of ChannelEdgeInfo encapsulating the channels attributes is + stored. The other portions relevant to routing policy of a channel are stored + within a ChannelEdgePolicy for each direction of the channel. + """ + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + @typing.final + class CustomRecordsEntry(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + KEY_FIELD_NUMBER: builtins.int + VALUE_FIELD_NUMBER: builtins.int + key: builtins.int + value: builtins.bytes + def __init__( + self, + *, + key: builtins.int = ..., + value: builtins.bytes = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["key", b"key", "value", b"value"]) -> None: ... + + CHANNEL_ID_FIELD_NUMBER: builtins.int + CHAN_POINT_FIELD_NUMBER: builtins.int + LAST_UPDATE_FIELD_NUMBER: builtins.int + NODE1_PUB_FIELD_NUMBER: builtins.int + NODE2_PUB_FIELD_NUMBER: builtins.int + CAPACITY_FIELD_NUMBER: builtins.int + NODE1_POLICY_FIELD_NUMBER: builtins.int + NODE2_POLICY_FIELD_NUMBER: builtins.int + CUSTOM_RECORDS_FIELD_NUMBER: builtins.int + channel_id: builtins.int + """ + The unique channel ID for the channel. The first 3 bytes are the block + height, the next 3 the index within the block, and the last 2 bytes are the + output index for the channel. + """ + chan_point: builtins.str + last_update: builtins.int + node1_pub: builtins.str + node2_pub: builtins.str + capacity: builtins.int + @property + def node1_policy(self) -> global___RoutingPolicy: ... + @property + def node2_policy(self) -> global___RoutingPolicy: ... + @property + def custom_records(self) -> google.protobuf.internal.containers.ScalarMap[builtins.int, builtins.bytes]: + """Custom channel announcement tlv records.""" + + def __init__( + self, + *, + channel_id: builtins.int = ..., + chan_point: builtins.str = ..., + last_update: builtins.int = ..., + node1_pub: builtins.str = ..., + node2_pub: builtins.str = ..., + capacity: builtins.int = ..., + node1_policy: global___RoutingPolicy | None = ..., + node2_policy: global___RoutingPolicy | None = ..., + custom_records: collections.abc.Mapping[builtins.int, builtins.bytes] | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["node1_policy", b"node1_policy", "node2_policy", b"node2_policy"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["capacity", b"capacity", "chan_point", b"chan_point", "channel_id", b"channel_id", "custom_records", b"custom_records", "last_update", b"last_update", "node1_policy", b"node1_policy", "node1_pub", b"node1_pub", "node2_policy", b"node2_policy", "node2_pub", b"node2_pub"]) -> None: ... + +global___ChannelEdge = ChannelEdge + +@typing.final +class ChannelGraphRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + INCLUDE_UNANNOUNCED_FIELD_NUMBER: builtins.int + include_unannounced: builtins.bool + """ + Whether unannounced channels are included in the response or not. If set, + unannounced channels are included. Unannounced channels are both private + channels, and public channels that are not yet announced to the network. + """ + def __init__( + self, + *, + include_unannounced: builtins.bool = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["include_unannounced", b"include_unannounced"]) -> None: ... + +global___ChannelGraphRequest = ChannelGraphRequest + +@typing.final +class ChannelGraph(google.protobuf.message.Message): + """Returns a new instance of the directed channel graph.""" + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + NODES_FIELD_NUMBER: builtins.int + EDGES_FIELD_NUMBER: builtins.int + @property + def nodes(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___LightningNode]: + """The list of `LightningNode`s in this channel graph""" + + @property + def edges(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___ChannelEdge]: + """The list of `ChannelEdge`s in this channel graph""" + + def __init__( + self, + *, + nodes: collections.abc.Iterable[global___LightningNode] | None = ..., + edges: collections.abc.Iterable[global___ChannelEdge] | None = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["edges", b"edges", "nodes", b"nodes"]) -> None: ... + +global___ChannelGraph = ChannelGraph + +@typing.final +class NodeMetricsRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + TYPES_FIELD_NUMBER: builtins.int + @property + def types(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[global___NodeMetricType.ValueType]: + """The requested node metrics.""" + + def __init__( + self, + *, + types: collections.abc.Iterable[global___NodeMetricType.ValueType] | None = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["types", b"types"]) -> None: ... + +global___NodeMetricsRequest = NodeMetricsRequest + +@typing.final +class NodeMetricsResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + @typing.final + class BetweennessCentralityEntry(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + KEY_FIELD_NUMBER: builtins.int + VALUE_FIELD_NUMBER: builtins.int + key: builtins.str + @property + def value(self) -> global___FloatMetric: ... + def __init__( + self, + *, + key: builtins.str = ..., + value: global___FloatMetric | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["value", b"value"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["key", b"key", "value", b"value"]) -> None: ... + + BETWEENNESS_CENTRALITY_FIELD_NUMBER: builtins.int + @property + def betweenness_centrality(self) -> google.protobuf.internal.containers.MessageMap[builtins.str, global___FloatMetric]: + """ + Betweenness centrality is the sum of the ratio of shortest paths that pass + through the node for each pair of nodes in the graph (not counting paths + starting or ending at this node). + Map of node pubkey to betweenness centrality of the node. Normalized + values are in the [0,1] closed interval. + """ + + def __init__( + self, + *, + betweenness_centrality: collections.abc.Mapping[builtins.str, global___FloatMetric] | None = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["betweenness_centrality", b"betweenness_centrality"]) -> None: ... + +global___NodeMetricsResponse = NodeMetricsResponse + +@typing.final +class FloatMetric(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + VALUE_FIELD_NUMBER: builtins.int + NORMALIZED_VALUE_FIELD_NUMBER: builtins.int + value: builtins.float + """Arbitrary float value.""" + normalized_value: builtins.float + """The value normalized to [0,1] or [-1,1].""" + def __init__( + self, + *, + value: builtins.float = ..., + normalized_value: builtins.float = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["normalized_value", b"normalized_value", "value", b"value"]) -> None: ... + +global___FloatMetric = FloatMetric + +@typing.final +class ChanInfoRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + CHAN_ID_FIELD_NUMBER: builtins.int + CHAN_POINT_FIELD_NUMBER: builtins.int + chan_id: builtins.int + """ + The unique channel ID for the channel. The first 3 bytes are the block + height, the next 3 the index within the block, and the last 2 bytes are the + output index for the channel. + """ + chan_point: builtins.str + """The channel point of the channel in format funding_txid:output_index. If + chan_id is specified, this field is ignored. + """ + def __init__( + self, + *, + chan_id: builtins.int = ..., + chan_point: builtins.str = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["chan_id", b"chan_id", "chan_point", b"chan_point"]) -> None: ... + +global___ChanInfoRequest = ChanInfoRequest + +@typing.final +class NetworkInfoRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +global___NetworkInfoRequest = NetworkInfoRequest + +@typing.final +class NetworkInfo(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + GRAPH_DIAMETER_FIELD_NUMBER: builtins.int + AVG_OUT_DEGREE_FIELD_NUMBER: builtins.int + MAX_OUT_DEGREE_FIELD_NUMBER: builtins.int + NUM_NODES_FIELD_NUMBER: builtins.int + NUM_CHANNELS_FIELD_NUMBER: builtins.int + TOTAL_NETWORK_CAPACITY_FIELD_NUMBER: builtins.int + AVG_CHANNEL_SIZE_FIELD_NUMBER: builtins.int + MIN_CHANNEL_SIZE_FIELD_NUMBER: builtins.int + MAX_CHANNEL_SIZE_FIELD_NUMBER: builtins.int + MEDIAN_CHANNEL_SIZE_SAT_FIELD_NUMBER: builtins.int + NUM_ZOMBIE_CHANS_FIELD_NUMBER: builtins.int + graph_diameter: builtins.int + avg_out_degree: builtins.float + max_out_degree: builtins.int + num_nodes: builtins.int + num_channels: builtins.int + total_network_capacity: builtins.int + avg_channel_size: builtins.float + min_channel_size: builtins.int + max_channel_size: builtins.int + median_channel_size_sat: builtins.int + num_zombie_chans: builtins.int + """The number of edges marked as zombies.""" + def __init__( + self, + *, + graph_diameter: builtins.int = ..., + avg_out_degree: builtins.float = ..., + max_out_degree: builtins.int = ..., + num_nodes: builtins.int = ..., + num_channels: builtins.int = ..., + total_network_capacity: builtins.int = ..., + avg_channel_size: builtins.float = ..., + min_channel_size: builtins.int = ..., + max_channel_size: builtins.int = ..., + median_channel_size_sat: builtins.int = ..., + num_zombie_chans: builtins.int = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["avg_channel_size", b"avg_channel_size", "avg_out_degree", b"avg_out_degree", "graph_diameter", b"graph_diameter", "max_channel_size", b"max_channel_size", "max_out_degree", b"max_out_degree", "median_channel_size_sat", b"median_channel_size_sat", "min_channel_size", b"min_channel_size", "num_channels", b"num_channels", "num_nodes", b"num_nodes", "num_zombie_chans", b"num_zombie_chans", "total_network_capacity", b"total_network_capacity"]) -> None: ... + +global___NetworkInfo = NetworkInfo + +@typing.final +class StopRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +global___StopRequest = StopRequest + +@typing.final +class StopResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +global___StopResponse = StopResponse + +@typing.final +class GraphTopologySubscription(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +global___GraphTopologySubscription = GraphTopologySubscription + +@typing.final +class GraphTopologyUpdate(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + NODE_UPDATES_FIELD_NUMBER: builtins.int + CHANNEL_UPDATES_FIELD_NUMBER: builtins.int + CLOSED_CHANS_FIELD_NUMBER: builtins.int + @property + def node_updates(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___NodeUpdate]: ... + @property + def channel_updates(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___ChannelEdgeUpdate]: ... + @property + def closed_chans(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___ClosedChannelUpdate]: ... + def __init__( + self, + *, + node_updates: collections.abc.Iterable[global___NodeUpdate] | None = ..., + channel_updates: collections.abc.Iterable[global___ChannelEdgeUpdate] | None = ..., + closed_chans: collections.abc.Iterable[global___ClosedChannelUpdate] | None = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["channel_updates", b"channel_updates", "closed_chans", b"closed_chans", "node_updates", b"node_updates"]) -> None: ... + +global___GraphTopologyUpdate = GraphTopologyUpdate + +@typing.final +class NodeUpdate(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + @typing.final + class FeaturesEntry(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + KEY_FIELD_NUMBER: builtins.int + VALUE_FIELD_NUMBER: builtins.int + key: builtins.int + @property + def value(self) -> global___Feature: ... + def __init__( + self, + *, + key: builtins.int = ..., + value: global___Feature | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["value", b"value"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["key", b"key", "value", b"value"]) -> None: ... + + ADDRESSES_FIELD_NUMBER: builtins.int + IDENTITY_KEY_FIELD_NUMBER: builtins.int + GLOBAL_FEATURES_FIELD_NUMBER: builtins.int + ALIAS_FIELD_NUMBER: builtins.int + COLOR_FIELD_NUMBER: builtins.int + NODE_ADDRESSES_FIELD_NUMBER: builtins.int + FEATURES_FIELD_NUMBER: builtins.int + identity_key: builtins.str + global_features: builtins.bytes + """ + Deprecated, use features. + """ + alias: builtins.str + color: builtins.str + @property + def addresses(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.str]: + """ + Deprecated, use node_addresses. + """ + + @property + def node_addresses(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___NodeAddress]: ... + @property + def features(self) -> google.protobuf.internal.containers.MessageMap[builtins.int, global___Feature]: + """ + Features that the node has advertised in the init message, node + announcements and invoices. + """ + + def __init__( + self, + *, + addresses: collections.abc.Iterable[builtins.str] | None = ..., + identity_key: builtins.str = ..., + global_features: builtins.bytes = ..., + alias: builtins.str = ..., + color: builtins.str = ..., + node_addresses: collections.abc.Iterable[global___NodeAddress] | None = ..., + features: collections.abc.Mapping[builtins.int, global___Feature] | None = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["addresses", b"addresses", "alias", b"alias", "color", b"color", "features", b"features", "global_features", b"global_features", "identity_key", b"identity_key", "node_addresses", b"node_addresses"]) -> None: ... + +global___NodeUpdate = NodeUpdate + +@typing.final +class ChannelEdgeUpdate(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + CHAN_ID_FIELD_NUMBER: builtins.int + CHAN_POINT_FIELD_NUMBER: builtins.int + CAPACITY_FIELD_NUMBER: builtins.int + ROUTING_POLICY_FIELD_NUMBER: builtins.int + ADVERTISING_NODE_FIELD_NUMBER: builtins.int + CONNECTING_NODE_FIELD_NUMBER: builtins.int + chan_id: builtins.int + """ + The unique channel ID for the channel. The first 3 bytes are the block + height, the next 3 the index within the block, and the last 2 bytes are the + output index for the channel. + """ + capacity: builtins.int + advertising_node: builtins.str + connecting_node: builtins.str + @property + def chan_point(self) -> global___ChannelPoint: ... + @property + def routing_policy(self) -> global___RoutingPolicy: ... + def __init__( + self, + *, + chan_id: builtins.int = ..., + chan_point: global___ChannelPoint | None = ..., + capacity: builtins.int = ..., + routing_policy: global___RoutingPolicy | None = ..., + advertising_node: builtins.str = ..., + connecting_node: builtins.str = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["chan_point", b"chan_point", "routing_policy", b"routing_policy"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["advertising_node", b"advertising_node", "capacity", b"capacity", "chan_id", b"chan_id", "chan_point", b"chan_point", "connecting_node", b"connecting_node", "routing_policy", b"routing_policy"]) -> None: ... + +global___ChannelEdgeUpdate = ChannelEdgeUpdate + +@typing.final +class ClosedChannelUpdate(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + CHAN_ID_FIELD_NUMBER: builtins.int + CAPACITY_FIELD_NUMBER: builtins.int + CLOSED_HEIGHT_FIELD_NUMBER: builtins.int + CHAN_POINT_FIELD_NUMBER: builtins.int + chan_id: builtins.int + """ + The unique channel ID for the channel. The first 3 bytes are the block + height, the next 3 the index within the block, and the last 2 bytes are the + output index for the channel. + """ + capacity: builtins.int + closed_height: builtins.int + @property + def chan_point(self) -> global___ChannelPoint: ... + def __init__( + self, + *, + chan_id: builtins.int = ..., + capacity: builtins.int = ..., + closed_height: builtins.int = ..., + chan_point: global___ChannelPoint | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["chan_point", b"chan_point"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["capacity", b"capacity", "chan_id", b"chan_id", "chan_point", b"chan_point", "closed_height", b"closed_height"]) -> None: ... + +global___ClosedChannelUpdate = ClosedChannelUpdate + +@typing.final +class HopHint(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + NODE_ID_FIELD_NUMBER: builtins.int + CHAN_ID_FIELD_NUMBER: builtins.int + FEE_BASE_MSAT_FIELD_NUMBER: builtins.int + FEE_PROPORTIONAL_MILLIONTHS_FIELD_NUMBER: builtins.int + CLTV_EXPIRY_DELTA_FIELD_NUMBER: builtins.int + node_id: builtins.str + """The public key of the node at the start of the channel.""" + chan_id: builtins.int + """The unique identifier of the channel.""" + fee_base_msat: builtins.int + """The base fee of the channel denominated in millisatoshis.""" + fee_proportional_millionths: builtins.int + """ + The fee rate of the channel for sending one satoshi across it denominated in + millionths of a satoshi. + """ + cltv_expiry_delta: builtins.int + """The time-lock delta of the channel.""" + def __init__( + self, + *, + node_id: builtins.str = ..., + chan_id: builtins.int = ..., + fee_base_msat: builtins.int = ..., + fee_proportional_millionths: builtins.int = ..., + cltv_expiry_delta: builtins.int = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["chan_id", b"chan_id", "cltv_expiry_delta", b"cltv_expiry_delta", "fee_base_msat", b"fee_base_msat", "fee_proportional_millionths", b"fee_proportional_millionths", "node_id", b"node_id"]) -> None: ... + +global___HopHint = HopHint + +@typing.final +class SetID(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + SET_ID_FIELD_NUMBER: builtins.int + set_id: builtins.bytes + def __init__( + self, + *, + set_id: builtins.bytes = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["set_id", b"set_id"]) -> None: ... + +global___SetID = SetID + +@typing.final +class RouteHint(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + HOP_HINTS_FIELD_NUMBER: builtins.int + @property + def hop_hints(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___HopHint]: + """ + A list of hop hints that when chained together can assist in reaching a + specific destination. + """ + + def __init__( + self, + *, + hop_hints: collections.abc.Iterable[global___HopHint] | None = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["hop_hints", b"hop_hints"]) -> None: ... + +global___RouteHint = RouteHint + +@typing.final +class BlindedPaymentPath(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + BLINDED_PATH_FIELD_NUMBER: builtins.int + BASE_FEE_MSAT_FIELD_NUMBER: builtins.int + PROPORTIONAL_FEE_RATE_FIELD_NUMBER: builtins.int + TOTAL_CLTV_DELTA_FIELD_NUMBER: builtins.int + HTLC_MIN_MSAT_FIELD_NUMBER: builtins.int + HTLC_MAX_MSAT_FIELD_NUMBER: builtins.int + FEATURES_FIELD_NUMBER: builtins.int + base_fee_msat: builtins.int + """The base fee for the blinded path provided, expressed in msat.""" + proportional_fee_rate: builtins.int + """ + The proportional fee for the blinded path provided, expressed in parts + per million. + """ + total_cltv_delta: builtins.int + """ + The total CLTV delta for the blinded path provided, including the + final CLTV delta for the receiving node. + """ + htlc_min_msat: builtins.int + """ + The minimum hltc size that may be sent over the blinded path, expressed + in msat. + """ + htlc_max_msat: builtins.int + """ + The maximum htlc size that may be sent over the blinded path, expressed + in msat. + """ + @property + def blinded_path(self) -> global___BlindedPath: + """The blinded path to send the payment to.""" + + @property + def features(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[global___FeatureBit.ValueType]: + """The feature bits for the route.""" + + def __init__( + self, + *, + blinded_path: global___BlindedPath | None = ..., + base_fee_msat: builtins.int = ..., + proportional_fee_rate: builtins.int = ..., + total_cltv_delta: builtins.int = ..., + htlc_min_msat: builtins.int = ..., + htlc_max_msat: builtins.int = ..., + features: collections.abc.Iterable[global___FeatureBit.ValueType] | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["blinded_path", b"blinded_path"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["base_fee_msat", b"base_fee_msat", "blinded_path", b"blinded_path", "features", b"features", "htlc_max_msat", b"htlc_max_msat", "htlc_min_msat", b"htlc_min_msat", "proportional_fee_rate", b"proportional_fee_rate", "total_cltv_delta", b"total_cltv_delta"]) -> None: ... + +global___BlindedPaymentPath = BlindedPaymentPath + +@typing.final +class BlindedPath(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + INTRODUCTION_NODE_FIELD_NUMBER: builtins.int + BLINDING_POINT_FIELD_NUMBER: builtins.int + BLINDED_HOPS_FIELD_NUMBER: builtins.int + introduction_node: builtins.bytes + """The unblinded pubkey of the introduction node for the route.""" + blinding_point: builtins.bytes + """The ephemeral pubkey used by nodes in the blinded route.""" + @property + def blinded_hops(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___BlindedHop]: + """ + A set of blinded node keys and data blobs for the blinded portion of the + route. Note that the first hop is expected to be the introduction node, + so the route is always expected to have at least one hop. + """ + + def __init__( + self, + *, + introduction_node: builtins.bytes = ..., + blinding_point: builtins.bytes = ..., + blinded_hops: collections.abc.Iterable[global___BlindedHop] | None = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["blinded_hops", b"blinded_hops", "blinding_point", b"blinding_point", "introduction_node", b"introduction_node"]) -> None: ... + +global___BlindedPath = BlindedPath + +@typing.final +class BlindedHop(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + BLINDED_NODE_FIELD_NUMBER: builtins.int + ENCRYPTED_DATA_FIELD_NUMBER: builtins.int + blinded_node: builtins.bytes + """The blinded public key of the node.""" + encrypted_data: builtins.bytes + """An encrypted blob of data provided to the blinded node.""" + def __init__( + self, + *, + blinded_node: builtins.bytes = ..., + encrypted_data: builtins.bytes = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["blinded_node", b"blinded_node", "encrypted_data", b"encrypted_data"]) -> None: ... + +global___BlindedHop = BlindedHop + +@typing.final +class AMPInvoiceState(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + STATE_FIELD_NUMBER: builtins.int + SETTLE_INDEX_FIELD_NUMBER: builtins.int + SETTLE_TIME_FIELD_NUMBER: builtins.int + AMT_PAID_MSAT_FIELD_NUMBER: builtins.int + state: global___InvoiceHTLCState.ValueType + """The state the HTLCs associated with this setID are in.""" + settle_index: builtins.int + """The settle index of this HTLC set, if the invoice state is settled.""" + settle_time: builtins.int + """The time this HTLC set was settled expressed in unix epoch.""" + amt_paid_msat: builtins.int + """The total amount paid for the sub-invoice expressed in milli satoshis.""" + def __init__( + self, + *, + state: global___InvoiceHTLCState.ValueType = ..., + settle_index: builtins.int = ..., + settle_time: builtins.int = ..., + amt_paid_msat: builtins.int = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["amt_paid_msat", b"amt_paid_msat", "settle_index", b"settle_index", "settle_time", b"settle_time", "state", b"state"]) -> None: ... + +global___AMPInvoiceState = AMPInvoiceState + +@typing.final +class Invoice(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + class _InvoiceState: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + + class _InvoiceStateEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[Invoice._InvoiceState.ValueType], builtins.type): # noqa: F821 + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + OPEN: Invoice._InvoiceState.ValueType # 0 + SETTLED: Invoice._InvoiceState.ValueType # 1 + CANCELED: Invoice._InvoiceState.ValueType # 2 + ACCEPTED: Invoice._InvoiceState.ValueType # 3 + + class InvoiceState(_InvoiceState, metaclass=_InvoiceStateEnumTypeWrapper): ... + OPEN: Invoice.InvoiceState.ValueType # 0 + SETTLED: Invoice.InvoiceState.ValueType # 1 + CANCELED: Invoice.InvoiceState.ValueType # 2 + ACCEPTED: Invoice.InvoiceState.ValueType # 3 + + @typing.final + class FeaturesEntry(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + KEY_FIELD_NUMBER: builtins.int + VALUE_FIELD_NUMBER: builtins.int + key: builtins.int + @property + def value(self) -> global___Feature: ... + def __init__( + self, + *, + key: builtins.int = ..., + value: global___Feature | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["value", b"value"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["key", b"key", "value", b"value"]) -> None: ... + + @typing.final + class AmpInvoiceStateEntry(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + KEY_FIELD_NUMBER: builtins.int + VALUE_FIELD_NUMBER: builtins.int + key: builtins.str + @property + def value(self) -> global___AMPInvoiceState: ... + def __init__( + self, + *, + key: builtins.str = ..., + value: global___AMPInvoiceState | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["value", b"value"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["key", b"key", "value", b"value"]) -> None: ... + + MEMO_FIELD_NUMBER: builtins.int + R_PREIMAGE_FIELD_NUMBER: builtins.int + R_HASH_FIELD_NUMBER: builtins.int + VALUE_FIELD_NUMBER: builtins.int + VALUE_MSAT_FIELD_NUMBER: builtins.int + SETTLED_FIELD_NUMBER: builtins.int + CREATION_DATE_FIELD_NUMBER: builtins.int + SETTLE_DATE_FIELD_NUMBER: builtins.int + PAYMENT_REQUEST_FIELD_NUMBER: builtins.int + DESCRIPTION_HASH_FIELD_NUMBER: builtins.int + EXPIRY_FIELD_NUMBER: builtins.int + FALLBACK_ADDR_FIELD_NUMBER: builtins.int + CLTV_EXPIRY_FIELD_NUMBER: builtins.int + ROUTE_HINTS_FIELD_NUMBER: builtins.int + PRIVATE_FIELD_NUMBER: builtins.int + ADD_INDEX_FIELD_NUMBER: builtins.int + SETTLE_INDEX_FIELD_NUMBER: builtins.int + AMT_PAID_FIELD_NUMBER: builtins.int + AMT_PAID_SAT_FIELD_NUMBER: builtins.int + AMT_PAID_MSAT_FIELD_NUMBER: builtins.int + STATE_FIELD_NUMBER: builtins.int + HTLCS_FIELD_NUMBER: builtins.int + FEATURES_FIELD_NUMBER: builtins.int + IS_KEYSEND_FIELD_NUMBER: builtins.int + PAYMENT_ADDR_FIELD_NUMBER: builtins.int + IS_AMP_FIELD_NUMBER: builtins.int + AMP_INVOICE_STATE_FIELD_NUMBER: builtins.int + memo: builtins.str + """ + An optional memo to attach along with the invoice. Used for record keeping + purposes for the invoice's creator, and will also be set in the description + field of the encoded payment request if the description_hash field is not + being used. + """ + r_preimage: builtins.bytes + """ + The hex-encoded preimage (32 byte) which will allow settling an incoming + HTLC payable to this preimage. When using REST, this field must be encoded + as base64. + """ + r_hash: builtins.bytes + """ + The hash of the preimage. When using REST, this field must be encoded as + base64. + Note: Output only, don't specify for creating an invoice. + """ + value: builtins.int + """ + The value of this invoice in satoshis + + The fields value and value_msat are mutually exclusive. + """ + value_msat: builtins.int + """ + The value of this invoice in millisatoshis + + The fields value and value_msat are mutually exclusive. + """ + settled: builtins.bool + """ + Whether this invoice has been fulfilled. + + The field is deprecated. Use the state field instead (compare to SETTLED). + """ + creation_date: builtins.int + """ + When this invoice was created. + Measured in seconds since the unix epoch. + Note: Output only, don't specify for creating an invoice. + """ + settle_date: builtins.int + """ + When this invoice was settled. + Measured in seconds since the unix epoch. + Note: Output only, don't specify for creating an invoice. + """ + payment_request: builtins.str + """ + A bare-bones invoice for a payment within the Lightning Network. With the + details of the invoice, the sender has all the data necessary to send a + payment to the recipient. + Note: Output only, don't specify for creating an invoice. + """ + description_hash: builtins.bytes + """ + Hash (SHA-256) of a description of the payment. Used if the description of + payment (memo) is too long to naturally fit within the description field + of an encoded payment request. When using REST, this field must be encoded + as base64. + """ + expiry: builtins.int + """Payment request expiry time in seconds. Default is 86400 (24 hours).""" + fallback_addr: builtins.str + """Fallback on-chain address.""" + cltv_expiry: builtins.int + """Delta to use for the time-lock of the CLTV extended to the final hop.""" + private: builtins.bool + """Whether this invoice should include routing hints for private channels. + Note: When enabled, if value and value_msat are zero, a large number of + hints with these channels can be included, which might not be desirable. + """ + add_index: builtins.int + """ + The "add" index of this invoice. Each newly created invoice will increment + this index making it monotonically increasing. Callers to the + SubscribeInvoices call can use this to instantly get notified of all added + invoices with an add_index greater than this one. + Note: Output only, don't specify for creating an invoice. + """ + settle_index: builtins.int + """ + The "settle" index of this invoice. Each newly settled invoice will + increment this index making it monotonically increasing. Callers to the + SubscribeInvoices call can use this to instantly get notified of all + settled invoices with an settle_index greater than this one. + Note: Output only, don't specify for creating an invoice. + """ + amt_paid: builtins.int + """Deprecated, use amt_paid_sat or amt_paid_msat.""" + amt_paid_sat: builtins.int + """ + The amount that was accepted for this invoice, in satoshis. This will ONLY + be set if this invoice has been settled or accepted. We provide this field + as if the invoice was created with a zero value, then we need to record what + amount was ultimately accepted. Additionally, it's possible that the sender + paid MORE that was specified in the original invoice. So we'll record that + here as well. + Note: Output only, don't specify for creating an invoice. + """ + amt_paid_msat: builtins.int + """ + The amount that was accepted for this invoice, in millisatoshis. This will + ONLY be set if this invoice has been settled or accepted. We provide this + field as if the invoice was created with a zero value, then we need to + record what amount was ultimately accepted. Additionally, it's possible that + the sender paid MORE that was specified in the original invoice. So we'll + record that here as well. + Note: Output only, don't specify for creating an invoice. + """ + state: global___Invoice.InvoiceState.ValueType + """ + The state the invoice is in. + Note: Output only, don't specify for creating an invoice. + """ + is_keysend: builtins.bool + """ + Indicates if this invoice was a spontaneous payment that arrived via keysend + [EXPERIMENTAL]. + Note: Output only, don't specify for creating an invoice. + """ + payment_addr: builtins.bytes + """ + The payment address of this invoice. This is also called payment secret in + specifications (e.g. BOLT 11). This value will be used in MPP payments, and + also for newer invoices that always require the MPP payload for added + end-to-end security. + Note: Output only, don't specify for creating an invoice. + """ + is_amp: builtins.bool + """ + Signals whether or not this is an AMP invoice. + """ + @property + def route_hints(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___RouteHint]: + """ + Route hints that can each be individually used to assist in reaching the + invoice's destination. + """ + + @property + def htlcs(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___InvoiceHTLC]: + """ + List of HTLCs paying to this invoice [EXPERIMENTAL]. + Note: Output only, don't specify for creating an invoice. + """ + + @property + def features(self) -> google.protobuf.internal.containers.MessageMap[builtins.int, global___Feature]: + """ + List of features advertised on the invoice. + Note: Output only, don't specify for creating an invoice. + """ + + @property + def amp_invoice_state(self) -> google.protobuf.internal.containers.MessageMap[builtins.str, global___AMPInvoiceState]: + """ + [EXPERIMENTAL]: + + Maps a 32-byte hex-encoded set ID to the sub-invoice AMP state for the + given set ID. This field is always populated for AMP invoices, and can be + used along side LookupInvoice to obtain the HTLC information related to a + given sub-invoice. + Note: Output only, don't specify for creating an invoice. + """ + + def __init__( + self, + *, + memo: builtins.str = ..., + r_preimage: builtins.bytes = ..., + r_hash: builtins.bytes = ..., + value: builtins.int = ..., + value_msat: builtins.int = ..., + settled: builtins.bool = ..., + creation_date: builtins.int = ..., + settle_date: builtins.int = ..., + payment_request: builtins.str = ..., + description_hash: builtins.bytes = ..., + expiry: builtins.int = ..., + fallback_addr: builtins.str = ..., + cltv_expiry: builtins.int = ..., + route_hints: collections.abc.Iterable[global___RouteHint] | None = ..., + private: builtins.bool = ..., + add_index: builtins.int = ..., + settle_index: builtins.int = ..., + amt_paid: builtins.int = ..., + amt_paid_sat: builtins.int = ..., + amt_paid_msat: builtins.int = ..., + state: global___Invoice.InvoiceState.ValueType = ..., + htlcs: collections.abc.Iterable[global___InvoiceHTLC] | None = ..., + features: collections.abc.Mapping[builtins.int, global___Feature] | None = ..., + is_keysend: builtins.bool = ..., + payment_addr: builtins.bytes = ..., + is_amp: builtins.bool = ..., + amp_invoice_state: collections.abc.Mapping[builtins.str, global___AMPInvoiceState] | None = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["add_index", b"add_index", "amp_invoice_state", b"amp_invoice_state", "amt_paid", b"amt_paid", "amt_paid_msat", b"amt_paid_msat", "amt_paid_sat", b"amt_paid_sat", "cltv_expiry", b"cltv_expiry", "creation_date", b"creation_date", "description_hash", b"description_hash", "expiry", b"expiry", "fallback_addr", b"fallback_addr", "features", b"features", "htlcs", b"htlcs", "is_amp", b"is_amp", "is_keysend", b"is_keysend", "memo", b"memo", "payment_addr", b"payment_addr", "payment_request", b"payment_request", "private", b"private", "r_hash", b"r_hash", "r_preimage", b"r_preimage", "route_hints", b"route_hints", "settle_date", b"settle_date", "settle_index", b"settle_index", "settled", b"settled", "state", b"state", "value", b"value", "value_msat", b"value_msat"]) -> None: ... + +global___Invoice = Invoice + +@typing.final +class InvoiceHTLC(google.protobuf.message.Message): + """Details of an HTLC that paid to an invoice""" + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + @typing.final + class CustomRecordsEntry(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + KEY_FIELD_NUMBER: builtins.int + VALUE_FIELD_NUMBER: builtins.int + key: builtins.int + value: builtins.bytes + def __init__( + self, + *, + key: builtins.int = ..., + value: builtins.bytes = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["key", b"key", "value", b"value"]) -> None: ... + + CHAN_ID_FIELD_NUMBER: builtins.int + HTLC_INDEX_FIELD_NUMBER: builtins.int + AMT_MSAT_FIELD_NUMBER: builtins.int + ACCEPT_HEIGHT_FIELD_NUMBER: builtins.int + ACCEPT_TIME_FIELD_NUMBER: builtins.int + RESOLVE_TIME_FIELD_NUMBER: builtins.int + EXPIRY_HEIGHT_FIELD_NUMBER: builtins.int + STATE_FIELD_NUMBER: builtins.int + CUSTOM_RECORDS_FIELD_NUMBER: builtins.int + MPP_TOTAL_AMT_MSAT_FIELD_NUMBER: builtins.int + AMP_FIELD_NUMBER: builtins.int + chan_id: builtins.int + """Short channel id over which the htlc was received.""" + htlc_index: builtins.int + """Index identifying the htlc on the channel.""" + amt_msat: builtins.int + """The amount of the htlc in msat.""" + accept_height: builtins.int + """Block height at which this htlc was accepted.""" + accept_time: builtins.int + """Time at which this htlc was accepted.""" + resolve_time: builtins.int + """Time at which this htlc was settled or canceled.""" + expiry_height: builtins.int + """Block height at which this htlc expires.""" + state: global___InvoiceHTLCState.ValueType + """Current state the htlc is in.""" + mpp_total_amt_msat: builtins.int + """The total amount of the mpp payment in msat.""" + @property + def custom_records(self) -> google.protobuf.internal.containers.ScalarMap[builtins.int, builtins.bytes]: + """Custom tlv records.""" + + @property + def amp(self) -> global___AMP: + """Details relevant to AMP HTLCs, only populated if this is an AMP HTLC.""" + + def __init__( + self, + *, + chan_id: builtins.int = ..., + htlc_index: builtins.int = ..., + amt_msat: builtins.int = ..., + accept_height: builtins.int = ..., + accept_time: builtins.int = ..., + resolve_time: builtins.int = ..., + expiry_height: builtins.int = ..., + state: global___InvoiceHTLCState.ValueType = ..., + custom_records: collections.abc.Mapping[builtins.int, builtins.bytes] | None = ..., + mpp_total_amt_msat: builtins.int = ..., + amp: global___AMP | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["amp", b"amp"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["accept_height", b"accept_height", "accept_time", b"accept_time", "amp", b"amp", "amt_msat", b"amt_msat", "chan_id", b"chan_id", "custom_records", b"custom_records", "expiry_height", b"expiry_height", "htlc_index", b"htlc_index", "mpp_total_amt_msat", b"mpp_total_amt_msat", "resolve_time", b"resolve_time", "state", b"state"]) -> None: ... + +global___InvoiceHTLC = InvoiceHTLC + +@typing.final +class AMP(google.protobuf.message.Message): + """Details specific to AMP HTLCs.""" + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + ROOT_SHARE_FIELD_NUMBER: builtins.int + SET_ID_FIELD_NUMBER: builtins.int + CHILD_INDEX_FIELD_NUMBER: builtins.int + HASH_FIELD_NUMBER: builtins.int + PREIMAGE_FIELD_NUMBER: builtins.int + root_share: builtins.bytes + """An n-of-n secret share of the root seed from which child payment hashes + and preimages are derived. + """ + set_id: builtins.bytes + """An identifier for the HTLC set that this HTLC belongs to.""" + child_index: builtins.int + """A nonce used to randomize the child preimage and child hash from a given + root_share. + """ + hash: builtins.bytes + """The payment hash of the AMP HTLC.""" + preimage: builtins.bytes + """The preimage used to settle this AMP htlc. This field will only be + populated if the invoice is in InvoiceState_ACCEPTED or + InvoiceState_SETTLED. + """ + def __init__( + self, + *, + root_share: builtins.bytes = ..., + set_id: builtins.bytes = ..., + child_index: builtins.int = ..., + hash: builtins.bytes = ..., + preimage: builtins.bytes = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["child_index", b"child_index", "hash", b"hash", "preimage", b"preimage", "root_share", b"root_share", "set_id", b"set_id"]) -> None: ... + +global___AMP = AMP + +@typing.final +class AddInvoiceResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + R_HASH_FIELD_NUMBER: builtins.int + PAYMENT_REQUEST_FIELD_NUMBER: builtins.int + ADD_INDEX_FIELD_NUMBER: builtins.int + PAYMENT_ADDR_FIELD_NUMBER: builtins.int + r_hash: builtins.bytes + payment_request: builtins.str + """ + A bare-bones invoice for a payment within the Lightning Network. With the + details of the invoice, the sender has all the data necessary to send a + payment to the recipient. + """ + add_index: builtins.int + """ + The "add" index of this invoice. Each newly created invoice will increment + this index making it monotonically increasing. Callers to the + SubscribeInvoices call can use this to instantly get notified of all added + invoices with an add_index greater than this one. + """ + payment_addr: builtins.bytes + """ + The payment address of the generated invoice. This is also called + payment secret in specifications (e.g. BOLT 11). This value should be used + in all payments for this invoice as we require it for end to end security. + """ + def __init__( + self, + *, + r_hash: builtins.bytes = ..., + payment_request: builtins.str = ..., + add_index: builtins.int = ..., + payment_addr: builtins.bytes = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["add_index", b"add_index", "payment_addr", b"payment_addr", "payment_request", b"payment_request", "r_hash", b"r_hash"]) -> None: ... + +global___AddInvoiceResponse = AddInvoiceResponse + +@typing.final +class PaymentHash(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + R_HASH_STR_FIELD_NUMBER: builtins.int + R_HASH_FIELD_NUMBER: builtins.int + r_hash_str: builtins.str + """ + The hex-encoded payment hash of the invoice to be looked up. The passed + payment hash must be exactly 32 bytes, otherwise an error is returned. + Deprecated now that the REST gateway supports base64 encoding of bytes + fields. + """ + r_hash: builtins.bytes + """ + The payment hash of the invoice to be looked up. When using REST, this field + must be encoded as base64. + """ + def __init__( + self, + *, + r_hash_str: builtins.str = ..., + r_hash: builtins.bytes = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["r_hash", b"r_hash", "r_hash_str", b"r_hash_str"]) -> None: ... + +global___PaymentHash = PaymentHash + +@typing.final +class ListInvoiceRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + PENDING_ONLY_FIELD_NUMBER: builtins.int + INDEX_OFFSET_FIELD_NUMBER: builtins.int + NUM_MAX_INVOICES_FIELD_NUMBER: builtins.int + REVERSED_FIELD_NUMBER: builtins.int + CREATION_DATE_START_FIELD_NUMBER: builtins.int + CREATION_DATE_END_FIELD_NUMBER: builtins.int + pending_only: builtins.bool + """ + If set, only invoices that are not settled and not canceled will be returned + in the response. + """ + index_offset: builtins.int + """ + The index of an invoice that will be used as either the start or end of a + query to determine which invoices should be returned in the response. + """ + num_max_invoices: builtins.int + """The max number of invoices to return in the response to this query.""" + reversed: builtins.bool + """ + If set, the invoices returned will result from seeking backwards from the + specified index offset. This can be used to paginate backwards. + """ + creation_date_start: builtins.int + """If set, returns all invoices with a creation date greater than or equal + to it. Measured in seconds since the unix epoch. + """ + creation_date_end: builtins.int + """If set, returns all invoices with a creation date less than or equal to + it. Measured in seconds since the unix epoch. + """ + def __init__( + self, + *, + pending_only: builtins.bool = ..., + index_offset: builtins.int = ..., + num_max_invoices: builtins.int = ..., + reversed: builtins.bool = ..., + creation_date_start: builtins.int = ..., + creation_date_end: builtins.int = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["creation_date_end", b"creation_date_end", "creation_date_start", b"creation_date_start", "index_offset", b"index_offset", "num_max_invoices", b"num_max_invoices", "pending_only", b"pending_only", "reversed", b"reversed"]) -> None: ... + +global___ListInvoiceRequest = ListInvoiceRequest + +@typing.final +class ListInvoiceResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + INVOICES_FIELD_NUMBER: builtins.int + LAST_INDEX_OFFSET_FIELD_NUMBER: builtins.int + FIRST_INDEX_OFFSET_FIELD_NUMBER: builtins.int + last_index_offset: builtins.int + """ + The index of the last item in the set of returned invoices. This can be used + to seek further, pagination style. + """ + first_index_offset: builtins.int + """ + The index of the last item in the set of returned invoices. This can be used + to seek backwards, pagination style. + """ + @property + def invoices(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___Invoice]: + """ + A list of invoices from the time slice of the time series specified in the + request. + """ + + def __init__( + self, + *, + invoices: collections.abc.Iterable[global___Invoice] | None = ..., + last_index_offset: builtins.int = ..., + first_index_offset: builtins.int = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["first_index_offset", b"first_index_offset", "invoices", b"invoices", "last_index_offset", b"last_index_offset"]) -> None: ... + +global___ListInvoiceResponse = ListInvoiceResponse + +@typing.final +class InvoiceSubscription(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + ADD_INDEX_FIELD_NUMBER: builtins.int + SETTLE_INDEX_FIELD_NUMBER: builtins.int + add_index: builtins.int + """ + If specified (non-zero), then we'll first start by sending out + notifications for all added indexes with an add_index greater than this + value. This allows callers to catch up on any events they missed while they + weren't connected to the streaming RPC. + """ + settle_index: builtins.int + """ + If specified (non-zero), then we'll first start by sending out + notifications for all settled indexes with an settle_index greater than + this value. This allows callers to catch up on any events they missed while + they weren't connected to the streaming RPC. + """ + def __init__( + self, + *, + add_index: builtins.int = ..., + settle_index: builtins.int = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["add_index", b"add_index", "settle_index", b"settle_index"]) -> None: ... + +global___InvoiceSubscription = InvoiceSubscription + +@typing.final +class Payment(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + class _PaymentStatus: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + + class _PaymentStatusEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[Payment._PaymentStatus.ValueType], builtins.type): # noqa: F821 + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + UNKNOWN: Payment._PaymentStatus.ValueType # 0 + """Deprecated. This status will never be returned.""" + IN_FLIGHT: Payment._PaymentStatus.ValueType # 1 + """Payment has inflight HTLCs.""" + SUCCEEDED: Payment._PaymentStatus.ValueType # 2 + """Payment is settled.""" + FAILED: Payment._PaymentStatus.ValueType # 3 + """Payment is failed.""" + INITIATED: Payment._PaymentStatus.ValueType # 4 + """Payment is created and has not attempted any HTLCs.""" + + class PaymentStatus(_PaymentStatus, metaclass=_PaymentStatusEnumTypeWrapper): ... + UNKNOWN: Payment.PaymentStatus.ValueType # 0 + """Deprecated. This status will never be returned.""" + IN_FLIGHT: Payment.PaymentStatus.ValueType # 1 + """Payment has inflight HTLCs.""" + SUCCEEDED: Payment.PaymentStatus.ValueType # 2 + """Payment is settled.""" + FAILED: Payment.PaymentStatus.ValueType # 3 + """Payment is failed.""" + INITIATED: Payment.PaymentStatus.ValueType # 4 + """Payment is created and has not attempted any HTLCs.""" + + PAYMENT_HASH_FIELD_NUMBER: builtins.int + VALUE_FIELD_NUMBER: builtins.int + CREATION_DATE_FIELD_NUMBER: builtins.int + FEE_FIELD_NUMBER: builtins.int + PAYMENT_PREIMAGE_FIELD_NUMBER: builtins.int + VALUE_SAT_FIELD_NUMBER: builtins.int + VALUE_MSAT_FIELD_NUMBER: builtins.int + PAYMENT_REQUEST_FIELD_NUMBER: builtins.int + STATUS_FIELD_NUMBER: builtins.int + FEE_SAT_FIELD_NUMBER: builtins.int + FEE_MSAT_FIELD_NUMBER: builtins.int + CREATION_TIME_NS_FIELD_NUMBER: builtins.int + HTLCS_FIELD_NUMBER: builtins.int + PAYMENT_INDEX_FIELD_NUMBER: builtins.int + FAILURE_REASON_FIELD_NUMBER: builtins.int + payment_hash: builtins.str + """The payment hash""" + value: builtins.int + """Deprecated, use value_sat or value_msat.""" + creation_date: builtins.int + """Deprecated, use creation_time_ns""" + fee: builtins.int + """Deprecated, use fee_sat or fee_msat.""" + payment_preimage: builtins.str + """The payment preimage""" + value_sat: builtins.int + """The value of the payment in satoshis""" + value_msat: builtins.int + """The value of the payment in milli-satoshis""" + payment_request: builtins.str + """The optional payment request being fulfilled.""" + status: global___Payment.PaymentStatus.ValueType + """The status of the payment.""" + fee_sat: builtins.int + """ The fee paid for this payment in satoshis""" + fee_msat: builtins.int + """ The fee paid for this payment in milli-satoshis""" + creation_time_ns: builtins.int + """The time in UNIX nanoseconds at which the payment was created.""" + payment_index: builtins.int + """ + The creation index of this payment. Each payment can be uniquely identified + by this index, which may not strictly increment by 1 for payments made in + older versions of lnd. + """ + failure_reason: global___PaymentFailureReason.ValueType + @property + def htlcs(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___HTLCAttempt]: + """The HTLCs made in attempt to settle the payment.""" + + def __init__( + self, + *, + payment_hash: builtins.str = ..., + value: builtins.int = ..., + creation_date: builtins.int = ..., + fee: builtins.int = ..., + payment_preimage: builtins.str = ..., + value_sat: builtins.int = ..., + value_msat: builtins.int = ..., + payment_request: builtins.str = ..., + status: global___Payment.PaymentStatus.ValueType = ..., + fee_sat: builtins.int = ..., + fee_msat: builtins.int = ..., + creation_time_ns: builtins.int = ..., + htlcs: collections.abc.Iterable[global___HTLCAttempt] | None = ..., + payment_index: builtins.int = ..., + failure_reason: global___PaymentFailureReason.ValueType = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["creation_date", b"creation_date", "creation_time_ns", b"creation_time_ns", "failure_reason", b"failure_reason", "fee", b"fee", "fee_msat", b"fee_msat", "fee_sat", b"fee_sat", "htlcs", b"htlcs", "payment_hash", b"payment_hash", "payment_index", b"payment_index", "payment_preimage", b"payment_preimage", "payment_request", b"payment_request", "status", b"status", "value", b"value", "value_msat", b"value_msat", "value_sat", b"value_sat"]) -> None: ... + +global___Payment = Payment + +@typing.final +class HTLCAttempt(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + class _HTLCStatus: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + + class _HTLCStatusEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[HTLCAttempt._HTLCStatus.ValueType], builtins.type): # noqa: F821 + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + IN_FLIGHT: HTLCAttempt._HTLCStatus.ValueType # 0 + SUCCEEDED: HTLCAttempt._HTLCStatus.ValueType # 1 + FAILED: HTLCAttempt._HTLCStatus.ValueType # 2 + + class HTLCStatus(_HTLCStatus, metaclass=_HTLCStatusEnumTypeWrapper): ... + IN_FLIGHT: HTLCAttempt.HTLCStatus.ValueType # 0 + SUCCEEDED: HTLCAttempt.HTLCStatus.ValueType # 1 + FAILED: HTLCAttempt.HTLCStatus.ValueType # 2 + + ATTEMPT_ID_FIELD_NUMBER: builtins.int + STATUS_FIELD_NUMBER: builtins.int + ROUTE_FIELD_NUMBER: builtins.int + ATTEMPT_TIME_NS_FIELD_NUMBER: builtins.int + RESOLVE_TIME_NS_FIELD_NUMBER: builtins.int + FAILURE_FIELD_NUMBER: builtins.int + PREIMAGE_FIELD_NUMBER: builtins.int + attempt_id: builtins.int + """The unique ID that is used for this attempt.""" + status: global___HTLCAttempt.HTLCStatus.ValueType + """The status of the HTLC.""" + attempt_time_ns: builtins.int + """The time in UNIX nanoseconds at which this HTLC was sent.""" + resolve_time_ns: builtins.int + """ + The time in UNIX nanoseconds at which this HTLC was settled or failed. + This value will not be set if the HTLC is still IN_FLIGHT. + """ + preimage: builtins.bytes + """The preimage that was used to settle the HTLC.""" + @property + def route(self) -> global___Route: + """The route taken by this HTLC.""" + + @property + def failure(self) -> global___Failure: + """Detailed htlc failure info.""" + + def __init__( + self, + *, + attempt_id: builtins.int = ..., + status: global___HTLCAttempt.HTLCStatus.ValueType = ..., + route: global___Route | None = ..., + attempt_time_ns: builtins.int = ..., + resolve_time_ns: builtins.int = ..., + failure: global___Failure | None = ..., + preimage: builtins.bytes = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["failure", b"failure", "route", b"route"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["attempt_id", b"attempt_id", "attempt_time_ns", b"attempt_time_ns", "failure", b"failure", "preimage", b"preimage", "resolve_time_ns", b"resolve_time_ns", "route", b"route", "status", b"status"]) -> None: ... + +global___HTLCAttempt = HTLCAttempt + +@typing.final +class ListPaymentsRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + INCLUDE_INCOMPLETE_FIELD_NUMBER: builtins.int + INDEX_OFFSET_FIELD_NUMBER: builtins.int + MAX_PAYMENTS_FIELD_NUMBER: builtins.int + REVERSED_FIELD_NUMBER: builtins.int + COUNT_TOTAL_PAYMENTS_FIELD_NUMBER: builtins.int + CREATION_DATE_START_FIELD_NUMBER: builtins.int + CREATION_DATE_END_FIELD_NUMBER: builtins.int + include_incomplete: builtins.bool + """ + If true, then return payments that have not yet fully completed. This means + that pending payments, as well as failed payments will show up if this + field is set to true. This flag doesn't change the meaning of the indices, + which are tied to individual payments. + """ + index_offset: builtins.int + """ + The index of a payment that will be used as either the start or end of a + query to determine which payments should be returned in the response. The + index_offset is exclusive. In the case of a zero index_offset, the query + will start with the oldest payment when paginating forwards, or will end + with the most recent payment when paginating backwards. + """ + max_payments: builtins.int + """The maximal number of payments returned in the response to this query.""" + reversed: builtins.bool + """ + If set, the payments returned will result from seeking backwards from the + specified index offset. This can be used to paginate backwards. The order + of the returned payments is always oldest first (ascending index order). + """ + count_total_payments: builtins.bool + """ + If set, all payments (complete and incomplete, independent of the + max_payments parameter) will be counted. Note that setting this to true will + increase the run time of the call significantly on systems that have a lot + of payments, as all of them have to be iterated through to be counted. + """ + creation_date_start: builtins.int + """If set, returns all payments with a creation date greater than or equal + to it. Measured in seconds since the unix epoch. + """ + creation_date_end: builtins.int + """If set, returns all payments with a creation date less than or equal to + it. Measured in seconds since the unix epoch. + """ + def __init__( + self, + *, + include_incomplete: builtins.bool = ..., + index_offset: builtins.int = ..., + max_payments: builtins.int = ..., + reversed: builtins.bool = ..., + count_total_payments: builtins.bool = ..., + creation_date_start: builtins.int = ..., + creation_date_end: builtins.int = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["count_total_payments", b"count_total_payments", "creation_date_end", b"creation_date_end", "creation_date_start", b"creation_date_start", "include_incomplete", b"include_incomplete", "index_offset", b"index_offset", "max_payments", b"max_payments", "reversed", b"reversed"]) -> None: ... + +global___ListPaymentsRequest = ListPaymentsRequest + +@typing.final +class ListPaymentsResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + PAYMENTS_FIELD_NUMBER: builtins.int + FIRST_INDEX_OFFSET_FIELD_NUMBER: builtins.int + LAST_INDEX_OFFSET_FIELD_NUMBER: builtins.int + TOTAL_NUM_PAYMENTS_FIELD_NUMBER: builtins.int + first_index_offset: builtins.int + """ + The index of the first item in the set of returned payments. This can be + used as the index_offset to continue seeking backwards in the next request. + """ + last_index_offset: builtins.int + """ + The index of the last item in the set of returned payments. This can be used + as the index_offset to continue seeking forwards in the next request. + """ + total_num_payments: builtins.int + """ + Will only be set if count_total_payments in the request was set. Represents + the total number of payments (complete and incomplete, independent of the + number of payments requested in the query) currently present in the payments + database. + """ + @property + def payments(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___Payment]: + """The list of payments""" + + def __init__( + self, + *, + payments: collections.abc.Iterable[global___Payment] | None = ..., + first_index_offset: builtins.int = ..., + last_index_offset: builtins.int = ..., + total_num_payments: builtins.int = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["first_index_offset", b"first_index_offset", "last_index_offset", b"last_index_offset", "payments", b"payments", "total_num_payments", b"total_num_payments"]) -> None: ... + +global___ListPaymentsResponse = ListPaymentsResponse + +@typing.final +class DeletePaymentRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + PAYMENT_HASH_FIELD_NUMBER: builtins.int + FAILED_HTLCS_ONLY_FIELD_NUMBER: builtins.int + payment_hash: builtins.bytes + """Payment hash to delete.""" + failed_htlcs_only: builtins.bool + """ + Only delete failed HTLCs from the payment, not the payment itself. + """ + def __init__( + self, + *, + payment_hash: builtins.bytes = ..., + failed_htlcs_only: builtins.bool = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["failed_htlcs_only", b"failed_htlcs_only", "payment_hash", b"payment_hash"]) -> None: ... + +global___DeletePaymentRequest = DeletePaymentRequest + +@typing.final +class DeleteAllPaymentsRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + FAILED_PAYMENTS_ONLY_FIELD_NUMBER: builtins.int + FAILED_HTLCS_ONLY_FIELD_NUMBER: builtins.int + ALL_PAYMENTS_FIELD_NUMBER: builtins.int + failed_payments_only: builtins.bool + """Only delete failed payments.""" + failed_htlcs_only: builtins.bool + """ + Only delete failed HTLCs from payments, not the payment itself. + """ + all_payments: builtins.bool + """Delete all payments. NOTE: Using this option requires careful + consideration as it is a destructive operation. + """ + def __init__( + self, + *, + failed_payments_only: builtins.bool = ..., + failed_htlcs_only: builtins.bool = ..., + all_payments: builtins.bool = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["all_payments", b"all_payments", "failed_htlcs_only", b"failed_htlcs_only", "failed_payments_only", b"failed_payments_only"]) -> None: ... + +global___DeleteAllPaymentsRequest = DeleteAllPaymentsRequest + +@typing.final +class DeletePaymentResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +global___DeletePaymentResponse = DeletePaymentResponse + +@typing.final +class DeleteAllPaymentsResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +global___DeleteAllPaymentsResponse = DeleteAllPaymentsResponse + +@typing.final +class AbandonChannelRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + CHANNEL_POINT_FIELD_NUMBER: builtins.int + PENDING_FUNDING_SHIM_ONLY_FIELD_NUMBER: builtins.int + I_KNOW_WHAT_I_AM_DOING_FIELD_NUMBER: builtins.int + pending_funding_shim_only: builtins.bool + i_know_what_i_am_doing: builtins.bool + """ + Override the requirement for being in dev mode by setting this to true and + confirming the user knows what they are doing and this is a potential foot + gun to lose funds if used on active channels. + """ + @property + def channel_point(self) -> global___ChannelPoint: ... + def __init__( + self, + *, + channel_point: global___ChannelPoint | None = ..., + pending_funding_shim_only: builtins.bool = ..., + i_know_what_i_am_doing: builtins.bool = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["channel_point", b"channel_point"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["channel_point", b"channel_point", "i_know_what_i_am_doing", b"i_know_what_i_am_doing", "pending_funding_shim_only", b"pending_funding_shim_only"]) -> None: ... + +global___AbandonChannelRequest = AbandonChannelRequest + +@typing.final +class AbandonChannelResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +global___AbandonChannelResponse = AbandonChannelResponse + +@typing.final +class DebugLevelRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + SHOW_FIELD_NUMBER: builtins.int + LEVEL_SPEC_FIELD_NUMBER: builtins.int + show: builtins.bool + level_spec: builtins.str + def __init__( + self, + *, + show: builtins.bool = ..., + level_spec: builtins.str = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["level_spec", b"level_spec", "show", b"show"]) -> None: ... + +global___DebugLevelRequest = DebugLevelRequest + +@typing.final +class DebugLevelResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + SUB_SYSTEMS_FIELD_NUMBER: builtins.int + sub_systems: builtins.str + def __init__( + self, + *, + sub_systems: builtins.str = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["sub_systems", b"sub_systems"]) -> None: ... + +global___DebugLevelResponse = DebugLevelResponse + +@typing.final +class PayReqString(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + PAY_REQ_FIELD_NUMBER: builtins.int + pay_req: builtins.str + """The payment request string to be decoded""" + def __init__( + self, + *, + pay_req: builtins.str = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["pay_req", b"pay_req"]) -> None: ... + +global___PayReqString = PayReqString + +@typing.final +class PayReq(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + @typing.final + class FeaturesEntry(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + KEY_FIELD_NUMBER: builtins.int + VALUE_FIELD_NUMBER: builtins.int + key: builtins.int + @property + def value(self) -> global___Feature: ... + def __init__( + self, + *, + key: builtins.int = ..., + value: global___Feature | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["value", b"value"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["key", b"key", "value", b"value"]) -> None: ... + + DESTINATION_FIELD_NUMBER: builtins.int + PAYMENT_HASH_FIELD_NUMBER: builtins.int + NUM_SATOSHIS_FIELD_NUMBER: builtins.int + TIMESTAMP_FIELD_NUMBER: builtins.int + EXPIRY_FIELD_NUMBER: builtins.int + DESCRIPTION_FIELD_NUMBER: builtins.int + DESCRIPTION_HASH_FIELD_NUMBER: builtins.int + FALLBACK_ADDR_FIELD_NUMBER: builtins.int + CLTV_EXPIRY_FIELD_NUMBER: builtins.int + ROUTE_HINTS_FIELD_NUMBER: builtins.int + PAYMENT_ADDR_FIELD_NUMBER: builtins.int + NUM_MSAT_FIELD_NUMBER: builtins.int + FEATURES_FIELD_NUMBER: builtins.int + BLINDED_PATHS_FIELD_NUMBER: builtins.int + destination: builtins.str + payment_hash: builtins.str + num_satoshis: builtins.int + timestamp: builtins.int + expiry: builtins.int + description: builtins.str + description_hash: builtins.str + fallback_addr: builtins.str + cltv_expiry: builtins.int + payment_addr: builtins.bytes + num_msat: builtins.int + @property + def route_hints(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___RouteHint]: ... + @property + def features(self) -> google.protobuf.internal.containers.MessageMap[builtins.int, global___Feature]: ... + @property + def blinded_paths(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___BlindedPaymentPath]: ... + def __init__( + self, + *, + destination: builtins.str = ..., + payment_hash: builtins.str = ..., + num_satoshis: builtins.int = ..., + timestamp: builtins.int = ..., + expiry: builtins.int = ..., + description: builtins.str = ..., + description_hash: builtins.str = ..., + fallback_addr: builtins.str = ..., + cltv_expiry: builtins.int = ..., + route_hints: collections.abc.Iterable[global___RouteHint] | None = ..., + payment_addr: builtins.bytes = ..., + num_msat: builtins.int = ..., + features: collections.abc.Mapping[builtins.int, global___Feature] | None = ..., + blinded_paths: collections.abc.Iterable[global___BlindedPaymentPath] | None = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["blinded_paths", b"blinded_paths", "cltv_expiry", b"cltv_expiry", "description", b"description", "description_hash", b"description_hash", "destination", b"destination", "expiry", b"expiry", "fallback_addr", b"fallback_addr", "features", b"features", "num_msat", b"num_msat", "num_satoshis", b"num_satoshis", "payment_addr", b"payment_addr", "payment_hash", b"payment_hash", "route_hints", b"route_hints", "timestamp", b"timestamp"]) -> None: ... + +global___PayReq = PayReq + +@typing.final +class Feature(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + NAME_FIELD_NUMBER: builtins.int + IS_REQUIRED_FIELD_NUMBER: builtins.int + IS_KNOWN_FIELD_NUMBER: builtins.int + name: builtins.str + is_required: builtins.bool + is_known: builtins.bool + def __init__( + self, + *, + name: builtins.str = ..., + is_required: builtins.bool = ..., + is_known: builtins.bool = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["is_known", b"is_known", "is_required", b"is_required", "name", b"name"]) -> None: ... + +global___Feature = Feature + +@typing.final +class FeeReportRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +global___FeeReportRequest = FeeReportRequest + +@typing.final +class ChannelFeeReport(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + CHAN_ID_FIELD_NUMBER: builtins.int + CHANNEL_POINT_FIELD_NUMBER: builtins.int + BASE_FEE_MSAT_FIELD_NUMBER: builtins.int + FEE_PER_MIL_FIELD_NUMBER: builtins.int + FEE_RATE_FIELD_NUMBER: builtins.int + INBOUND_BASE_FEE_MSAT_FIELD_NUMBER: builtins.int + INBOUND_FEE_PER_MIL_FIELD_NUMBER: builtins.int + chan_id: builtins.int + """The short channel id that this fee report belongs to.""" + channel_point: builtins.str + """The channel that this fee report belongs to.""" + base_fee_msat: builtins.int + """The base fee charged regardless of the number of milli-satoshis sent.""" + fee_per_mil: builtins.int + """The amount charged per milli-satoshis transferred expressed in + millionths of a satoshi. + """ + fee_rate: builtins.float + """The effective fee rate in milli-satoshis. Computed by dividing the + fee_per_mil value by 1 million. + """ + inbound_base_fee_msat: builtins.int + """The base fee charged regardless of the number of milli-satoshis sent.""" + inbound_fee_per_mil: builtins.int + """The amount charged per milli-satoshis transferred expressed in + millionths of a satoshi. + """ + def __init__( + self, + *, + chan_id: builtins.int = ..., + channel_point: builtins.str = ..., + base_fee_msat: builtins.int = ..., + fee_per_mil: builtins.int = ..., + fee_rate: builtins.float = ..., + inbound_base_fee_msat: builtins.int = ..., + inbound_fee_per_mil: builtins.int = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["base_fee_msat", b"base_fee_msat", "chan_id", b"chan_id", "channel_point", b"channel_point", "fee_per_mil", b"fee_per_mil", "fee_rate", b"fee_rate", "inbound_base_fee_msat", b"inbound_base_fee_msat", "inbound_fee_per_mil", b"inbound_fee_per_mil"]) -> None: ... + +global___ChannelFeeReport = ChannelFeeReport + +@typing.final +class FeeReportResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + CHANNEL_FEES_FIELD_NUMBER: builtins.int + DAY_FEE_SUM_FIELD_NUMBER: builtins.int + WEEK_FEE_SUM_FIELD_NUMBER: builtins.int + MONTH_FEE_SUM_FIELD_NUMBER: builtins.int + day_fee_sum: builtins.int + """The total amount of fee revenue (in satoshis) the switch has collected + over the past 24 hrs. + """ + week_fee_sum: builtins.int + """The total amount of fee revenue (in satoshis) the switch has collected + over the past 1 week. + """ + month_fee_sum: builtins.int + """The total amount of fee revenue (in satoshis) the switch has collected + over the past 1 month. + """ + @property + def channel_fees(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___ChannelFeeReport]: + """An array of channel fee reports which describes the current fee schedule + for each channel. + """ + + def __init__( + self, + *, + channel_fees: collections.abc.Iterable[global___ChannelFeeReport] | None = ..., + day_fee_sum: builtins.int = ..., + week_fee_sum: builtins.int = ..., + month_fee_sum: builtins.int = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["channel_fees", b"channel_fees", "day_fee_sum", b"day_fee_sum", "month_fee_sum", b"month_fee_sum", "week_fee_sum", b"week_fee_sum"]) -> None: ... + +global___FeeReportResponse = FeeReportResponse + +@typing.final +class InboundFee(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + BASE_FEE_MSAT_FIELD_NUMBER: builtins.int + FEE_RATE_PPM_FIELD_NUMBER: builtins.int + base_fee_msat: builtins.int + """The inbound base fee charged regardless of the number of milli-satoshis + received in the channel. By default, only negative values are accepted. + """ + fee_rate_ppm: builtins.int + """The effective inbound fee rate in micro-satoshis (parts per million). + By default, only negative values are accepted. + """ + def __init__( + self, + *, + base_fee_msat: builtins.int = ..., + fee_rate_ppm: builtins.int = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["base_fee_msat", b"base_fee_msat", "fee_rate_ppm", b"fee_rate_ppm"]) -> None: ... + +global___InboundFee = InboundFee + +@typing.final +class PolicyUpdateRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + GLOBAL_FIELD_NUMBER: builtins.int + CHAN_POINT_FIELD_NUMBER: builtins.int + BASE_FEE_MSAT_FIELD_NUMBER: builtins.int + FEE_RATE_FIELD_NUMBER: builtins.int + FEE_RATE_PPM_FIELD_NUMBER: builtins.int + TIME_LOCK_DELTA_FIELD_NUMBER: builtins.int + MAX_HTLC_MSAT_FIELD_NUMBER: builtins.int + MIN_HTLC_MSAT_FIELD_NUMBER: builtins.int + MIN_HTLC_MSAT_SPECIFIED_FIELD_NUMBER: builtins.int + INBOUND_FEE_FIELD_NUMBER: builtins.int + base_fee_msat: builtins.int + """The base fee charged regardless of the number of milli-satoshis sent.""" + fee_rate: builtins.float + """The effective fee rate in milli-satoshis. The precision of this value + goes up to 6 decimal places, so 1e-6. + """ + fee_rate_ppm: builtins.int + """The effective fee rate in micro-satoshis (parts per million).""" + time_lock_delta: builtins.int + """The required timelock delta for HTLCs forwarded over the channel.""" + max_htlc_msat: builtins.int + """If set, the maximum HTLC size in milli-satoshis. If unset, the maximum + HTLC will be unchanged. + """ + min_htlc_msat: builtins.int + """The minimum HTLC size in milli-satoshis. Only applied if + min_htlc_msat_specified is true. + """ + min_htlc_msat_specified: builtins.bool + """If true, min_htlc_msat is applied.""" + @property + def chan_point(self) -> global___ChannelPoint: + """If set, this update will target a specific channel.""" + + @property + def inbound_fee(self) -> global___InboundFee: + """Optional inbound fee. If unset, the previously set value will be + retained [EXPERIMENTAL]. + """ + + def __init__( + self, + *, + chan_point: global___ChannelPoint | None = ..., + base_fee_msat: builtins.int = ..., + fee_rate: builtins.float = ..., + fee_rate_ppm: builtins.int = ..., + time_lock_delta: builtins.int = ..., + max_htlc_msat: builtins.int = ..., + min_htlc_msat: builtins.int = ..., + min_htlc_msat_specified: builtins.bool = ..., + inbound_fee: global___InboundFee | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["chan_point", b"chan_point", "global", b"global", "inbound_fee", b"inbound_fee", "scope", b"scope"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["base_fee_msat", b"base_fee_msat", "chan_point", b"chan_point", "fee_rate", b"fee_rate", "fee_rate_ppm", b"fee_rate_ppm", "global", b"global", "inbound_fee", b"inbound_fee", "max_htlc_msat", b"max_htlc_msat", "min_htlc_msat", b"min_htlc_msat", "min_htlc_msat_specified", b"min_htlc_msat_specified", "scope", b"scope", "time_lock_delta", b"time_lock_delta"]) -> None: ... + def WhichOneof(self, oneof_group: typing.Literal["scope", b"scope"]) -> typing.Literal["global", "chan_point"] | None: ... + +global___PolicyUpdateRequest = PolicyUpdateRequest + +@typing.final +class FailedUpdate(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + OUTPOINT_FIELD_NUMBER: builtins.int + REASON_FIELD_NUMBER: builtins.int + UPDATE_ERROR_FIELD_NUMBER: builtins.int + reason: global___UpdateFailure.ValueType + """Reason for the policy update failure.""" + update_error: builtins.str + """A string representation of the policy update error.""" + @property + def outpoint(self) -> global___OutPoint: + """The outpoint in format txid:n""" + + def __init__( + self, + *, + outpoint: global___OutPoint | None = ..., + reason: global___UpdateFailure.ValueType = ..., + update_error: builtins.str = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["outpoint", b"outpoint"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["outpoint", b"outpoint", "reason", b"reason", "update_error", b"update_error"]) -> None: ... + +global___FailedUpdate = FailedUpdate + +@typing.final +class PolicyUpdateResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + FAILED_UPDATES_FIELD_NUMBER: builtins.int + @property + def failed_updates(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___FailedUpdate]: + """List of failed policy updates.""" + + def __init__( + self, + *, + failed_updates: collections.abc.Iterable[global___FailedUpdate] | None = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["failed_updates", b"failed_updates"]) -> None: ... + +global___PolicyUpdateResponse = PolicyUpdateResponse + +@typing.final +class ForwardingHistoryRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + START_TIME_FIELD_NUMBER: builtins.int + END_TIME_FIELD_NUMBER: builtins.int + INDEX_OFFSET_FIELD_NUMBER: builtins.int + NUM_MAX_EVENTS_FIELD_NUMBER: builtins.int + PEER_ALIAS_LOOKUP_FIELD_NUMBER: builtins.int + start_time: builtins.int + """Start time is the starting point of the forwarding history request. All + records beyond this point will be included, respecting the end time, and + the index offset. + """ + end_time: builtins.int + """End time is the end point of the forwarding history request. The + response will carry at most 50k records between the start time and the + end time. The index offset can be used to implement pagination. + """ + index_offset: builtins.int + """Index offset is the offset in the time series to start at. As each + response can only contain 50k records, callers can use this to skip + around within a packed time series. + """ + num_max_events: builtins.int + """The max number of events to return in the response to this query.""" + peer_alias_lookup: builtins.bool + """Informs the server if the peer alias should be looked up for each + forwarding event. + """ + def __init__( + self, + *, + start_time: builtins.int = ..., + end_time: builtins.int = ..., + index_offset: builtins.int = ..., + num_max_events: builtins.int = ..., + peer_alias_lookup: builtins.bool = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["end_time", b"end_time", "index_offset", b"index_offset", "num_max_events", b"num_max_events", "peer_alias_lookup", b"peer_alias_lookup", "start_time", b"start_time"]) -> None: ... + +global___ForwardingHistoryRequest = ForwardingHistoryRequest + +@typing.final +class ForwardingEvent(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + TIMESTAMP_FIELD_NUMBER: builtins.int + CHAN_ID_IN_FIELD_NUMBER: builtins.int + CHAN_ID_OUT_FIELD_NUMBER: builtins.int + AMT_IN_FIELD_NUMBER: builtins.int + AMT_OUT_FIELD_NUMBER: builtins.int + FEE_FIELD_NUMBER: builtins.int + FEE_MSAT_FIELD_NUMBER: builtins.int + AMT_IN_MSAT_FIELD_NUMBER: builtins.int + AMT_OUT_MSAT_FIELD_NUMBER: builtins.int + TIMESTAMP_NS_FIELD_NUMBER: builtins.int + PEER_ALIAS_IN_FIELD_NUMBER: builtins.int + PEER_ALIAS_OUT_FIELD_NUMBER: builtins.int + timestamp: builtins.int + """Timestamp is the time (unix epoch offset) that this circuit was + completed. Deprecated by timestamp_ns. + """ + chan_id_in: builtins.int + """The incoming channel ID that carried the HTLC that created the circuit.""" + chan_id_out: builtins.int + """The outgoing channel ID that carried the preimage that completed the + circuit. + """ + amt_in: builtins.int + """The total amount (in satoshis) of the incoming HTLC that created half + the circuit. + """ + amt_out: builtins.int + """The total amount (in satoshis) of the outgoing HTLC that created the + second half of the circuit. + """ + fee: builtins.int + """The total fee (in satoshis) that this payment circuit carried.""" + fee_msat: builtins.int + """The total fee (in milli-satoshis) that this payment circuit carried.""" + amt_in_msat: builtins.int + """The total amount (in milli-satoshis) of the incoming HTLC that created + half the circuit. + """ + amt_out_msat: builtins.int + """The total amount (in milli-satoshis) of the outgoing HTLC that created + the second half of the circuit. + """ + timestamp_ns: builtins.int + """The number of nanoseconds elapsed since January 1, 1970 UTC when this + circuit was completed. + """ + peer_alias_in: builtins.str + """The peer alias of the incoming channel.""" + peer_alias_out: builtins.str + """The peer alias of the outgoing channel.""" + def __init__( + self, + *, + timestamp: builtins.int = ..., + chan_id_in: builtins.int = ..., + chan_id_out: builtins.int = ..., + amt_in: builtins.int = ..., + amt_out: builtins.int = ..., + fee: builtins.int = ..., + fee_msat: builtins.int = ..., + amt_in_msat: builtins.int = ..., + amt_out_msat: builtins.int = ..., + timestamp_ns: builtins.int = ..., + peer_alias_in: builtins.str = ..., + peer_alias_out: builtins.str = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["amt_in", b"amt_in", "amt_in_msat", b"amt_in_msat", "amt_out", b"amt_out", "amt_out_msat", b"amt_out_msat", "chan_id_in", b"chan_id_in", "chan_id_out", b"chan_id_out", "fee", b"fee", "fee_msat", b"fee_msat", "peer_alias_in", b"peer_alias_in", "peer_alias_out", b"peer_alias_out", "timestamp", b"timestamp", "timestamp_ns", b"timestamp_ns"]) -> None: ... + +global___ForwardingEvent = ForwardingEvent + +@typing.final +class ForwardingHistoryResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + FORWARDING_EVENTS_FIELD_NUMBER: builtins.int + LAST_OFFSET_INDEX_FIELD_NUMBER: builtins.int + last_offset_index: builtins.int + """The index of the last time in the set of returned forwarding events. Can + be used to seek further, pagination style. + """ + @property + def forwarding_events(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___ForwardingEvent]: + """A list of forwarding events from the time slice of the time series + specified in the request. + """ + + def __init__( + self, + *, + forwarding_events: collections.abc.Iterable[global___ForwardingEvent] | None = ..., + last_offset_index: builtins.int = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["forwarding_events", b"forwarding_events", "last_offset_index", b"last_offset_index"]) -> None: ... + +global___ForwardingHistoryResponse = ForwardingHistoryResponse + +@typing.final +class ExportChannelBackupRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + CHAN_POINT_FIELD_NUMBER: builtins.int + @property + def chan_point(self) -> global___ChannelPoint: + """The target channel point to obtain a back up for.""" + + def __init__( + self, + *, + chan_point: global___ChannelPoint | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["chan_point", b"chan_point"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["chan_point", b"chan_point"]) -> None: ... + +global___ExportChannelBackupRequest = ExportChannelBackupRequest + +@typing.final +class ChannelBackup(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + CHAN_POINT_FIELD_NUMBER: builtins.int + CHAN_BACKUP_FIELD_NUMBER: builtins.int + chan_backup: builtins.bytes + """ + Is an encrypted single-chan backup. this can be passed to + RestoreChannelBackups, or the WalletUnlocker Init and Unlock methods in + order to trigger the recovery protocol. When using REST, this field must be + encoded as base64. + """ + @property + def chan_point(self) -> global___ChannelPoint: + """ + Identifies the channel that this backup belongs to. + """ + + def __init__( + self, + *, + chan_point: global___ChannelPoint | None = ..., + chan_backup: builtins.bytes = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["chan_point", b"chan_point"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["chan_backup", b"chan_backup", "chan_point", b"chan_point"]) -> None: ... + +global___ChannelBackup = ChannelBackup + +@typing.final +class MultiChanBackup(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + CHAN_POINTS_FIELD_NUMBER: builtins.int + MULTI_CHAN_BACKUP_FIELD_NUMBER: builtins.int + multi_chan_backup: builtins.bytes + """ + A single encrypted blob containing all the static channel backups of the + channel listed above. This can be stored as a single file or blob, and + safely be replaced with any prior/future versions. When using REST, this + field must be encoded as base64. + """ + @property + def chan_points(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___ChannelPoint]: + """ + Is the set of all channels that are included in this multi-channel backup. + """ + + def __init__( + self, + *, + chan_points: collections.abc.Iterable[global___ChannelPoint] | None = ..., + multi_chan_backup: builtins.bytes = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["chan_points", b"chan_points", "multi_chan_backup", b"multi_chan_backup"]) -> None: ... + +global___MultiChanBackup = MultiChanBackup + +@typing.final +class ChanBackupExportRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +global___ChanBackupExportRequest = ChanBackupExportRequest + +@typing.final +class ChanBackupSnapshot(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + SINGLE_CHAN_BACKUPS_FIELD_NUMBER: builtins.int + MULTI_CHAN_BACKUP_FIELD_NUMBER: builtins.int + @property + def single_chan_backups(self) -> global___ChannelBackups: + """ + The set of new channels that have been added since the last channel backup + snapshot was requested. + """ + + @property + def multi_chan_backup(self) -> global___MultiChanBackup: + """ + A multi-channel backup that covers all open channels currently known to + lnd. + """ + + def __init__( + self, + *, + single_chan_backups: global___ChannelBackups | None = ..., + multi_chan_backup: global___MultiChanBackup | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["multi_chan_backup", b"multi_chan_backup", "single_chan_backups", b"single_chan_backups"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["multi_chan_backup", b"multi_chan_backup", "single_chan_backups", b"single_chan_backups"]) -> None: ... + +global___ChanBackupSnapshot = ChanBackupSnapshot + +@typing.final +class ChannelBackups(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + CHAN_BACKUPS_FIELD_NUMBER: builtins.int + @property + def chan_backups(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___ChannelBackup]: + """ + A set of single-chan static channel backups. + """ + + def __init__( + self, + *, + chan_backups: collections.abc.Iterable[global___ChannelBackup] | None = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["chan_backups", b"chan_backups"]) -> None: ... + +global___ChannelBackups = ChannelBackups + +@typing.final +class RestoreChanBackupRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + CHAN_BACKUPS_FIELD_NUMBER: builtins.int + MULTI_CHAN_BACKUP_FIELD_NUMBER: builtins.int + multi_chan_backup: builtins.bytes + """ + The channels to restore in the packed multi backup format. When using + REST, this field must be encoded as base64. + """ + @property + def chan_backups(self) -> global___ChannelBackups: + """ + The channels to restore as a list of channel/backup pairs. + """ + + def __init__( + self, + *, + chan_backups: global___ChannelBackups | None = ..., + multi_chan_backup: builtins.bytes = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["backup", b"backup", "chan_backups", b"chan_backups", "multi_chan_backup", b"multi_chan_backup"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["backup", b"backup", "chan_backups", b"chan_backups", "multi_chan_backup", b"multi_chan_backup"]) -> None: ... + def WhichOneof(self, oneof_group: typing.Literal["backup", b"backup"]) -> typing.Literal["chan_backups", "multi_chan_backup"] | None: ... + +global___RestoreChanBackupRequest = RestoreChanBackupRequest + +@typing.final +class RestoreBackupResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +global___RestoreBackupResponse = RestoreBackupResponse + +@typing.final +class ChannelBackupSubscription(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +global___ChannelBackupSubscription = ChannelBackupSubscription + +@typing.final +class VerifyChanBackupResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +global___VerifyChanBackupResponse = VerifyChanBackupResponse + +@typing.final +class MacaroonPermission(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + ENTITY_FIELD_NUMBER: builtins.int + ACTION_FIELD_NUMBER: builtins.int + entity: builtins.str + """The entity a permission grants access to.""" + action: builtins.str + """The action that is granted.""" + def __init__( + self, + *, + entity: builtins.str = ..., + action: builtins.str = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["action", b"action", "entity", b"entity"]) -> None: ... + +global___MacaroonPermission = MacaroonPermission + +@typing.final +class BakeMacaroonRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + PERMISSIONS_FIELD_NUMBER: builtins.int + ROOT_KEY_ID_FIELD_NUMBER: builtins.int + ALLOW_EXTERNAL_PERMISSIONS_FIELD_NUMBER: builtins.int + root_key_id: builtins.int + """The root key ID used to create the macaroon, must be a positive integer.""" + allow_external_permissions: builtins.bool + """ + Informs the RPC on whether to allow external permissions that LND is not + aware of. + """ + @property + def permissions(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___MacaroonPermission]: + """The list of permissions the new macaroon should grant.""" + + def __init__( + self, + *, + permissions: collections.abc.Iterable[global___MacaroonPermission] | None = ..., + root_key_id: builtins.int = ..., + allow_external_permissions: builtins.bool = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["allow_external_permissions", b"allow_external_permissions", "permissions", b"permissions", "root_key_id", b"root_key_id"]) -> None: ... + +global___BakeMacaroonRequest = BakeMacaroonRequest + +@typing.final +class BakeMacaroonResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + MACAROON_FIELD_NUMBER: builtins.int + macaroon: builtins.str + """The hex encoded macaroon, serialized in binary format.""" + def __init__( + self, + *, + macaroon: builtins.str = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["macaroon", b"macaroon"]) -> None: ... + +global___BakeMacaroonResponse = BakeMacaroonResponse + +@typing.final +class ListMacaroonIDsRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +global___ListMacaroonIDsRequest = ListMacaroonIDsRequest + +@typing.final +class ListMacaroonIDsResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + ROOT_KEY_IDS_FIELD_NUMBER: builtins.int + @property + def root_key_ids(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.int]: + """The list of root key IDs that are in use.""" + + def __init__( + self, + *, + root_key_ids: collections.abc.Iterable[builtins.int] | None = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["root_key_ids", b"root_key_ids"]) -> None: ... + +global___ListMacaroonIDsResponse = ListMacaroonIDsResponse + +@typing.final +class DeleteMacaroonIDRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + ROOT_KEY_ID_FIELD_NUMBER: builtins.int + root_key_id: builtins.int + """The root key ID to be removed.""" + def __init__( + self, + *, + root_key_id: builtins.int = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["root_key_id", b"root_key_id"]) -> None: ... + +global___DeleteMacaroonIDRequest = DeleteMacaroonIDRequest + +@typing.final +class DeleteMacaroonIDResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + DELETED_FIELD_NUMBER: builtins.int + deleted: builtins.bool + """A boolean indicates that the deletion is successful.""" + def __init__( + self, + *, + deleted: builtins.bool = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["deleted", b"deleted"]) -> None: ... + +global___DeleteMacaroonIDResponse = DeleteMacaroonIDResponse + +@typing.final +class MacaroonPermissionList(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + PERMISSIONS_FIELD_NUMBER: builtins.int + @property + def permissions(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___MacaroonPermission]: + """A list of macaroon permissions.""" + + def __init__( + self, + *, + permissions: collections.abc.Iterable[global___MacaroonPermission] | None = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["permissions", b"permissions"]) -> None: ... + +global___MacaroonPermissionList = MacaroonPermissionList + +@typing.final +class ListPermissionsRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +global___ListPermissionsRequest = ListPermissionsRequest + +@typing.final +class ListPermissionsResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + @typing.final + class MethodPermissionsEntry(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + KEY_FIELD_NUMBER: builtins.int + VALUE_FIELD_NUMBER: builtins.int + key: builtins.str + @property + def value(self) -> global___MacaroonPermissionList: ... + def __init__( + self, + *, + key: builtins.str = ..., + value: global___MacaroonPermissionList | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["value", b"value"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["key", b"key", "value", b"value"]) -> None: ... + + METHOD_PERMISSIONS_FIELD_NUMBER: builtins.int + @property + def method_permissions(self) -> google.protobuf.internal.containers.MessageMap[builtins.str, global___MacaroonPermissionList]: + """ + A map between all RPC method URIs and their required macaroon permissions to + access them. + """ + + def __init__( + self, + *, + method_permissions: collections.abc.Mapping[builtins.str, global___MacaroonPermissionList] | None = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["method_permissions", b"method_permissions"]) -> None: ... + +global___ListPermissionsResponse = ListPermissionsResponse + +@typing.final +class Failure(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + class _FailureCode: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + + class _FailureCodeEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[Failure._FailureCode.ValueType], builtins.type): # noqa: F821 + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + RESERVED: Failure._FailureCode.ValueType # 0 + """ + The numbers assigned in this enumeration match the failure codes as + defined in BOLT #4. Because protobuf 3 requires enums to start with 0, + a RESERVED value is added. + """ + INCORRECT_OR_UNKNOWN_PAYMENT_DETAILS: Failure._FailureCode.ValueType # 1 + INCORRECT_PAYMENT_AMOUNT: Failure._FailureCode.ValueType # 2 + FINAL_INCORRECT_CLTV_EXPIRY: Failure._FailureCode.ValueType # 3 + FINAL_INCORRECT_HTLC_AMOUNT: Failure._FailureCode.ValueType # 4 + FINAL_EXPIRY_TOO_SOON: Failure._FailureCode.ValueType # 5 + INVALID_REALM: Failure._FailureCode.ValueType # 6 + EXPIRY_TOO_SOON: Failure._FailureCode.ValueType # 7 + INVALID_ONION_VERSION: Failure._FailureCode.ValueType # 8 + INVALID_ONION_HMAC: Failure._FailureCode.ValueType # 9 + INVALID_ONION_KEY: Failure._FailureCode.ValueType # 10 + AMOUNT_BELOW_MINIMUM: Failure._FailureCode.ValueType # 11 + FEE_INSUFFICIENT: Failure._FailureCode.ValueType # 12 + INCORRECT_CLTV_EXPIRY: Failure._FailureCode.ValueType # 13 + CHANNEL_DISABLED: Failure._FailureCode.ValueType # 14 + TEMPORARY_CHANNEL_FAILURE: Failure._FailureCode.ValueType # 15 + REQUIRED_NODE_FEATURE_MISSING: Failure._FailureCode.ValueType # 16 + REQUIRED_CHANNEL_FEATURE_MISSING: Failure._FailureCode.ValueType # 17 + UNKNOWN_NEXT_PEER: Failure._FailureCode.ValueType # 18 + TEMPORARY_NODE_FAILURE: Failure._FailureCode.ValueType # 19 + PERMANENT_NODE_FAILURE: Failure._FailureCode.ValueType # 20 + PERMANENT_CHANNEL_FAILURE: Failure._FailureCode.ValueType # 21 + EXPIRY_TOO_FAR: Failure._FailureCode.ValueType # 22 + MPP_TIMEOUT: Failure._FailureCode.ValueType # 23 + INVALID_ONION_PAYLOAD: Failure._FailureCode.ValueType # 24 + INVALID_ONION_BLINDING: Failure._FailureCode.ValueType # 25 + INTERNAL_FAILURE: Failure._FailureCode.ValueType # 997 + """ + An internal error occurred. + """ + UNKNOWN_FAILURE: Failure._FailureCode.ValueType # 998 + """ + The error source is known, but the failure itself couldn't be decoded. + """ + UNREADABLE_FAILURE: Failure._FailureCode.ValueType # 999 + """ + An unreadable failure result is returned if the received failure message + cannot be decrypted. In that case the error source is unknown. + """ + + class FailureCode(_FailureCode, metaclass=_FailureCodeEnumTypeWrapper): ... + RESERVED: Failure.FailureCode.ValueType # 0 + """ + The numbers assigned in this enumeration match the failure codes as + defined in BOLT #4. Because protobuf 3 requires enums to start with 0, + a RESERVED value is added. + """ + INCORRECT_OR_UNKNOWN_PAYMENT_DETAILS: Failure.FailureCode.ValueType # 1 + INCORRECT_PAYMENT_AMOUNT: Failure.FailureCode.ValueType # 2 + FINAL_INCORRECT_CLTV_EXPIRY: Failure.FailureCode.ValueType # 3 + FINAL_INCORRECT_HTLC_AMOUNT: Failure.FailureCode.ValueType # 4 + FINAL_EXPIRY_TOO_SOON: Failure.FailureCode.ValueType # 5 + INVALID_REALM: Failure.FailureCode.ValueType # 6 + EXPIRY_TOO_SOON: Failure.FailureCode.ValueType # 7 + INVALID_ONION_VERSION: Failure.FailureCode.ValueType # 8 + INVALID_ONION_HMAC: Failure.FailureCode.ValueType # 9 + INVALID_ONION_KEY: Failure.FailureCode.ValueType # 10 + AMOUNT_BELOW_MINIMUM: Failure.FailureCode.ValueType # 11 + FEE_INSUFFICIENT: Failure.FailureCode.ValueType # 12 + INCORRECT_CLTV_EXPIRY: Failure.FailureCode.ValueType # 13 + CHANNEL_DISABLED: Failure.FailureCode.ValueType # 14 + TEMPORARY_CHANNEL_FAILURE: Failure.FailureCode.ValueType # 15 + REQUIRED_NODE_FEATURE_MISSING: Failure.FailureCode.ValueType # 16 + REQUIRED_CHANNEL_FEATURE_MISSING: Failure.FailureCode.ValueType # 17 + UNKNOWN_NEXT_PEER: Failure.FailureCode.ValueType # 18 + TEMPORARY_NODE_FAILURE: Failure.FailureCode.ValueType # 19 + PERMANENT_NODE_FAILURE: Failure.FailureCode.ValueType # 20 + PERMANENT_CHANNEL_FAILURE: Failure.FailureCode.ValueType # 21 + EXPIRY_TOO_FAR: Failure.FailureCode.ValueType # 22 + MPP_TIMEOUT: Failure.FailureCode.ValueType # 23 + INVALID_ONION_PAYLOAD: Failure.FailureCode.ValueType # 24 + INVALID_ONION_BLINDING: Failure.FailureCode.ValueType # 25 + INTERNAL_FAILURE: Failure.FailureCode.ValueType # 997 + """ + An internal error occurred. + """ + UNKNOWN_FAILURE: Failure.FailureCode.ValueType # 998 + """ + The error source is known, but the failure itself couldn't be decoded. + """ + UNREADABLE_FAILURE: Failure.FailureCode.ValueType # 999 + """ + An unreadable failure result is returned if the received failure message + cannot be decrypted. In that case the error source is unknown. + """ + + CODE_FIELD_NUMBER: builtins.int + CHANNEL_UPDATE_FIELD_NUMBER: builtins.int + HTLC_MSAT_FIELD_NUMBER: builtins.int + ONION_SHA_256_FIELD_NUMBER: builtins.int + CLTV_EXPIRY_FIELD_NUMBER: builtins.int + FLAGS_FIELD_NUMBER: builtins.int + FAILURE_SOURCE_INDEX_FIELD_NUMBER: builtins.int + HEIGHT_FIELD_NUMBER: builtins.int + code: global___Failure.FailureCode.ValueType + """Failure code as defined in the Lightning spec""" + htlc_msat: builtins.int + """A failure type-dependent htlc value.""" + onion_sha_256: builtins.bytes + """The sha256 sum of the onion payload.""" + cltv_expiry: builtins.int + """A failure type-dependent cltv expiry value.""" + flags: builtins.int + """A failure type-dependent flags value.""" + failure_source_index: builtins.int + """ + The position in the path of the intermediate or final node that generated + the failure message. Position zero is the sender node. + """ + height: builtins.int + """A failure type-dependent block height.""" + @property + def channel_update(self) -> global___ChannelUpdate: + """An optional channel update message.""" + + def __init__( + self, + *, + code: global___Failure.FailureCode.ValueType = ..., + channel_update: global___ChannelUpdate | None = ..., + htlc_msat: builtins.int = ..., + onion_sha_256: builtins.bytes = ..., + cltv_expiry: builtins.int = ..., + flags: builtins.int = ..., + failure_source_index: builtins.int = ..., + height: builtins.int = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["channel_update", b"channel_update"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["channel_update", b"channel_update", "cltv_expiry", b"cltv_expiry", "code", b"code", "failure_source_index", b"failure_source_index", "flags", b"flags", "height", b"height", "htlc_msat", b"htlc_msat", "onion_sha_256", b"onion_sha_256"]) -> None: ... + +global___Failure = Failure + +@typing.final +class ChannelUpdate(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + SIGNATURE_FIELD_NUMBER: builtins.int + CHAIN_HASH_FIELD_NUMBER: builtins.int + CHAN_ID_FIELD_NUMBER: builtins.int + TIMESTAMP_FIELD_NUMBER: builtins.int + MESSAGE_FLAGS_FIELD_NUMBER: builtins.int + CHANNEL_FLAGS_FIELD_NUMBER: builtins.int + TIME_LOCK_DELTA_FIELD_NUMBER: builtins.int + HTLC_MINIMUM_MSAT_FIELD_NUMBER: builtins.int + BASE_FEE_FIELD_NUMBER: builtins.int + FEE_RATE_FIELD_NUMBER: builtins.int + HTLC_MAXIMUM_MSAT_FIELD_NUMBER: builtins.int + EXTRA_OPAQUE_DATA_FIELD_NUMBER: builtins.int + signature: builtins.bytes + """ + The signature that validates the announced data and proves the ownership + of node id. + """ + chain_hash: builtins.bytes + """ + The target chain that this channel was opened within. This value + should be the genesis hash of the target chain. Along with the short + channel ID, this uniquely identifies the channel globally in a + blockchain. + """ + chan_id: builtins.int + """ + The unique description of the funding transaction. + """ + timestamp: builtins.int + """ + A timestamp that allows ordering in the case of multiple announcements. + We should ignore the message if timestamp is not greater than the + last-received. + """ + message_flags: builtins.int + """ + The bitfield that describes whether optional fields are present in this + update. Currently, the least-significant bit must be set to 1 if the + optional field MaxHtlc is present. + """ + channel_flags: builtins.int + """ + The bitfield that describes additional meta-data concerning how the + update is to be interpreted. Currently, the least-significant bit must be + set to 0 if the creating node corresponds to the first node in the + previously sent channel announcement and 1 otherwise. If the second bit + is set, then the channel is set to be disabled. + """ + time_lock_delta: builtins.int + """ + The minimum number of blocks this node requires to be added to the expiry + of HTLCs. This is a security parameter determined by the node operator. + This value represents the required gap between the time locks of the + incoming and outgoing HTLC's set to this node. + """ + htlc_minimum_msat: builtins.int + """ + The minimum HTLC value which will be accepted. + """ + base_fee: builtins.int + """ + The base fee that must be used for incoming HTLC's to this particular + channel. This value will be tacked onto the required for a payment + independent of the size of the payment. + """ + fee_rate: builtins.int + """ + The fee rate that will be charged per millionth of a satoshi. + """ + htlc_maximum_msat: builtins.int + """ + The maximum HTLC value which will be accepted. + """ + extra_opaque_data: builtins.bytes + """ + The set of data that was appended to this message, some of which we may + not actually know how to iterate or parse. By holding onto this data, we + ensure that we're able to properly validate the set of signatures that + cover these new fields, and ensure we're able to make upgrades to the + network in a forwards compatible manner. + """ + def __init__( + self, + *, + signature: builtins.bytes = ..., + chain_hash: builtins.bytes = ..., + chan_id: builtins.int = ..., + timestamp: builtins.int = ..., + message_flags: builtins.int = ..., + channel_flags: builtins.int = ..., + time_lock_delta: builtins.int = ..., + htlc_minimum_msat: builtins.int = ..., + base_fee: builtins.int = ..., + fee_rate: builtins.int = ..., + htlc_maximum_msat: builtins.int = ..., + extra_opaque_data: builtins.bytes = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["base_fee", b"base_fee", "chain_hash", b"chain_hash", "chan_id", b"chan_id", "channel_flags", b"channel_flags", "extra_opaque_data", b"extra_opaque_data", "fee_rate", b"fee_rate", "htlc_maximum_msat", b"htlc_maximum_msat", "htlc_minimum_msat", b"htlc_minimum_msat", "message_flags", b"message_flags", "signature", b"signature", "time_lock_delta", b"time_lock_delta", "timestamp", b"timestamp"]) -> None: ... + +global___ChannelUpdate = ChannelUpdate + +@typing.final +class MacaroonId(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + NONCE_FIELD_NUMBER: builtins.int + STORAGEID_FIELD_NUMBER: builtins.int + OPS_FIELD_NUMBER: builtins.int + nonce: builtins.bytes + storageId: builtins.bytes + @property + def ops(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___Op]: ... + def __init__( + self, + *, + nonce: builtins.bytes = ..., + storageId: builtins.bytes = ..., + ops: collections.abc.Iterable[global___Op] | None = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["nonce", b"nonce", "ops", b"ops", "storageId", b"storageId"]) -> None: ... + +global___MacaroonId = MacaroonId + +@typing.final +class Op(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + ENTITY_FIELD_NUMBER: builtins.int + ACTIONS_FIELD_NUMBER: builtins.int + entity: builtins.str + @property + def actions(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.str]: ... + def __init__( + self, + *, + entity: builtins.str = ..., + actions: collections.abc.Iterable[builtins.str] | None = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["actions", b"actions", "entity", b"entity"]) -> None: ... + +global___Op = Op + +@typing.final +class CheckMacPermRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + MACAROON_FIELD_NUMBER: builtins.int + PERMISSIONS_FIELD_NUMBER: builtins.int + FULLMETHOD_FIELD_NUMBER: builtins.int + macaroon: builtins.bytes + fullMethod: builtins.str + @property + def permissions(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___MacaroonPermission]: ... + def __init__( + self, + *, + macaroon: builtins.bytes = ..., + permissions: collections.abc.Iterable[global___MacaroonPermission] | None = ..., + fullMethod: builtins.str = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["fullMethod", b"fullMethod", "macaroon", b"macaroon", "permissions", b"permissions"]) -> None: ... + +global___CheckMacPermRequest = CheckMacPermRequest + +@typing.final +class CheckMacPermResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + VALID_FIELD_NUMBER: builtins.int + valid: builtins.bool + def __init__( + self, + *, + valid: builtins.bool = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["valid", b"valid"]) -> None: ... + +global___CheckMacPermResponse = CheckMacPermResponse + +@typing.final +class RPCMiddlewareRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + REQUEST_ID_FIELD_NUMBER: builtins.int + RAW_MACAROON_FIELD_NUMBER: builtins.int + CUSTOM_CAVEAT_CONDITION_FIELD_NUMBER: builtins.int + STREAM_AUTH_FIELD_NUMBER: builtins.int + REQUEST_FIELD_NUMBER: builtins.int + RESPONSE_FIELD_NUMBER: builtins.int + REG_COMPLETE_FIELD_NUMBER: builtins.int + MSG_ID_FIELD_NUMBER: builtins.int + request_id: builtins.int + """ + The unique ID of the intercepted original gRPC request. Useful for mapping + request to response when implementing full duplex message interception. For + streaming requests, this will be the same ID for all incoming and outgoing + middleware intercept messages of the _same_ stream. + """ + raw_macaroon: builtins.bytes + """ + The raw bytes of the complete macaroon as sent by the gRPC client in the + original request. This might be empty for a request that doesn't require + macaroons such as the wallet unlocker RPCs. + """ + custom_caveat_condition: builtins.str + """ + The parsed condition of the macaroon's custom caveat for convenient access. + This field only contains the value of the custom caveat that the handling + middleware has registered itself for. The condition _must_ be validated for + messages of intercept_type stream_auth and request! + """ + reg_complete: builtins.bool + """ + This is used to indicate to the client that the server has successfully + registered the interceptor. This is only used in the very first message + that the server sends to the client after the client sends the server + the middleware registration message. + """ + msg_id: builtins.int + """ + The unique message ID of this middleware intercept message. There can be + multiple middleware intercept messages per single gRPC request (one for the + incoming request and one for the outgoing response) or gRPC stream (one for + each incoming message and one for each outgoing response). This message ID + must be referenced when responding (accepting/rejecting/modifying) to an + intercept message. + """ + @property + def stream_auth(self) -> global___StreamAuth: + """ + Intercept stream authentication: each new streaming RPC call that is + initiated against lnd and contains the middleware's custom macaroon + caveat can be approved or denied based upon the macaroon in the stream + header. This message will only be sent for streaming RPCs, unary RPCs + must handle the macaroon authentication in the request interception to + avoid an additional message round trip between lnd and the middleware. + """ + + @property + def request(self) -> global___RPCMessage: + """ + Intercept incoming gRPC client request message: all incoming messages, + both on streaming and unary RPCs, are forwarded to the middleware for + inspection. For unary RPC messages the middleware is also expected to + validate the custom macaroon caveat of the request. + """ + + @property + def response(self) -> global___RPCMessage: + """ + Intercept outgoing gRPC response message: all outgoing messages, both on + streaming and unary RPCs, are forwarded to the middleware for inspection + and amendment. The response in this message is the original response as + it was generated by the main RPC server. It can either be accepted + (=forwarded to the client), replaced/overwritten with a new message of + the same type, or replaced by an error message. + """ + + def __init__( + self, + *, + request_id: builtins.int = ..., + raw_macaroon: builtins.bytes = ..., + custom_caveat_condition: builtins.str = ..., + stream_auth: global___StreamAuth | None = ..., + request: global___RPCMessage | None = ..., + response: global___RPCMessage | None = ..., + reg_complete: builtins.bool = ..., + msg_id: builtins.int = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["intercept_type", b"intercept_type", "reg_complete", b"reg_complete", "request", b"request", "response", b"response", "stream_auth", b"stream_auth"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["custom_caveat_condition", b"custom_caveat_condition", "intercept_type", b"intercept_type", "msg_id", b"msg_id", "raw_macaroon", b"raw_macaroon", "reg_complete", b"reg_complete", "request", b"request", "request_id", b"request_id", "response", b"response", "stream_auth", b"stream_auth"]) -> None: ... + def WhichOneof(self, oneof_group: typing.Literal["intercept_type", b"intercept_type"]) -> typing.Literal["stream_auth", "request", "response", "reg_complete"] | None: ... + +global___RPCMiddlewareRequest = RPCMiddlewareRequest + +@typing.final +class StreamAuth(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + METHOD_FULL_URI_FIELD_NUMBER: builtins.int + method_full_uri: builtins.str + """ + The full URI (in the format /./MethodName, for + example /lnrpc.Lightning/GetInfo) of the streaming RPC method that was just + established. + """ + def __init__( + self, + *, + method_full_uri: builtins.str = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["method_full_uri", b"method_full_uri"]) -> None: ... + +global___StreamAuth = StreamAuth + +@typing.final +class RPCMessage(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + METHOD_FULL_URI_FIELD_NUMBER: builtins.int + STREAM_RPC_FIELD_NUMBER: builtins.int + TYPE_NAME_FIELD_NUMBER: builtins.int + SERIALIZED_FIELD_NUMBER: builtins.int + IS_ERROR_FIELD_NUMBER: builtins.int + method_full_uri: builtins.str + """ + The full URI (in the format /./MethodName, for + example /lnrpc.Lightning/GetInfo) of the RPC method the message was sent + to/from. + """ + stream_rpc: builtins.bool + """ + Indicates whether the message was sent over a streaming RPC method or not. + """ + type_name: builtins.str + """ + The full canonical gRPC name of the message type (in the format + .TypeName, for example lnrpc.GetInfoRequest). In case of an + error being returned from lnd, this simply contains the string "error". + """ + serialized: builtins.bytes + """ + The full content of the gRPC message, serialized in the binary protobuf + format. + """ + is_error: builtins.bool + """ + Indicates that the response from lnd was an error, not a gRPC response. If + this is set to true then the type_name contains the string "error" and + serialized contains the error string. + """ + def __init__( + self, + *, + method_full_uri: builtins.str = ..., + stream_rpc: builtins.bool = ..., + type_name: builtins.str = ..., + serialized: builtins.bytes = ..., + is_error: builtins.bool = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["is_error", b"is_error", "method_full_uri", b"method_full_uri", "serialized", b"serialized", "stream_rpc", b"stream_rpc", "type_name", b"type_name"]) -> None: ... + +global___RPCMessage = RPCMessage + +@typing.final +class RPCMiddlewareResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + REF_MSG_ID_FIELD_NUMBER: builtins.int + REGISTER_FIELD_NUMBER: builtins.int + FEEDBACK_FIELD_NUMBER: builtins.int + ref_msg_id: builtins.int + """ + The request message ID this response refers to. Must always be set when + giving feedback to an intercept but is ignored for the initial registration + message. + """ + @property + def register(self) -> global___MiddlewareRegistration: + """ + The registration message identifies the middleware that's being + registered in lnd. The registration message must be sent immediately + after initiating the RegisterRpcMiddleware stream, otherwise lnd will + time out the attempt and terminate the request. NOTE: The middleware + will only receive interception messages for requests that contain a + macaroon with the custom caveat that the middleware declares it is + responsible for handling in the registration message! As a security + measure, _no_ middleware can intercept requests made with _unencumbered_ + macaroons! + """ + + @property + def feedback(self) -> global___InterceptFeedback: + """ + The middleware received an interception request and gives feedback to + it. The request_id indicates what message the feedback refers to. + """ + + def __init__( + self, + *, + ref_msg_id: builtins.int = ..., + register: global___MiddlewareRegistration | None = ..., + feedback: global___InterceptFeedback | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["feedback", b"feedback", "middleware_message", b"middleware_message", "register", b"register"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["feedback", b"feedback", "middleware_message", b"middleware_message", "ref_msg_id", b"ref_msg_id", "register", b"register"]) -> None: ... + def WhichOneof(self, oneof_group: typing.Literal["middleware_message", b"middleware_message"]) -> typing.Literal["register", "feedback"] | None: ... + +global___RPCMiddlewareResponse = RPCMiddlewareResponse + +@typing.final +class MiddlewareRegistration(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + MIDDLEWARE_NAME_FIELD_NUMBER: builtins.int + CUSTOM_MACAROON_CAVEAT_NAME_FIELD_NUMBER: builtins.int + READ_ONLY_MODE_FIELD_NUMBER: builtins.int + middleware_name: builtins.str + """ + The name of the middleware to register. The name should be as informative + as possible and is logged on registration. + """ + custom_macaroon_caveat_name: builtins.str + """ + The name of the custom macaroon caveat that this middleware is responsible + for. Only requests/responses that contain a macaroon with the registered + custom caveat are forwarded for interception to the middleware. The + exception being the read-only mode: All requests/responses are forwarded to + a middleware that requests read-only access but such a middleware won't be + allowed to _alter_ responses. As a security measure, _no_ middleware can + change responses to requests made with _unencumbered_ macaroons! + NOTE: Cannot be used at the same time as read_only_mode. + """ + read_only_mode: builtins.bool + """ + Instead of defining a custom macaroon caveat name a middleware can register + itself for read-only access only. In that mode all requests/responses are + forwarded to the middleware but the middleware isn't allowed to alter any of + the responses. + NOTE: Cannot be used at the same time as custom_macaroon_caveat_name. + """ + def __init__( + self, + *, + middleware_name: builtins.str = ..., + custom_macaroon_caveat_name: builtins.str = ..., + read_only_mode: builtins.bool = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["custom_macaroon_caveat_name", b"custom_macaroon_caveat_name", "middleware_name", b"middleware_name", "read_only_mode", b"read_only_mode"]) -> None: ... + +global___MiddlewareRegistration = MiddlewareRegistration + +@typing.final +class InterceptFeedback(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + ERROR_FIELD_NUMBER: builtins.int + REPLACE_RESPONSE_FIELD_NUMBER: builtins.int + REPLACEMENT_SERIALIZED_FIELD_NUMBER: builtins.int + error: builtins.str + """ + The error to return to the user. If this is non-empty, the incoming gRPC + stream/request is aborted and the error is returned to the gRPC client. If + this value is empty, it means the middleware accepts the stream/request/ + response and the processing of it can continue. + """ + replace_response: builtins.bool + """ + A boolean indicating that the gRPC message should be replaced/overwritten. + This boolean is needed because in protobuf an empty message is serialized as + a 0-length or nil byte slice and we wouldn't be able to distinguish between + an empty replacement message and the "don't replace anything" case. + """ + replacement_serialized: builtins.bytes + """ + If the replace_response field is set to true, this field must contain the + binary serialized gRPC message in the protobuf format. + """ + def __init__( + self, + *, + error: builtins.str = ..., + replace_response: builtins.bool = ..., + replacement_serialized: builtins.bytes = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["error", b"error", "replace_response", b"replace_response", "replacement_serialized", b"replacement_serialized"]) -> None: ... + +global___InterceptFeedback = InterceptFeedback diff --git a/cashu/lightning/lnd_grpc/protos/lightning_pb2_grpc.py b/cashu/lightning/lnd_grpc/protos/lightning_pb2_grpc.py new file mode 100644 index 00000000..73442c64 --- /dev/null +++ b/cashu/lightning/lnd_grpc/protos/lightning_pb2_grpc.py @@ -0,0 +1,3382 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import warnings + +import grpc + +import cashu.lightning.lnd_grpc.protos.lightning_pb2 as lightning__pb2 + +GRPC_GENERATED_VERSION = '1.63.0' +GRPC_VERSION = grpc.__version__ +EXPECTED_ERROR_RELEASE = '1.65.0' +SCHEDULED_RELEASE_DATE = 'June 25, 2024' +_version_not_supported = False + +try: + from grpc._utilities import first_version_is_lower + _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION) +except ImportError: + _version_not_supported = True + +if _version_not_supported: + warnings.warn( + f'The grpc package installed is at version {GRPC_VERSION},' + + ' but the generated code in cashu.lightning.lnd_grpc.protos.lightning_pb2_grpc.py depends on' + + f' grpcio>={GRPC_GENERATED_VERSION}.' + + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}' + + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.' + + f' This warning will become an error in {EXPECTED_ERROR_RELEASE},' + + f' scheduled for release on {SCHEDULED_RELEASE_DATE}.', + RuntimeWarning + ) + + +class LightningStub(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. + + 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 + + Lightning is the main RPC server of the daemon. + """ + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.WalletBalance = channel.unary_unary( + '/lnrpc.Lightning/WalletBalance', + request_serializer=lightning__pb2.WalletBalanceRequest.SerializeToString, + response_deserializer=lightning__pb2.WalletBalanceResponse.FromString, + _registered_method=True) + self.ChannelBalance = channel.unary_unary( + '/lnrpc.Lightning/ChannelBalance', + request_serializer=lightning__pb2.ChannelBalanceRequest.SerializeToString, + response_deserializer=lightning__pb2.ChannelBalanceResponse.FromString, + _registered_method=True) + self.GetTransactions = channel.unary_unary( + '/lnrpc.Lightning/GetTransactions', + request_serializer=lightning__pb2.GetTransactionsRequest.SerializeToString, + response_deserializer=lightning__pb2.TransactionDetails.FromString, + _registered_method=True) + self.EstimateFee = channel.unary_unary( + '/lnrpc.Lightning/EstimateFee', + request_serializer=lightning__pb2.EstimateFeeRequest.SerializeToString, + response_deserializer=lightning__pb2.EstimateFeeResponse.FromString, + _registered_method=True) + self.SendCoins = channel.unary_unary( + '/lnrpc.Lightning/SendCoins', + request_serializer=lightning__pb2.SendCoinsRequest.SerializeToString, + response_deserializer=lightning__pb2.SendCoinsResponse.FromString, + _registered_method=True) + self.ListUnspent = channel.unary_unary( + '/lnrpc.Lightning/ListUnspent', + request_serializer=lightning__pb2.ListUnspentRequest.SerializeToString, + response_deserializer=lightning__pb2.ListUnspentResponse.FromString, + _registered_method=True) + self.SubscribeTransactions = channel.unary_stream( + '/lnrpc.Lightning/SubscribeTransactions', + request_serializer=lightning__pb2.GetTransactionsRequest.SerializeToString, + response_deserializer=lightning__pb2.Transaction.FromString, + _registered_method=True) + self.SendMany = channel.unary_unary( + '/lnrpc.Lightning/SendMany', + request_serializer=lightning__pb2.SendManyRequest.SerializeToString, + response_deserializer=lightning__pb2.SendManyResponse.FromString, + _registered_method=True) + self.NewAddress = channel.unary_unary( + '/lnrpc.Lightning/NewAddress', + request_serializer=lightning__pb2.NewAddressRequest.SerializeToString, + response_deserializer=lightning__pb2.NewAddressResponse.FromString, + _registered_method=True) + self.SignMessage = channel.unary_unary( + '/lnrpc.Lightning/SignMessage', + request_serializer=lightning__pb2.SignMessageRequest.SerializeToString, + response_deserializer=lightning__pb2.SignMessageResponse.FromString, + _registered_method=True) + self.VerifyMessage = channel.unary_unary( + '/lnrpc.Lightning/VerifyMessage', + request_serializer=lightning__pb2.VerifyMessageRequest.SerializeToString, + response_deserializer=lightning__pb2.VerifyMessageResponse.FromString, + _registered_method=True) + self.ConnectPeer = channel.unary_unary( + '/lnrpc.Lightning/ConnectPeer', + request_serializer=lightning__pb2.ConnectPeerRequest.SerializeToString, + response_deserializer=lightning__pb2.ConnectPeerResponse.FromString, + _registered_method=True) + self.DisconnectPeer = channel.unary_unary( + '/lnrpc.Lightning/DisconnectPeer', + request_serializer=lightning__pb2.DisconnectPeerRequest.SerializeToString, + response_deserializer=lightning__pb2.DisconnectPeerResponse.FromString, + _registered_method=True) + self.ListPeers = channel.unary_unary( + '/lnrpc.Lightning/ListPeers', + request_serializer=lightning__pb2.ListPeersRequest.SerializeToString, + response_deserializer=lightning__pb2.ListPeersResponse.FromString, + _registered_method=True) + self.SubscribePeerEvents = channel.unary_stream( + '/lnrpc.Lightning/SubscribePeerEvents', + request_serializer=lightning__pb2.PeerEventSubscription.SerializeToString, + response_deserializer=lightning__pb2.PeerEvent.FromString, + _registered_method=True) + self.GetInfo = channel.unary_unary( + '/lnrpc.Lightning/GetInfo', + request_serializer=lightning__pb2.GetInfoRequest.SerializeToString, + response_deserializer=lightning__pb2.GetInfoResponse.FromString, + _registered_method=True) + self.GetDebugInfo = channel.unary_unary( + '/lnrpc.Lightning/GetDebugInfo', + request_serializer=lightning__pb2.GetDebugInfoRequest.SerializeToString, + response_deserializer=lightning__pb2.GetDebugInfoResponse.FromString, + _registered_method=True) + self.GetRecoveryInfo = channel.unary_unary( + '/lnrpc.Lightning/GetRecoveryInfo', + request_serializer=lightning__pb2.GetRecoveryInfoRequest.SerializeToString, + response_deserializer=lightning__pb2.GetRecoveryInfoResponse.FromString, + _registered_method=True) + self.PendingChannels = channel.unary_unary( + '/lnrpc.Lightning/PendingChannels', + request_serializer=lightning__pb2.PendingChannelsRequest.SerializeToString, + response_deserializer=lightning__pb2.PendingChannelsResponse.FromString, + _registered_method=True) + self.ListChannels = channel.unary_unary( + '/lnrpc.Lightning/ListChannels', + request_serializer=lightning__pb2.ListChannelsRequest.SerializeToString, + response_deserializer=lightning__pb2.ListChannelsResponse.FromString, + _registered_method=True) + self.SubscribeChannelEvents = channel.unary_stream( + '/lnrpc.Lightning/SubscribeChannelEvents', + request_serializer=lightning__pb2.ChannelEventSubscription.SerializeToString, + response_deserializer=lightning__pb2.ChannelEventUpdate.FromString, + _registered_method=True) + self.ClosedChannels = channel.unary_unary( + '/lnrpc.Lightning/ClosedChannels', + request_serializer=lightning__pb2.ClosedChannelsRequest.SerializeToString, + response_deserializer=lightning__pb2.ClosedChannelsResponse.FromString, + _registered_method=True) + self.OpenChannelSync = channel.unary_unary( + '/lnrpc.Lightning/OpenChannelSync', + request_serializer=lightning__pb2.OpenChannelRequest.SerializeToString, + response_deserializer=lightning__pb2.ChannelPoint.FromString, + _registered_method=True) + self.OpenChannel = channel.unary_stream( + '/lnrpc.Lightning/OpenChannel', + request_serializer=lightning__pb2.OpenChannelRequest.SerializeToString, + response_deserializer=lightning__pb2.OpenStatusUpdate.FromString, + _registered_method=True) + self.BatchOpenChannel = channel.unary_unary( + '/lnrpc.Lightning/BatchOpenChannel', + request_serializer=lightning__pb2.BatchOpenChannelRequest.SerializeToString, + response_deserializer=lightning__pb2.BatchOpenChannelResponse.FromString, + _registered_method=True) + self.FundingStateStep = channel.unary_unary( + '/lnrpc.Lightning/FundingStateStep', + request_serializer=lightning__pb2.FundingTransitionMsg.SerializeToString, + response_deserializer=lightning__pb2.FundingStateStepResp.FromString, + _registered_method=True) + self.ChannelAcceptor = channel.stream_stream( + '/lnrpc.Lightning/ChannelAcceptor', + request_serializer=lightning__pb2.ChannelAcceptResponse.SerializeToString, + response_deserializer=lightning__pb2.ChannelAcceptRequest.FromString, + _registered_method=True) + self.CloseChannel = channel.unary_stream( + '/lnrpc.Lightning/CloseChannel', + request_serializer=lightning__pb2.CloseChannelRequest.SerializeToString, + response_deserializer=lightning__pb2.CloseStatusUpdate.FromString, + _registered_method=True) + self.AbandonChannel = channel.unary_unary( + '/lnrpc.Lightning/AbandonChannel', + request_serializer=lightning__pb2.AbandonChannelRequest.SerializeToString, + response_deserializer=lightning__pb2.AbandonChannelResponse.FromString, + _registered_method=True) + self.SendPayment = channel.stream_stream( + '/lnrpc.Lightning/SendPayment', + request_serializer=lightning__pb2.SendRequest.SerializeToString, + response_deserializer=lightning__pb2.SendResponse.FromString, + _registered_method=True) + self.SendPaymentSync = channel.unary_unary( + '/lnrpc.Lightning/SendPaymentSync', + request_serializer=lightning__pb2.SendRequest.SerializeToString, + response_deserializer=lightning__pb2.SendResponse.FromString, + _registered_method=True) + self.SendToRoute = channel.stream_stream( + '/lnrpc.Lightning/SendToRoute', + request_serializer=lightning__pb2.SendToRouteRequest.SerializeToString, + response_deserializer=lightning__pb2.SendResponse.FromString, + _registered_method=True) + self.SendToRouteSync = channel.unary_unary( + '/lnrpc.Lightning/SendToRouteSync', + request_serializer=lightning__pb2.SendToRouteRequest.SerializeToString, + response_deserializer=lightning__pb2.SendResponse.FromString, + _registered_method=True) + self.AddInvoice = channel.unary_unary( + '/lnrpc.Lightning/AddInvoice', + request_serializer=lightning__pb2.Invoice.SerializeToString, + response_deserializer=lightning__pb2.AddInvoiceResponse.FromString, + _registered_method=True) + self.ListInvoices = channel.unary_unary( + '/lnrpc.Lightning/ListInvoices', + request_serializer=lightning__pb2.ListInvoiceRequest.SerializeToString, + response_deserializer=lightning__pb2.ListInvoiceResponse.FromString, + _registered_method=True) + self.LookupInvoice = channel.unary_unary( + '/lnrpc.Lightning/LookupInvoice', + request_serializer=lightning__pb2.PaymentHash.SerializeToString, + response_deserializer=lightning__pb2.Invoice.FromString, + _registered_method=True) + self.SubscribeInvoices = channel.unary_stream( + '/lnrpc.Lightning/SubscribeInvoices', + request_serializer=lightning__pb2.InvoiceSubscription.SerializeToString, + response_deserializer=lightning__pb2.Invoice.FromString, + _registered_method=True) + self.DecodePayReq = channel.unary_unary( + '/lnrpc.Lightning/DecodePayReq', + request_serializer=lightning__pb2.PayReqString.SerializeToString, + response_deserializer=lightning__pb2.PayReq.FromString, + _registered_method=True) + self.ListPayments = channel.unary_unary( + '/lnrpc.Lightning/ListPayments', + request_serializer=lightning__pb2.ListPaymentsRequest.SerializeToString, + response_deserializer=lightning__pb2.ListPaymentsResponse.FromString, + _registered_method=True) + self.DeletePayment = channel.unary_unary( + '/lnrpc.Lightning/DeletePayment', + request_serializer=lightning__pb2.DeletePaymentRequest.SerializeToString, + response_deserializer=lightning__pb2.DeletePaymentResponse.FromString, + _registered_method=True) + self.DeleteAllPayments = channel.unary_unary( + '/lnrpc.Lightning/DeleteAllPayments', + request_serializer=lightning__pb2.DeleteAllPaymentsRequest.SerializeToString, + response_deserializer=lightning__pb2.DeleteAllPaymentsResponse.FromString, + _registered_method=True) + self.DescribeGraph = channel.unary_unary( + '/lnrpc.Lightning/DescribeGraph', + request_serializer=lightning__pb2.ChannelGraphRequest.SerializeToString, + response_deserializer=lightning__pb2.ChannelGraph.FromString, + _registered_method=True) + self.GetNodeMetrics = channel.unary_unary( + '/lnrpc.Lightning/GetNodeMetrics', + request_serializer=lightning__pb2.NodeMetricsRequest.SerializeToString, + response_deserializer=lightning__pb2.NodeMetricsResponse.FromString, + _registered_method=True) + self.GetChanInfo = channel.unary_unary( + '/lnrpc.Lightning/GetChanInfo', + request_serializer=lightning__pb2.ChanInfoRequest.SerializeToString, + response_deserializer=lightning__pb2.ChannelEdge.FromString, + _registered_method=True) + self.GetNodeInfo = channel.unary_unary( + '/lnrpc.Lightning/GetNodeInfo', + request_serializer=lightning__pb2.NodeInfoRequest.SerializeToString, + response_deserializer=lightning__pb2.NodeInfo.FromString, + _registered_method=True) + self.QueryRoutes = channel.unary_unary( + '/lnrpc.Lightning/QueryRoutes', + request_serializer=lightning__pb2.QueryRoutesRequest.SerializeToString, + response_deserializer=lightning__pb2.QueryRoutesResponse.FromString, + _registered_method=True) + self.GetNetworkInfo = channel.unary_unary( + '/lnrpc.Lightning/GetNetworkInfo', + request_serializer=lightning__pb2.NetworkInfoRequest.SerializeToString, + response_deserializer=lightning__pb2.NetworkInfo.FromString, + _registered_method=True) + self.StopDaemon = channel.unary_unary( + '/lnrpc.Lightning/StopDaemon', + request_serializer=lightning__pb2.StopRequest.SerializeToString, + response_deserializer=lightning__pb2.StopResponse.FromString, + _registered_method=True) + self.SubscribeChannelGraph = channel.unary_stream( + '/lnrpc.Lightning/SubscribeChannelGraph', + request_serializer=lightning__pb2.GraphTopologySubscription.SerializeToString, + response_deserializer=lightning__pb2.GraphTopologyUpdate.FromString, + _registered_method=True) + self.DebugLevel = channel.unary_unary( + '/lnrpc.Lightning/DebugLevel', + request_serializer=lightning__pb2.DebugLevelRequest.SerializeToString, + response_deserializer=lightning__pb2.DebugLevelResponse.FromString, + _registered_method=True) + self.FeeReport = channel.unary_unary( + '/lnrpc.Lightning/FeeReport', + request_serializer=lightning__pb2.FeeReportRequest.SerializeToString, + response_deserializer=lightning__pb2.FeeReportResponse.FromString, + _registered_method=True) + self.UpdateChannelPolicy = channel.unary_unary( + '/lnrpc.Lightning/UpdateChannelPolicy', + request_serializer=lightning__pb2.PolicyUpdateRequest.SerializeToString, + response_deserializer=lightning__pb2.PolicyUpdateResponse.FromString, + _registered_method=True) + self.ForwardingHistory = channel.unary_unary( + '/lnrpc.Lightning/ForwardingHistory', + request_serializer=lightning__pb2.ForwardingHistoryRequest.SerializeToString, + response_deserializer=lightning__pb2.ForwardingHistoryResponse.FromString, + _registered_method=True) + self.ExportChannelBackup = channel.unary_unary( + '/lnrpc.Lightning/ExportChannelBackup', + request_serializer=lightning__pb2.ExportChannelBackupRequest.SerializeToString, + response_deserializer=lightning__pb2.ChannelBackup.FromString, + _registered_method=True) + self.ExportAllChannelBackups = channel.unary_unary( + '/lnrpc.Lightning/ExportAllChannelBackups', + request_serializer=lightning__pb2.ChanBackupExportRequest.SerializeToString, + response_deserializer=lightning__pb2.ChanBackupSnapshot.FromString, + _registered_method=True) + self.VerifyChanBackup = channel.unary_unary( + '/lnrpc.Lightning/VerifyChanBackup', + request_serializer=lightning__pb2.ChanBackupSnapshot.SerializeToString, + response_deserializer=lightning__pb2.VerifyChanBackupResponse.FromString, + _registered_method=True) + self.RestoreChannelBackups = channel.unary_unary( + '/lnrpc.Lightning/RestoreChannelBackups', + request_serializer=lightning__pb2.RestoreChanBackupRequest.SerializeToString, + response_deserializer=lightning__pb2.RestoreBackupResponse.FromString, + _registered_method=True) + self.SubscribeChannelBackups = channel.unary_stream( + '/lnrpc.Lightning/SubscribeChannelBackups', + request_serializer=lightning__pb2.ChannelBackupSubscription.SerializeToString, + response_deserializer=lightning__pb2.ChanBackupSnapshot.FromString, + _registered_method=True) + self.BakeMacaroon = channel.unary_unary( + '/lnrpc.Lightning/BakeMacaroon', + request_serializer=lightning__pb2.BakeMacaroonRequest.SerializeToString, + response_deserializer=lightning__pb2.BakeMacaroonResponse.FromString, + _registered_method=True) + self.ListMacaroonIDs = channel.unary_unary( + '/lnrpc.Lightning/ListMacaroonIDs', + request_serializer=lightning__pb2.ListMacaroonIDsRequest.SerializeToString, + response_deserializer=lightning__pb2.ListMacaroonIDsResponse.FromString, + _registered_method=True) + self.DeleteMacaroonID = channel.unary_unary( + '/lnrpc.Lightning/DeleteMacaroonID', + request_serializer=lightning__pb2.DeleteMacaroonIDRequest.SerializeToString, + response_deserializer=lightning__pb2.DeleteMacaroonIDResponse.FromString, + _registered_method=True) + self.ListPermissions = channel.unary_unary( + '/lnrpc.Lightning/ListPermissions', + request_serializer=lightning__pb2.ListPermissionsRequest.SerializeToString, + response_deserializer=lightning__pb2.ListPermissionsResponse.FromString, + _registered_method=True) + self.CheckMacaroonPermissions = channel.unary_unary( + '/lnrpc.Lightning/CheckMacaroonPermissions', + request_serializer=lightning__pb2.CheckMacPermRequest.SerializeToString, + response_deserializer=lightning__pb2.CheckMacPermResponse.FromString, + _registered_method=True) + self.RegisterRPCMiddleware = channel.stream_stream( + '/lnrpc.Lightning/RegisterRPCMiddleware', + request_serializer=lightning__pb2.RPCMiddlewareResponse.SerializeToString, + response_deserializer=lightning__pb2.RPCMiddlewareRequest.FromString, + _registered_method=True) + self.SendCustomMessage = channel.unary_unary( + '/lnrpc.Lightning/SendCustomMessage', + request_serializer=lightning__pb2.SendCustomMessageRequest.SerializeToString, + response_deserializer=lightning__pb2.SendCustomMessageResponse.FromString, + _registered_method=True) + self.SubscribeCustomMessages = channel.unary_stream( + '/lnrpc.Lightning/SubscribeCustomMessages', + request_serializer=lightning__pb2.SubscribeCustomMessagesRequest.SerializeToString, + response_deserializer=lightning__pb2.CustomMessage.FromString, + _registered_method=True) + self.ListAliases = channel.unary_unary( + '/lnrpc.Lightning/ListAliases', + request_serializer=lightning__pb2.ListAliasesRequest.SerializeToString, + response_deserializer=lightning__pb2.ListAliasesResponse.FromString, + _registered_method=True) + self.LookupHtlcResolution = channel.unary_unary( + '/lnrpc.Lightning/LookupHtlcResolution', + request_serializer=lightning__pb2.LookupHtlcResolutionRequest.SerializeToString, + response_deserializer=lightning__pb2.LookupHtlcResolutionResponse.FromString, + _registered_method=True) + + +class LightningServicer(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. + + 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 + + Lightning is the main RPC server of the daemon. + """ + + 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 a report on the total funds across all open channels, + categorized in local/remote, pending local/remote and unsettled local/remote + balances. + """ + 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. + + When using REST, the `AddrToAmount` map type can be set by appending + `&AddrToAmount[
]=` to the URL. Unfortunately this + map type doesn't appear in the REST API documentation because of a bug in + the grpc-gateway library. + """ + 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_vbyte 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` + Deprecated, use walletrpc.ListUnspent instead. + + 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_vbyte 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 message and recovers the signer's + public key. The signature is only deemed valid if the recovered public key + corresponds to a node key in the public Lightning network. 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 SubscribePeerEvents(self, request, context): + """ + SubscribePeerEvents creates a uni-directional stream from the server to + the client in which any events relevant to the state of peers are sent + over. Events include peers going online and offline. + """ + 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 GetDebugInfo(self, request, context): + """lncli: 'getdebuginfo' + GetDebugInfo returns debug information concerning the state of the daemon + and its subsystems. This includes the full configuration and the latest log + entries from the log file. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetRecoveryInfo(self, request, context): + """* lncli: `getrecoveryinfo` + GetRecoveryInfo returns information concerning the recovery mode including + whether it's in a recovery mode, whether the recovery is finished, and the + progress made so far. + """ + 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): + """ + 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. Each OpenStatusUpdate will return + the pending channel ID of the in-progress channel. Depending on the + arguments specified in the OpenChannelRequest, this pending channel ID can + then be used to manually progress the channel funding flow. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def BatchOpenChannel(self, request, context): + """lncli: `batchopenchannel` + BatchOpenChannel attempts to open multiple single-funded channels in a + single transaction in an atomic way. This means either all channel open + requests succeed at once or all attempts are aborted if any of them fail. + This is the safer variant of using PSBTs to manually fund a batch of + channels through the OpenChannel RPC. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def FundingStateStep(self, request, context): + """ + FundingStateStep is an advanced funding related call that allows the caller + to either execute some preparatory steps for a funding workflow, or + manually progress a funding workflow. The primary way a funding flow is + identified is via its pending channel ID. As an example, this method can be + used to specify that we're expecting a funding flow for a particular + pending channel ID, for which we need to use specific parameters. + Alternatively, this can be used to interactively drive PSBT signing for + funding for partially complete funding transactions. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ChannelAcceptor(self, request_iterator, context): + """ + ChannelAcceptor dispatches a bi-directional streaming RPC in which + OpenChannel requests are sent to the client and the client responds with + a boolean that tells LND whether or not to accept the channel. This allows + node operators to specify their own criteria for accepting inbound channels + through a single persistent connection. + """ + 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. This method can also be + used to remove externally funded channels where the funding transaction was + never broadcast. Only available for non-externally funded channels in dev + build. + """ + 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` + Deprecated, use routerrpc.SendPaymentV2. 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` + Deprecated, use routerrpc.SendToRouteV2. 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, then 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 DeletePayment(self, request, context): + """lncli: `deletepayments` + DeletePayment deletes an outgoing payment from DB. Note that it will not + attempt to delete an In-Flight payment, since that would be unsafe. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DeleteAllPayments(self, request, context): + """lncli: `deletepayments --all` + DeleteAllPayments deletes all outgoing payments from DB. Note that it will + not attempt to delete In-Flight payments, since that would be unsafe. + """ + 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 GetNodeMetrics(self, request, context): + """lncli: `getnodemetrics` + GetNodeMetrics returns node metrics calculated from the graph. Currently + the only supported metric is betweenness centrality of individual nodes. + """ + 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 returned 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. + + When using REST, the `dest_custom_records` map type can be set by appending + `&dest_custom_records[]=` + to the URL. Unfortunately this map type doesn't appear in the REST API + documentation because of a bug in the grpc-gateway library. + """ + 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, for a maximum number of events. If no maximum number + of events is specified, up to 100 events will be returned. If no time-range + is specified, then events will be returned in the order that they occured. + + 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): + """lncli: `verifychanbackup` + 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 BakeMacaroon(self, request, context): + """lncli: `bakemacaroon` + BakeMacaroon allows the creation of a new macaroon with custom read and + write permissions. No first-party caveats are added since this can be done + offline. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ListMacaroonIDs(self, request, context): + """lncli: `listmacaroonids` + ListMacaroonIDs returns all root key IDs that are in use. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DeleteMacaroonID(self, request, context): + """lncli: `deletemacaroonid` + DeleteMacaroonID deletes the specified macaroon ID and invalidates all + macaroons derived from that ID. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ListPermissions(self, request, context): + """lncli: `listpermissions` + ListPermissions lists all RPC method URIs and their required macaroon + permissions to access them. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def CheckMacaroonPermissions(self, request, context): + """ + CheckMacaroonPermissions checks whether a request follows the constraints + imposed on the macaroon and that the macaroon is authorized to follow the + provided permissions. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def RegisterRPCMiddleware(self, request_iterator, context): + """ + RegisterRPCMiddleware adds a new gRPC middleware to the interceptor chain. A + gRPC middleware is software component external to lnd that aims to add + additional business logic to lnd by observing/intercepting/validating + incoming gRPC client requests and (if needed) replacing/overwriting outgoing + messages before they're sent to the client. When registering the middleware + must identify itself and indicate what custom macaroon caveats it wants to + be responsible for. Only requests that contain a macaroon with that specific + custom caveat are then sent to the middleware for inspection. The other + option is to register for the read-only mode in which all requests/responses + are forwarded for interception to the middleware but the middleware is not + allowed to modify any responses. As a security measure, _no_ middleware can + modify responses for requests made with _unencumbered_ macaroons! + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SendCustomMessage(self, request, context): + """lncli: `sendcustom` + SendCustomMessage sends a custom peer message. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SubscribeCustomMessages(self, request, context): + """lncli: `subscribecustom` + SubscribeCustomMessages subscribes to a stream of incoming custom peer + messages. + + To include messages with type outside of the custom range (>= 32768) lnd + needs to be compiled with the `dev` build tag, and the message type to + override should be specified in lnd's experimental protocol configuration. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def ListAliases(self, request, context): + """lncli: `listaliases` + ListAliases returns the set of all aliases that have ever existed with + their confirmed SCID (if it exists) and/or the base SCID (in the case of + zero conf). + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def LookupHtlcResolution(self, request, context): + """ + LookupHtlcResolution retrieves a final htlc resolution from the database. + If the htlc has no final resolution yet, a NotFound grpc status code is + returned. + """ + 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=lightning__pb2.WalletBalanceRequest.FromString, + response_serializer=lightning__pb2.WalletBalanceResponse.SerializeToString, + ), + 'ChannelBalance': grpc.unary_unary_rpc_method_handler( + servicer.ChannelBalance, + request_deserializer=lightning__pb2.ChannelBalanceRequest.FromString, + response_serializer=lightning__pb2.ChannelBalanceResponse.SerializeToString, + ), + 'GetTransactions': grpc.unary_unary_rpc_method_handler( + servicer.GetTransactions, + request_deserializer=lightning__pb2.GetTransactionsRequest.FromString, + response_serializer=lightning__pb2.TransactionDetails.SerializeToString, + ), + 'EstimateFee': grpc.unary_unary_rpc_method_handler( + servicer.EstimateFee, + request_deserializer=lightning__pb2.EstimateFeeRequest.FromString, + response_serializer=lightning__pb2.EstimateFeeResponse.SerializeToString, + ), + 'SendCoins': grpc.unary_unary_rpc_method_handler( + servicer.SendCoins, + request_deserializer=lightning__pb2.SendCoinsRequest.FromString, + response_serializer=lightning__pb2.SendCoinsResponse.SerializeToString, + ), + 'ListUnspent': grpc.unary_unary_rpc_method_handler( + servicer.ListUnspent, + request_deserializer=lightning__pb2.ListUnspentRequest.FromString, + response_serializer=lightning__pb2.ListUnspentResponse.SerializeToString, + ), + 'SubscribeTransactions': grpc.unary_stream_rpc_method_handler( + servicer.SubscribeTransactions, + request_deserializer=lightning__pb2.GetTransactionsRequest.FromString, + response_serializer=lightning__pb2.Transaction.SerializeToString, + ), + 'SendMany': grpc.unary_unary_rpc_method_handler( + servicer.SendMany, + request_deserializer=lightning__pb2.SendManyRequest.FromString, + response_serializer=lightning__pb2.SendManyResponse.SerializeToString, + ), + 'NewAddress': grpc.unary_unary_rpc_method_handler( + servicer.NewAddress, + request_deserializer=lightning__pb2.NewAddressRequest.FromString, + response_serializer=lightning__pb2.NewAddressResponse.SerializeToString, + ), + 'SignMessage': grpc.unary_unary_rpc_method_handler( + servicer.SignMessage, + request_deserializer=lightning__pb2.SignMessageRequest.FromString, + response_serializer=lightning__pb2.SignMessageResponse.SerializeToString, + ), + 'VerifyMessage': grpc.unary_unary_rpc_method_handler( + servicer.VerifyMessage, + request_deserializer=lightning__pb2.VerifyMessageRequest.FromString, + response_serializer=lightning__pb2.VerifyMessageResponse.SerializeToString, + ), + 'ConnectPeer': grpc.unary_unary_rpc_method_handler( + servicer.ConnectPeer, + request_deserializer=lightning__pb2.ConnectPeerRequest.FromString, + response_serializer=lightning__pb2.ConnectPeerResponse.SerializeToString, + ), + 'DisconnectPeer': grpc.unary_unary_rpc_method_handler( + servicer.DisconnectPeer, + request_deserializer=lightning__pb2.DisconnectPeerRequest.FromString, + response_serializer=lightning__pb2.DisconnectPeerResponse.SerializeToString, + ), + 'ListPeers': grpc.unary_unary_rpc_method_handler( + servicer.ListPeers, + request_deserializer=lightning__pb2.ListPeersRequest.FromString, + response_serializer=lightning__pb2.ListPeersResponse.SerializeToString, + ), + 'SubscribePeerEvents': grpc.unary_stream_rpc_method_handler( + servicer.SubscribePeerEvents, + request_deserializer=lightning__pb2.PeerEventSubscription.FromString, + response_serializer=lightning__pb2.PeerEvent.SerializeToString, + ), + 'GetInfo': grpc.unary_unary_rpc_method_handler( + servicer.GetInfo, + request_deserializer=lightning__pb2.GetInfoRequest.FromString, + response_serializer=lightning__pb2.GetInfoResponse.SerializeToString, + ), + 'GetDebugInfo': grpc.unary_unary_rpc_method_handler( + servicer.GetDebugInfo, + request_deserializer=lightning__pb2.GetDebugInfoRequest.FromString, + response_serializer=lightning__pb2.GetDebugInfoResponse.SerializeToString, + ), + 'GetRecoveryInfo': grpc.unary_unary_rpc_method_handler( + servicer.GetRecoveryInfo, + request_deserializer=lightning__pb2.GetRecoveryInfoRequest.FromString, + response_serializer=lightning__pb2.GetRecoveryInfoResponse.SerializeToString, + ), + 'PendingChannels': grpc.unary_unary_rpc_method_handler( + servicer.PendingChannels, + request_deserializer=lightning__pb2.PendingChannelsRequest.FromString, + response_serializer=lightning__pb2.PendingChannelsResponse.SerializeToString, + ), + 'ListChannels': grpc.unary_unary_rpc_method_handler( + servicer.ListChannels, + request_deserializer=lightning__pb2.ListChannelsRequest.FromString, + response_serializer=lightning__pb2.ListChannelsResponse.SerializeToString, + ), + 'SubscribeChannelEvents': grpc.unary_stream_rpc_method_handler( + servicer.SubscribeChannelEvents, + request_deserializer=lightning__pb2.ChannelEventSubscription.FromString, + response_serializer=lightning__pb2.ChannelEventUpdate.SerializeToString, + ), + 'ClosedChannels': grpc.unary_unary_rpc_method_handler( + servicer.ClosedChannels, + request_deserializer=lightning__pb2.ClosedChannelsRequest.FromString, + response_serializer=lightning__pb2.ClosedChannelsResponse.SerializeToString, + ), + 'OpenChannelSync': grpc.unary_unary_rpc_method_handler( + servicer.OpenChannelSync, + request_deserializer=lightning__pb2.OpenChannelRequest.FromString, + response_serializer=lightning__pb2.ChannelPoint.SerializeToString, + ), + 'OpenChannel': grpc.unary_stream_rpc_method_handler( + servicer.OpenChannel, + request_deserializer=lightning__pb2.OpenChannelRequest.FromString, + response_serializer=lightning__pb2.OpenStatusUpdate.SerializeToString, + ), + 'BatchOpenChannel': grpc.unary_unary_rpc_method_handler( + servicer.BatchOpenChannel, + request_deserializer=lightning__pb2.BatchOpenChannelRequest.FromString, + response_serializer=lightning__pb2.BatchOpenChannelResponse.SerializeToString, + ), + 'FundingStateStep': grpc.unary_unary_rpc_method_handler( + servicer.FundingStateStep, + request_deserializer=lightning__pb2.FundingTransitionMsg.FromString, + response_serializer=lightning__pb2.FundingStateStepResp.SerializeToString, + ), + 'ChannelAcceptor': grpc.stream_stream_rpc_method_handler( + servicer.ChannelAcceptor, + request_deserializer=lightning__pb2.ChannelAcceptResponse.FromString, + response_serializer=lightning__pb2.ChannelAcceptRequest.SerializeToString, + ), + 'CloseChannel': grpc.unary_stream_rpc_method_handler( + servicer.CloseChannel, + request_deserializer=lightning__pb2.CloseChannelRequest.FromString, + response_serializer=lightning__pb2.CloseStatusUpdate.SerializeToString, + ), + 'AbandonChannel': grpc.unary_unary_rpc_method_handler( + servicer.AbandonChannel, + request_deserializer=lightning__pb2.AbandonChannelRequest.FromString, + response_serializer=lightning__pb2.AbandonChannelResponse.SerializeToString, + ), + 'SendPayment': grpc.stream_stream_rpc_method_handler( + servicer.SendPayment, + request_deserializer=lightning__pb2.SendRequest.FromString, + response_serializer=lightning__pb2.SendResponse.SerializeToString, + ), + 'SendPaymentSync': grpc.unary_unary_rpc_method_handler( + servicer.SendPaymentSync, + request_deserializer=lightning__pb2.SendRequest.FromString, + response_serializer=lightning__pb2.SendResponse.SerializeToString, + ), + 'SendToRoute': grpc.stream_stream_rpc_method_handler( + servicer.SendToRoute, + request_deserializer=lightning__pb2.SendToRouteRequest.FromString, + response_serializer=lightning__pb2.SendResponse.SerializeToString, + ), + 'SendToRouteSync': grpc.unary_unary_rpc_method_handler( + servicer.SendToRouteSync, + request_deserializer=lightning__pb2.SendToRouteRequest.FromString, + response_serializer=lightning__pb2.SendResponse.SerializeToString, + ), + 'AddInvoice': grpc.unary_unary_rpc_method_handler( + servicer.AddInvoice, + request_deserializer=lightning__pb2.Invoice.FromString, + response_serializer=lightning__pb2.AddInvoiceResponse.SerializeToString, + ), + 'ListInvoices': grpc.unary_unary_rpc_method_handler( + servicer.ListInvoices, + request_deserializer=lightning__pb2.ListInvoiceRequest.FromString, + response_serializer=lightning__pb2.ListInvoiceResponse.SerializeToString, + ), + 'LookupInvoice': grpc.unary_unary_rpc_method_handler( + servicer.LookupInvoice, + request_deserializer=lightning__pb2.PaymentHash.FromString, + response_serializer=lightning__pb2.Invoice.SerializeToString, + ), + 'SubscribeInvoices': grpc.unary_stream_rpc_method_handler( + servicer.SubscribeInvoices, + request_deserializer=lightning__pb2.InvoiceSubscription.FromString, + response_serializer=lightning__pb2.Invoice.SerializeToString, + ), + 'DecodePayReq': grpc.unary_unary_rpc_method_handler( + servicer.DecodePayReq, + request_deserializer=lightning__pb2.PayReqString.FromString, + response_serializer=lightning__pb2.PayReq.SerializeToString, + ), + 'ListPayments': grpc.unary_unary_rpc_method_handler( + servicer.ListPayments, + request_deserializer=lightning__pb2.ListPaymentsRequest.FromString, + response_serializer=lightning__pb2.ListPaymentsResponse.SerializeToString, + ), + 'DeletePayment': grpc.unary_unary_rpc_method_handler( + servicer.DeletePayment, + request_deserializer=lightning__pb2.DeletePaymentRequest.FromString, + response_serializer=lightning__pb2.DeletePaymentResponse.SerializeToString, + ), + 'DeleteAllPayments': grpc.unary_unary_rpc_method_handler( + servicer.DeleteAllPayments, + request_deserializer=lightning__pb2.DeleteAllPaymentsRequest.FromString, + response_serializer=lightning__pb2.DeleteAllPaymentsResponse.SerializeToString, + ), + 'DescribeGraph': grpc.unary_unary_rpc_method_handler( + servicer.DescribeGraph, + request_deserializer=lightning__pb2.ChannelGraphRequest.FromString, + response_serializer=lightning__pb2.ChannelGraph.SerializeToString, + ), + 'GetNodeMetrics': grpc.unary_unary_rpc_method_handler( + servicer.GetNodeMetrics, + request_deserializer=lightning__pb2.NodeMetricsRequest.FromString, + response_serializer=lightning__pb2.NodeMetricsResponse.SerializeToString, + ), + 'GetChanInfo': grpc.unary_unary_rpc_method_handler( + servicer.GetChanInfo, + request_deserializer=lightning__pb2.ChanInfoRequest.FromString, + response_serializer=lightning__pb2.ChannelEdge.SerializeToString, + ), + 'GetNodeInfo': grpc.unary_unary_rpc_method_handler( + servicer.GetNodeInfo, + request_deserializer=lightning__pb2.NodeInfoRequest.FromString, + response_serializer=lightning__pb2.NodeInfo.SerializeToString, + ), + 'QueryRoutes': grpc.unary_unary_rpc_method_handler( + servicer.QueryRoutes, + request_deserializer=lightning__pb2.QueryRoutesRequest.FromString, + response_serializer=lightning__pb2.QueryRoutesResponse.SerializeToString, + ), + 'GetNetworkInfo': grpc.unary_unary_rpc_method_handler( + servicer.GetNetworkInfo, + request_deserializer=lightning__pb2.NetworkInfoRequest.FromString, + response_serializer=lightning__pb2.NetworkInfo.SerializeToString, + ), + 'StopDaemon': grpc.unary_unary_rpc_method_handler( + servicer.StopDaemon, + request_deserializer=lightning__pb2.StopRequest.FromString, + response_serializer=lightning__pb2.StopResponse.SerializeToString, + ), + 'SubscribeChannelGraph': grpc.unary_stream_rpc_method_handler( + servicer.SubscribeChannelGraph, + request_deserializer=lightning__pb2.GraphTopologySubscription.FromString, + response_serializer=lightning__pb2.GraphTopologyUpdate.SerializeToString, + ), + 'DebugLevel': grpc.unary_unary_rpc_method_handler( + servicer.DebugLevel, + request_deserializer=lightning__pb2.DebugLevelRequest.FromString, + response_serializer=lightning__pb2.DebugLevelResponse.SerializeToString, + ), + 'FeeReport': grpc.unary_unary_rpc_method_handler( + servicer.FeeReport, + request_deserializer=lightning__pb2.FeeReportRequest.FromString, + response_serializer=lightning__pb2.FeeReportResponse.SerializeToString, + ), + 'UpdateChannelPolicy': grpc.unary_unary_rpc_method_handler( + servicer.UpdateChannelPolicy, + request_deserializer=lightning__pb2.PolicyUpdateRequest.FromString, + response_serializer=lightning__pb2.PolicyUpdateResponse.SerializeToString, + ), + 'ForwardingHistory': grpc.unary_unary_rpc_method_handler( + servicer.ForwardingHistory, + request_deserializer=lightning__pb2.ForwardingHistoryRequest.FromString, + response_serializer=lightning__pb2.ForwardingHistoryResponse.SerializeToString, + ), + 'ExportChannelBackup': grpc.unary_unary_rpc_method_handler( + servicer.ExportChannelBackup, + request_deserializer=lightning__pb2.ExportChannelBackupRequest.FromString, + response_serializer=lightning__pb2.ChannelBackup.SerializeToString, + ), + 'ExportAllChannelBackups': grpc.unary_unary_rpc_method_handler( + servicer.ExportAllChannelBackups, + request_deserializer=lightning__pb2.ChanBackupExportRequest.FromString, + response_serializer=lightning__pb2.ChanBackupSnapshot.SerializeToString, + ), + 'VerifyChanBackup': grpc.unary_unary_rpc_method_handler( + servicer.VerifyChanBackup, + request_deserializer=lightning__pb2.ChanBackupSnapshot.FromString, + response_serializer=lightning__pb2.VerifyChanBackupResponse.SerializeToString, + ), + 'RestoreChannelBackups': grpc.unary_unary_rpc_method_handler( + servicer.RestoreChannelBackups, + request_deserializer=lightning__pb2.RestoreChanBackupRequest.FromString, + response_serializer=lightning__pb2.RestoreBackupResponse.SerializeToString, + ), + 'SubscribeChannelBackups': grpc.unary_stream_rpc_method_handler( + servicer.SubscribeChannelBackups, + request_deserializer=lightning__pb2.ChannelBackupSubscription.FromString, + response_serializer=lightning__pb2.ChanBackupSnapshot.SerializeToString, + ), + 'BakeMacaroon': grpc.unary_unary_rpc_method_handler( + servicer.BakeMacaroon, + request_deserializer=lightning__pb2.BakeMacaroonRequest.FromString, + response_serializer=lightning__pb2.BakeMacaroonResponse.SerializeToString, + ), + 'ListMacaroonIDs': grpc.unary_unary_rpc_method_handler( + servicer.ListMacaroonIDs, + request_deserializer=lightning__pb2.ListMacaroonIDsRequest.FromString, + response_serializer=lightning__pb2.ListMacaroonIDsResponse.SerializeToString, + ), + 'DeleteMacaroonID': grpc.unary_unary_rpc_method_handler( + servicer.DeleteMacaroonID, + request_deserializer=lightning__pb2.DeleteMacaroonIDRequest.FromString, + response_serializer=lightning__pb2.DeleteMacaroonIDResponse.SerializeToString, + ), + 'ListPermissions': grpc.unary_unary_rpc_method_handler( + servicer.ListPermissions, + request_deserializer=lightning__pb2.ListPermissionsRequest.FromString, + response_serializer=lightning__pb2.ListPermissionsResponse.SerializeToString, + ), + 'CheckMacaroonPermissions': grpc.unary_unary_rpc_method_handler( + servicer.CheckMacaroonPermissions, + request_deserializer=lightning__pb2.CheckMacPermRequest.FromString, + response_serializer=lightning__pb2.CheckMacPermResponse.SerializeToString, + ), + 'RegisterRPCMiddleware': grpc.stream_stream_rpc_method_handler( + servicer.RegisterRPCMiddleware, + request_deserializer=lightning__pb2.RPCMiddlewareResponse.FromString, + response_serializer=lightning__pb2.RPCMiddlewareRequest.SerializeToString, + ), + 'SendCustomMessage': grpc.unary_unary_rpc_method_handler( + servicer.SendCustomMessage, + request_deserializer=lightning__pb2.SendCustomMessageRequest.FromString, + response_serializer=lightning__pb2.SendCustomMessageResponse.SerializeToString, + ), + 'SubscribeCustomMessages': grpc.unary_stream_rpc_method_handler( + servicer.SubscribeCustomMessages, + request_deserializer=lightning__pb2.SubscribeCustomMessagesRequest.FromString, + response_serializer=lightning__pb2.CustomMessage.SerializeToString, + ), + 'ListAliases': grpc.unary_unary_rpc_method_handler( + servicer.ListAliases, + request_deserializer=lightning__pb2.ListAliasesRequest.FromString, + response_serializer=lightning__pb2.ListAliasesResponse.SerializeToString, + ), + 'LookupHtlcResolution': grpc.unary_unary_rpc_method_handler( + servicer.LookupHtlcResolution, + request_deserializer=lightning__pb2.LookupHtlcResolutionRequest.FromString, + response_serializer=lightning__pb2.LookupHtlcResolutionResponse.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'lnrpc.Lightning', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class Lightning(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. + + 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 + + Lightning is the main RPC server of the daemon. + """ + + @staticmethod + def WalletBalance(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/WalletBalance', + lightning__pb2.WalletBalanceRequest.SerializeToString, + lightning__pb2.WalletBalanceResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def ChannelBalance(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/ChannelBalance', + lightning__pb2.ChannelBalanceRequest.SerializeToString, + lightning__pb2.ChannelBalanceResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def GetTransactions(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/GetTransactions', + lightning__pb2.GetTransactionsRequest.SerializeToString, + lightning__pb2.TransactionDetails.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def EstimateFee(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/EstimateFee', + lightning__pb2.EstimateFeeRequest.SerializeToString, + lightning__pb2.EstimateFeeResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SendCoins(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/SendCoins', + lightning__pb2.SendCoinsRequest.SerializeToString, + lightning__pb2.SendCoinsResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def ListUnspent(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/ListUnspent', + lightning__pb2.ListUnspentRequest.SerializeToString, + lightning__pb2.ListUnspentResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SubscribeTransactions(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_stream( + request, + target, + '/lnrpc.Lightning/SubscribeTransactions', + lightning__pb2.GetTransactionsRequest.SerializeToString, + lightning__pb2.Transaction.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SendMany(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/SendMany', + lightning__pb2.SendManyRequest.SerializeToString, + lightning__pb2.SendManyResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def NewAddress(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/NewAddress', + lightning__pb2.NewAddressRequest.SerializeToString, + lightning__pb2.NewAddressResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SignMessage(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/SignMessage', + lightning__pb2.SignMessageRequest.SerializeToString, + lightning__pb2.SignMessageResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def VerifyMessage(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/VerifyMessage', + lightning__pb2.VerifyMessageRequest.SerializeToString, + lightning__pb2.VerifyMessageResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def ConnectPeer(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/ConnectPeer', + lightning__pb2.ConnectPeerRequest.SerializeToString, + lightning__pb2.ConnectPeerResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def DisconnectPeer(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/DisconnectPeer', + lightning__pb2.DisconnectPeerRequest.SerializeToString, + lightning__pb2.DisconnectPeerResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def ListPeers(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/ListPeers', + lightning__pb2.ListPeersRequest.SerializeToString, + lightning__pb2.ListPeersResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SubscribePeerEvents(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_stream( + request, + target, + '/lnrpc.Lightning/SubscribePeerEvents', + lightning__pb2.PeerEventSubscription.SerializeToString, + lightning__pb2.PeerEvent.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def GetInfo(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/GetInfo', + lightning__pb2.GetInfoRequest.SerializeToString, + lightning__pb2.GetInfoResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def GetDebugInfo(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/GetDebugInfo', + lightning__pb2.GetDebugInfoRequest.SerializeToString, + lightning__pb2.GetDebugInfoResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def GetRecoveryInfo(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/GetRecoveryInfo', + lightning__pb2.GetRecoveryInfoRequest.SerializeToString, + lightning__pb2.GetRecoveryInfoResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def PendingChannels(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/PendingChannels', + lightning__pb2.PendingChannelsRequest.SerializeToString, + lightning__pb2.PendingChannelsResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def ListChannels(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/ListChannels', + lightning__pb2.ListChannelsRequest.SerializeToString, + lightning__pb2.ListChannelsResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SubscribeChannelEvents(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_stream( + request, + target, + '/lnrpc.Lightning/SubscribeChannelEvents', + lightning__pb2.ChannelEventSubscription.SerializeToString, + lightning__pb2.ChannelEventUpdate.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def ClosedChannels(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/ClosedChannels', + lightning__pb2.ClosedChannelsRequest.SerializeToString, + lightning__pb2.ClosedChannelsResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def OpenChannelSync(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/OpenChannelSync', + lightning__pb2.OpenChannelRequest.SerializeToString, + lightning__pb2.ChannelPoint.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def OpenChannel(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_stream( + request, + target, + '/lnrpc.Lightning/OpenChannel', + lightning__pb2.OpenChannelRequest.SerializeToString, + lightning__pb2.OpenStatusUpdate.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def BatchOpenChannel(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/BatchOpenChannel', + lightning__pb2.BatchOpenChannelRequest.SerializeToString, + lightning__pb2.BatchOpenChannelResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def FundingStateStep(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/FundingStateStep', + lightning__pb2.FundingTransitionMsg.SerializeToString, + lightning__pb2.FundingStateStepResp.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def ChannelAcceptor(request_iterator, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.stream_stream( + request_iterator, + target, + '/lnrpc.Lightning/ChannelAcceptor', + lightning__pb2.ChannelAcceptResponse.SerializeToString, + lightning__pb2.ChannelAcceptRequest.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def CloseChannel(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_stream( + request, + target, + '/lnrpc.Lightning/CloseChannel', + lightning__pb2.CloseChannelRequest.SerializeToString, + lightning__pb2.CloseStatusUpdate.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def AbandonChannel(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/AbandonChannel', + lightning__pb2.AbandonChannelRequest.SerializeToString, + lightning__pb2.AbandonChannelResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SendPayment(request_iterator, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.stream_stream( + request_iterator, + target, + '/lnrpc.Lightning/SendPayment', + lightning__pb2.SendRequest.SerializeToString, + lightning__pb2.SendResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SendPaymentSync(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/SendPaymentSync', + lightning__pb2.SendRequest.SerializeToString, + lightning__pb2.SendResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SendToRoute(request_iterator, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.stream_stream( + request_iterator, + target, + '/lnrpc.Lightning/SendToRoute', + lightning__pb2.SendToRouteRequest.SerializeToString, + lightning__pb2.SendResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SendToRouteSync(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/SendToRouteSync', + lightning__pb2.SendToRouteRequest.SerializeToString, + lightning__pb2.SendResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def AddInvoice(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/AddInvoice', + lightning__pb2.Invoice.SerializeToString, + lightning__pb2.AddInvoiceResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def ListInvoices(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/ListInvoices', + lightning__pb2.ListInvoiceRequest.SerializeToString, + lightning__pb2.ListInvoiceResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def LookupInvoice(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/LookupInvoice', + lightning__pb2.PaymentHash.SerializeToString, + lightning__pb2.Invoice.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SubscribeInvoices(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_stream( + request, + target, + '/lnrpc.Lightning/SubscribeInvoices', + lightning__pb2.InvoiceSubscription.SerializeToString, + lightning__pb2.Invoice.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def DecodePayReq(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/DecodePayReq', + lightning__pb2.PayReqString.SerializeToString, + lightning__pb2.PayReq.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def ListPayments(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/ListPayments', + lightning__pb2.ListPaymentsRequest.SerializeToString, + lightning__pb2.ListPaymentsResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def DeletePayment(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/DeletePayment', + lightning__pb2.DeletePaymentRequest.SerializeToString, + lightning__pb2.DeletePaymentResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def DeleteAllPayments(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/DeleteAllPayments', + lightning__pb2.DeleteAllPaymentsRequest.SerializeToString, + lightning__pb2.DeleteAllPaymentsResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def DescribeGraph(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/DescribeGraph', + lightning__pb2.ChannelGraphRequest.SerializeToString, + lightning__pb2.ChannelGraph.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def GetNodeMetrics(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/GetNodeMetrics', + lightning__pb2.NodeMetricsRequest.SerializeToString, + lightning__pb2.NodeMetricsResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def GetChanInfo(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/GetChanInfo', + lightning__pb2.ChanInfoRequest.SerializeToString, + lightning__pb2.ChannelEdge.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def GetNodeInfo(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/GetNodeInfo', + lightning__pb2.NodeInfoRequest.SerializeToString, + lightning__pb2.NodeInfo.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def QueryRoutes(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/QueryRoutes', + lightning__pb2.QueryRoutesRequest.SerializeToString, + lightning__pb2.QueryRoutesResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def GetNetworkInfo(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/GetNetworkInfo', + lightning__pb2.NetworkInfoRequest.SerializeToString, + lightning__pb2.NetworkInfo.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def StopDaemon(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/StopDaemon', + lightning__pb2.StopRequest.SerializeToString, + lightning__pb2.StopResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SubscribeChannelGraph(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_stream( + request, + target, + '/lnrpc.Lightning/SubscribeChannelGraph', + lightning__pb2.GraphTopologySubscription.SerializeToString, + lightning__pb2.GraphTopologyUpdate.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def DebugLevel(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/DebugLevel', + lightning__pb2.DebugLevelRequest.SerializeToString, + lightning__pb2.DebugLevelResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def FeeReport(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/FeeReport', + lightning__pb2.FeeReportRequest.SerializeToString, + lightning__pb2.FeeReportResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def UpdateChannelPolicy(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/UpdateChannelPolicy', + lightning__pb2.PolicyUpdateRequest.SerializeToString, + lightning__pb2.PolicyUpdateResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def ForwardingHistory(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/ForwardingHistory', + lightning__pb2.ForwardingHistoryRequest.SerializeToString, + lightning__pb2.ForwardingHistoryResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def ExportChannelBackup(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/ExportChannelBackup', + lightning__pb2.ExportChannelBackupRequest.SerializeToString, + lightning__pb2.ChannelBackup.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def ExportAllChannelBackups(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/ExportAllChannelBackups', + lightning__pb2.ChanBackupExportRequest.SerializeToString, + lightning__pb2.ChanBackupSnapshot.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def VerifyChanBackup(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/VerifyChanBackup', + lightning__pb2.ChanBackupSnapshot.SerializeToString, + lightning__pb2.VerifyChanBackupResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def RestoreChannelBackups(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/RestoreChannelBackups', + lightning__pb2.RestoreChanBackupRequest.SerializeToString, + lightning__pb2.RestoreBackupResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SubscribeChannelBackups(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_stream( + request, + target, + '/lnrpc.Lightning/SubscribeChannelBackups', + lightning__pb2.ChannelBackupSubscription.SerializeToString, + lightning__pb2.ChanBackupSnapshot.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def BakeMacaroon(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/BakeMacaroon', + lightning__pb2.BakeMacaroonRequest.SerializeToString, + lightning__pb2.BakeMacaroonResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def ListMacaroonIDs(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/ListMacaroonIDs', + lightning__pb2.ListMacaroonIDsRequest.SerializeToString, + lightning__pb2.ListMacaroonIDsResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def DeleteMacaroonID(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/DeleteMacaroonID', + lightning__pb2.DeleteMacaroonIDRequest.SerializeToString, + lightning__pb2.DeleteMacaroonIDResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def ListPermissions(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/ListPermissions', + lightning__pb2.ListPermissionsRequest.SerializeToString, + lightning__pb2.ListPermissionsResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def CheckMacaroonPermissions(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/CheckMacaroonPermissions', + lightning__pb2.CheckMacPermRequest.SerializeToString, + lightning__pb2.CheckMacPermResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def RegisterRPCMiddleware(request_iterator, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.stream_stream( + request_iterator, + target, + '/lnrpc.Lightning/RegisterRPCMiddleware', + lightning__pb2.RPCMiddlewareResponse.SerializeToString, + lightning__pb2.RPCMiddlewareRequest.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SendCustomMessage(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/SendCustomMessage', + lightning__pb2.SendCustomMessageRequest.SerializeToString, + lightning__pb2.SendCustomMessageResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SubscribeCustomMessages(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_stream( + request, + target, + '/lnrpc.Lightning/SubscribeCustomMessages', + lightning__pb2.SubscribeCustomMessagesRequest.SerializeToString, + lightning__pb2.CustomMessage.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def ListAliases(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/ListAliases', + lightning__pb2.ListAliasesRequest.SerializeToString, + lightning__pb2.ListAliasesResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def LookupHtlcResolution(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/lnrpc.Lightning/LookupHtlcResolution', + lightning__pb2.LookupHtlcResolutionRequest.SerializeToString, + lightning__pb2.LookupHtlcResolutionResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) diff --git a/cashu/lightning/lnd_grpc/protos/lightning_pb2_grpc.pyi b/cashu/lightning/lnd_grpc/protos/lightning_pb2_grpc.pyi new file mode 100644 index 00000000..349b68a5 --- /dev/null +++ b/cashu/lightning/lnd_grpc/protos/lightning_pb2_grpc.pyi @@ -0,0 +1,2481 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import abc +import collections.abc +import typing + +import grpc +import grpc.aio + +import cashu.lightning.lnd_grpc.protos.lightning_pb2 + +_T = typing.TypeVar("_T") + +class _MaybeAsyncIterator(collections.abc.AsyncIterator[_T], collections.abc.Iterator[_T], metaclass=abc.ABCMeta): ... + +class _ServicerContext(grpc.ServicerContext, grpc.aio.ServicerContext): # type: ignore[misc, type-arg] + ... + +class LightningStub: + """ + 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. + + 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 + + Lightning is the main RPC server of the daemon. + """ + + def __init__(self, channel: typing.Union[grpc.Channel, grpc.aio.Channel]) -> None: ... + WalletBalance: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.WalletBalanceRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.WalletBalanceResponse, + ] + """lncli: `walletbalance` + WalletBalance returns total unspent outputs(confirmed and unconfirmed), all + confirmed unspent outputs and all unconfirmed unspent outputs under control + of the wallet. + """ + + ChannelBalance: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.ChannelBalanceRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.ChannelBalanceResponse, + ] + """lncli: `channelbalance` + ChannelBalance returns a report on the total funds across all open channels, + categorized in local/remote, pending local/remote and unsettled local/remote + balances. + """ + + GetTransactions: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.GetTransactionsRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.TransactionDetails, + ] + """lncli: `listchaintxns` + GetTransactions returns a list describing all the known transactions + relevant to the wallet. + """ + + EstimateFee: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.EstimateFeeRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.EstimateFeeResponse, + ] + """lncli: `estimatefee` + EstimateFee asks the chain backend to estimate the fee rate and total fees + for a transaction that pays to multiple specified outputs. + + When using REST, the `AddrToAmount` map type can be set by appending + `&AddrToAmount[
]=` to the URL. Unfortunately this + map type doesn't appear in the REST API documentation because of a bug in + the grpc-gateway library. + """ + + SendCoins: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.SendCoinsRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.SendCoinsResponse, + ] + """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_vbyte are set, then the internal wallet will + consult its fee model to determine a fee for the default confirmation + target. + """ + + ListUnspent: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.ListUnspentRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.ListUnspentResponse, + ] + """lncli: `listunspent` + Deprecated, use walletrpc.ListUnspent instead. + + ListUnspent returns a list of all utxos spendable by the wallet with a + number of confirmations between the specified minimum and maximum. + """ + + SubscribeTransactions: grpc.UnaryStreamMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.GetTransactionsRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.Transaction, + ] + """ + 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. + """ + + SendMany: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.SendManyRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.SendManyResponse, + ] + """lncli: `sendmany` + SendMany handles a request for a transaction that creates multiple specified + outputs in parallel. If neither target_conf, or sat_per_vbyte are set, then + the internal wallet will consult its fee model to determine a fee for the + default confirmation target. + """ + + NewAddress: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.NewAddressRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.NewAddressResponse, + ] + """lncli: `newaddress` + NewAddress creates a new address under control of the local wallet. + """ + + SignMessage: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.SignMessageRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.SignMessageResponse, + ] + """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. + """ + + VerifyMessage: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.VerifyMessageRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.VerifyMessageResponse, + ] + """lncli: `verifymessage` + VerifyMessage verifies a signature over a message and recovers the signer's + public key. The signature is only deemed valid if the recovered public key + corresponds to a node key in the public Lightning network. 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. + """ + + ConnectPeer: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.ConnectPeerRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.ConnectPeerResponse, + ] + """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. + """ + + DisconnectPeer: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.DisconnectPeerRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.DisconnectPeerResponse, + ] + """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. + """ + + ListPeers: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.ListPeersRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.ListPeersResponse, + ] + """lncli: `listpeers` + ListPeers returns a verbose listing of all currently active peers. + """ + + SubscribePeerEvents: grpc.UnaryStreamMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.PeerEventSubscription, + cashu.lightning.lnd_grpc.protos.lightning_pb2.PeerEvent, + ] + """ + SubscribePeerEvents creates a uni-directional stream from the server to + the client in which any events relevant to the state of peers are sent + over. Events include peers going online and offline. + """ + + GetInfo: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.GetInfoRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.GetInfoResponse, + ] + """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. + """ + + GetDebugInfo: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.GetDebugInfoRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.GetDebugInfoResponse, + ] + """lncli: 'getdebuginfo' + GetDebugInfo returns debug information concerning the state of the daemon + and its subsystems. This includes the full configuration and the latest log + entries from the log file. + """ + + GetRecoveryInfo: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.GetRecoveryInfoRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.GetRecoveryInfoResponse, + ] + """* lncli: `getrecoveryinfo` + GetRecoveryInfo returns information concerning the recovery mode including + whether it's in a recovery mode, whether the recovery is finished, and the + progress made so far. + """ + + PendingChannels: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.PendingChannelsRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.PendingChannelsResponse, + ] + """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. + """ + + ListChannels: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.ListChannelsRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.ListChannelsResponse, + ] + """lncli: `listchannels` + ListChannels returns a description of all the open channels that this node + is a participant in. + """ + + SubscribeChannelEvents: grpc.UnaryStreamMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.ChannelEventSubscription, + cashu.lightning.lnd_grpc.protos.lightning_pb2.ChannelEventUpdate, + ] + """ + 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. + """ + + ClosedChannels: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.ClosedChannelsRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.ClosedChannelsResponse, + ] + """lncli: `closedchannels` + ClosedChannels returns a description of all the closed channels that + this node was a participant in. + """ + + OpenChannelSync: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.OpenChannelRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.ChannelPoint, + ] + """ + 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. + """ + + OpenChannel: grpc.UnaryStreamMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.OpenChannelRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.OpenStatusUpdate, + ] + """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. Each OpenStatusUpdate will return + the pending channel ID of the in-progress channel. Depending on the + arguments specified in the OpenChannelRequest, this pending channel ID can + then be used to manually progress the channel funding flow. + """ + + BatchOpenChannel: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.BatchOpenChannelRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.BatchOpenChannelResponse, + ] + """lncli: `batchopenchannel` + BatchOpenChannel attempts to open multiple single-funded channels in a + single transaction in an atomic way. This means either all channel open + requests succeed at once or all attempts are aborted if any of them fail. + This is the safer variant of using PSBTs to manually fund a batch of + channels through the OpenChannel RPC. + """ + + FundingStateStep: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.FundingTransitionMsg, + cashu.lightning.lnd_grpc.protos.lightning_pb2.FundingStateStepResp, + ] + """ + FundingStateStep is an advanced funding related call that allows the caller + to either execute some preparatory steps for a funding workflow, or + manually progress a funding workflow. The primary way a funding flow is + identified is via its pending channel ID. As an example, this method can be + used to specify that we're expecting a funding flow for a particular + pending channel ID, for which we need to use specific parameters. + Alternatively, this can be used to interactively drive PSBT signing for + funding for partially complete funding transactions. + """ + + ChannelAcceptor: grpc.StreamStreamMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.ChannelAcceptResponse, + cashu.lightning.lnd_grpc.protos.lightning_pb2.ChannelAcceptRequest, + ] + """ + ChannelAcceptor dispatches a bi-directional streaming RPC in which + OpenChannel requests are sent to the client and the client responds with + a boolean that tells LND whether or not to accept the channel. This allows + node operators to specify their own criteria for accepting inbound channels + through a single persistent connection. + """ + + CloseChannel: grpc.UnaryStreamMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.CloseChannelRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.CloseStatusUpdate, + ] + """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. + """ + + AbandonChannel: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.AbandonChannelRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.AbandonChannelResponse, + ] + """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. This method can also be + used to remove externally funded channels where the funding transaction was + never broadcast. Only available for non-externally funded channels in dev + build. + """ + + SendPayment: grpc.StreamStreamMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.SendRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.SendResponse, + ] + """lncli: `sendpayment` + Deprecated, use routerrpc.SendPaymentV2. 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. + """ + + SendPaymentSync: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.SendRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.SendResponse, + ] + """ + 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. + """ + + SendToRoute: grpc.StreamStreamMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.SendToRouteRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.SendResponse, + ] + """lncli: `sendtoroute` + Deprecated, use routerrpc.SendToRouteV2. 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. + """ + + SendToRouteSync: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.SendToRouteRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.SendResponse, + ] + """ + SendToRouteSync is a synchronous version of SendToRoute. It Will block + until the payment either fails or succeeds. + """ + + AddInvoice: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.Invoice, + cashu.lightning.lnd_grpc.protos.lightning_pb2.AddInvoiceResponse, + ] + """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. + """ + + ListInvoices: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.ListInvoiceRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.ListInvoiceResponse, + ] + """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. + """ + + LookupInvoice: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.PaymentHash, + cashu.lightning.lnd_grpc.protos.lightning_pb2.Invoice, + ] + """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. + """ + + SubscribeInvoices: grpc.UnaryStreamMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.InvoiceSubscription, + cashu.lightning.lnd_grpc.protos.lightning_pb2.Invoice, + ] + """ + 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, then 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. + """ + + DecodePayReq: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.PayReqString, + cashu.lightning.lnd_grpc.protos.lightning_pb2.PayReq, + ] + """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. + """ + + ListPayments: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.ListPaymentsRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.ListPaymentsResponse, + ] + """lncli: `listpayments` + ListPayments returns a list of all outgoing payments. + """ + + DeletePayment: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.DeletePaymentRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.DeletePaymentResponse, + ] + """lncli: `deletepayments` + DeletePayment deletes an outgoing payment from DB. Note that it will not + attempt to delete an In-Flight payment, since that would be unsafe. + """ + + DeleteAllPayments: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.DeleteAllPaymentsRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.DeleteAllPaymentsResponse, + ] + """lncli: `deletepayments --all` + DeleteAllPayments deletes all outgoing payments from DB. Note that it will + not attempt to delete In-Flight payments, since that would be unsafe. + """ + + DescribeGraph: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.ChannelGraphRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.ChannelGraph, + ] + """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. + """ + + GetNodeMetrics: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.NodeMetricsRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.NodeMetricsResponse, + ] + """lncli: `getnodemetrics` + GetNodeMetrics returns node metrics calculated from the graph. Currently + the only supported metric is betweenness centrality of individual nodes. + """ + + GetChanInfo: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.ChanInfoRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.ChannelEdge, + ] + """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. + """ + + GetNodeInfo: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.NodeInfoRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.NodeInfo, + ] + """lncli: `getnodeinfo` + GetNodeInfo returns the latest advertised, aggregated, and authenticated + channel information for the specified node identified by its public key. + """ + + QueryRoutes: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.QueryRoutesRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.QueryRoutesResponse, + ] + """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 returned 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. + + When using REST, the `dest_custom_records` map type can be set by appending + `&dest_custom_records[]=` + to the URL. Unfortunately this map type doesn't appear in the REST API + documentation because of a bug in the grpc-gateway library. + """ + + GetNetworkInfo: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.NetworkInfoRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.NetworkInfo, + ] + """lncli: `getnetworkinfo` + GetNetworkInfo returns some basic stats about the known channel graph from + the point of view of the node. + """ + + StopDaemon: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.StopRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.StopResponse, + ] + """lncli: `stop` + StopDaemon will send a shutdown request to the interrupt handler, triggering + a graceful shutdown of the daemon. + """ + + SubscribeChannelGraph: grpc.UnaryStreamMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.GraphTopologySubscription, + cashu.lightning.lnd_grpc.protos.lightning_pb2.GraphTopologyUpdate, + ] + """ + 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. + """ + + DebugLevel: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.DebugLevelRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.DebugLevelResponse, + ] + """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. + """ + + FeeReport: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.FeeReportRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.FeeReportResponse, + ] + """lncli: `feereport` + FeeReport allows the caller to obtain a report detailing the current fee + schedule enforced by the node globally for each channel. + """ + + UpdateChannelPolicy: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.PolicyUpdateRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.PolicyUpdateResponse, + ] + """lncli: `updatechanpolicy` + UpdateChannelPolicy allows the caller to update the fee schedule and + channel policies for all channels globally, or a particular channel. + """ + + ForwardingHistory: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.ForwardingHistoryRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.ForwardingHistoryResponse, + ] + """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, for a maximum number of events. If no maximum number + of events is specified, up to 100 events will be returned. If no time-range + is specified, then events will be returned in the order that they occured. + + 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. + """ + + ExportChannelBackup: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.ExportChannelBackupRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.ChannelBackup, + ] + """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. + """ + + ExportAllChannelBackups: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.ChanBackupExportRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.ChanBackupSnapshot, + ] + """ + 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. + """ + + VerifyChanBackup: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.ChanBackupSnapshot, + cashu.lightning.lnd_grpc.protos.lightning_pb2.VerifyChanBackupResponse, + ] + """lncli: `verifychanbackup` + 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. + """ + + RestoreChannelBackups: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.RestoreChanBackupRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.RestoreBackupResponse, + ] + """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. + """ + + SubscribeChannelBackups: grpc.UnaryStreamMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.ChannelBackupSubscription, + cashu.lightning.lnd_grpc.protos.lightning_pb2.ChanBackupSnapshot, + ] + """ + 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. + """ + + BakeMacaroon: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.BakeMacaroonRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.BakeMacaroonResponse, + ] + """lncli: `bakemacaroon` + BakeMacaroon allows the creation of a new macaroon with custom read and + write permissions. No first-party caveats are added since this can be done + offline. + """ + + ListMacaroonIDs: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.ListMacaroonIDsRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.ListMacaroonIDsResponse, + ] + """lncli: `listmacaroonids` + ListMacaroonIDs returns all root key IDs that are in use. + """ + + DeleteMacaroonID: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.DeleteMacaroonIDRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.DeleteMacaroonIDResponse, + ] + """lncli: `deletemacaroonid` + DeleteMacaroonID deletes the specified macaroon ID and invalidates all + macaroons derived from that ID. + """ + + ListPermissions: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.ListPermissionsRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.ListPermissionsResponse, + ] + """lncli: `listpermissions` + ListPermissions lists all RPC method URIs and their required macaroon + permissions to access them. + """ + + CheckMacaroonPermissions: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.CheckMacPermRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.CheckMacPermResponse, + ] + """ + CheckMacaroonPermissions checks whether a request follows the constraints + imposed on the macaroon and that the macaroon is authorized to follow the + provided permissions. + """ + + RegisterRPCMiddleware: grpc.StreamStreamMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.RPCMiddlewareResponse, + cashu.lightning.lnd_grpc.protos.lightning_pb2.RPCMiddlewareRequest, + ] + """ + RegisterRPCMiddleware adds a new gRPC middleware to the interceptor chain. A + gRPC middleware is software component external to lnd that aims to add + additional business logic to lnd by observing/intercepting/validating + incoming gRPC client requests and (if needed) replacing/overwriting outgoing + messages before they're sent to the client. When registering the middleware + must identify itself and indicate what custom macaroon caveats it wants to + be responsible for. Only requests that contain a macaroon with that specific + custom caveat are then sent to the middleware for inspection. The other + option is to register for the read-only mode in which all requests/responses + are forwarded for interception to the middleware but the middleware is not + allowed to modify any responses. As a security measure, _no_ middleware can + modify responses for requests made with _unencumbered_ macaroons! + """ + + SendCustomMessage: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.SendCustomMessageRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.SendCustomMessageResponse, + ] + """lncli: `sendcustom` + SendCustomMessage sends a custom peer message. + """ + + SubscribeCustomMessages: grpc.UnaryStreamMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.SubscribeCustomMessagesRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.CustomMessage, + ] + """lncli: `subscribecustom` + SubscribeCustomMessages subscribes to a stream of incoming custom peer + messages. + + To include messages with type outside of the custom range (>= 32768) lnd + needs to be compiled with the `dev` build tag, and the message type to + override should be specified in lnd's experimental protocol configuration. + """ + + ListAliases: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.ListAliasesRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.ListAliasesResponse, + ] + """lncli: `listaliases` + ListAliases returns the set of all aliases that have ever existed with + their confirmed SCID (if it exists) and/or the base SCID (in the case of + zero conf). + """ + + LookupHtlcResolution: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.LookupHtlcResolutionRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.LookupHtlcResolutionResponse, + ] + """ + LookupHtlcResolution retrieves a final htlc resolution from the database. + If the htlc has no final resolution yet, a NotFound grpc status code is + returned. + """ + +class LightningAsyncStub: + """ + 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. + + 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 + + Lightning is the main RPC server of the daemon. + """ + + WalletBalance: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.WalletBalanceRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.WalletBalanceResponse, + ] + """lncli: `walletbalance` + WalletBalance returns total unspent outputs(confirmed and unconfirmed), all + confirmed unspent outputs and all unconfirmed unspent outputs under control + of the wallet. + """ + + ChannelBalance: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.ChannelBalanceRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.ChannelBalanceResponse, + ] + """lncli: `channelbalance` + ChannelBalance returns a report on the total funds across all open channels, + categorized in local/remote, pending local/remote and unsettled local/remote + balances. + """ + + GetTransactions: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.GetTransactionsRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.TransactionDetails, + ] + """lncli: `listchaintxns` + GetTransactions returns a list describing all the known transactions + relevant to the wallet. + """ + + EstimateFee: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.EstimateFeeRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.EstimateFeeResponse, + ] + """lncli: `estimatefee` + EstimateFee asks the chain backend to estimate the fee rate and total fees + for a transaction that pays to multiple specified outputs. + + When using REST, the `AddrToAmount` map type can be set by appending + `&AddrToAmount[
]=` to the URL. Unfortunately this + map type doesn't appear in the REST API documentation because of a bug in + the grpc-gateway library. + """ + + SendCoins: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.SendCoinsRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.SendCoinsResponse, + ] + """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_vbyte are set, then the internal wallet will + consult its fee model to determine a fee for the default confirmation + target. + """ + + ListUnspent: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.ListUnspentRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.ListUnspentResponse, + ] + """lncli: `listunspent` + Deprecated, use walletrpc.ListUnspent instead. + + ListUnspent returns a list of all utxos spendable by the wallet with a + number of confirmations between the specified minimum and maximum. + """ + + SubscribeTransactions: grpc.aio.UnaryStreamMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.GetTransactionsRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.Transaction, + ] + """ + 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. + """ + + SendMany: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.SendManyRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.SendManyResponse, + ] + """lncli: `sendmany` + SendMany handles a request for a transaction that creates multiple specified + outputs in parallel. If neither target_conf, or sat_per_vbyte are set, then + the internal wallet will consult its fee model to determine a fee for the + default confirmation target. + """ + + NewAddress: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.NewAddressRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.NewAddressResponse, + ] + """lncli: `newaddress` + NewAddress creates a new address under control of the local wallet. + """ + + SignMessage: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.SignMessageRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.SignMessageResponse, + ] + """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. + """ + + VerifyMessage: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.VerifyMessageRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.VerifyMessageResponse, + ] + """lncli: `verifymessage` + VerifyMessage verifies a signature over a message and recovers the signer's + public key. The signature is only deemed valid if the recovered public key + corresponds to a node key in the public Lightning network. 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. + """ + + ConnectPeer: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.ConnectPeerRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.ConnectPeerResponse, + ] + """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. + """ + + DisconnectPeer: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.DisconnectPeerRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.DisconnectPeerResponse, + ] + """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. + """ + + ListPeers: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.ListPeersRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.ListPeersResponse, + ] + """lncli: `listpeers` + ListPeers returns a verbose listing of all currently active peers. + """ + + SubscribePeerEvents: grpc.aio.UnaryStreamMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.PeerEventSubscription, + cashu.lightning.lnd_grpc.protos.lightning_pb2.PeerEvent, + ] + """ + SubscribePeerEvents creates a uni-directional stream from the server to + the client in which any events relevant to the state of peers are sent + over. Events include peers going online and offline. + """ + + GetInfo: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.GetInfoRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.GetInfoResponse, + ] + """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. + """ + + GetDebugInfo: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.GetDebugInfoRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.GetDebugInfoResponse, + ] + """lncli: 'getdebuginfo' + GetDebugInfo returns debug information concerning the state of the daemon + and its subsystems. This includes the full configuration and the latest log + entries from the log file. + """ + + GetRecoveryInfo: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.GetRecoveryInfoRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.GetRecoveryInfoResponse, + ] + """* lncli: `getrecoveryinfo` + GetRecoveryInfo returns information concerning the recovery mode including + whether it's in a recovery mode, whether the recovery is finished, and the + progress made so far. + """ + + PendingChannels: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.PendingChannelsRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.PendingChannelsResponse, + ] + """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. + """ + + ListChannels: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.ListChannelsRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.ListChannelsResponse, + ] + """lncli: `listchannels` + ListChannels returns a description of all the open channels that this node + is a participant in. + """ + + SubscribeChannelEvents: grpc.aio.UnaryStreamMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.ChannelEventSubscription, + cashu.lightning.lnd_grpc.protos.lightning_pb2.ChannelEventUpdate, + ] + """ + 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. + """ + + ClosedChannels: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.ClosedChannelsRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.ClosedChannelsResponse, + ] + """lncli: `closedchannels` + ClosedChannels returns a description of all the closed channels that + this node was a participant in. + """ + + OpenChannelSync: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.OpenChannelRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.ChannelPoint, + ] + """ + 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. + """ + + OpenChannel: grpc.aio.UnaryStreamMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.OpenChannelRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.OpenStatusUpdate, + ] + """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. Each OpenStatusUpdate will return + the pending channel ID of the in-progress channel. Depending on the + arguments specified in the OpenChannelRequest, this pending channel ID can + then be used to manually progress the channel funding flow. + """ + + BatchOpenChannel: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.BatchOpenChannelRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.BatchOpenChannelResponse, + ] + """lncli: `batchopenchannel` + BatchOpenChannel attempts to open multiple single-funded channels in a + single transaction in an atomic way. This means either all channel open + requests succeed at once or all attempts are aborted if any of them fail. + This is the safer variant of using PSBTs to manually fund a batch of + channels through the OpenChannel RPC. + """ + + FundingStateStep: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.FundingTransitionMsg, + cashu.lightning.lnd_grpc.protos.lightning_pb2.FundingStateStepResp, + ] + """ + FundingStateStep is an advanced funding related call that allows the caller + to either execute some preparatory steps for a funding workflow, or + manually progress a funding workflow. The primary way a funding flow is + identified is via its pending channel ID. As an example, this method can be + used to specify that we're expecting a funding flow for a particular + pending channel ID, for which we need to use specific parameters. + Alternatively, this can be used to interactively drive PSBT signing for + funding for partially complete funding transactions. + """ + + ChannelAcceptor: grpc.aio.StreamStreamMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.ChannelAcceptResponse, + cashu.lightning.lnd_grpc.protos.lightning_pb2.ChannelAcceptRequest, + ] + """ + ChannelAcceptor dispatches a bi-directional streaming RPC in which + OpenChannel requests are sent to the client and the client responds with + a boolean that tells LND whether or not to accept the channel. This allows + node operators to specify their own criteria for accepting inbound channels + through a single persistent connection. + """ + + CloseChannel: grpc.aio.UnaryStreamMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.CloseChannelRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.CloseStatusUpdate, + ] + """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. + """ + + AbandonChannel: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.AbandonChannelRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.AbandonChannelResponse, + ] + """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. This method can also be + used to remove externally funded channels where the funding transaction was + never broadcast. Only available for non-externally funded channels in dev + build. + """ + + SendPayment: grpc.aio.StreamStreamMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.SendRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.SendResponse, + ] + """lncli: `sendpayment` + Deprecated, use routerrpc.SendPaymentV2. 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. + """ + + SendPaymentSync: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.SendRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.SendResponse, + ] + """ + 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. + """ + + SendToRoute: grpc.aio.StreamStreamMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.SendToRouteRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.SendResponse, + ] + """lncli: `sendtoroute` + Deprecated, use routerrpc.SendToRouteV2. 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. + """ + + SendToRouteSync: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.SendToRouteRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.SendResponse, + ] + """ + SendToRouteSync is a synchronous version of SendToRoute. It Will block + until the payment either fails or succeeds. + """ + + AddInvoice: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.Invoice, + cashu.lightning.lnd_grpc.protos.lightning_pb2.AddInvoiceResponse, + ] + """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. + """ + + ListInvoices: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.ListInvoiceRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.ListInvoiceResponse, + ] + """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. + """ + + LookupInvoice: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.PaymentHash, + cashu.lightning.lnd_grpc.protos.lightning_pb2.Invoice, + ] + """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. + """ + + SubscribeInvoices: grpc.aio.UnaryStreamMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.InvoiceSubscription, + cashu.lightning.lnd_grpc.protos.lightning_pb2.Invoice, + ] + """ + 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, then 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. + """ + + DecodePayReq: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.PayReqString, + cashu.lightning.lnd_grpc.protos.lightning_pb2.PayReq, + ] + """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. + """ + + ListPayments: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.ListPaymentsRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.ListPaymentsResponse, + ] + """lncli: `listpayments` + ListPayments returns a list of all outgoing payments. + """ + + DeletePayment: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.DeletePaymentRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.DeletePaymentResponse, + ] + """lncli: `deletepayments` + DeletePayment deletes an outgoing payment from DB. Note that it will not + attempt to delete an In-Flight payment, since that would be unsafe. + """ + + DeleteAllPayments: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.DeleteAllPaymentsRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.DeleteAllPaymentsResponse, + ] + """lncli: `deletepayments --all` + DeleteAllPayments deletes all outgoing payments from DB. Note that it will + not attempt to delete In-Flight payments, since that would be unsafe. + """ + + DescribeGraph: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.ChannelGraphRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.ChannelGraph, + ] + """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. + """ + + GetNodeMetrics: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.NodeMetricsRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.NodeMetricsResponse, + ] + """lncli: `getnodemetrics` + GetNodeMetrics returns node metrics calculated from the graph. Currently + the only supported metric is betweenness centrality of individual nodes. + """ + + GetChanInfo: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.ChanInfoRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.ChannelEdge, + ] + """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. + """ + + GetNodeInfo: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.NodeInfoRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.NodeInfo, + ] + """lncli: `getnodeinfo` + GetNodeInfo returns the latest advertised, aggregated, and authenticated + channel information for the specified node identified by its public key. + """ + + QueryRoutes: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.QueryRoutesRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.QueryRoutesResponse, + ] + """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 returned 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. + + When using REST, the `dest_custom_records` map type can be set by appending + `&dest_custom_records[]=` + to the URL. Unfortunately this map type doesn't appear in the REST API + documentation because of a bug in the grpc-gateway library. + """ + + GetNetworkInfo: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.NetworkInfoRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.NetworkInfo, + ] + """lncli: `getnetworkinfo` + GetNetworkInfo returns some basic stats about the known channel graph from + the point of view of the node. + """ + + StopDaemon: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.StopRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.StopResponse, + ] + """lncli: `stop` + StopDaemon will send a shutdown request to the interrupt handler, triggering + a graceful shutdown of the daemon. + """ + + SubscribeChannelGraph: grpc.aio.UnaryStreamMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.GraphTopologySubscription, + cashu.lightning.lnd_grpc.protos.lightning_pb2.GraphTopologyUpdate, + ] + """ + 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. + """ + + DebugLevel: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.DebugLevelRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.DebugLevelResponse, + ] + """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. + """ + + FeeReport: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.FeeReportRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.FeeReportResponse, + ] + """lncli: `feereport` + FeeReport allows the caller to obtain a report detailing the current fee + schedule enforced by the node globally for each channel. + """ + + UpdateChannelPolicy: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.PolicyUpdateRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.PolicyUpdateResponse, + ] + """lncli: `updatechanpolicy` + UpdateChannelPolicy allows the caller to update the fee schedule and + channel policies for all channels globally, or a particular channel. + """ + + ForwardingHistory: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.ForwardingHistoryRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.ForwardingHistoryResponse, + ] + """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, for a maximum number of events. If no maximum number + of events is specified, up to 100 events will be returned. If no time-range + is specified, then events will be returned in the order that they occured. + + 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. + """ + + ExportChannelBackup: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.ExportChannelBackupRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.ChannelBackup, + ] + """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. + """ + + ExportAllChannelBackups: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.ChanBackupExportRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.ChanBackupSnapshot, + ] + """ + 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. + """ + + VerifyChanBackup: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.ChanBackupSnapshot, + cashu.lightning.lnd_grpc.protos.lightning_pb2.VerifyChanBackupResponse, + ] + """lncli: `verifychanbackup` + 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. + """ + + RestoreChannelBackups: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.RestoreChanBackupRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.RestoreBackupResponse, + ] + """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. + """ + + SubscribeChannelBackups: grpc.aio.UnaryStreamMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.ChannelBackupSubscription, + cashu.lightning.lnd_grpc.protos.lightning_pb2.ChanBackupSnapshot, + ] + """ + 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. + """ + + BakeMacaroon: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.BakeMacaroonRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.BakeMacaroonResponse, + ] + """lncli: `bakemacaroon` + BakeMacaroon allows the creation of a new macaroon with custom read and + write permissions. No first-party caveats are added since this can be done + offline. + """ + + ListMacaroonIDs: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.ListMacaroonIDsRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.ListMacaroonIDsResponse, + ] + """lncli: `listmacaroonids` + ListMacaroonIDs returns all root key IDs that are in use. + """ + + DeleteMacaroonID: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.DeleteMacaroonIDRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.DeleteMacaroonIDResponse, + ] + """lncli: `deletemacaroonid` + DeleteMacaroonID deletes the specified macaroon ID and invalidates all + macaroons derived from that ID. + """ + + ListPermissions: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.ListPermissionsRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.ListPermissionsResponse, + ] + """lncli: `listpermissions` + ListPermissions lists all RPC method URIs and their required macaroon + permissions to access them. + """ + + CheckMacaroonPermissions: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.CheckMacPermRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.CheckMacPermResponse, + ] + """ + CheckMacaroonPermissions checks whether a request follows the constraints + imposed on the macaroon and that the macaroon is authorized to follow the + provided permissions. + """ + + RegisterRPCMiddleware: grpc.aio.StreamStreamMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.RPCMiddlewareResponse, + cashu.lightning.lnd_grpc.protos.lightning_pb2.RPCMiddlewareRequest, + ] + """ + RegisterRPCMiddleware adds a new gRPC middleware to the interceptor chain. A + gRPC middleware is software component external to lnd that aims to add + additional business logic to lnd by observing/intercepting/validating + incoming gRPC client requests and (if needed) replacing/overwriting outgoing + messages before they're sent to the client. When registering the middleware + must identify itself and indicate what custom macaroon caveats it wants to + be responsible for. Only requests that contain a macaroon with that specific + custom caveat are then sent to the middleware for inspection. The other + option is to register for the read-only mode in which all requests/responses + are forwarded for interception to the middleware but the middleware is not + allowed to modify any responses. As a security measure, _no_ middleware can + modify responses for requests made with _unencumbered_ macaroons! + """ + + SendCustomMessage: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.SendCustomMessageRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.SendCustomMessageResponse, + ] + """lncli: `sendcustom` + SendCustomMessage sends a custom peer message. + """ + + SubscribeCustomMessages: grpc.aio.UnaryStreamMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.SubscribeCustomMessagesRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.CustomMessage, + ] + """lncli: `subscribecustom` + SubscribeCustomMessages subscribes to a stream of incoming custom peer + messages. + + To include messages with type outside of the custom range (>= 32768) lnd + needs to be compiled with the `dev` build tag, and the message type to + override should be specified in lnd's experimental protocol configuration. + """ + + ListAliases: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.ListAliasesRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.ListAliasesResponse, + ] + """lncli: `listaliases` + ListAliases returns the set of all aliases that have ever existed with + their confirmed SCID (if it exists) and/or the base SCID (in the case of + zero conf). + """ + + LookupHtlcResolution: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.lightning_pb2.LookupHtlcResolutionRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.LookupHtlcResolutionResponse, + ] + """ + LookupHtlcResolution retrieves a final htlc resolution from the database. + If the htlc has no final resolution yet, a NotFound grpc status code is + returned. + """ + +class LightningServicer(metaclass=abc.ABCMeta): + """ + 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. + + 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 + + Lightning is the main RPC server of the daemon. + """ + + @abc.abstractmethod + def WalletBalance( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.WalletBalanceRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.WalletBalanceResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.WalletBalanceResponse]]: + """lncli: `walletbalance` + WalletBalance returns total unspent outputs(confirmed and unconfirmed), all + confirmed unspent outputs and all unconfirmed unspent outputs under control + of the wallet. + """ + + @abc.abstractmethod + def ChannelBalance( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.ChannelBalanceRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.ChannelBalanceResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.ChannelBalanceResponse]]: + """lncli: `channelbalance` + ChannelBalance returns a report on the total funds across all open channels, + categorized in local/remote, pending local/remote and unsettled local/remote + balances. + """ + + @abc.abstractmethod + def GetTransactions( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.GetTransactionsRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.TransactionDetails, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.TransactionDetails]]: + """lncli: `listchaintxns` + GetTransactions returns a list describing all the known transactions + relevant to the wallet. + """ + + @abc.abstractmethod + def EstimateFee( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.EstimateFeeRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.EstimateFeeResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.EstimateFeeResponse]]: + """lncli: `estimatefee` + EstimateFee asks the chain backend to estimate the fee rate and total fees + for a transaction that pays to multiple specified outputs. + + When using REST, the `AddrToAmount` map type can be set by appending + `&AddrToAmount[
]=` to the URL. Unfortunately this + map type doesn't appear in the REST API documentation because of a bug in + the grpc-gateway library. + """ + + @abc.abstractmethod + def SendCoins( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.SendCoinsRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.SendCoinsResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.SendCoinsResponse]]: + """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_vbyte are set, then the internal wallet will + consult its fee model to determine a fee for the default confirmation + target. + """ + + @abc.abstractmethod + def ListUnspent( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.ListUnspentRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.ListUnspentResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.ListUnspentResponse]]: + """lncli: `listunspent` + Deprecated, use walletrpc.ListUnspent instead. + + ListUnspent returns a list of all utxos spendable by the wallet with a + number of confirmations between the specified minimum and maximum. + """ + + @abc.abstractmethod + def SubscribeTransactions( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.GetTransactionsRequest, + context: _ServicerContext, + ) -> typing.Union[collections.abc.Iterator[cashu.lightning.lnd_grpc.protos.lightning_pb2.Transaction], collections.abc.AsyncIterator[cashu.lightning.lnd_grpc.protos.lightning_pb2.Transaction]]: + """ + 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. + """ + + @abc.abstractmethod + def SendMany( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.SendManyRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.SendManyResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.SendManyResponse]]: + """lncli: `sendmany` + SendMany handles a request for a transaction that creates multiple specified + outputs in parallel. If neither target_conf, or sat_per_vbyte are set, then + the internal wallet will consult its fee model to determine a fee for the + default confirmation target. + """ + + @abc.abstractmethod + def NewAddress( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.NewAddressRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.NewAddressResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.NewAddressResponse]]: + """lncli: `newaddress` + NewAddress creates a new address under control of the local wallet. + """ + + @abc.abstractmethod + def SignMessage( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.SignMessageRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.SignMessageResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.SignMessageResponse]]: + """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. + """ + + @abc.abstractmethod + def VerifyMessage( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.VerifyMessageRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.VerifyMessageResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.VerifyMessageResponse]]: + """lncli: `verifymessage` + VerifyMessage verifies a signature over a message and recovers the signer's + public key. The signature is only deemed valid if the recovered public key + corresponds to a node key in the public Lightning network. 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. + """ + + @abc.abstractmethod + def ConnectPeer( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.ConnectPeerRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.ConnectPeerResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.ConnectPeerResponse]]: + """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. + """ + + @abc.abstractmethod + def DisconnectPeer( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.DisconnectPeerRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.DisconnectPeerResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.DisconnectPeerResponse]]: + """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. + """ + + @abc.abstractmethod + def ListPeers( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.ListPeersRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.ListPeersResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.ListPeersResponse]]: + """lncli: `listpeers` + ListPeers returns a verbose listing of all currently active peers. + """ + + @abc.abstractmethod + def SubscribePeerEvents( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.PeerEventSubscription, + context: _ServicerContext, + ) -> typing.Union[collections.abc.Iterator[cashu.lightning.lnd_grpc.protos.lightning_pb2.PeerEvent], collections.abc.AsyncIterator[cashu.lightning.lnd_grpc.protos.lightning_pb2.PeerEvent]]: + """ + SubscribePeerEvents creates a uni-directional stream from the server to + the client in which any events relevant to the state of peers are sent + over. Events include peers going online and offline. + """ + + @abc.abstractmethod + def GetInfo( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.GetInfoRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.GetInfoResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.GetInfoResponse]]: + """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. + """ + + @abc.abstractmethod + def GetDebugInfo( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.GetDebugInfoRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.GetDebugInfoResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.GetDebugInfoResponse]]: + """lncli: 'getdebuginfo' + GetDebugInfo returns debug information concerning the state of the daemon + and its subsystems. This includes the full configuration and the latest log + entries from the log file. + """ + + @abc.abstractmethod + def GetRecoveryInfo( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.GetRecoveryInfoRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.GetRecoveryInfoResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.GetRecoveryInfoResponse]]: + """* lncli: `getrecoveryinfo` + GetRecoveryInfo returns information concerning the recovery mode including + whether it's in a recovery mode, whether the recovery is finished, and the + progress made so far. + """ + + @abc.abstractmethod + def PendingChannels( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.PendingChannelsRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.PendingChannelsResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.PendingChannelsResponse]]: + """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. + """ + + @abc.abstractmethod + def ListChannels( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.ListChannelsRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.ListChannelsResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.ListChannelsResponse]]: + """lncli: `listchannels` + ListChannels returns a description of all the open channels that this node + is a participant in. + """ + + @abc.abstractmethod + def SubscribeChannelEvents( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.ChannelEventSubscription, + context: _ServicerContext, + ) -> typing.Union[collections.abc.Iterator[cashu.lightning.lnd_grpc.protos.lightning_pb2.ChannelEventUpdate], collections.abc.AsyncIterator[cashu.lightning.lnd_grpc.protos.lightning_pb2.ChannelEventUpdate]]: + """ + 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. + """ + + @abc.abstractmethod + def ClosedChannels( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.ClosedChannelsRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.ClosedChannelsResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.ClosedChannelsResponse]]: + """lncli: `closedchannels` + ClosedChannels returns a description of all the closed channels that + this node was a participant in. + """ + + @abc.abstractmethod + def OpenChannelSync( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.OpenChannelRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.ChannelPoint, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.ChannelPoint]]: + """ + 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. + """ + + @abc.abstractmethod + def OpenChannel( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.OpenChannelRequest, + context: _ServicerContext, + ) -> typing.Union[collections.abc.Iterator[cashu.lightning.lnd_grpc.protos.lightning_pb2.OpenStatusUpdate], collections.abc.AsyncIterator[cashu.lightning.lnd_grpc.protos.lightning_pb2.OpenStatusUpdate]]: + """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. Each OpenStatusUpdate will return + the pending channel ID of the in-progress channel. Depending on the + arguments specified in the OpenChannelRequest, this pending channel ID can + then be used to manually progress the channel funding flow. + """ + + @abc.abstractmethod + def BatchOpenChannel( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.BatchOpenChannelRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.BatchOpenChannelResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.BatchOpenChannelResponse]]: + """lncli: `batchopenchannel` + BatchOpenChannel attempts to open multiple single-funded channels in a + single transaction in an atomic way. This means either all channel open + requests succeed at once or all attempts are aborted if any of them fail. + This is the safer variant of using PSBTs to manually fund a batch of + channels through the OpenChannel RPC. + """ + + @abc.abstractmethod + def FundingStateStep( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.FundingTransitionMsg, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.FundingStateStepResp, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.FundingStateStepResp]]: + """ + FundingStateStep is an advanced funding related call that allows the caller + to either execute some preparatory steps for a funding workflow, or + manually progress a funding workflow. The primary way a funding flow is + identified is via its pending channel ID. As an example, this method can be + used to specify that we're expecting a funding flow for a particular + pending channel ID, for which we need to use specific parameters. + Alternatively, this can be used to interactively drive PSBT signing for + funding for partially complete funding transactions. + """ + + @abc.abstractmethod + def ChannelAcceptor( + self, + request_iterator: _MaybeAsyncIterator[cashu.lightning.lnd_grpc.protos.lightning_pb2.ChannelAcceptResponse], + context: _ServicerContext, + ) -> typing.Union[collections.abc.Iterator[cashu.lightning.lnd_grpc.protos.lightning_pb2.ChannelAcceptRequest], collections.abc.AsyncIterator[cashu.lightning.lnd_grpc.protos.lightning_pb2.ChannelAcceptRequest]]: + """ + ChannelAcceptor dispatches a bi-directional streaming RPC in which + OpenChannel requests are sent to the client and the client responds with + a boolean that tells LND whether or not to accept the channel. This allows + node operators to specify their own criteria for accepting inbound channels + through a single persistent connection. + """ + + @abc.abstractmethod + def CloseChannel( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.CloseChannelRequest, + context: _ServicerContext, + ) -> typing.Union[collections.abc.Iterator[cashu.lightning.lnd_grpc.protos.lightning_pb2.CloseStatusUpdate], collections.abc.AsyncIterator[cashu.lightning.lnd_grpc.protos.lightning_pb2.CloseStatusUpdate]]: + """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. + """ + + @abc.abstractmethod + def AbandonChannel( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.AbandonChannelRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.AbandonChannelResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.AbandonChannelResponse]]: + """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. This method can also be + used to remove externally funded channels where the funding transaction was + never broadcast. Only available for non-externally funded channels in dev + build. + """ + + @abc.abstractmethod + def SendPayment( + self, + request_iterator: _MaybeAsyncIterator[cashu.lightning.lnd_grpc.protos.lightning_pb2.SendRequest], + context: _ServicerContext, + ) -> typing.Union[collections.abc.Iterator[cashu.lightning.lnd_grpc.protos.lightning_pb2.SendResponse], collections.abc.AsyncIterator[cashu.lightning.lnd_grpc.protos.lightning_pb2.SendResponse]]: + """lncli: `sendpayment` + Deprecated, use routerrpc.SendPaymentV2. 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. + """ + + @abc.abstractmethod + def SendPaymentSync( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.SendRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.SendResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.SendResponse]]: + """ + 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. + """ + + @abc.abstractmethod + def SendToRoute( + self, + request_iterator: _MaybeAsyncIterator[cashu.lightning.lnd_grpc.protos.lightning_pb2.SendToRouteRequest], + context: _ServicerContext, + ) -> typing.Union[collections.abc.Iterator[cashu.lightning.lnd_grpc.protos.lightning_pb2.SendResponse], collections.abc.AsyncIterator[cashu.lightning.lnd_grpc.protos.lightning_pb2.SendResponse]]: + """lncli: `sendtoroute` + Deprecated, use routerrpc.SendToRouteV2. 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. + """ + + @abc.abstractmethod + def SendToRouteSync( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.SendToRouteRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.SendResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.SendResponse]]: + """ + SendToRouteSync is a synchronous version of SendToRoute. It Will block + until the payment either fails or succeeds. + """ + + @abc.abstractmethod + def AddInvoice( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.Invoice, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.AddInvoiceResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.AddInvoiceResponse]]: + """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. + """ + + @abc.abstractmethod + def ListInvoices( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.ListInvoiceRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.ListInvoiceResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.ListInvoiceResponse]]: + """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. + """ + + @abc.abstractmethod + def LookupInvoice( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.PaymentHash, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.Invoice, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.Invoice]]: + """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. + """ + + @abc.abstractmethod + def SubscribeInvoices( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.InvoiceSubscription, + context: _ServicerContext, + ) -> typing.Union[collections.abc.Iterator[cashu.lightning.lnd_grpc.protos.lightning_pb2.Invoice], collections.abc.AsyncIterator[cashu.lightning.lnd_grpc.protos.lightning_pb2.Invoice]]: + """ + 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, then 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. + """ + + @abc.abstractmethod + def DecodePayReq( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.PayReqString, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.PayReq, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.PayReq]]: + """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. + """ + + @abc.abstractmethod + def ListPayments( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.ListPaymentsRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.ListPaymentsResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.ListPaymentsResponse]]: + """lncli: `listpayments` + ListPayments returns a list of all outgoing payments. + """ + + @abc.abstractmethod + def DeletePayment( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.DeletePaymentRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.DeletePaymentResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.DeletePaymentResponse]]: + """lncli: `deletepayments` + DeletePayment deletes an outgoing payment from DB. Note that it will not + attempt to delete an In-Flight payment, since that would be unsafe. + """ + + @abc.abstractmethod + def DeleteAllPayments( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.DeleteAllPaymentsRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.DeleteAllPaymentsResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.DeleteAllPaymentsResponse]]: + """lncli: `deletepayments --all` + DeleteAllPayments deletes all outgoing payments from DB. Note that it will + not attempt to delete In-Flight payments, since that would be unsafe. + """ + + @abc.abstractmethod + def DescribeGraph( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.ChannelGraphRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.ChannelGraph, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.ChannelGraph]]: + """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. + """ + + @abc.abstractmethod + def GetNodeMetrics( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.NodeMetricsRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.NodeMetricsResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.NodeMetricsResponse]]: + """lncli: `getnodemetrics` + GetNodeMetrics returns node metrics calculated from the graph. Currently + the only supported metric is betweenness centrality of individual nodes. + """ + + @abc.abstractmethod + def GetChanInfo( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.ChanInfoRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.ChannelEdge, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.ChannelEdge]]: + """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. + """ + + @abc.abstractmethod + def GetNodeInfo( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.NodeInfoRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.NodeInfo, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.NodeInfo]]: + """lncli: `getnodeinfo` + GetNodeInfo returns the latest advertised, aggregated, and authenticated + channel information for the specified node identified by its public key. + """ + + @abc.abstractmethod + def QueryRoutes( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.QueryRoutesRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.QueryRoutesResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.QueryRoutesResponse]]: + """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 returned 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. + + When using REST, the `dest_custom_records` map type can be set by appending + `&dest_custom_records[]=` + to the URL. Unfortunately this map type doesn't appear in the REST API + documentation because of a bug in the grpc-gateway library. + """ + + @abc.abstractmethod + def GetNetworkInfo( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.NetworkInfoRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.NetworkInfo, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.NetworkInfo]]: + """lncli: `getnetworkinfo` + GetNetworkInfo returns some basic stats about the known channel graph from + the point of view of the node. + """ + + @abc.abstractmethod + def StopDaemon( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.StopRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.StopResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.StopResponse]]: + """lncli: `stop` + StopDaemon will send a shutdown request to the interrupt handler, triggering + a graceful shutdown of the daemon. + """ + + @abc.abstractmethod + def SubscribeChannelGraph( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.GraphTopologySubscription, + context: _ServicerContext, + ) -> typing.Union[collections.abc.Iterator[cashu.lightning.lnd_grpc.protos.lightning_pb2.GraphTopologyUpdate], collections.abc.AsyncIterator[cashu.lightning.lnd_grpc.protos.lightning_pb2.GraphTopologyUpdate]]: + """ + 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. + """ + + @abc.abstractmethod + def DebugLevel( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.DebugLevelRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.DebugLevelResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.DebugLevelResponse]]: + """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. + """ + + @abc.abstractmethod + def FeeReport( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.FeeReportRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.FeeReportResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.FeeReportResponse]]: + """lncli: `feereport` + FeeReport allows the caller to obtain a report detailing the current fee + schedule enforced by the node globally for each channel. + """ + + @abc.abstractmethod + def UpdateChannelPolicy( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.PolicyUpdateRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.PolicyUpdateResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.PolicyUpdateResponse]]: + """lncli: `updatechanpolicy` + UpdateChannelPolicy allows the caller to update the fee schedule and + channel policies for all channels globally, or a particular channel. + """ + + @abc.abstractmethod + def ForwardingHistory( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.ForwardingHistoryRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.ForwardingHistoryResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.ForwardingHistoryResponse]]: + """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, for a maximum number of events. If no maximum number + of events is specified, up to 100 events will be returned. If no time-range + is specified, then events will be returned in the order that they occured. + + 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. + """ + + @abc.abstractmethod + def ExportChannelBackup( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.ExportChannelBackupRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.ChannelBackup, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.ChannelBackup]]: + """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. + """ + + @abc.abstractmethod + def ExportAllChannelBackups( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.ChanBackupExportRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.ChanBackupSnapshot, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.ChanBackupSnapshot]]: + """ + 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. + """ + + @abc.abstractmethod + def VerifyChanBackup( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.ChanBackupSnapshot, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.VerifyChanBackupResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.VerifyChanBackupResponse]]: + """lncli: `verifychanbackup` + 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. + """ + + @abc.abstractmethod + def RestoreChannelBackups( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.RestoreChanBackupRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.RestoreBackupResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.RestoreBackupResponse]]: + """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. + """ + + @abc.abstractmethod + def SubscribeChannelBackups( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.ChannelBackupSubscription, + context: _ServicerContext, + ) -> typing.Union[collections.abc.Iterator[cashu.lightning.lnd_grpc.protos.lightning_pb2.ChanBackupSnapshot], collections.abc.AsyncIterator[cashu.lightning.lnd_grpc.protos.lightning_pb2.ChanBackupSnapshot]]: + """ + 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. + """ + + @abc.abstractmethod + def BakeMacaroon( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.BakeMacaroonRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.BakeMacaroonResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.BakeMacaroonResponse]]: + """lncli: `bakemacaroon` + BakeMacaroon allows the creation of a new macaroon with custom read and + write permissions. No first-party caveats are added since this can be done + offline. + """ + + @abc.abstractmethod + def ListMacaroonIDs( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.ListMacaroonIDsRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.ListMacaroonIDsResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.ListMacaroonIDsResponse]]: + """lncli: `listmacaroonids` + ListMacaroonIDs returns all root key IDs that are in use. + """ + + @abc.abstractmethod + def DeleteMacaroonID( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.DeleteMacaroonIDRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.DeleteMacaroonIDResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.DeleteMacaroonIDResponse]]: + """lncli: `deletemacaroonid` + DeleteMacaroonID deletes the specified macaroon ID and invalidates all + macaroons derived from that ID. + """ + + @abc.abstractmethod + def ListPermissions( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.ListPermissionsRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.ListPermissionsResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.ListPermissionsResponse]]: + """lncli: `listpermissions` + ListPermissions lists all RPC method URIs and their required macaroon + permissions to access them. + """ + + @abc.abstractmethod + def CheckMacaroonPermissions( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.CheckMacPermRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.CheckMacPermResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.CheckMacPermResponse]]: + """ + CheckMacaroonPermissions checks whether a request follows the constraints + imposed on the macaroon and that the macaroon is authorized to follow the + provided permissions. + """ + + @abc.abstractmethod + def RegisterRPCMiddleware( + self, + request_iterator: _MaybeAsyncIterator[cashu.lightning.lnd_grpc.protos.lightning_pb2.RPCMiddlewareResponse], + context: _ServicerContext, + ) -> typing.Union[collections.abc.Iterator[cashu.lightning.lnd_grpc.protos.lightning_pb2.RPCMiddlewareRequest], collections.abc.AsyncIterator[cashu.lightning.lnd_grpc.protos.lightning_pb2.RPCMiddlewareRequest]]: + """ + RegisterRPCMiddleware adds a new gRPC middleware to the interceptor chain. A + gRPC middleware is software component external to lnd that aims to add + additional business logic to lnd by observing/intercepting/validating + incoming gRPC client requests and (if needed) replacing/overwriting outgoing + messages before they're sent to the client. When registering the middleware + must identify itself and indicate what custom macaroon caveats it wants to + be responsible for. Only requests that contain a macaroon with that specific + custom caveat are then sent to the middleware for inspection. The other + option is to register for the read-only mode in which all requests/responses + are forwarded for interception to the middleware but the middleware is not + allowed to modify any responses. As a security measure, _no_ middleware can + modify responses for requests made with _unencumbered_ macaroons! + """ + + @abc.abstractmethod + def SendCustomMessage( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.SendCustomMessageRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.SendCustomMessageResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.SendCustomMessageResponse]]: + """lncli: `sendcustom` + SendCustomMessage sends a custom peer message. + """ + + @abc.abstractmethod + def SubscribeCustomMessages( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.SubscribeCustomMessagesRequest, + context: _ServicerContext, + ) -> typing.Union[collections.abc.Iterator[cashu.lightning.lnd_grpc.protos.lightning_pb2.CustomMessage], collections.abc.AsyncIterator[cashu.lightning.lnd_grpc.protos.lightning_pb2.CustomMessage]]: + """lncli: `subscribecustom` + SubscribeCustomMessages subscribes to a stream of incoming custom peer + messages. + + To include messages with type outside of the custom range (>= 32768) lnd + needs to be compiled with the `dev` build tag, and the message type to + override should be specified in lnd's experimental protocol configuration. + """ + + @abc.abstractmethod + def ListAliases( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.ListAliasesRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.ListAliasesResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.ListAliasesResponse]]: + """lncli: `listaliases` + ListAliases returns the set of all aliases that have ever existed with + their confirmed SCID (if it exists) and/or the base SCID (in the case of + zero conf). + """ + + @abc.abstractmethod + def LookupHtlcResolution( + self, + request: cashu.lightning.lnd_grpc.protos.lightning_pb2.LookupHtlcResolutionRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.LookupHtlcResolutionResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.LookupHtlcResolutionResponse]]: + """ + LookupHtlcResolution retrieves a final htlc resolution from the database. + If the htlc has no final resolution yet, a NotFound grpc status code is + returned. + """ + +def add_LightningServicer_to_server(servicer: LightningServicer, server: typing.Union[grpc.Server, grpc.aio.Server]) -> None: ... diff --git a/cashu/lightning/lnd_grpc/protos/router.proto b/cashu/lightning/lnd_grpc/protos/router.proto new file mode 100644 index 00000000..1856bccb --- /dev/null +++ b/cashu/lightning/lnd_grpc/protos/router.proto @@ -0,0 +1,1023 @@ +syntax = "proto3"; + +package routerrpc; + +import "lightning.proto"; + +option go_package = "github.com/lightningnetwork/lnd/lnrpc/routerrpc"; + +/* + * 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. + * + * 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 + */ + +// Router is a service that offers advanced interaction with the router +// subsystem of the daemon. +service Router { + /* + SendPaymentV2 attempts to route a payment described by the passed + PaymentRequest to the final destination. The call returns a stream of + payment updates. When using this RPC, make sure to set a fee limit, as the + default routing fee limit is 0 sats. Without a non-zero fee limit only + routes without fees will be attempted which often fails with + FAILURE_REASON_NO_ROUTE. + */ + rpc SendPaymentV2 (SendPaymentRequest) returns (stream lnrpc.Payment); + + /* lncli: `trackpayment` + TrackPaymentV2 returns an update stream for the payment identified by the + payment hash. + */ + rpc TrackPaymentV2 (TrackPaymentRequest) returns (stream lnrpc.Payment); + + /* + TrackPayments returns an update stream for every payment that is not in a + terminal state. Note that if payments are in-flight while starting a new + subscription, the start of the payment stream could produce out-of-order + and/or duplicate events. In order to get updates for every in-flight + payment attempt make sure to subscribe to this method before initiating any + payments. + */ + rpc TrackPayments (TrackPaymentsRequest) returns (stream lnrpc.Payment); + + /* + EstimateRouteFee allows callers to obtain a lower bound w.r.t how much it + may cost to send an HTLC to the target end destination. + */ + rpc EstimateRouteFee (RouteFeeRequest) returns (RouteFeeResponse); + + /* + Deprecated, use SendToRouteV2. SendToRoute attempts to make a payment via + the specified route. 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. It differs from the newer + SendToRouteV2 in that it doesn't return the full HTLC information. + */ + rpc SendToRoute (SendToRouteRequest) returns (SendToRouteResponse) { + option deprecated = true; + } + + /* + SendToRouteV2 attempts to make a payment via the specified route. 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. + */ + rpc SendToRouteV2 (SendToRouteRequest) returns (lnrpc.HTLCAttempt); + + /* lncli: `resetmc` + ResetMissionControl clears all mission control state and starts with a clean + slate. + */ + rpc ResetMissionControl (ResetMissionControlRequest) + returns (ResetMissionControlResponse); + + /* lncli: `querymc` + QueryMissionControl exposes the internal mission control state to callers. + It is a development feature. + */ + rpc QueryMissionControl (QueryMissionControlRequest) + returns (QueryMissionControlResponse); + + /* lncli: `importmc` + XImportMissionControl is an experimental API that imports the state provided + to the internal mission control's state, using all results which are more + recent than our existing values. These values will only be imported + in-memory, and will not be persisted across restarts. + */ + rpc XImportMissionControl (XImportMissionControlRequest) + returns (XImportMissionControlResponse); + + /* lncli: `getmccfg` + GetMissionControlConfig returns mission control's current config. + */ + rpc GetMissionControlConfig (GetMissionControlConfigRequest) + returns (GetMissionControlConfigResponse); + + /* lncli: `setmccfg` + SetMissionControlConfig will set mission control's config, if the config + provided is valid. + */ + rpc SetMissionControlConfig (SetMissionControlConfigRequest) + returns (SetMissionControlConfigResponse); + + /* lncli: `queryprob` + Deprecated. QueryProbability returns the current success probability + estimate for a given node pair and amount. The call returns a zero success + probability if no channel is available or if the amount violates min/max + HTLC constraints. + */ + rpc QueryProbability (QueryProbabilityRequest) + returns (QueryProbabilityResponse); + + /* lncli: `buildroute` + BuildRoute builds a fully specified route based on a list of hop public + keys. It retrieves the relevant channel policies from the graph in order to + calculate the correct fees and time locks. + Note that LND will use its default final_cltv_delta if no value is supplied. + Make sure to add the correct final_cltv_delta depending on the invoice + restriction. Moreover the caller has to make sure to provide the + payment_addr if the route is paying an invoice which signaled it. + */ + rpc BuildRoute (BuildRouteRequest) returns (BuildRouteResponse); + + /* + SubscribeHtlcEvents creates a uni-directional stream from the server to + the client which delivers a stream of htlc events. + */ + rpc SubscribeHtlcEvents (SubscribeHtlcEventsRequest) + returns (stream HtlcEvent); + + /* + Deprecated, use SendPaymentV2. SendPayment attempts to route a payment + described by the passed PaymentRequest to the final destination. The call + returns a stream of payment status updates. + */ + rpc SendPayment (SendPaymentRequest) returns (stream PaymentStatus) { + option deprecated = true; + } + + /* + Deprecated, use TrackPaymentV2. TrackPayment returns an update stream for + the payment identified by the payment hash. + */ + rpc TrackPayment (TrackPaymentRequest) returns (stream PaymentStatus) { + option deprecated = true; + } + + /** + HtlcInterceptor dispatches a bi-directional streaming RPC in which + Forwarded HTLC requests are sent to the client and the client responds with + a boolean that tells LND if this htlc should be intercepted. + In case of interception, the htlc can be either settled, cancelled or + resumed later by using the ResolveHoldForward endpoint. + */ + rpc HtlcInterceptor (stream ForwardHtlcInterceptResponse) + returns (stream ForwardHtlcInterceptRequest); + + /* lncli: `updatechanstatus` + UpdateChanStatus attempts to manually set the state of a channel + (enabled, disabled, or auto). A manual "disable" request will cause the + channel to stay disabled until a subsequent manual request of either + "enable" or "auto". + */ + rpc UpdateChanStatus (UpdateChanStatusRequest) + returns (UpdateChanStatusResponse); +} + +message SendPaymentRequest { + // The identity pubkey of the payment recipient + bytes dest = 1; + + /* + Number of satoshis to send. + + The fields amt and amt_msat are mutually exclusive. + */ + int64 amt = 2; + + // The hash to use within the payment's HTLC + bytes payment_hash = 3; + + /* + The CLTV delta from the current height that should be used to set the + timelock for the final hop. + */ + int32 final_cltv_delta = 4; + + /* + A bare-bones invoice for a payment within the Lightning Network. With the + details of the invoice, the sender has all the data necessary to send a + payment to the recipient. The amount in the payment request may be zero. In + that case it is required to set the amt field as well. If no payment request + is specified, the following fields are required: dest, amt and payment_hash. + */ + string payment_request = 5; + + /* + An upper limit on the amount of time we should spend when attempting to + fulfill the payment. This is expressed in seconds. If we cannot make a + successful payment within this time frame, an error will be returned. + This field must be non-zero. + */ + int32 timeout_seconds = 6; + + /* + The maximum number of satoshis that will be paid as a fee of the payment. + If this field is left to the default value of 0, only zero-fee routes will + be considered. This usually means single hop routes connecting directly to + the destination. To send the payment without a fee limit, use max int here. + + The fields fee_limit_sat and fee_limit_msat are mutually exclusive. + */ + int64 fee_limit_sat = 7; + + /* + Deprecated, use outgoing_chan_ids. The channel id of the channel that must + be taken to the first hop. If zero, any channel may be used (unless + outgoing_chan_ids are set). + */ + uint64 outgoing_chan_id = 8 [jstype = JS_STRING, deprecated = true]; + + /* + An optional maximum total time lock for the route. This should not + exceed lnd's `--max-cltv-expiry` setting. If zero, then the value of + `--max-cltv-expiry` is enforced. + */ + int32 cltv_limit = 9; + + /* + Optional route hints to reach the destination through private channels. + */ + repeated lnrpc.RouteHint route_hints = 10; + + /* + An optional field that can be used to pass an arbitrary set of TLV records + to a peer which understands the new records. This can be used to pass + application specific data during the payment attempt. Record types are + required to be in the custom range >= 65536. When using REST, the values + must be encoded as base64. + */ + map dest_custom_records = 11; + + /* + Number of millisatoshis to send. + + The fields amt and amt_msat are mutually exclusive. + */ + int64 amt_msat = 12; + + /* + The maximum number of millisatoshis that will be paid as a fee of the + payment. If this field is left to the default value of 0, only zero-fee + routes will be considered. This usually means single hop routes connecting + directly to the destination. To send the payment without a fee limit, use + max int here. + + The fields fee_limit_sat and fee_limit_msat are mutually exclusive. + */ + int64 fee_limit_msat = 13; + + /* + The pubkey of the last hop of the route. If empty, any hop may be used. + */ + bytes last_hop_pubkey = 14; + + // If set, circular payments to self are permitted. + bool allow_self_payment = 15; + + /* + Features assumed to be supported by the final node. All transitive feature + dependencies must also be set properly. For a given feature bit pair, either + optional or remote may be set, but not both. If this field is nil or empty, + the router will try to load destination features from the graph as a + fallback. + */ + repeated lnrpc.FeatureBit dest_features = 16; + + /* + The maximum number of partial payments that may be use to complete the full + amount. + */ + uint32 max_parts = 17; + + /* + If set, only the final payment update is streamed back. Intermediate updates + that show which htlcs are still in flight are suppressed. + */ + bool no_inflight_updates = 18; + + /* + The channel ids of the channels are allowed for the first hop. If empty, + any channel may be used. + */ + repeated uint64 outgoing_chan_ids = 19; + + /* + An optional payment addr to be included within the last hop of the route. + This is also called payment secret in specifications (e.g. BOLT 11). + */ + bytes payment_addr = 20; + + /* + The largest payment split that should be attempted when making a payment if + splitting is necessary. Setting this value will effectively cause lnd to + split more aggressively, vs only when it thinks it needs to. Note that this + value is in milli-satoshis. + */ + uint64 max_shard_size_msat = 21; + + /* + If set, an AMP-payment will be attempted. + */ + bool amp = 22; + + /* + The time preference for this payment. Set to -1 to optimize for fees + only, to 1 to optimize for reliability only or a value inbetween for a mix. + */ + double time_pref = 23; + + /* + If set, the payment loop can be interrupted by manually canceling the + payment context, even before the payment timeout is reached. Note that the + payment may still succeed after cancellation, as in-flight attempts can + still settle afterwards. Canceling will only prevent further attempts from + being sent. + */ + bool cancelable = 24; +} + +message TrackPaymentRequest { + // The hash of the payment to look up. + bytes payment_hash = 1; + + /* + If set, only the final payment update is streamed back. Intermediate updates + that show which htlcs are still in flight are suppressed. + */ + bool no_inflight_updates = 2; +} + +message TrackPaymentsRequest { + /* + If set, only the final payment updates are streamed back. Intermediate + updates that show which htlcs are still in flight are suppressed. + */ + bool no_inflight_updates = 1; +} + +message RouteFeeRequest { + /* + The destination one wishes to obtain a routing fee quote to. If set, this + parameter requires the amt_sat parameter also to be set. This parameter + combination triggers a graph based routing fee estimation as opposed to a + payment probe based estimate in case a payment request is provided. The + graph based estimation is an algorithm that is executed on the in memory + graph. Hence its runtime is significantly shorter than a payment probe + estimation that sends out actual payments to the network. + */ + bytes dest = 1; + + /* + The amount one wishes to send to the target destination. It is only to be + used in combination with the dest parameter. + */ + int64 amt_sat = 2; + + /* + A payment request of the target node that the route fee request is intended + for. Its parameters are input to probe payments that estimate routing fees. + The timeout parameter can be specified to set a maximum time on the probing + attempt. Cannot be used in combination with dest and amt_sat. + */ + string payment_request = 3; + + /* + A user preference of how long a probe payment should maximally be allowed to + take, denoted in seconds. The probing payment loop is aborted if this + timeout is reached. Note that the probing process itself can take longer + than the timeout if the HTLC becomes delayed or stuck. Canceling the context + of this call will not cancel the payment loop, the duration is only + controlled by the timeout parameter. + */ + uint32 timeout = 4; +} + +message RouteFeeResponse { + /* + A lower bound of the estimated fee to the target destination within the + network, expressed in milli-satoshis. + */ + int64 routing_fee_msat = 1; + + /* + An estimate of the worst case time delay that can occur. Note that callers + will still need to factor in the final CLTV delta of the last hop into this + value. + */ + int64 time_lock_delay = 2; + + /* + An indication whether a probing payment succeeded or whether and why it + failed. FAILURE_REASON_NONE indicates success. + */ + lnrpc.PaymentFailureReason failure_reason = 5; +} + +message SendToRouteRequest { + // The payment hash to use for the HTLC. + bytes payment_hash = 1; + + // Route that should be used to attempt to complete the payment. + lnrpc.Route route = 2; + + /* + Whether the payment should be marked as failed when a temporary error is + returned from the given route. Set it to true so the payment won't be + failed unless a terminal error is occurred, such as payment timeout, no + routes, incorrect payment details, or insufficient funds. + */ + bool skip_temp_err = 3; +} + +message SendToRouteResponse { + // The preimage obtained by making the payment. + bytes preimage = 1; + + // The failure message in case the payment failed. + lnrpc.Failure failure = 2; +} + +message ResetMissionControlRequest { +} + +message ResetMissionControlResponse { +} + +message QueryMissionControlRequest { +} + +// QueryMissionControlResponse contains mission control state. +message QueryMissionControlResponse { + reserved 1; + + // Node pair-level mission control state. + repeated PairHistory pairs = 2; +} + +message XImportMissionControlRequest { + // Node pair-level mission control state to be imported. + repeated PairHistory pairs = 1; + + // Whether to force override MC pair history. Note that even with force + // override the failure pair is imported before the success pair and both + // still clamp existing failure/success amounts. + bool force = 2; +} + +message XImportMissionControlResponse { +} + +// PairHistory contains the mission control state for a particular node pair. +message PairHistory { + // The source node pubkey of the pair. + bytes node_from = 1; + + // The destination node pubkey of the pair. + bytes node_to = 2; + + reserved 3, 4, 5, 6; + + PairData history = 7; +} + +message PairData { + // Time of last failure. + int64 fail_time = 1; + + /* + Lowest amount that failed to forward rounded to whole sats. This may be + set to zero if the failure is independent of amount. + */ + int64 fail_amt_sat = 2; + + /* + Lowest amount that failed to forward in millisats. This may be + set to zero if the failure is independent of amount. + */ + int64 fail_amt_msat = 4; + + reserved 3; + + // Time of last success. + int64 success_time = 5; + + // Highest amount that we could successfully forward rounded to whole sats. + int64 success_amt_sat = 6; + + // Highest amount that we could successfully forward in millisats. + int64 success_amt_msat = 7; +} + +message GetMissionControlConfigRequest { +} + +message GetMissionControlConfigResponse { + /* + Mission control's currently active config. + */ + MissionControlConfig config = 1; +} + +message SetMissionControlConfigRequest { + /* + The config to set for mission control. Note that all values *must* be set, + because the full config will be applied. + */ + MissionControlConfig config = 1; +} + +message SetMissionControlConfigResponse { +} + +message MissionControlConfig { + /* + Deprecated, use AprioriParameters. The amount of time mission control will + take to restore a penalized node or channel back to 50% success probability, + expressed in seconds. Setting this value to a higher value will penalize + failures for longer, making mission control less likely to route through + nodes and channels that we have previously recorded failures for. + */ + uint64 half_life_seconds = 1 [deprecated = true]; + + /* + Deprecated, use AprioriParameters. The probability of success mission + control should assign to hop in a route where it has no other information + available. Higher values will make mission control more willing to try hops + that we have no information about, lower values will discourage trying these + hops. + */ + float hop_probability = 2 [deprecated = true]; + + /* + Deprecated, use AprioriParameters. The importance that mission control + should place on historical results, expressed as a value in [0;1]. Setting + this value to 1 will ignore all historical payments and just use the hop + probability to assess the probability of success for each hop. A zero value + ignores hop probability completely and relies entirely on historical + results, unless none are available. + */ + float weight = 3 [deprecated = true]; + + /* + The maximum number of payment results that mission control will store. + */ + uint32 maximum_payment_results = 4; + + /* + The minimum time that must have passed since the previously recorded failure + before we raise the failure amount. + */ + uint64 minimum_failure_relax_interval = 5; + + enum ProbabilityModel { + APRIORI = 0; + BIMODAL = 1; + } + + /* + ProbabilityModel defines which probability estimator should be used in + pathfinding. Note that the bimodal estimator is experimental. + */ + ProbabilityModel model = 6; + + /* + EstimatorConfig is populated dependent on the estimator type. + */ + oneof EstimatorConfig { + AprioriParameters apriori = 7; + BimodalParameters bimodal = 8; + } +} + +message BimodalParameters { + /* + NodeWeight defines how strongly other previous forwardings on channels of a + router should be taken into account when computing a channel's probability + to route. The allowed values are in the range [0, 1], where a value of 0 + means that only direct information about a channel is taken into account. + */ + double node_weight = 1; + + /* + ScaleMsat describes the scale over which channels statistically have some + liquidity left. The value determines how quickly the bimodal distribution + drops off from the edges of a channel. A larger value (compared to typical + channel capacities) means that the drop off is slow and that channel + balances are distributed more uniformly. A small value leads to the + assumption of very unbalanced channels. + */ + uint64 scale_msat = 2; + + /* + DecayTime describes the information decay of knowledge about previous + successes and failures in channels. The smaller the decay time, the quicker + we forget about past forwardings. + */ + uint64 decay_time = 3; +} + +message AprioriParameters { + /* + The amount of time mission control will take to restore a penalized node + or channel back to 50% success probability, expressed in seconds. Setting + this value to a higher value will penalize failures for longer, making + mission control less likely to route through nodes and channels that we + have previously recorded failures for. + */ + uint64 half_life_seconds = 1; + + /* + The probability of success mission control should assign to hop in a route + where it has no other information available. Higher values will make mission + control more willing to try hops that we have no information about, lower + values will discourage trying these hops. + */ + double hop_probability = 2; + + /* + The importance that mission control should place on historical results, + expressed as a value in [0;1]. Setting this value to 1 will ignore all + historical payments and just use the hop probability to assess the + probability of success for each hop. A zero value ignores hop probability + completely and relies entirely on historical results, unless none are + available. + */ + double weight = 3; + + /* + The fraction of a channel's capacity that we consider to have liquidity. For + amounts that come close to or exceed the fraction, an additional penalty is + applied. A value of 1.0 disables the capacity factor. Allowed values are in + [0.75, 1.0]. + */ + double capacity_fraction = 4; +} + +message QueryProbabilityRequest { + // The source node pubkey of the pair. + bytes from_node = 1; + + // The destination node pubkey of the pair. + bytes to_node = 2; + + // The amount for which to calculate a probability. + int64 amt_msat = 3; +} + +message QueryProbabilityResponse { + // The success probability for the requested pair. + double probability = 1; + + // The historical data for the requested pair. + PairData history = 2; +} + +message BuildRouteRequest { + /* + The amount to send expressed in msat. If set to zero, the minimum routable + amount is used. + */ + int64 amt_msat = 1; + + /* + CLTV delta from the current height that should be used for the timelock + of the final hop + */ + int32 final_cltv_delta = 2; + + /* + The channel id of the channel that must be taken to the first hop. If zero, + any channel may be used. + */ + uint64 outgoing_chan_id = 3 [jstype = JS_STRING]; + + /* + A list of hops that defines the route. This does not include the source hop + pubkey. + */ + repeated bytes hop_pubkeys = 4; + + /* + An optional payment addr to be included within the last hop of the route. + This is also called payment secret in specifications (e.g. BOLT 11). + */ + bytes payment_addr = 5; +} + +message BuildRouteResponse { + /* + Fully specified route that can be used to execute the payment. + */ + lnrpc.Route route = 1; +} + +message SubscribeHtlcEventsRequest { +} + +/* +HtlcEvent contains the htlc event that was processed. These are served on a +best-effort basis; events are not persisted, delivery is not guaranteed +(in the event of a crash in the switch, forward events may be lost) and +some events may be replayed upon restart. Events consumed from this package +should be de-duplicated by the htlc's unique combination of incoming and +outgoing channel id and htlc id. [EXPERIMENTAL] +*/ +message HtlcEvent { + /* + The short channel id that the incoming htlc arrived at our node on. This + value is zero for sends. + */ + uint64 incoming_channel_id = 1; + + /* + The short channel id that the outgoing htlc left our node on. This value + is zero for receives. + */ + uint64 outgoing_channel_id = 2; + + /* + Incoming id is the index of the incoming htlc in the incoming channel. + This value is zero for sends. + */ + uint64 incoming_htlc_id = 3; + + /* + Outgoing id is the index of the outgoing htlc in the outgoing channel. + This value is zero for receives. + */ + uint64 outgoing_htlc_id = 4; + + /* + The time in unix nanoseconds that the event occurred. + */ + uint64 timestamp_ns = 5; + + enum EventType { + UNKNOWN = 0; + SEND = 1; + RECEIVE = 2; + FORWARD = 3; + } + + /* + The event type indicates whether the htlc was part of a send, receive or + forward. + */ + EventType event_type = 6; + + oneof event { + ForwardEvent forward_event = 7; + ForwardFailEvent forward_fail_event = 8; + SettleEvent settle_event = 9; + LinkFailEvent link_fail_event = 10; + SubscribedEvent subscribed_event = 11; + FinalHtlcEvent final_htlc_event = 12; + } +} + +message HtlcInfo { + // The timelock on the incoming htlc. + uint32 incoming_timelock = 1; + + // The timelock on the outgoing htlc. + uint32 outgoing_timelock = 2; + + // The amount of the incoming htlc. + uint64 incoming_amt_msat = 3; + + // The amount of the outgoing htlc. + uint64 outgoing_amt_msat = 4; +} + +message ForwardEvent { + // Info contains details about the htlc that was forwarded. + HtlcInfo info = 1; +} + +message ForwardFailEvent { +} + +message SettleEvent { + // The revealed preimage. + bytes preimage = 1; +} + +message FinalHtlcEvent { + bool settled = 1; + bool offchain = 2; +} + +message SubscribedEvent { +} + +message LinkFailEvent { + // Info contains details about the htlc that we failed. + HtlcInfo info = 1; + + // FailureCode is the BOLT error code for the failure. + lnrpc.Failure.FailureCode wire_failure = 2; + + /* + FailureDetail provides additional information about the reason for the + failure. This detail enriches the information provided by the wire message + and may be 'no detail' if the wire message requires no additional metadata. + */ + FailureDetail failure_detail = 3; + + // A string representation of the link failure. + string failure_string = 4; +} + +enum FailureDetail { + UNKNOWN = 0; + NO_DETAIL = 1; + ONION_DECODE = 2; + LINK_NOT_ELIGIBLE = 3; + ON_CHAIN_TIMEOUT = 4; + HTLC_EXCEEDS_MAX = 5; + INSUFFICIENT_BALANCE = 6; + INCOMPLETE_FORWARD = 7; + HTLC_ADD_FAILED = 8; + FORWARDS_DISABLED = 9; + INVOICE_CANCELED = 10; + INVOICE_UNDERPAID = 11; + INVOICE_EXPIRY_TOO_SOON = 12; + INVOICE_NOT_OPEN = 13; + MPP_INVOICE_TIMEOUT = 14; + ADDRESS_MISMATCH = 15; + SET_TOTAL_MISMATCH = 16; + SET_TOTAL_TOO_LOW = 17; + SET_OVERPAID = 18; + UNKNOWN_INVOICE = 19; + INVALID_KEYSEND = 20; + MPP_IN_PROGRESS = 21; + CIRCULAR_ROUTE = 22; +} + +enum PaymentState { + /* + Payment is still in flight. + */ + IN_FLIGHT = 0; + + /* + Payment completed successfully. + */ + SUCCEEDED = 1; + + /* + There are more routes to try, but the payment timeout was exceeded. + */ + FAILED_TIMEOUT = 2; + + /* + All possible routes were tried and failed permanently. Or were no + routes to the destination at all. + */ + FAILED_NO_ROUTE = 3; + + /* + A non-recoverable error has occurred. + */ + FAILED_ERROR = 4; + + /* + Payment details incorrect (unknown hash, invalid amt or + invalid final cltv delta) + */ + FAILED_INCORRECT_PAYMENT_DETAILS = 5; + + /* + Insufficient local balance. + */ + FAILED_INSUFFICIENT_BALANCE = 6; +} + +message PaymentStatus { + // Current state the payment is in. + PaymentState state = 1; + + /* + The pre-image of the payment when state is SUCCEEDED. + */ + bytes preimage = 2; + + reserved 3; + + /* + The HTLCs made in attempt to settle the payment [EXPERIMENTAL]. + */ + repeated lnrpc.HTLCAttempt htlcs = 4; +} + +message CircuitKey { + /// The id of the channel that the is part of this circuit. + uint64 chan_id = 1; + + /// The index of the incoming htlc in the incoming channel. + uint64 htlc_id = 2; +} + +message ForwardHtlcInterceptRequest { + /* + The key of this forwarded htlc. It defines the incoming channel id and + the index in this channel. + */ + CircuitKey incoming_circuit_key = 1; + + // The incoming htlc amount. + uint64 incoming_amount_msat = 5; + + // The incoming htlc expiry. + uint32 incoming_expiry = 6; + + /* + The htlc payment hash. This value is not guaranteed to be unique per + request. + */ + bytes payment_hash = 2; + + // The requested outgoing channel id for this forwarded htlc. Because of + // non-strict forwarding, this isn't necessarily the channel over which the + // packet will be forwarded eventually. A different channel to the same peer + // may be selected as well. + uint64 outgoing_requested_chan_id = 7; + + // The outgoing htlc amount. + uint64 outgoing_amount_msat = 3; + + // The outgoing htlc expiry. + uint32 outgoing_expiry = 4; + + // Any custom records that were present in the payload. + map custom_records = 8; + + // The onion blob for the next hop + bytes onion_blob = 9; + + // The block height at which this htlc will be auto-failed to prevent the + // channel from force-closing. + int32 auto_fail_height = 10; +} + +/** +ForwardHtlcInterceptResponse enables the caller to resolve a previously hold +forward. The caller can choose either to: +- `Resume`: Execute the default behavior (usually forward). +- `Reject`: Fail the htlc backwards. +- `Settle`: Settle this htlc with a given preimage. +*/ +message ForwardHtlcInterceptResponse { + /** + The key of this forwarded htlc. It defines the incoming channel id and + the index in this channel. + */ + CircuitKey incoming_circuit_key = 1; + + // The resolve action for this intercepted htlc. + ResolveHoldForwardAction action = 2; + + // The preimage in case the resolve action is Settle. + bytes preimage = 3; + + // Encrypted failure message in case the resolve action is Fail. + // + // If failure_message is specified, the failure_code field must be set + // to zero. + bytes failure_message = 4; + + // Return the specified failure code in case the resolve action is Fail. The + // message data fields are populated automatically. + // + // If a non-zero failure_code is specified, failure_message must not be set. + // + // For backwards-compatibility reasons, TEMPORARY_CHANNEL_FAILURE is the + // default value for this field. + lnrpc.Failure.FailureCode failure_code = 5; +} + +enum ResolveHoldForwardAction { + SETTLE = 0; + FAIL = 1; + RESUME = 2; +} + +message UpdateChanStatusRequest { + lnrpc.ChannelPoint chan_point = 1; + + ChanStatusAction action = 2; +} + +enum ChanStatusAction { + ENABLE = 0; + DISABLE = 1; + AUTO = 2; +} + +message UpdateChanStatusResponse { +} diff --git a/cashu/lightning/lnd_grpc/protos/router_pb2.py b/cashu/lightning/lnd_grpc/protos/router_pb2.py new file mode 100644 index 00000000..d4172e1a --- /dev/null +++ b/cashu/lightning/lnd_grpc/protos/router_pb2.py @@ -0,0 +1,146 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: router.proto +# Protobuf Python Version: 5.26.1 +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder + +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x0crouter.proto\x12\trouterrpc\x1a\x0flightning.proto\"\xcb\x05\n\x12SendPaymentRequest\x12\x0c\n\x04\x64\x65st\x18\x01 \x01(\x0c\x12\x0b\n\x03\x61mt\x18\x02 \x01(\x03\x12\x14\n\x0cpayment_hash\x18\x03 \x01(\x0c\x12\x18\n\x10\x66inal_cltv_delta\x18\x04 \x01(\x05\x12\x17\n\x0fpayment_request\x18\x05 \x01(\t\x12\x17\n\x0ftimeout_seconds\x18\x06 \x01(\x05\x12\x15\n\rfee_limit_sat\x18\x07 \x01(\x03\x12\x1e\n\x10outgoing_chan_id\x18\x08 \x01(\x04\x42\x04\x18\x01\x30\x01\x12\x12\n\ncltv_limit\x18\t \x01(\x05\x12%\n\x0broute_hints\x18\n \x03(\x0b\x32\x10.lnrpc.RouteHint\x12Q\n\x13\x64\x65st_custom_records\x18\x0b \x03(\x0b\x32\x34.routerrpc.SendPaymentRequest.DestCustomRecordsEntry\x12\x10\n\x08\x61mt_msat\x18\x0c \x01(\x03\x12\x16\n\x0e\x66\x65\x65_limit_msat\x18\r \x01(\x03\x12\x17\n\x0flast_hop_pubkey\x18\x0e \x01(\x0c\x12\x1a\n\x12\x61llow_self_payment\x18\x0f \x01(\x08\x12(\n\rdest_features\x18\x10 \x03(\x0e\x32\x11.lnrpc.FeatureBit\x12\x11\n\tmax_parts\x18\x11 \x01(\r\x12\x1b\n\x13no_inflight_updates\x18\x12 \x01(\x08\x12\x19\n\x11outgoing_chan_ids\x18\x13 \x03(\x04\x12\x14\n\x0cpayment_addr\x18\x14 \x01(\x0c\x12\x1b\n\x13max_shard_size_msat\x18\x15 \x01(\x04\x12\x0b\n\x03\x61mp\x18\x16 \x01(\x08\x12\x11\n\ttime_pref\x18\x17 \x01(\x01\x12\x12\n\ncancelable\x18\x18 \x01(\x08\x1a\x38\n\x16\x44\x65stCustomRecordsEntry\x12\x0b\n\x03key\x18\x01 \x01(\x04\x12\r\n\x05value\x18\x02 \x01(\x0c:\x02\x38\x01\"H\n\x13TrackPaymentRequest\x12\x14\n\x0cpayment_hash\x18\x01 \x01(\x0c\x12\x1b\n\x13no_inflight_updates\x18\x02 \x01(\x08\"3\n\x14TrackPaymentsRequest\x12\x1b\n\x13no_inflight_updates\x18\x01 \x01(\x08\"Z\n\x0fRouteFeeRequest\x12\x0c\n\x04\x64\x65st\x18\x01 \x01(\x0c\x12\x0f\n\x07\x61mt_sat\x18\x02 \x01(\x03\x12\x17\n\x0fpayment_request\x18\x03 \x01(\t\x12\x0f\n\x07timeout\x18\x04 \x01(\r\"z\n\x10RouteFeeResponse\x12\x18\n\x10routing_fee_msat\x18\x01 \x01(\x03\x12\x17\n\x0ftime_lock_delay\x18\x02 \x01(\x03\x12\x33\n\x0e\x66\x61ilure_reason\x18\x05 \x01(\x0e\x32\x1b.lnrpc.PaymentFailureReason\"^\n\x12SendToRouteRequest\x12\x14\n\x0cpayment_hash\x18\x01 \x01(\x0c\x12\x1b\n\x05route\x18\x02 \x01(\x0b\x32\x0c.lnrpc.Route\x12\x15\n\rskip_temp_err\x18\x03 \x01(\x08\"H\n\x13SendToRouteResponse\x12\x10\n\x08preimage\x18\x01 \x01(\x0c\x12\x1f\n\x07\x66\x61ilure\x18\x02 \x01(\x0b\x32\x0e.lnrpc.Failure\"\x1c\n\x1aResetMissionControlRequest\"\x1d\n\x1bResetMissionControlResponse\"\x1c\n\x1aQueryMissionControlRequest\"J\n\x1bQueryMissionControlResponse\x12%\n\x05pairs\x18\x02 \x03(\x0b\x32\x16.routerrpc.PairHistoryJ\x04\x08\x01\x10\x02\"T\n\x1cXImportMissionControlRequest\x12%\n\x05pairs\x18\x01 \x03(\x0b\x32\x16.routerrpc.PairHistory\x12\r\n\x05\x66orce\x18\x02 \x01(\x08\"\x1f\n\x1dXImportMissionControlResponse\"o\n\x0bPairHistory\x12\x11\n\tnode_from\x18\x01 \x01(\x0c\x12\x0f\n\x07node_to\x18\x02 \x01(\x0c\x12$\n\x07history\x18\x07 \x01(\x0b\x32\x13.routerrpc.PairDataJ\x04\x08\x03\x10\x04J\x04\x08\x04\x10\x05J\x04\x08\x05\x10\x06J\x04\x08\x06\x10\x07\"\x99\x01\n\x08PairData\x12\x11\n\tfail_time\x18\x01 \x01(\x03\x12\x14\n\x0c\x66\x61il_amt_sat\x18\x02 \x01(\x03\x12\x15\n\rfail_amt_msat\x18\x04 \x01(\x03\x12\x14\n\x0csuccess_time\x18\x05 \x01(\x03\x12\x17\n\x0fsuccess_amt_sat\x18\x06 \x01(\x03\x12\x18\n\x10success_amt_msat\x18\x07 \x01(\x03J\x04\x08\x03\x10\x04\" \n\x1eGetMissionControlConfigRequest\"R\n\x1fGetMissionControlConfigResponse\x12/\n\x06\x63onfig\x18\x01 \x01(\x0b\x32\x1f.routerrpc.MissionControlConfig\"Q\n\x1eSetMissionControlConfigRequest\x12/\n\x06\x63onfig\x18\x01 \x01(\x0b\x32\x1f.routerrpc.MissionControlConfig\"!\n\x1fSetMissionControlConfigResponse\"\x93\x03\n\x14MissionControlConfig\x12\x1d\n\x11half_life_seconds\x18\x01 \x01(\x04\x42\x02\x18\x01\x12\x1b\n\x0fhop_probability\x18\x02 \x01(\x02\x42\x02\x18\x01\x12\x12\n\x06weight\x18\x03 \x01(\x02\x42\x02\x18\x01\x12\x1f\n\x17maximum_payment_results\x18\x04 \x01(\r\x12&\n\x1eminimum_failure_relax_interval\x18\x05 \x01(\x04\x12?\n\x05model\x18\x06 \x01(\x0e\x32\x30.routerrpc.MissionControlConfig.ProbabilityModel\x12/\n\x07\x61priori\x18\x07 \x01(\x0b\x32\x1c.routerrpc.AprioriParametersH\x00\x12/\n\x07\x62imodal\x18\x08 \x01(\x0b\x32\x1c.routerrpc.BimodalParametersH\x00\",\n\x10ProbabilityModel\x12\x0b\n\x07\x41PRIORI\x10\x00\x12\x0b\n\x07\x42IMODAL\x10\x01\x42\x11\n\x0f\x45stimatorConfig\"P\n\x11\x42imodalParameters\x12\x13\n\x0bnode_weight\x18\x01 \x01(\x01\x12\x12\n\nscale_msat\x18\x02 \x01(\x04\x12\x12\n\ndecay_time\x18\x03 \x01(\x04\"r\n\x11\x41prioriParameters\x12\x19\n\x11half_life_seconds\x18\x01 \x01(\x04\x12\x17\n\x0fhop_probability\x18\x02 \x01(\x01\x12\x0e\n\x06weight\x18\x03 \x01(\x01\x12\x19\n\x11\x63\x61pacity_fraction\x18\x04 \x01(\x01\"O\n\x17QueryProbabilityRequest\x12\x11\n\tfrom_node\x18\x01 \x01(\x0c\x12\x0f\n\x07to_node\x18\x02 \x01(\x0c\x12\x10\n\x08\x61mt_msat\x18\x03 \x01(\x03\"U\n\x18QueryProbabilityResponse\x12\x13\n\x0bprobability\x18\x01 \x01(\x01\x12$\n\x07history\x18\x02 \x01(\x0b\x32\x13.routerrpc.PairData\"\x88\x01\n\x11\x42uildRouteRequest\x12\x10\n\x08\x61mt_msat\x18\x01 \x01(\x03\x12\x18\n\x10\x66inal_cltv_delta\x18\x02 \x01(\x05\x12\x1c\n\x10outgoing_chan_id\x18\x03 \x01(\x04\x42\x02\x30\x01\x12\x13\n\x0bhop_pubkeys\x18\x04 \x03(\x0c\x12\x14\n\x0cpayment_addr\x18\x05 \x01(\x0c\"1\n\x12\x42uildRouteResponse\x12\x1b\n\x05route\x18\x01 \x01(\x0b\x32\x0c.lnrpc.Route\"\x1c\n\x1aSubscribeHtlcEventsRequest\"\xcb\x04\n\tHtlcEvent\x12\x1b\n\x13incoming_channel_id\x18\x01 \x01(\x04\x12\x1b\n\x13outgoing_channel_id\x18\x02 \x01(\x04\x12\x18\n\x10incoming_htlc_id\x18\x03 \x01(\x04\x12\x18\n\x10outgoing_htlc_id\x18\x04 \x01(\x04\x12\x14\n\x0ctimestamp_ns\x18\x05 \x01(\x04\x12\x32\n\nevent_type\x18\x06 \x01(\x0e\x32\x1e.routerrpc.HtlcEvent.EventType\x12\x30\n\rforward_event\x18\x07 \x01(\x0b\x32\x17.routerrpc.ForwardEventH\x00\x12\x39\n\x12\x66orward_fail_event\x18\x08 \x01(\x0b\x32\x1b.routerrpc.ForwardFailEventH\x00\x12.\n\x0csettle_event\x18\t \x01(\x0b\x32\x16.routerrpc.SettleEventH\x00\x12\x33\n\x0flink_fail_event\x18\n \x01(\x0b\x32\x18.routerrpc.LinkFailEventH\x00\x12\x36\n\x10subscribed_event\x18\x0b \x01(\x0b\x32\x1a.routerrpc.SubscribedEventH\x00\x12\x35\n\x10\x66inal_htlc_event\x18\x0c \x01(\x0b\x32\x19.routerrpc.FinalHtlcEventH\x00\"<\n\tEventType\x12\x0b\n\x07UNKNOWN\x10\x00\x12\x08\n\x04SEND\x10\x01\x12\x0b\n\x07RECEIVE\x10\x02\x12\x0b\n\x07\x46ORWARD\x10\x03\x42\x07\n\x05\x65vent\"v\n\x08HtlcInfo\x12\x19\n\x11incoming_timelock\x18\x01 \x01(\r\x12\x19\n\x11outgoing_timelock\x18\x02 \x01(\r\x12\x19\n\x11incoming_amt_msat\x18\x03 \x01(\x04\x12\x19\n\x11outgoing_amt_msat\x18\x04 \x01(\x04\"1\n\x0c\x46orwardEvent\x12!\n\x04info\x18\x01 \x01(\x0b\x32\x13.routerrpc.HtlcInfo\"\x12\n\x10\x46orwardFailEvent\"\x1f\n\x0bSettleEvent\x12\x10\n\x08preimage\x18\x01 \x01(\x0c\"3\n\x0e\x46inalHtlcEvent\x12\x0f\n\x07settled\x18\x01 \x01(\x08\x12\x10\n\x08offchain\x18\x02 \x01(\x08\"\x11\n\x0fSubscribedEvent\"\xae\x01\n\rLinkFailEvent\x12!\n\x04info\x18\x01 \x01(\x0b\x32\x13.routerrpc.HtlcInfo\x12\x30\n\x0cwire_failure\x18\x02 \x01(\x0e\x32\x1a.lnrpc.Failure.FailureCode\x12\x30\n\x0e\x66\x61ilure_detail\x18\x03 \x01(\x0e\x32\x18.routerrpc.FailureDetail\x12\x16\n\x0e\x66\x61ilure_string\x18\x04 \x01(\t\"r\n\rPaymentStatus\x12&\n\x05state\x18\x01 \x01(\x0e\x32\x17.routerrpc.PaymentState\x12\x10\n\x08preimage\x18\x02 \x01(\x0c\x12!\n\x05htlcs\x18\x04 \x03(\x0b\x32\x12.lnrpc.HTLCAttemptJ\x04\x08\x03\x10\x04\".\n\nCircuitKey\x12\x0f\n\x07\x63han_id\x18\x01 \x01(\x04\x12\x0f\n\x07htlc_id\x18\x02 \x01(\x04\"\xb1\x03\n\x1b\x46orwardHtlcInterceptRequest\x12\x33\n\x14incoming_circuit_key\x18\x01 \x01(\x0b\x32\x15.routerrpc.CircuitKey\x12\x1c\n\x14incoming_amount_msat\x18\x05 \x01(\x04\x12\x17\n\x0fincoming_expiry\x18\x06 \x01(\r\x12\x14\n\x0cpayment_hash\x18\x02 \x01(\x0c\x12\"\n\x1aoutgoing_requested_chan_id\x18\x07 \x01(\x04\x12\x1c\n\x14outgoing_amount_msat\x18\x03 \x01(\x04\x12\x17\n\x0foutgoing_expiry\x18\x04 \x01(\r\x12Q\n\x0e\x63ustom_records\x18\x08 \x03(\x0b\x32\x39.routerrpc.ForwardHtlcInterceptRequest.CustomRecordsEntry\x12\x12\n\nonion_blob\x18\t \x01(\x0c\x12\x18\n\x10\x61uto_fail_height\x18\n \x01(\x05\x1a\x34\n\x12\x43ustomRecordsEntry\x12\x0b\n\x03key\x18\x01 \x01(\x04\x12\r\n\x05value\x18\x02 \x01(\x0c:\x02\x38\x01\"\xe5\x01\n\x1c\x46orwardHtlcInterceptResponse\x12\x33\n\x14incoming_circuit_key\x18\x01 \x01(\x0b\x32\x15.routerrpc.CircuitKey\x12\x33\n\x06\x61\x63tion\x18\x02 \x01(\x0e\x32#.routerrpc.ResolveHoldForwardAction\x12\x10\n\x08preimage\x18\x03 \x01(\x0c\x12\x17\n\x0f\x66\x61ilure_message\x18\x04 \x01(\x0c\x12\x30\n\x0c\x66\x61ilure_code\x18\x05 \x01(\x0e\x32\x1a.lnrpc.Failure.FailureCode\"o\n\x17UpdateChanStatusRequest\x12\'\n\nchan_point\x18\x01 \x01(\x0b\x32\x13.lnrpc.ChannelPoint\x12+\n\x06\x61\x63tion\x18\x02 \x01(\x0e\x32\x1b.routerrpc.ChanStatusAction\"\x1a\n\x18UpdateChanStatusResponse*\x81\x04\n\rFailureDetail\x12\x0b\n\x07UNKNOWN\x10\x00\x12\r\n\tNO_DETAIL\x10\x01\x12\x10\n\x0cONION_DECODE\x10\x02\x12\x15\n\x11LINK_NOT_ELIGIBLE\x10\x03\x12\x14\n\x10ON_CHAIN_TIMEOUT\x10\x04\x12\x14\n\x10HTLC_EXCEEDS_MAX\x10\x05\x12\x18\n\x14INSUFFICIENT_BALANCE\x10\x06\x12\x16\n\x12INCOMPLETE_FORWARD\x10\x07\x12\x13\n\x0fHTLC_ADD_FAILED\x10\x08\x12\x15\n\x11\x46ORWARDS_DISABLED\x10\t\x12\x14\n\x10INVOICE_CANCELED\x10\n\x12\x15\n\x11INVOICE_UNDERPAID\x10\x0b\x12\x1b\n\x17INVOICE_EXPIRY_TOO_SOON\x10\x0c\x12\x14\n\x10INVOICE_NOT_OPEN\x10\r\x12\x17\n\x13MPP_INVOICE_TIMEOUT\x10\x0e\x12\x14\n\x10\x41\x44\x44RESS_MISMATCH\x10\x0f\x12\x16\n\x12SET_TOTAL_MISMATCH\x10\x10\x12\x15\n\x11SET_TOTAL_TOO_LOW\x10\x11\x12\x10\n\x0cSET_OVERPAID\x10\x12\x12\x13\n\x0fUNKNOWN_INVOICE\x10\x13\x12\x13\n\x0fINVALID_KEYSEND\x10\x14\x12\x13\n\x0fMPP_IN_PROGRESS\x10\x15\x12\x12\n\x0e\x43IRCULAR_ROUTE\x10\x16*\xae\x01\n\x0cPaymentState\x12\r\n\tIN_FLIGHT\x10\x00\x12\r\n\tSUCCEEDED\x10\x01\x12\x12\n\x0e\x46\x41ILED_TIMEOUT\x10\x02\x12\x13\n\x0f\x46\x41ILED_NO_ROUTE\x10\x03\x12\x10\n\x0c\x46\x41ILED_ERROR\x10\x04\x12$\n FAILED_INCORRECT_PAYMENT_DETAILS\x10\x05\x12\x1f\n\x1b\x46\x41ILED_INSUFFICIENT_BALANCE\x10\x06*<\n\x18ResolveHoldForwardAction\x12\n\n\x06SETTLE\x10\x00\x12\x08\n\x04\x46\x41IL\x10\x01\x12\n\n\x06RESUME\x10\x02*5\n\x10\x43hanStatusAction\x12\n\n\x06\x45NABLE\x10\x00\x12\x0b\n\x07\x44ISABLE\x10\x01\x12\x08\n\x04\x41UTO\x10\x02\x32\xb5\x0c\n\x06Router\x12@\n\rSendPaymentV2\x12\x1d.routerrpc.SendPaymentRequest\x1a\x0e.lnrpc.Payment0\x01\x12\x42\n\x0eTrackPaymentV2\x12\x1e.routerrpc.TrackPaymentRequest\x1a\x0e.lnrpc.Payment0\x01\x12\x42\n\rTrackPayments\x12\x1f.routerrpc.TrackPaymentsRequest\x1a\x0e.lnrpc.Payment0\x01\x12K\n\x10\x45stimateRouteFee\x12\x1a.routerrpc.RouteFeeRequest\x1a\x1b.routerrpc.RouteFeeResponse\x12Q\n\x0bSendToRoute\x12\x1d.routerrpc.SendToRouteRequest\x1a\x1e.routerrpc.SendToRouteResponse\"\x03\x88\x02\x01\x12\x42\n\rSendToRouteV2\x12\x1d.routerrpc.SendToRouteRequest\x1a\x12.lnrpc.HTLCAttempt\x12\x64\n\x13ResetMissionControl\x12%.routerrpc.ResetMissionControlRequest\x1a&.routerrpc.ResetMissionControlResponse\x12\x64\n\x13QueryMissionControl\x12%.routerrpc.QueryMissionControlRequest\x1a&.routerrpc.QueryMissionControlResponse\x12j\n\x15XImportMissionControl\x12\'.routerrpc.XImportMissionControlRequest\x1a(.routerrpc.XImportMissionControlResponse\x12p\n\x17GetMissionControlConfig\x12).routerrpc.GetMissionControlConfigRequest\x1a*.routerrpc.GetMissionControlConfigResponse\x12p\n\x17SetMissionControlConfig\x12).routerrpc.SetMissionControlConfigRequest\x1a*.routerrpc.SetMissionControlConfigResponse\x12[\n\x10QueryProbability\x12\".routerrpc.QueryProbabilityRequest\x1a#.routerrpc.QueryProbabilityResponse\x12I\n\nBuildRoute\x12\x1c.routerrpc.BuildRouteRequest\x1a\x1d.routerrpc.BuildRouteResponse\x12T\n\x13SubscribeHtlcEvents\x12%.routerrpc.SubscribeHtlcEventsRequest\x1a\x14.routerrpc.HtlcEvent0\x01\x12M\n\x0bSendPayment\x12\x1d.routerrpc.SendPaymentRequest\x1a\x18.routerrpc.PaymentStatus\"\x03\x88\x02\x01\x30\x01\x12O\n\x0cTrackPayment\x12\x1e.routerrpc.TrackPaymentRequest\x1a\x18.routerrpc.PaymentStatus\"\x03\x88\x02\x01\x30\x01\x12\x66\n\x0fHtlcInterceptor\x12\'.routerrpc.ForwardHtlcInterceptResponse\x1a&.routerrpc.ForwardHtlcInterceptRequest(\x01\x30\x01\x12[\n\x10UpdateChanStatus\x12\".routerrpc.UpdateChanStatusRequest\x1a#.routerrpc.UpdateChanStatusResponseB1Z/github.com/lightningnetwork/lnd/lnrpc/routerrpcb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'cashu.lightning.lnd_grpc.protos.router_pb2', _globals) +if not _descriptor._USE_C_DESCRIPTORS: + _globals['DESCRIPTOR']._loaded_options = None + _globals['DESCRIPTOR']._serialized_options = b'Z/github.com/lightningnetwork/lnd/lnrpc/routerrpc' + _globals['_SENDPAYMENTREQUEST_DESTCUSTOMRECORDSENTRY']._loaded_options = None + _globals['_SENDPAYMENTREQUEST_DESTCUSTOMRECORDSENTRY']._serialized_options = b'8\001' + _globals['_SENDPAYMENTREQUEST'].fields_by_name['outgoing_chan_id']._loaded_options = None + _globals['_SENDPAYMENTREQUEST'].fields_by_name['outgoing_chan_id']._serialized_options = b'\030\0010\001' + _globals['_MISSIONCONTROLCONFIG'].fields_by_name['half_life_seconds']._loaded_options = None + _globals['_MISSIONCONTROLCONFIG'].fields_by_name['half_life_seconds']._serialized_options = b'\030\001' + _globals['_MISSIONCONTROLCONFIG'].fields_by_name['hop_probability']._loaded_options = None + _globals['_MISSIONCONTROLCONFIG'].fields_by_name['hop_probability']._serialized_options = b'\030\001' + _globals['_MISSIONCONTROLCONFIG'].fields_by_name['weight']._loaded_options = None + _globals['_MISSIONCONTROLCONFIG'].fields_by_name['weight']._serialized_options = b'\030\001' + _globals['_BUILDROUTEREQUEST'].fields_by_name['outgoing_chan_id']._loaded_options = None + _globals['_BUILDROUTEREQUEST'].fields_by_name['outgoing_chan_id']._serialized_options = b'0\001' + _globals['_FORWARDHTLCINTERCEPTREQUEST_CUSTOMRECORDSENTRY']._loaded_options = None + _globals['_FORWARDHTLCINTERCEPTREQUEST_CUSTOMRECORDSENTRY']._serialized_options = b'8\001' + _globals['_ROUTER'].methods_by_name['SendToRoute']._loaded_options = None + _globals['_ROUTER'].methods_by_name['SendToRoute']._serialized_options = b'\210\002\001' + _globals['_ROUTER'].methods_by_name['SendPayment']._loaded_options = None + _globals['_ROUTER'].methods_by_name['SendPayment']._serialized_options = b'\210\002\001' + _globals['_ROUTER'].methods_by_name['TrackPayment']._loaded_options = None + _globals['_ROUTER'].methods_by_name['TrackPayment']._serialized_options = b'\210\002\001' + _globals['_FAILUREDETAIL']._serialized_start=5095 + _globals['_FAILUREDETAIL']._serialized_end=5608 + _globals['_PAYMENTSTATE']._serialized_start=5611 + _globals['_PAYMENTSTATE']._serialized_end=5785 + _globals['_RESOLVEHOLDFORWARDACTION']._serialized_start=5787 + _globals['_RESOLVEHOLDFORWARDACTION']._serialized_end=5847 + _globals['_CHANSTATUSACTION']._serialized_start=5849 + _globals['_CHANSTATUSACTION']._serialized_end=5902 + _globals['_SENDPAYMENTREQUEST']._serialized_start=45 + _globals['_SENDPAYMENTREQUEST']._serialized_end=760 + _globals['_SENDPAYMENTREQUEST_DESTCUSTOMRECORDSENTRY']._serialized_start=704 + _globals['_SENDPAYMENTREQUEST_DESTCUSTOMRECORDSENTRY']._serialized_end=760 + _globals['_TRACKPAYMENTREQUEST']._serialized_start=762 + _globals['_TRACKPAYMENTREQUEST']._serialized_end=834 + _globals['_TRACKPAYMENTSREQUEST']._serialized_start=836 + _globals['_TRACKPAYMENTSREQUEST']._serialized_end=887 + _globals['_ROUTEFEEREQUEST']._serialized_start=889 + _globals['_ROUTEFEEREQUEST']._serialized_end=979 + _globals['_ROUTEFEERESPONSE']._serialized_start=981 + _globals['_ROUTEFEERESPONSE']._serialized_end=1103 + _globals['_SENDTOROUTEREQUEST']._serialized_start=1105 + _globals['_SENDTOROUTEREQUEST']._serialized_end=1199 + _globals['_SENDTOROUTERESPONSE']._serialized_start=1201 + _globals['_SENDTOROUTERESPONSE']._serialized_end=1273 + _globals['_RESETMISSIONCONTROLREQUEST']._serialized_start=1275 + _globals['_RESETMISSIONCONTROLREQUEST']._serialized_end=1303 + _globals['_RESETMISSIONCONTROLRESPONSE']._serialized_start=1305 + _globals['_RESETMISSIONCONTROLRESPONSE']._serialized_end=1334 + _globals['_QUERYMISSIONCONTROLREQUEST']._serialized_start=1336 + _globals['_QUERYMISSIONCONTROLREQUEST']._serialized_end=1364 + _globals['_QUERYMISSIONCONTROLRESPONSE']._serialized_start=1366 + _globals['_QUERYMISSIONCONTROLRESPONSE']._serialized_end=1440 + _globals['_XIMPORTMISSIONCONTROLREQUEST']._serialized_start=1442 + _globals['_XIMPORTMISSIONCONTROLREQUEST']._serialized_end=1526 + _globals['_XIMPORTMISSIONCONTROLRESPONSE']._serialized_start=1528 + _globals['_XIMPORTMISSIONCONTROLRESPONSE']._serialized_end=1559 + _globals['_PAIRHISTORY']._serialized_start=1561 + _globals['_PAIRHISTORY']._serialized_end=1672 + _globals['_PAIRDATA']._serialized_start=1675 + _globals['_PAIRDATA']._serialized_end=1828 + _globals['_GETMISSIONCONTROLCONFIGREQUEST']._serialized_start=1830 + _globals['_GETMISSIONCONTROLCONFIGREQUEST']._serialized_end=1862 + _globals['_GETMISSIONCONTROLCONFIGRESPONSE']._serialized_start=1864 + _globals['_GETMISSIONCONTROLCONFIGRESPONSE']._serialized_end=1946 + _globals['_SETMISSIONCONTROLCONFIGREQUEST']._serialized_start=1948 + _globals['_SETMISSIONCONTROLCONFIGREQUEST']._serialized_end=2029 + _globals['_SETMISSIONCONTROLCONFIGRESPONSE']._serialized_start=2031 + _globals['_SETMISSIONCONTROLCONFIGRESPONSE']._serialized_end=2064 + _globals['_MISSIONCONTROLCONFIG']._serialized_start=2067 + _globals['_MISSIONCONTROLCONFIG']._serialized_end=2470 + _globals['_MISSIONCONTROLCONFIG_PROBABILITYMODEL']._serialized_start=2407 + _globals['_MISSIONCONTROLCONFIG_PROBABILITYMODEL']._serialized_end=2451 + _globals['_BIMODALPARAMETERS']._serialized_start=2472 + _globals['_BIMODALPARAMETERS']._serialized_end=2552 + _globals['_APRIORIPARAMETERS']._serialized_start=2554 + _globals['_APRIORIPARAMETERS']._serialized_end=2668 + _globals['_QUERYPROBABILITYREQUEST']._serialized_start=2670 + _globals['_QUERYPROBABILITYREQUEST']._serialized_end=2749 + _globals['_QUERYPROBABILITYRESPONSE']._serialized_start=2751 + _globals['_QUERYPROBABILITYRESPONSE']._serialized_end=2836 + _globals['_BUILDROUTEREQUEST']._serialized_start=2839 + _globals['_BUILDROUTEREQUEST']._serialized_end=2975 + _globals['_BUILDROUTERESPONSE']._serialized_start=2977 + _globals['_BUILDROUTERESPONSE']._serialized_end=3026 + _globals['_SUBSCRIBEHTLCEVENTSREQUEST']._serialized_start=3028 + _globals['_SUBSCRIBEHTLCEVENTSREQUEST']._serialized_end=3056 + _globals['_HTLCEVENT']._serialized_start=3059 + _globals['_HTLCEVENT']._serialized_end=3646 + _globals['_HTLCEVENT_EVENTTYPE']._serialized_start=3577 + _globals['_HTLCEVENT_EVENTTYPE']._serialized_end=3637 + _globals['_HTLCINFO']._serialized_start=3648 + _globals['_HTLCINFO']._serialized_end=3766 + _globals['_FORWARDEVENT']._serialized_start=3768 + _globals['_FORWARDEVENT']._serialized_end=3817 + _globals['_FORWARDFAILEVENT']._serialized_start=3819 + _globals['_FORWARDFAILEVENT']._serialized_end=3837 + _globals['_SETTLEEVENT']._serialized_start=3839 + _globals['_SETTLEEVENT']._serialized_end=3870 + _globals['_FINALHTLCEVENT']._serialized_start=3872 + _globals['_FINALHTLCEVENT']._serialized_end=3923 + _globals['_SUBSCRIBEDEVENT']._serialized_start=3925 + _globals['_SUBSCRIBEDEVENT']._serialized_end=3942 + _globals['_LINKFAILEVENT']._serialized_start=3945 + _globals['_LINKFAILEVENT']._serialized_end=4119 + _globals['_PAYMENTSTATUS']._serialized_start=4121 + _globals['_PAYMENTSTATUS']._serialized_end=4235 + _globals['_CIRCUITKEY']._serialized_start=4237 + _globals['_CIRCUITKEY']._serialized_end=4283 + _globals['_FORWARDHTLCINTERCEPTREQUEST']._serialized_start=4286 + _globals['_FORWARDHTLCINTERCEPTREQUEST']._serialized_end=4719 + _globals['_FORWARDHTLCINTERCEPTREQUEST_CUSTOMRECORDSENTRY']._serialized_start=4667 + _globals['_FORWARDHTLCINTERCEPTREQUEST_CUSTOMRECORDSENTRY']._serialized_end=4719 + _globals['_FORWARDHTLCINTERCEPTRESPONSE']._serialized_start=4722 + _globals['_FORWARDHTLCINTERCEPTRESPONSE']._serialized_end=4951 + _globals['_UPDATECHANSTATUSREQUEST']._serialized_start=4953 + _globals['_UPDATECHANSTATUSREQUEST']._serialized_end=5064 + _globals['_UPDATECHANSTATUSRESPONSE']._serialized_start=5066 + _globals['_UPDATECHANSTATUSRESPONSE']._serialized_end=5092 + _globals['_ROUTER']._serialized_start=5905 + _globals['_ROUTER']._serialized_end=7494 +# @@protoc_insertion_point(module_scope) diff --git a/cashu/lightning/lnd_grpc/protos/router_pb2.pyi b/cashu/lightning/lnd_grpc/protos/router_pb2.pyi new file mode 100644 index 00000000..75ebbae5 --- /dev/null +++ b/cashu/lightning/lnd_grpc/protos/router_pb2.pyi @@ -0,0 +1,1572 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import builtins +import collections.abc +import sys +import typing + +import google.protobuf.descriptor +import google.protobuf.internal.containers +import google.protobuf.internal.enum_type_wrapper +import google.protobuf.message + +import cashu.lightning.lnd_grpc.protos.lightning_pb2 + +if sys.version_info >= (3, 10): + import typing as typing_extensions +else: + import typing_extensions + +DESCRIPTOR: google.protobuf.descriptor.FileDescriptor + +class _FailureDetail: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + +class _FailureDetailEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_FailureDetail.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + UNKNOWN: _FailureDetail.ValueType # 0 + NO_DETAIL: _FailureDetail.ValueType # 1 + ONION_DECODE: _FailureDetail.ValueType # 2 + LINK_NOT_ELIGIBLE: _FailureDetail.ValueType # 3 + ON_CHAIN_TIMEOUT: _FailureDetail.ValueType # 4 + HTLC_EXCEEDS_MAX: _FailureDetail.ValueType # 5 + INSUFFICIENT_BALANCE: _FailureDetail.ValueType # 6 + INCOMPLETE_FORWARD: _FailureDetail.ValueType # 7 + HTLC_ADD_FAILED: _FailureDetail.ValueType # 8 + FORWARDS_DISABLED: _FailureDetail.ValueType # 9 + INVOICE_CANCELED: _FailureDetail.ValueType # 10 + INVOICE_UNDERPAID: _FailureDetail.ValueType # 11 + INVOICE_EXPIRY_TOO_SOON: _FailureDetail.ValueType # 12 + INVOICE_NOT_OPEN: _FailureDetail.ValueType # 13 + MPP_INVOICE_TIMEOUT: _FailureDetail.ValueType # 14 + ADDRESS_MISMATCH: _FailureDetail.ValueType # 15 + SET_TOTAL_MISMATCH: _FailureDetail.ValueType # 16 + SET_TOTAL_TOO_LOW: _FailureDetail.ValueType # 17 + SET_OVERPAID: _FailureDetail.ValueType # 18 + UNKNOWN_INVOICE: _FailureDetail.ValueType # 19 + INVALID_KEYSEND: _FailureDetail.ValueType # 20 + MPP_IN_PROGRESS: _FailureDetail.ValueType # 21 + CIRCULAR_ROUTE: _FailureDetail.ValueType # 22 + +class FailureDetail(_FailureDetail, metaclass=_FailureDetailEnumTypeWrapper): ... + +UNKNOWN: FailureDetail.ValueType # 0 +NO_DETAIL: FailureDetail.ValueType # 1 +ONION_DECODE: FailureDetail.ValueType # 2 +LINK_NOT_ELIGIBLE: FailureDetail.ValueType # 3 +ON_CHAIN_TIMEOUT: FailureDetail.ValueType # 4 +HTLC_EXCEEDS_MAX: FailureDetail.ValueType # 5 +INSUFFICIENT_BALANCE: FailureDetail.ValueType # 6 +INCOMPLETE_FORWARD: FailureDetail.ValueType # 7 +HTLC_ADD_FAILED: FailureDetail.ValueType # 8 +FORWARDS_DISABLED: FailureDetail.ValueType # 9 +INVOICE_CANCELED: FailureDetail.ValueType # 10 +INVOICE_UNDERPAID: FailureDetail.ValueType # 11 +INVOICE_EXPIRY_TOO_SOON: FailureDetail.ValueType # 12 +INVOICE_NOT_OPEN: FailureDetail.ValueType # 13 +MPP_INVOICE_TIMEOUT: FailureDetail.ValueType # 14 +ADDRESS_MISMATCH: FailureDetail.ValueType # 15 +SET_TOTAL_MISMATCH: FailureDetail.ValueType # 16 +SET_TOTAL_TOO_LOW: FailureDetail.ValueType # 17 +SET_OVERPAID: FailureDetail.ValueType # 18 +UNKNOWN_INVOICE: FailureDetail.ValueType # 19 +INVALID_KEYSEND: FailureDetail.ValueType # 20 +MPP_IN_PROGRESS: FailureDetail.ValueType # 21 +CIRCULAR_ROUTE: FailureDetail.ValueType # 22 +global___FailureDetail = FailureDetail + +class _PaymentState: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + +class _PaymentStateEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_PaymentState.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + IN_FLIGHT: _PaymentState.ValueType # 0 + """ + Payment is still in flight. + """ + SUCCEEDED: _PaymentState.ValueType # 1 + """ + Payment completed successfully. + """ + FAILED_TIMEOUT: _PaymentState.ValueType # 2 + """ + There are more routes to try, but the payment timeout was exceeded. + """ + FAILED_NO_ROUTE: _PaymentState.ValueType # 3 + """ + All possible routes were tried and failed permanently. Or were no + routes to the destination at all. + """ + FAILED_ERROR: _PaymentState.ValueType # 4 + """ + A non-recoverable error has occurred. + """ + FAILED_INCORRECT_PAYMENT_DETAILS: _PaymentState.ValueType # 5 + """ + Payment details incorrect (unknown hash, invalid amt or + invalid final cltv delta) + """ + FAILED_INSUFFICIENT_BALANCE: _PaymentState.ValueType # 6 + """ + Insufficient local balance. + """ + +class PaymentState(_PaymentState, metaclass=_PaymentStateEnumTypeWrapper): ... + +IN_FLIGHT: PaymentState.ValueType # 0 +""" +Payment is still in flight. +""" +SUCCEEDED: PaymentState.ValueType # 1 +""" +Payment completed successfully. +""" +FAILED_TIMEOUT: PaymentState.ValueType # 2 +""" +There are more routes to try, but the payment timeout was exceeded. +""" +FAILED_NO_ROUTE: PaymentState.ValueType # 3 +""" +All possible routes were tried and failed permanently. Or were no +routes to the destination at all. +""" +FAILED_ERROR: PaymentState.ValueType # 4 +""" +A non-recoverable error has occurred. +""" +FAILED_INCORRECT_PAYMENT_DETAILS: PaymentState.ValueType # 5 +""" +Payment details incorrect (unknown hash, invalid amt or +invalid final cltv delta) +""" +FAILED_INSUFFICIENT_BALANCE: PaymentState.ValueType # 6 +""" +Insufficient local balance. +""" +global___PaymentState = PaymentState + +class _ResolveHoldForwardAction: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + +class _ResolveHoldForwardActionEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_ResolveHoldForwardAction.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + SETTLE: _ResolveHoldForwardAction.ValueType # 0 + FAIL: _ResolveHoldForwardAction.ValueType # 1 + RESUME: _ResolveHoldForwardAction.ValueType # 2 + +class ResolveHoldForwardAction(_ResolveHoldForwardAction, metaclass=_ResolveHoldForwardActionEnumTypeWrapper): ... + +SETTLE: ResolveHoldForwardAction.ValueType # 0 +FAIL: ResolveHoldForwardAction.ValueType # 1 +RESUME: ResolveHoldForwardAction.ValueType # 2 +global___ResolveHoldForwardAction = ResolveHoldForwardAction + +class _ChanStatusAction: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + +class _ChanStatusActionEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_ChanStatusAction.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + ENABLE: _ChanStatusAction.ValueType # 0 + DISABLE: _ChanStatusAction.ValueType # 1 + AUTO: _ChanStatusAction.ValueType # 2 + +class ChanStatusAction(_ChanStatusAction, metaclass=_ChanStatusActionEnumTypeWrapper): ... + +ENABLE: ChanStatusAction.ValueType # 0 +DISABLE: ChanStatusAction.ValueType # 1 +AUTO: ChanStatusAction.ValueType # 2 +global___ChanStatusAction = ChanStatusAction + +@typing.final +class SendPaymentRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + @typing.final + class DestCustomRecordsEntry(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + KEY_FIELD_NUMBER: builtins.int + VALUE_FIELD_NUMBER: builtins.int + key: builtins.int + value: builtins.bytes + def __init__( + self, + *, + key: builtins.int = ..., + value: builtins.bytes = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["key", b"key", "value", b"value"]) -> None: ... + + DEST_FIELD_NUMBER: builtins.int + AMT_FIELD_NUMBER: builtins.int + PAYMENT_HASH_FIELD_NUMBER: builtins.int + FINAL_CLTV_DELTA_FIELD_NUMBER: builtins.int + PAYMENT_REQUEST_FIELD_NUMBER: builtins.int + TIMEOUT_SECONDS_FIELD_NUMBER: builtins.int + FEE_LIMIT_SAT_FIELD_NUMBER: builtins.int + OUTGOING_CHAN_ID_FIELD_NUMBER: builtins.int + CLTV_LIMIT_FIELD_NUMBER: builtins.int + ROUTE_HINTS_FIELD_NUMBER: builtins.int + DEST_CUSTOM_RECORDS_FIELD_NUMBER: builtins.int + AMT_MSAT_FIELD_NUMBER: builtins.int + FEE_LIMIT_MSAT_FIELD_NUMBER: builtins.int + LAST_HOP_PUBKEY_FIELD_NUMBER: builtins.int + ALLOW_SELF_PAYMENT_FIELD_NUMBER: builtins.int + DEST_FEATURES_FIELD_NUMBER: builtins.int + MAX_PARTS_FIELD_NUMBER: builtins.int + NO_INFLIGHT_UPDATES_FIELD_NUMBER: builtins.int + OUTGOING_CHAN_IDS_FIELD_NUMBER: builtins.int + PAYMENT_ADDR_FIELD_NUMBER: builtins.int + MAX_SHARD_SIZE_MSAT_FIELD_NUMBER: builtins.int + AMP_FIELD_NUMBER: builtins.int + TIME_PREF_FIELD_NUMBER: builtins.int + CANCELABLE_FIELD_NUMBER: builtins.int + dest: builtins.bytes + """The identity pubkey of the payment recipient""" + amt: builtins.int + """ + Number of satoshis to send. + + The fields amt and amt_msat are mutually exclusive. + """ + payment_hash: builtins.bytes + """The hash to use within the payment's HTLC""" + final_cltv_delta: builtins.int + """ + The CLTV delta from the current height that should be used to set the + timelock for the final hop. + """ + payment_request: builtins.str + """ + A bare-bones invoice for a payment within the Lightning Network. With the + details of the invoice, the sender has all the data necessary to send a + payment to the recipient. The amount in the payment request may be zero. In + that case it is required to set the amt field as well. If no payment request + is specified, the following fields are required: dest, amt and payment_hash. + """ + timeout_seconds: builtins.int + """ + An upper limit on the amount of time we should spend when attempting to + fulfill the payment. This is expressed in seconds. If we cannot make a + successful payment within this time frame, an error will be returned. + This field must be non-zero. + """ + fee_limit_sat: builtins.int + """ + The maximum number of satoshis that will be paid as a fee of the payment. + If this field is left to the default value of 0, only zero-fee routes will + be considered. This usually means single hop routes connecting directly to + the destination. To send the payment without a fee limit, use max int here. + + The fields fee_limit_sat and fee_limit_msat are mutually exclusive. + """ + outgoing_chan_id: builtins.int + """ + Deprecated, use outgoing_chan_ids. The channel id of the channel that must + be taken to the first hop. If zero, any channel may be used (unless + outgoing_chan_ids are set). + """ + cltv_limit: builtins.int + """ + An optional maximum total time lock for the route. This should not + exceed lnd's `--max-cltv-expiry` setting. If zero, then the value of + `--max-cltv-expiry` is enforced. + """ + amt_msat: builtins.int + """ + Number of millisatoshis to send. + + The fields amt and amt_msat are mutually exclusive. + """ + fee_limit_msat: builtins.int + """ + The maximum number of millisatoshis that will be paid as a fee of the + payment. If this field is left to the default value of 0, only zero-fee + routes will be considered. This usually means single hop routes connecting + directly to the destination. To send the payment without a fee limit, use + max int here. + + The fields fee_limit_sat and fee_limit_msat are mutually exclusive. + """ + last_hop_pubkey: builtins.bytes + """ + The pubkey of the last hop of the route. If empty, any hop may be used. + """ + allow_self_payment: builtins.bool + """If set, circular payments to self are permitted.""" + max_parts: builtins.int + """ + The maximum number of partial payments that may be use to complete the full + amount. + """ + no_inflight_updates: builtins.bool + """ + If set, only the final payment update is streamed back. Intermediate updates + that show which htlcs are still in flight are suppressed. + """ + payment_addr: builtins.bytes + """ + An optional payment addr to be included within the last hop of the route. + This is also called payment secret in specifications (e.g. BOLT 11). + """ + max_shard_size_msat: builtins.int + """ + The largest payment split that should be attempted when making a payment if + splitting is necessary. Setting this value will effectively cause lnd to + split more aggressively, vs only when it thinks it needs to. Note that this + value is in milli-satoshis. + """ + amp: builtins.bool + """ + If set, an AMP-payment will be attempted. + """ + time_pref: builtins.float + """ + The time preference for this payment. Set to -1 to optimize for fees + only, to 1 to optimize for reliability only or a value inbetween for a mix. + """ + cancelable: builtins.bool + """ + If set, the payment loop can be interrupted by manually canceling the + payment context, even before the payment timeout is reached. Note that the + payment may still succeed after cancellation, as in-flight attempts can + still settle afterwards. Canceling will only prevent further attempts from + being sent. + """ + @property + def route_hints(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[cashu.lightning.lnd_grpc.protos.lightning_pb2.RouteHint]: + """ + Optional route hints to reach the destination through private channels. + """ + + @property + def dest_custom_records(self) -> google.protobuf.internal.containers.ScalarMap[builtins.int, builtins.bytes]: + """ + An optional field that can be used to pass an arbitrary set of TLV records + to a peer which understands the new records. This can be used to pass + application specific data during the payment attempt. Record types are + required to be in the custom range >= 65536. When using REST, the values + must be encoded as base64. + """ + + @property + def dest_features(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[cashu.lightning.lnd_grpc.protos.lightning_pb2.FeatureBit.ValueType]: + """ + Features assumed to be supported by the final node. All transitive feature + dependencies must also be set properly. For a given feature bit pair, either + optional or remote may be set, but not both. If this field is nil or empty, + the router will try to load destination features from the graph as a + fallback. + """ + + @property + def outgoing_chan_ids(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.int]: + """ + The channel ids of the channels are allowed for the first hop. If empty, + any channel may be used. + """ + + def __init__( + self, + *, + dest: builtins.bytes = ..., + amt: builtins.int = ..., + payment_hash: builtins.bytes = ..., + final_cltv_delta: builtins.int = ..., + payment_request: builtins.str = ..., + timeout_seconds: builtins.int = ..., + fee_limit_sat: builtins.int = ..., + outgoing_chan_id: builtins.int = ..., + cltv_limit: builtins.int = ..., + route_hints: collections.abc.Iterable[cashu.lightning.lnd_grpc.protos.lightning_pb2.RouteHint] | None = ..., + dest_custom_records: collections.abc.Mapping[builtins.int, builtins.bytes] | None = ..., + amt_msat: builtins.int = ..., + fee_limit_msat: builtins.int = ..., + last_hop_pubkey: builtins.bytes = ..., + allow_self_payment: builtins.bool = ..., + dest_features: collections.abc.Iterable[cashu.lightning.lnd_grpc.protos.lightning_pb2.FeatureBit.ValueType] | None = ..., + max_parts: builtins.int = ..., + no_inflight_updates: builtins.bool = ..., + outgoing_chan_ids: collections.abc.Iterable[builtins.int] | None = ..., + payment_addr: builtins.bytes = ..., + max_shard_size_msat: builtins.int = ..., + amp: builtins.bool = ..., + time_pref: builtins.float = ..., + cancelable: builtins.bool = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["allow_self_payment", b"allow_self_payment", "amp", b"amp", "amt", b"amt", "amt_msat", b"amt_msat", "cancelable", b"cancelable", "cltv_limit", b"cltv_limit", "dest", b"dest", "dest_custom_records", b"dest_custom_records", "dest_features", b"dest_features", "fee_limit_msat", b"fee_limit_msat", "fee_limit_sat", b"fee_limit_sat", "final_cltv_delta", b"final_cltv_delta", "last_hop_pubkey", b"last_hop_pubkey", "max_parts", b"max_parts", "max_shard_size_msat", b"max_shard_size_msat", "no_inflight_updates", b"no_inflight_updates", "outgoing_chan_id", b"outgoing_chan_id", "outgoing_chan_ids", b"outgoing_chan_ids", "payment_addr", b"payment_addr", "payment_hash", b"payment_hash", "payment_request", b"payment_request", "route_hints", b"route_hints", "time_pref", b"time_pref", "timeout_seconds", b"timeout_seconds"]) -> None: ... + +global___SendPaymentRequest = SendPaymentRequest + +@typing.final +class TrackPaymentRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + PAYMENT_HASH_FIELD_NUMBER: builtins.int + NO_INFLIGHT_UPDATES_FIELD_NUMBER: builtins.int + payment_hash: builtins.bytes + """The hash of the payment to look up.""" + no_inflight_updates: builtins.bool + """ + If set, only the final payment update is streamed back. Intermediate updates + that show which htlcs are still in flight are suppressed. + """ + def __init__( + self, + *, + payment_hash: builtins.bytes = ..., + no_inflight_updates: builtins.bool = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["no_inflight_updates", b"no_inflight_updates", "payment_hash", b"payment_hash"]) -> None: ... + +global___TrackPaymentRequest = TrackPaymentRequest + +@typing.final +class TrackPaymentsRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + NO_INFLIGHT_UPDATES_FIELD_NUMBER: builtins.int + no_inflight_updates: builtins.bool + """ + If set, only the final payment updates are streamed back. Intermediate + updates that show which htlcs are still in flight are suppressed. + """ + def __init__( + self, + *, + no_inflight_updates: builtins.bool = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["no_inflight_updates", b"no_inflight_updates"]) -> None: ... + +global___TrackPaymentsRequest = TrackPaymentsRequest + +@typing.final +class RouteFeeRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + DEST_FIELD_NUMBER: builtins.int + AMT_SAT_FIELD_NUMBER: builtins.int + PAYMENT_REQUEST_FIELD_NUMBER: builtins.int + TIMEOUT_FIELD_NUMBER: builtins.int + dest: builtins.bytes + """ + The destination one wishes to obtain a routing fee quote to. If set, this + parameter requires the amt_sat parameter also to be set. This parameter + combination triggers a graph based routing fee estimation as opposed to a + payment probe based estimate in case a payment request is provided. The + graph based estimation is an algorithm that is executed on the in memory + graph. Hence its runtime is significantly shorter than a payment probe + estimation that sends out actual payments to the network. + """ + amt_sat: builtins.int + """ + The amount one wishes to send to the target destination. It is only to be + used in combination with the dest parameter. + """ + payment_request: builtins.str + """ + A payment request of the target node that the route fee request is intended + for. Its parameters are input to probe payments that estimate routing fees. + The timeout parameter can be specified to set a maximum time on the probing + attempt. Cannot be used in combination with dest and amt_sat. + """ + timeout: builtins.int + """ + A user preference of how long a probe payment should maximally be allowed to + take, denoted in seconds. The probing payment loop is aborted if this + timeout is reached. Note that the probing process itself can take longer + than the timeout if the HTLC becomes delayed or stuck. Canceling the context + of this call will not cancel the payment loop, the duration is only + controlled by the timeout parameter. + """ + def __init__( + self, + *, + dest: builtins.bytes = ..., + amt_sat: builtins.int = ..., + payment_request: builtins.str = ..., + timeout: builtins.int = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["amt_sat", b"amt_sat", "dest", b"dest", "payment_request", b"payment_request", "timeout", b"timeout"]) -> None: ... + +global___RouteFeeRequest = RouteFeeRequest + +@typing.final +class RouteFeeResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + ROUTING_FEE_MSAT_FIELD_NUMBER: builtins.int + TIME_LOCK_DELAY_FIELD_NUMBER: builtins.int + FAILURE_REASON_FIELD_NUMBER: builtins.int + routing_fee_msat: builtins.int + """ + A lower bound of the estimated fee to the target destination within the + network, expressed in milli-satoshis. + """ + time_lock_delay: builtins.int + """ + An estimate of the worst case time delay that can occur. Note that callers + will still need to factor in the final CLTV delta of the last hop into this + value. + """ + failure_reason: cashu.lightning.lnd_grpc.protos.lightning_pb2.PaymentFailureReason.ValueType + """ + An indication whether a probing payment succeeded or whether and why it + failed. FAILURE_REASON_NONE indicates success. + """ + def __init__( + self, + *, + routing_fee_msat: builtins.int = ..., + time_lock_delay: builtins.int = ..., + failure_reason: cashu.lightning.lnd_grpc.protos.lightning_pb2.PaymentFailureReason.ValueType = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["failure_reason", b"failure_reason", "routing_fee_msat", b"routing_fee_msat", "time_lock_delay", b"time_lock_delay"]) -> None: ... + +global___RouteFeeResponse = RouteFeeResponse + +@typing.final +class SendToRouteRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + PAYMENT_HASH_FIELD_NUMBER: builtins.int + ROUTE_FIELD_NUMBER: builtins.int + SKIP_TEMP_ERR_FIELD_NUMBER: builtins.int + payment_hash: builtins.bytes + """The payment hash to use for the HTLC.""" + skip_temp_err: builtins.bool + """ + Whether the payment should be marked as failed when a temporary error is + returned from the given route. Set it to true so the payment won't be + failed unless a terminal error is occurred, such as payment timeout, no + routes, incorrect payment details, or insufficient funds. + """ + @property + def route(self) -> cashu.lightning.lnd_grpc.protos.lightning_pb2.Route: + """Route that should be used to attempt to complete the payment.""" + + def __init__( + self, + *, + payment_hash: builtins.bytes = ..., + route: cashu.lightning.lnd_grpc.protos.lightning_pb2.Route | None = ..., + skip_temp_err: builtins.bool = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["route", b"route"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["payment_hash", b"payment_hash", "route", b"route", "skip_temp_err", b"skip_temp_err"]) -> None: ... + +global___SendToRouteRequest = SendToRouteRequest + +@typing.final +class SendToRouteResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + PREIMAGE_FIELD_NUMBER: builtins.int + FAILURE_FIELD_NUMBER: builtins.int + preimage: builtins.bytes + """The preimage obtained by making the payment.""" + @property + def failure(self) -> cashu.lightning.lnd_grpc.protos.lightning_pb2.Failure: + """The failure message in case the payment failed.""" + + def __init__( + self, + *, + preimage: builtins.bytes = ..., + failure: cashu.lightning.lnd_grpc.protos.lightning_pb2.Failure | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["failure", b"failure"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["failure", b"failure", "preimage", b"preimage"]) -> None: ... + +global___SendToRouteResponse = SendToRouteResponse + +@typing.final +class ResetMissionControlRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +global___ResetMissionControlRequest = ResetMissionControlRequest + +@typing.final +class ResetMissionControlResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +global___ResetMissionControlResponse = ResetMissionControlResponse + +@typing.final +class QueryMissionControlRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +global___QueryMissionControlRequest = QueryMissionControlRequest + +@typing.final +class QueryMissionControlResponse(google.protobuf.message.Message): + """QueryMissionControlResponse contains mission control state.""" + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + PAIRS_FIELD_NUMBER: builtins.int + @property + def pairs(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___PairHistory]: + """Node pair-level mission control state.""" + + def __init__( + self, + *, + pairs: collections.abc.Iterable[global___PairHistory] | None = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["pairs", b"pairs"]) -> None: ... + +global___QueryMissionControlResponse = QueryMissionControlResponse + +@typing.final +class XImportMissionControlRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + PAIRS_FIELD_NUMBER: builtins.int + FORCE_FIELD_NUMBER: builtins.int + force: builtins.bool + """Whether to force override MC pair history. Note that even with force + override the failure pair is imported before the success pair and both + still clamp existing failure/success amounts. + """ + @property + def pairs(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___PairHistory]: + """Node pair-level mission control state to be imported.""" + + def __init__( + self, + *, + pairs: collections.abc.Iterable[global___PairHistory] | None = ..., + force: builtins.bool = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["force", b"force", "pairs", b"pairs"]) -> None: ... + +global___XImportMissionControlRequest = XImportMissionControlRequest + +@typing.final +class XImportMissionControlResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +global___XImportMissionControlResponse = XImportMissionControlResponse + +@typing.final +class PairHistory(google.protobuf.message.Message): + """PairHistory contains the mission control state for a particular node pair.""" + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + NODE_FROM_FIELD_NUMBER: builtins.int + NODE_TO_FIELD_NUMBER: builtins.int + HISTORY_FIELD_NUMBER: builtins.int + node_from: builtins.bytes + """The source node pubkey of the pair.""" + node_to: builtins.bytes + """The destination node pubkey of the pair.""" + @property + def history(self) -> global___PairData: ... + def __init__( + self, + *, + node_from: builtins.bytes = ..., + node_to: builtins.bytes = ..., + history: global___PairData | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["history", b"history"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["history", b"history", "node_from", b"node_from", "node_to", b"node_to"]) -> None: ... + +global___PairHistory = PairHistory + +@typing.final +class PairData(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + FAIL_TIME_FIELD_NUMBER: builtins.int + FAIL_AMT_SAT_FIELD_NUMBER: builtins.int + FAIL_AMT_MSAT_FIELD_NUMBER: builtins.int + SUCCESS_TIME_FIELD_NUMBER: builtins.int + SUCCESS_AMT_SAT_FIELD_NUMBER: builtins.int + SUCCESS_AMT_MSAT_FIELD_NUMBER: builtins.int + fail_time: builtins.int + """Time of last failure.""" + fail_amt_sat: builtins.int + """ + Lowest amount that failed to forward rounded to whole sats. This may be + set to zero if the failure is independent of amount. + """ + fail_amt_msat: builtins.int + """ + Lowest amount that failed to forward in millisats. This may be + set to zero if the failure is independent of amount. + """ + success_time: builtins.int + """Time of last success.""" + success_amt_sat: builtins.int + """Highest amount that we could successfully forward rounded to whole sats.""" + success_amt_msat: builtins.int + """Highest amount that we could successfully forward in millisats.""" + def __init__( + self, + *, + fail_time: builtins.int = ..., + fail_amt_sat: builtins.int = ..., + fail_amt_msat: builtins.int = ..., + success_time: builtins.int = ..., + success_amt_sat: builtins.int = ..., + success_amt_msat: builtins.int = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["fail_amt_msat", b"fail_amt_msat", "fail_amt_sat", b"fail_amt_sat", "fail_time", b"fail_time", "success_amt_msat", b"success_amt_msat", "success_amt_sat", b"success_amt_sat", "success_time", b"success_time"]) -> None: ... + +global___PairData = PairData + +@typing.final +class GetMissionControlConfigRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +global___GetMissionControlConfigRequest = GetMissionControlConfigRequest + +@typing.final +class GetMissionControlConfigResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + CONFIG_FIELD_NUMBER: builtins.int + @property + def config(self) -> global___MissionControlConfig: + """ + Mission control's currently active config. + """ + + def __init__( + self, + *, + config: global___MissionControlConfig | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["config", b"config"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["config", b"config"]) -> None: ... + +global___GetMissionControlConfigResponse = GetMissionControlConfigResponse + +@typing.final +class SetMissionControlConfigRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + CONFIG_FIELD_NUMBER: builtins.int + @property + def config(self) -> global___MissionControlConfig: + """ + The config to set for mission control. Note that all values *must* be set, + because the full config will be applied. + """ + + def __init__( + self, + *, + config: global___MissionControlConfig | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["config", b"config"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["config", b"config"]) -> None: ... + +global___SetMissionControlConfigRequest = SetMissionControlConfigRequest + +@typing.final +class SetMissionControlConfigResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +global___SetMissionControlConfigResponse = SetMissionControlConfigResponse + +@typing.final +class MissionControlConfig(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + class _ProbabilityModel: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + + class _ProbabilityModelEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[MissionControlConfig._ProbabilityModel.ValueType], builtins.type): # noqa: F821 + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + APRIORI: MissionControlConfig._ProbabilityModel.ValueType # 0 + BIMODAL: MissionControlConfig._ProbabilityModel.ValueType # 1 + + class ProbabilityModel(_ProbabilityModel, metaclass=_ProbabilityModelEnumTypeWrapper): ... + APRIORI: MissionControlConfig.ProbabilityModel.ValueType # 0 + BIMODAL: MissionControlConfig.ProbabilityModel.ValueType # 1 + + HALF_LIFE_SECONDS_FIELD_NUMBER: builtins.int + HOP_PROBABILITY_FIELD_NUMBER: builtins.int + WEIGHT_FIELD_NUMBER: builtins.int + MAXIMUM_PAYMENT_RESULTS_FIELD_NUMBER: builtins.int + MINIMUM_FAILURE_RELAX_INTERVAL_FIELD_NUMBER: builtins.int + MODEL_FIELD_NUMBER: builtins.int + APRIORI_FIELD_NUMBER: builtins.int + BIMODAL_FIELD_NUMBER: builtins.int + half_life_seconds: builtins.int + """ + Deprecated, use AprioriParameters. The amount of time mission control will + take to restore a penalized node or channel back to 50% success probability, + expressed in seconds. Setting this value to a higher value will penalize + failures for longer, making mission control less likely to route through + nodes and channels that we have previously recorded failures for. + """ + hop_probability: builtins.float + """ + Deprecated, use AprioriParameters. The probability of success mission + control should assign to hop in a route where it has no other information + available. Higher values will make mission control more willing to try hops + that we have no information about, lower values will discourage trying these + hops. + """ + weight: builtins.float + """ + Deprecated, use AprioriParameters. The importance that mission control + should place on historical results, expressed as a value in [0;1]. Setting + this value to 1 will ignore all historical payments and just use the hop + probability to assess the probability of success for each hop. A zero value + ignores hop probability completely and relies entirely on historical + results, unless none are available. + """ + maximum_payment_results: builtins.int + """ + The maximum number of payment results that mission control will store. + """ + minimum_failure_relax_interval: builtins.int + """ + The minimum time that must have passed since the previously recorded failure + before we raise the failure amount. + """ + model: global___MissionControlConfig.ProbabilityModel.ValueType + """ + ProbabilityModel defines which probability estimator should be used in + pathfinding. Note that the bimodal estimator is experimental. + """ + @property + def apriori(self) -> global___AprioriParameters: ... + @property + def bimodal(self) -> global___BimodalParameters: ... + def __init__( + self, + *, + half_life_seconds: builtins.int = ..., + hop_probability: builtins.float = ..., + weight: builtins.float = ..., + maximum_payment_results: builtins.int = ..., + minimum_failure_relax_interval: builtins.int = ..., + model: global___MissionControlConfig.ProbabilityModel.ValueType = ..., + apriori: global___AprioriParameters | None = ..., + bimodal: global___BimodalParameters | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["EstimatorConfig", b"EstimatorConfig", "apriori", b"apriori", "bimodal", b"bimodal"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["EstimatorConfig", b"EstimatorConfig", "apriori", b"apriori", "bimodal", b"bimodal", "half_life_seconds", b"half_life_seconds", "hop_probability", b"hop_probability", "maximum_payment_results", b"maximum_payment_results", "minimum_failure_relax_interval", b"minimum_failure_relax_interval", "model", b"model", "weight", b"weight"]) -> None: ... + def WhichOneof(self, oneof_group: typing.Literal["EstimatorConfig", b"EstimatorConfig"]) -> typing.Literal["apriori", "bimodal"] | None: ... + +global___MissionControlConfig = MissionControlConfig + +@typing.final +class BimodalParameters(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + NODE_WEIGHT_FIELD_NUMBER: builtins.int + SCALE_MSAT_FIELD_NUMBER: builtins.int + DECAY_TIME_FIELD_NUMBER: builtins.int + node_weight: builtins.float + """ + NodeWeight defines how strongly other previous forwardings on channels of a + router should be taken into account when computing a channel's probability + to route. The allowed values are in the range [0, 1], where a value of 0 + means that only direct information about a channel is taken into account. + """ + scale_msat: builtins.int + """ + ScaleMsat describes the scale over which channels statistically have some + liquidity left. The value determines how quickly the bimodal distribution + drops off from the edges of a channel. A larger value (compared to typical + channel capacities) means that the drop off is slow and that channel + balances are distributed more uniformly. A small value leads to the + assumption of very unbalanced channels. + """ + decay_time: builtins.int + """ + DecayTime describes the information decay of knowledge about previous + successes and failures in channels. The smaller the decay time, the quicker + we forget about past forwardings. + """ + def __init__( + self, + *, + node_weight: builtins.float = ..., + scale_msat: builtins.int = ..., + decay_time: builtins.int = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["decay_time", b"decay_time", "node_weight", b"node_weight", "scale_msat", b"scale_msat"]) -> None: ... + +global___BimodalParameters = BimodalParameters + +@typing.final +class AprioriParameters(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + HALF_LIFE_SECONDS_FIELD_NUMBER: builtins.int + HOP_PROBABILITY_FIELD_NUMBER: builtins.int + WEIGHT_FIELD_NUMBER: builtins.int + CAPACITY_FRACTION_FIELD_NUMBER: builtins.int + half_life_seconds: builtins.int + """ + The amount of time mission control will take to restore a penalized node + or channel back to 50% success probability, expressed in seconds. Setting + this value to a higher value will penalize failures for longer, making + mission control less likely to route through nodes and channels that we + have previously recorded failures for. + """ + hop_probability: builtins.float + """ + The probability of success mission control should assign to hop in a route + where it has no other information available. Higher values will make mission + control more willing to try hops that we have no information about, lower + values will discourage trying these hops. + """ + weight: builtins.float + """ + The importance that mission control should place on historical results, + expressed as a value in [0;1]. Setting this value to 1 will ignore all + historical payments and just use the hop probability to assess the + probability of success for each hop. A zero value ignores hop probability + completely and relies entirely on historical results, unless none are + available. + """ + capacity_fraction: builtins.float + """ + The fraction of a channel's capacity that we consider to have liquidity. For + amounts that come close to or exceed the fraction, an additional penalty is + applied. A value of 1.0 disables the capacity factor. Allowed values are in + [0.75, 1.0]. + """ + def __init__( + self, + *, + half_life_seconds: builtins.int = ..., + hop_probability: builtins.float = ..., + weight: builtins.float = ..., + capacity_fraction: builtins.float = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["capacity_fraction", b"capacity_fraction", "half_life_seconds", b"half_life_seconds", "hop_probability", b"hop_probability", "weight", b"weight"]) -> None: ... + +global___AprioriParameters = AprioriParameters + +@typing.final +class QueryProbabilityRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + FROM_NODE_FIELD_NUMBER: builtins.int + TO_NODE_FIELD_NUMBER: builtins.int + AMT_MSAT_FIELD_NUMBER: builtins.int + from_node: builtins.bytes + """The source node pubkey of the pair.""" + to_node: builtins.bytes + """The destination node pubkey of the pair.""" + amt_msat: builtins.int + """The amount for which to calculate a probability.""" + def __init__( + self, + *, + from_node: builtins.bytes = ..., + to_node: builtins.bytes = ..., + amt_msat: builtins.int = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["amt_msat", b"amt_msat", "from_node", b"from_node", "to_node", b"to_node"]) -> None: ... + +global___QueryProbabilityRequest = QueryProbabilityRequest + +@typing.final +class QueryProbabilityResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + PROBABILITY_FIELD_NUMBER: builtins.int + HISTORY_FIELD_NUMBER: builtins.int + probability: builtins.float + """The success probability for the requested pair.""" + @property + def history(self) -> global___PairData: + """The historical data for the requested pair.""" + + def __init__( + self, + *, + probability: builtins.float = ..., + history: global___PairData | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["history", b"history"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["history", b"history", "probability", b"probability"]) -> None: ... + +global___QueryProbabilityResponse = QueryProbabilityResponse + +@typing.final +class BuildRouteRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + AMT_MSAT_FIELD_NUMBER: builtins.int + FINAL_CLTV_DELTA_FIELD_NUMBER: builtins.int + OUTGOING_CHAN_ID_FIELD_NUMBER: builtins.int + HOP_PUBKEYS_FIELD_NUMBER: builtins.int + PAYMENT_ADDR_FIELD_NUMBER: builtins.int + amt_msat: builtins.int + """ + The amount to send expressed in msat. If set to zero, the minimum routable + amount is used. + """ + final_cltv_delta: builtins.int + """ + CLTV delta from the current height that should be used for the timelock + of the final hop + """ + outgoing_chan_id: builtins.int + """ + The channel id of the channel that must be taken to the first hop. If zero, + any channel may be used. + """ + payment_addr: builtins.bytes + """ + An optional payment addr to be included within the last hop of the route. + This is also called payment secret in specifications (e.g. BOLT 11). + """ + @property + def hop_pubkeys(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.bytes]: + """ + A list of hops that defines the route. This does not include the source hop + pubkey. + """ + + def __init__( + self, + *, + amt_msat: builtins.int = ..., + final_cltv_delta: builtins.int = ..., + outgoing_chan_id: builtins.int = ..., + hop_pubkeys: collections.abc.Iterable[builtins.bytes] | None = ..., + payment_addr: builtins.bytes = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["amt_msat", b"amt_msat", "final_cltv_delta", b"final_cltv_delta", "hop_pubkeys", b"hop_pubkeys", "outgoing_chan_id", b"outgoing_chan_id", "payment_addr", b"payment_addr"]) -> None: ... + +global___BuildRouteRequest = BuildRouteRequest + +@typing.final +class BuildRouteResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + ROUTE_FIELD_NUMBER: builtins.int + @property + def route(self) -> cashu.lightning.lnd_grpc.protos.lightning_pb2.Route: + """ + Fully specified route that can be used to execute the payment. + """ + + def __init__( + self, + *, + route: cashu.lightning.lnd_grpc.protos.lightning_pb2.Route | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["route", b"route"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["route", b"route"]) -> None: ... + +global___BuildRouteResponse = BuildRouteResponse + +@typing.final +class SubscribeHtlcEventsRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +global___SubscribeHtlcEventsRequest = SubscribeHtlcEventsRequest + +@typing.final +class HtlcEvent(google.protobuf.message.Message): + """ + HtlcEvent contains the htlc event that was processed. These are served on a + best-effort basis; events are not persisted, delivery is not guaranteed + (in the event of a crash in the switch, forward events may be lost) and + some events may be replayed upon restart. Events consumed from this package + should be de-duplicated by the htlc's unique combination of incoming and + outgoing channel id and htlc id. [EXPERIMENTAL] + """ + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + class _EventType: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + + class _EventTypeEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[HtlcEvent._EventType.ValueType], builtins.type): # noqa: F821 + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + UNKNOWN: HtlcEvent._EventType.ValueType # 0 + SEND: HtlcEvent._EventType.ValueType # 1 + RECEIVE: HtlcEvent._EventType.ValueType # 2 + FORWARD: HtlcEvent._EventType.ValueType # 3 + + class EventType(_EventType, metaclass=_EventTypeEnumTypeWrapper): ... + UNKNOWN: HtlcEvent.EventType.ValueType # 0 + SEND: HtlcEvent.EventType.ValueType # 1 + RECEIVE: HtlcEvent.EventType.ValueType # 2 + FORWARD: HtlcEvent.EventType.ValueType # 3 + + INCOMING_CHANNEL_ID_FIELD_NUMBER: builtins.int + OUTGOING_CHANNEL_ID_FIELD_NUMBER: builtins.int + INCOMING_HTLC_ID_FIELD_NUMBER: builtins.int + OUTGOING_HTLC_ID_FIELD_NUMBER: builtins.int + TIMESTAMP_NS_FIELD_NUMBER: builtins.int + EVENT_TYPE_FIELD_NUMBER: builtins.int + FORWARD_EVENT_FIELD_NUMBER: builtins.int + FORWARD_FAIL_EVENT_FIELD_NUMBER: builtins.int + SETTLE_EVENT_FIELD_NUMBER: builtins.int + LINK_FAIL_EVENT_FIELD_NUMBER: builtins.int + SUBSCRIBED_EVENT_FIELD_NUMBER: builtins.int + FINAL_HTLC_EVENT_FIELD_NUMBER: builtins.int + incoming_channel_id: builtins.int + """ + The short channel id that the incoming htlc arrived at our node on. This + value is zero for sends. + """ + outgoing_channel_id: builtins.int + """ + The short channel id that the outgoing htlc left our node on. This value + is zero for receives. + """ + incoming_htlc_id: builtins.int + """ + Incoming id is the index of the incoming htlc in the incoming channel. + This value is zero for sends. + """ + outgoing_htlc_id: builtins.int + """ + Outgoing id is the index of the outgoing htlc in the outgoing channel. + This value is zero for receives. + """ + timestamp_ns: builtins.int + """ + The time in unix nanoseconds that the event occurred. + """ + event_type: global___HtlcEvent.EventType.ValueType + """ + The event type indicates whether the htlc was part of a send, receive or + forward. + """ + @property + def forward_event(self) -> global___ForwardEvent: ... + @property + def forward_fail_event(self) -> global___ForwardFailEvent: ... + @property + def settle_event(self) -> global___SettleEvent: ... + @property + def link_fail_event(self) -> global___LinkFailEvent: ... + @property + def subscribed_event(self) -> global___SubscribedEvent: ... + @property + def final_htlc_event(self) -> global___FinalHtlcEvent: ... + def __init__( + self, + *, + incoming_channel_id: builtins.int = ..., + outgoing_channel_id: builtins.int = ..., + incoming_htlc_id: builtins.int = ..., + outgoing_htlc_id: builtins.int = ..., + timestamp_ns: builtins.int = ..., + event_type: global___HtlcEvent.EventType.ValueType = ..., + forward_event: global___ForwardEvent | None = ..., + forward_fail_event: global___ForwardFailEvent | None = ..., + settle_event: global___SettleEvent | None = ..., + link_fail_event: global___LinkFailEvent | None = ..., + subscribed_event: global___SubscribedEvent | None = ..., + final_htlc_event: global___FinalHtlcEvent | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["event", b"event", "final_htlc_event", b"final_htlc_event", "forward_event", b"forward_event", "forward_fail_event", b"forward_fail_event", "link_fail_event", b"link_fail_event", "settle_event", b"settle_event", "subscribed_event", b"subscribed_event"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["event", b"event", "event_type", b"event_type", "final_htlc_event", b"final_htlc_event", "forward_event", b"forward_event", "forward_fail_event", b"forward_fail_event", "incoming_channel_id", b"incoming_channel_id", "incoming_htlc_id", b"incoming_htlc_id", "link_fail_event", b"link_fail_event", "outgoing_channel_id", b"outgoing_channel_id", "outgoing_htlc_id", b"outgoing_htlc_id", "settle_event", b"settle_event", "subscribed_event", b"subscribed_event", "timestamp_ns", b"timestamp_ns"]) -> None: ... + def WhichOneof(self, oneof_group: typing.Literal["event", b"event"]) -> typing.Literal["forward_event", "forward_fail_event", "settle_event", "link_fail_event", "subscribed_event", "final_htlc_event"] | None: ... + +global___HtlcEvent = HtlcEvent + +@typing.final +class HtlcInfo(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + INCOMING_TIMELOCK_FIELD_NUMBER: builtins.int + OUTGOING_TIMELOCK_FIELD_NUMBER: builtins.int + INCOMING_AMT_MSAT_FIELD_NUMBER: builtins.int + OUTGOING_AMT_MSAT_FIELD_NUMBER: builtins.int + incoming_timelock: builtins.int + """The timelock on the incoming htlc.""" + outgoing_timelock: builtins.int + """The timelock on the outgoing htlc.""" + incoming_amt_msat: builtins.int + """The amount of the incoming htlc.""" + outgoing_amt_msat: builtins.int + """The amount of the outgoing htlc.""" + def __init__( + self, + *, + incoming_timelock: builtins.int = ..., + outgoing_timelock: builtins.int = ..., + incoming_amt_msat: builtins.int = ..., + outgoing_amt_msat: builtins.int = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["incoming_amt_msat", b"incoming_amt_msat", "incoming_timelock", b"incoming_timelock", "outgoing_amt_msat", b"outgoing_amt_msat", "outgoing_timelock", b"outgoing_timelock"]) -> None: ... + +global___HtlcInfo = HtlcInfo + +@typing.final +class ForwardEvent(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + INFO_FIELD_NUMBER: builtins.int + @property + def info(self) -> global___HtlcInfo: + """Info contains details about the htlc that was forwarded.""" + + def __init__( + self, + *, + info: global___HtlcInfo | None = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["info", b"info"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["info", b"info"]) -> None: ... + +global___ForwardEvent = ForwardEvent + +@typing.final +class ForwardFailEvent(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +global___ForwardFailEvent = ForwardFailEvent + +@typing.final +class SettleEvent(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + PREIMAGE_FIELD_NUMBER: builtins.int + preimage: builtins.bytes + """The revealed preimage.""" + def __init__( + self, + *, + preimage: builtins.bytes = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["preimage", b"preimage"]) -> None: ... + +global___SettleEvent = SettleEvent + +@typing.final +class FinalHtlcEvent(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + SETTLED_FIELD_NUMBER: builtins.int + OFFCHAIN_FIELD_NUMBER: builtins.int + settled: builtins.bool + offchain: builtins.bool + def __init__( + self, + *, + settled: builtins.bool = ..., + offchain: builtins.bool = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["offchain", b"offchain", "settled", b"settled"]) -> None: ... + +global___FinalHtlcEvent = FinalHtlcEvent + +@typing.final +class SubscribedEvent(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +global___SubscribedEvent = SubscribedEvent + +@typing.final +class LinkFailEvent(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + INFO_FIELD_NUMBER: builtins.int + WIRE_FAILURE_FIELD_NUMBER: builtins.int + FAILURE_DETAIL_FIELD_NUMBER: builtins.int + FAILURE_STRING_FIELD_NUMBER: builtins.int + wire_failure: cashu.lightning.lnd_grpc.protos.lightning_pb2.Failure.FailureCode.ValueType + """FailureCode is the BOLT error code for the failure.""" + failure_detail: global___FailureDetail.ValueType + """ + FailureDetail provides additional information about the reason for the + failure. This detail enriches the information provided by the wire message + and may be 'no detail' if the wire message requires no additional metadata. + """ + failure_string: builtins.str + """A string representation of the link failure.""" + @property + def info(self) -> global___HtlcInfo: + """Info contains details about the htlc that we failed.""" + + def __init__( + self, + *, + info: global___HtlcInfo | None = ..., + wire_failure: cashu.lightning.lnd_grpc.protos.lightning_pb2.Failure.FailureCode.ValueType = ..., + failure_detail: global___FailureDetail.ValueType = ..., + failure_string: builtins.str = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["info", b"info"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["failure_detail", b"failure_detail", "failure_string", b"failure_string", "info", b"info", "wire_failure", b"wire_failure"]) -> None: ... + +global___LinkFailEvent = LinkFailEvent + +@typing.final +class PaymentStatus(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + STATE_FIELD_NUMBER: builtins.int + PREIMAGE_FIELD_NUMBER: builtins.int + HTLCS_FIELD_NUMBER: builtins.int + state: global___PaymentState.ValueType + """Current state the payment is in.""" + preimage: builtins.bytes + """ + The pre-image of the payment when state is SUCCEEDED. + """ + @property + def htlcs(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[cashu.lightning.lnd_grpc.protos.lightning_pb2.HTLCAttempt]: + """ + The HTLCs made in attempt to settle the payment [EXPERIMENTAL]. + """ + + def __init__( + self, + *, + state: global___PaymentState.ValueType = ..., + preimage: builtins.bytes = ..., + htlcs: collections.abc.Iterable[cashu.lightning.lnd_grpc.protos.lightning_pb2.HTLCAttempt] | None = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["htlcs", b"htlcs", "preimage", b"preimage", "state", b"state"]) -> None: ... + +global___PaymentStatus = PaymentStatus + +@typing.final +class CircuitKey(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + CHAN_ID_FIELD_NUMBER: builtins.int + HTLC_ID_FIELD_NUMBER: builtins.int + chan_id: builtins.int + """/ The id of the channel that the is part of this circuit.""" + htlc_id: builtins.int + """/ The index of the incoming htlc in the incoming channel.""" + def __init__( + self, + *, + chan_id: builtins.int = ..., + htlc_id: builtins.int = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["chan_id", b"chan_id", "htlc_id", b"htlc_id"]) -> None: ... + +global___CircuitKey = CircuitKey + +@typing.final +class ForwardHtlcInterceptRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + @typing.final + class CustomRecordsEntry(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + KEY_FIELD_NUMBER: builtins.int + VALUE_FIELD_NUMBER: builtins.int + key: builtins.int + value: builtins.bytes + def __init__( + self, + *, + key: builtins.int = ..., + value: builtins.bytes = ..., + ) -> None: ... + def ClearField(self, field_name: typing.Literal["key", b"key", "value", b"value"]) -> None: ... + + INCOMING_CIRCUIT_KEY_FIELD_NUMBER: builtins.int + INCOMING_AMOUNT_MSAT_FIELD_NUMBER: builtins.int + INCOMING_EXPIRY_FIELD_NUMBER: builtins.int + PAYMENT_HASH_FIELD_NUMBER: builtins.int + OUTGOING_REQUESTED_CHAN_ID_FIELD_NUMBER: builtins.int + OUTGOING_AMOUNT_MSAT_FIELD_NUMBER: builtins.int + OUTGOING_EXPIRY_FIELD_NUMBER: builtins.int + CUSTOM_RECORDS_FIELD_NUMBER: builtins.int + ONION_BLOB_FIELD_NUMBER: builtins.int + AUTO_FAIL_HEIGHT_FIELD_NUMBER: builtins.int + incoming_amount_msat: builtins.int + """The incoming htlc amount.""" + incoming_expiry: builtins.int + """The incoming htlc expiry.""" + payment_hash: builtins.bytes + """ + The htlc payment hash. This value is not guaranteed to be unique per + request. + """ + outgoing_requested_chan_id: builtins.int + """The requested outgoing channel id for this forwarded htlc. Because of + non-strict forwarding, this isn't necessarily the channel over which the + packet will be forwarded eventually. A different channel to the same peer + may be selected as well. + """ + outgoing_amount_msat: builtins.int + """The outgoing htlc amount.""" + outgoing_expiry: builtins.int + """The outgoing htlc expiry.""" + onion_blob: builtins.bytes + """The onion blob for the next hop""" + auto_fail_height: builtins.int + """The block height at which this htlc will be auto-failed to prevent the + channel from force-closing. + """ + @property + def incoming_circuit_key(self) -> global___CircuitKey: + """ + The key of this forwarded htlc. It defines the incoming channel id and + the index in this channel. + """ + + @property + def custom_records(self) -> google.protobuf.internal.containers.ScalarMap[builtins.int, builtins.bytes]: + """Any custom records that were present in the payload.""" + + def __init__( + self, + *, + incoming_circuit_key: global___CircuitKey | None = ..., + incoming_amount_msat: builtins.int = ..., + incoming_expiry: builtins.int = ..., + payment_hash: builtins.bytes = ..., + outgoing_requested_chan_id: builtins.int = ..., + outgoing_amount_msat: builtins.int = ..., + outgoing_expiry: builtins.int = ..., + custom_records: collections.abc.Mapping[builtins.int, builtins.bytes] | None = ..., + onion_blob: builtins.bytes = ..., + auto_fail_height: builtins.int = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["incoming_circuit_key", b"incoming_circuit_key"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["auto_fail_height", b"auto_fail_height", "custom_records", b"custom_records", "incoming_amount_msat", b"incoming_amount_msat", "incoming_circuit_key", b"incoming_circuit_key", "incoming_expiry", b"incoming_expiry", "onion_blob", b"onion_blob", "outgoing_amount_msat", b"outgoing_amount_msat", "outgoing_expiry", b"outgoing_expiry", "outgoing_requested_chan_id", b"outgoing_requested_chan_id", "payment_hash", b"payment_hash"]) -> None: ... + +global___ForwardHtlcInterceptRequest = ForwardHtlcInterceptRequest + +@typing.final +class ForwardHtlcInterceptResponse(google.protobuf.message.Message): + """* + ForwardHtlcInterceptResponse enables the caller to resolve a previously hold + forward. The caller can choose either to: + - `Resume`: Execute the default behavior (usually forward). + - `Reject`: Fail the htlc backwards. + - `Settle`: Settle this htlc with a given preimage. + """ + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + INCOMING_CIRCUIT_KEY_FIELD_NUMBER: builtins.int + ACTION_FIELD_NUMBER: builtins.int + PREIMAGE_FIELD_NUMBER: builtins.int + FAILURE_MESSAGE_FIELD_NUMBER: builtins.int + FAILURE_CODE_FIELD_NUMBER: builtins.int + action: global___ResolveHoldForwardAction.ValueType + """The resolve action for this intercepted htlc.""" + preimage: builtins.bytes + """The preimage in case the resolve action is Settle.""" + failure_message: builtins.bytes + """Encrypted failure message in case the resolve action is Fail. + + If failure_message is specified, the failure_code field must be set + to zero. + """ + failure_code: cashu.lightning.lnd_grpc.protos.lightning_pb2.Failure.FailureCode.ValueType + """Return the specified failure code in case the resolve action is Fail. The + message data fields are populated automatically. + + If a non-zero failure_code is specified, failure_message must not be set. + + For backwards-compatibility reasons, TEMPORARY_CHANNEL_FAILURE is the + default value for this field. + """ + @property + def incoming_circuit_key(self) -> global___CircuitKey: + """* + The key of this forwarded htlc. It defines the incoming channel id and + the index in this channel. + """ + + def __init__( + self, + *, + incoming_circuit_key: global___CircuitKey | None = ..., + action: global___ResolveHoldForwardAction.ValueType = ..., + preimage: builtins.bytes = ..., + failure_message: builtins.bytes = ..., + failure_code: cashu.lightning.lnd_grpc.protos.lightning_pb2.Failure.FailureCode.ValueType = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["incoming_circuit_key", b"incoming_circuit_key"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["action", b"action", "failure_code", b"failure_code", "failure_message", b"failure_message", "incoming_circuit_key", b"incoming_circuit_key", "preimage", b"preimage"]) -> None: ... + +global___ForwardHtlcInterceptResponse = ForwardHtlcInterceptResponse + +@typing.final +class UpdateChanStatusRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + CHAN_POINT_FIELD_NUMBER: builtins.int + ACTION_FIELD_NUMBER: builtins.int + action: global___ChanStatusAction.ValueType + @property + def chan_point(self) -> cashu.lightning.lnd_grpc.protos.lightning_pb2.ChannelPoint: ... + def __init__( + self, + *, + chan_point: cashu.lightning.lnd_grpc.protos.lightning_pb2.ChannelPoint | None = ..., + action: global___ChanStatusAction.ValueType = ..., + ) -> None: ... + def HasField(self, field_name: typing.Literal["chan_point", b"chan_point"]) -> builtins.bool: ... + def ClearField(self, field_name: typing.Literal["action", b"action", "chan_point", b"chan_point"]) -> None: ... + +global___UpdateChanStatusRequest = UpdateChanStatusRequest + +@typing.final +class UpdateChanStatusResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +global___UpdateChanStatusResponse = UpdateChanStatusResponse diff --git a/cashu/lightning/lnd_grpc/protos/router_pb2_grpc.py b/cashu/lightning/lnd_grpc/protos/router_pb2_grpc.py new file mode 100644 index 00000000..39fac1fd --- /dev/null +++ b/cashu/lightning/lnd_grpc/protos/router_pb2_grpc.py @@ -0,0 +1,972 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" +import warnings + +import grpc + +import cashu.lightning.lnd_grpc.protos.lightning_pb2 as lightning__pb2 +import cashu.lightning.lnd_grpc.protos.router_pb2 as router__pb2 + +GRPC_GENERATED_VERSION = '1.63.0' +GRPC_VERSION = grpc.__version__ +EXPECTED_ERROR_RELEASE = '1.65.0' +SCHEDULED_RELEASE_DATE = 'June 25, 2024' +_version_not_supported = False + +try: + from grpc._utilities import first_version_is_lower + _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION) +except ImportError: + _version_not_supported = True + +if _version_not_supported: + warnings.warn( + f'The grpc package installed is at version {GRPC_VERSION},' + + ' but the generated code in cashu.lightning.lnd_grpc.protos.router_pb2_grpc.py depends on' + + f' grpcio>={GRPC_GENERATED_VERSION}.' + + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}' + + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.' + + f' This warning will become an error in {EXPECTED_ERROR_RELEASE},' + + f' scheduled for release on {SCHEDULED_RELEASE_DATE}.', + RuntimeWarning + ) + + +class RouterStub(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. + + 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 + + Router is a service that offers advanced interaction with the router + subsystem of the daemon. + """ + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.SendPaymentV2 = channel.unary_stream( + '/routerrpc.Router/SendPaymentV2', + request_serializer=router__pb2.SendPaymentRequest.SerializeToString, + response_deserializer=lightning__pb2.Payment.FromString, + _registered_method=True) + self.TrackPaymentV2 = channel.unary_stream( + '/routerrpc.Router/TrackPaymentV2', + request_serializer=router__pb2.TrackPaymentRequest.SerializeToString, + response_deserializer=lightning__pb2.Payment.FromString, + _registered_method=True) + self.TrackPayments = channel.unary_stream( + '/routerrpc.Router/TrackPayments', + request_serializer=router__pb2.TrackPaymentsRequest.SerializeToString, + response_deserializer=lightning__pb2.Payment.FromString, + _registered_method=True) + self.EstimateRouteFee = channel.unary_unary( + '/routerrpc.Router/EstimateRouteFee', + request_serializer=router__pb2.RouteFeeRequest.SerializeToString, + response_deserializer=router__pb2.RouteFeeResponse.FromString, + _registered_method=True) + self.SendToRoute = channel.unary_unary( + '/routerrpc.Router/SendToRoute', + request_serializer=router__pb2.SendToRouteRequest.SerializeToString, + response_deserializer=router__pb2.SendToRouteResponse.FromString, + _registered_method=True) + self.SendToRouteV2 = channel.unary_unary( + '/routerrpc.Router/SendToRouteV2', + request_serializer=router__pb2.SendToRouteRequest.SerializeToString, + response_deserializer=lightning__pb2.HTLCAttempt.FromString, + _registered_method=True) + self.ResetMissionControl = channel.unary_unary( + '/routerrpc.Router/ResetMissionControl', + request_serializer=router__pb2.ResetMissionControlRequest.SerializeToString, + response_deserializer=router__pb2.ResetMissionControlResponse.FromString, + _registered_method=True) + self.QueryMissionControl = channel.unary_unary( + '/routerrpc.Router/QueryMissionControl', + request_serializer=router__pb2.QueryMissionControlRequest.SerializeToString, + response_deserializer=router__pb2.QueryMissionControlResponse.FromString, + _registered_method=True) + self.XImportMissionControl = channel.unary_unary( + '/routerrpc.Router/XImportMissionControl', + request_serializer=router__pb2.XImportMissionControlRequest.SerializeToString, + response_deserializer=router__pb2.XImportMissionControlResponse.FromString, + _registered_method=True) + self.GetMissionControlConfig = channel.unary_unary( + '/routerrpc.Router/GetMissionControlConfig', + request_serializer=router__pb2.GetMissionControlConfigRequest.SerializeToString, + response_deserializer=router__pb2.GetMissionControlConfigResponse.FromString, + _registered_method=True) + self.SetMissionControlConfig = channel.unary_unary( + '/routerrpc.Router/SetMissionControlConfig', + request_serializer=router__pb2.SetMissionControlConfigRequest.SerializeToString, + response_deserializer=router__pb2.SetMissionControlConfigResponse.FromString, + _registered_method=True) + self.QueryProbability = channel.unary_unary( + '/routerrpc.Router/QueryProbability', + request_serializer=router__pb2.QueryProbabilityRequest.SerializeToString, + response_deserializer=router__pb2.QueryProbabilityResponse.FromString, + _registered_method=True) + self.BuildRoute = channel.unary_unary( + '/routerrpc.Router/BuildRoute', + request_serializer=router__pb2.BuildRouteRequest.SerializeToString, + response_deserializer=router__pb2.BuildRouteResponse.FromString, + _registered_method=True) + self.SubscribeHtlcEvents = channel.unary_stream( + '/routerrpc.Router/SubscribeHtlcEvents', + request_serializer=router__pb2.SubscribeHtlcEventsRequest.SerializeToString, + response_deserializer=router__pb2.HtlcEvent.FromString, + _registered_method=True) + self.SendPayment = channel.unary_stream( + '/routerrpc.Router/SendPayment', + request_serializer=router__pb2.SendPaymentRequest.SerializeToString, + response_deserializer=router__pb2.PaymentStatus.FromString, + _registered_method=True) + self.TrackPayment = channel.unary_stream( + '/routerrpc.Router/TrackPayment', + request_serializer=router__pb2.TrackPaymentRequest.SerializeToString, + response_deserializer=router__pb2.PaymentStatus.FromString, + _registered_method=True) + self.HtlcInterceptor = channel.stream_stream( + '/routerrpc.Router/HtlcInterceptor', + request_serializer=router__pb2.ForwardHtlcInterceptResponse.SerializeToString, + response_deserializer=router__pb2.ForwardHtlcInterceptRequest.FromString, + _registered_method=True) + self.UpdateChanStatus = channel.unary_unary( + '/routerrpc.Router/UpdateChanStatus', + request_serializer=router__pb2.UpdateChanStatusRequest.SerializeToString, + response_deserializer=router__pb2.UpdateChanStatusResponse.FromString, + _registered_method=True) + + +class RouterServicer(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. + + 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 + + Router is a service that offers advanced interaction with the router + subsystem of the daemon. + """ + + def SendPaymentV2(self, request, context): + """ + SendPaymentV2 attempts to route a payment described by the passed + PaymentRequest to the final destination. The call returns a stream of + payment updates. When using this RPC, make sure to set a fee limit, as the + default routing fee limit is 0 sats. Without a non-zero fee limit only + routes without fees will be attempted which often fails with + FAILURE_REASON_NO_ROUTE. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def TrackPaymentV2(self, request, context): + """lncli: `trackpayment` + TrackPaymentV2 returns an update stream for the payment identified by the + payment hash. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def TrackPayments(self, request, context): + """ + TrackPayments returns an update stream for every payment that is not in a + terminal state. Note that if payments are in-flight while starting a new + subscription, the start of the payment stream could produce out-of-order + and/or duplicate events. In order to get updates for every in-flight + payment attempt make sure to subscribe to this method before initiating any + payments. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def EstimateRouteFee(self, request, context): + """ + EstimateRouteFee allows callers to obtain a lower bound w.r.t how much it + may cost to send an HTLC to the target end destination. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SendToRoute(self, request, context): + """ + Deprecated, use SendToRouteV2. SendToRoute attempts to make a payment via + the specified route. 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. It differs from the newer + SendToRouteV2 in that it doesn't return the full HTLC information. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SendToRouteV2(self, request, context): + """ + SendToRouteV2 attempts to make a payment via the specified route. 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 ResetMissionControl(self, request, context): + """lncli: `resetmc` + ResetMissionControl clears all mission control state and starts with a clean + slate. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def QueryMissionControl(self, request, context): + """lncli: `querymc` + QueryMissionControl exposes the internal mission control state to callers. + It is a development feature. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def XImportMissionControl(self, request, context): + """lncli: `importmc` + XImportMissionControl is an experimental API that imports the state provided + to the internal mission control's state, using all results which are more + recent than our existing values. These values will only be imported + in-memory, and will not be persisted across restarts. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetMissionControlConfig(self, request, context): + """lncli: `getmccfg` + GetMissionControlConfig returns mission control's current config. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SetMissionControlConfig(self, request, context): + """lncli: `setmccfg` + SetMissionControlConfig will set mission control's config, if the config + provided is valid. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def QueryProbability(self, request, context): + """lncli: `queryprob` + Deprecated. QueryProbability returns the current success probability + estimate for a given node pair and amount. The call returns a zero success + probability if no channel is available or if the amount violates min/max + HTLC constraints. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def BuildRoute(self, request, context): + """lncli: `buildroute` + BuildRoute builds a fully specified route based on a list of hop public + keys. It retrieves the relevant channel policies from the graph in order to + calculate the correct fees and time locks. + Note that LND will use its default final_cltv_delta if no value is supplied. + Make sure to add the correct final_cltv_delta depending on the invoice + restriction. Moreover the caller has to make sure to provide the + payment_addr if the route is paying an invoice which signaled it. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SubscribeHtlcEvents(self, request, context): + """ + SubscribeHtlcEvents creates a uni-directional stream from the server to + the client which delivers a stream of htlc events. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SendPayment(self, request, context): + """ + Deprecated, use SendPaymentV2. SendPayment attempts to route a payment + described by the passed PaymentRequest to the final destination. The call + returns a stream of payment status updates. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def TrackPayment(self, request, context): + """ + Deprecated, use TrackPaymentV2. TrackPayment returns an update stream for + the payment identified by the payment hash. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def HtlcInterceptor(self, request_iterator, context): + """* + HtlcInterceptor dispatches a bi-directional streaming RPC in which + Forwarded HTLC requests are sent to the client and the client responds with + a boolean that tells LND if this htlc should be intercepted. + In case of interception, the htlc can be either settled, cancelled or + resumed later by using the ResolveHoldForward endpoint. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def UpdateChanStatus(self, request, context): + """lncli: `updatechanstatus` + UpdateChanStatus attempts to manually set the state of a channel + (enabled, disabled, or auto). A manual "disable" request will cause the + channel to stay disabled until a subsequent manual request of either + "enable" or "auto". + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_RouterServicer_to_server(servicer, server): + rpc_method_handlers = { + 'SendPaymentV2': grpc.unary_stream_rpc_method_handler( + servicer.SendPaymentV2, + request_deserializer=router__pb2.SendPaymentRequest.FromString, + response_serializer=lightning__pb2.Payment.SerializeToString, + ), + 'TrackPaymentV2': grpc.unary_stream_rpc_method_handler( + servicer.TrackPaymentV2, + request_deserializer=router__pb2.TrackPaymentRequest.FromString, + response_serializer=lightning__pb2.Payment.SerializeToString, + ), + 'TrackPayments': grpc.unary_stream_rpc_method_handler( + servicer.TrackPayments, + request_deserializer=router__pb2.TrackPaymentsRequest.FromString, + response_serializer=lightning__pb2.Payment.SerializeToString, + ), + 'EstimateRouteFee': grpc.unary_unary_rpc_method_handler( + servicer.EstimateRouteFee, + request_deserializer=router__pb2.RouteFeeRequest.FromString, + response_serializer=router__pb2.RouteFeeResponse.SerializeToString, + ), + 'SendToRoute': grpc.unary_unary_rpc_method_handler( + servicer.SendToRoute, + request_deserializer=router__pb2.SendToRouteRequest.FromString, + response_serializer=router__pb2.SendToRouteResponse.SerializeToString, + ), + 'SendToRouteV2': grpc.unary_unary_rpc_method_handler( + servicer.SendToRouteV2, + request_deserializer=router__pb2.SendToRouteRequest.FromString, + response_serializer=lightning__pb2.HTLCAttempt.SerializeToString, + ), + 'ResetMissionControl': grpc.unary_unary_rpc_method_handler( + servicer.ResetMissionControl, + request_deserializer=router__pb2.ResetMissionControlRequest.FromString, + response_serializer=router__pb2.ResetMissionControlResponse.SerializeToString, + ), + 'QueryMissionControl': grpc.unary_unary_rpc_method_handler( + servicer.QueryMissionControl, + request_deserializer=router__pb2.QueryMissionControlRequest.FromString, + response_serializer=router__pb2.QueryMissionControlResponse.SerializeToString, + ), + 'XImportMissionControl': grpc.unary_unary_rpc_method_handler( + servicer.XImportMissionControl, + request_deserializer=router__pb2.XImportMissionControlRequest.FromString, + response_serializer=router__pb2.XImportMissionControlResponse.SerializeToString, + ), + 'GetMissionControlConfig': grpc.unary_unary_rpc_method_handler( + servicer.GetMissionControlConfig, + request_deserializer=router__pb2.GetMissionControlConfigRequest.FromString, + response_serializer=router__pb2.GetMissionControlConfigResponse.SerializeToString, + ), + 'SetMissionControlConfig': grpc.unary_unary_rpc_method_handler( + servicer.SetMissionControlConfig, + request_deserializer=router__pb2.SetMissionControlConfigRequest.FromString, + response_serializer=router__pb2.SetMissionControlConfigResponse.SerializeToString, + ), + 'QueryProbability': grpc.unary_unary_rpc_method_handler( + servicer.QueryProbability, + request_deserializer=router__pb2.QueryProbabilityRequest.FromString, + response_serializer=router__pb2.QueryProbabilityResponse.SerializeToString, + ), + 'BuildRoute': grpc.unary_unary_rpc_method_handler( + servicer.BuildRoute, + request_deserializer=router__pb2.BuildRouteRequest.FromString, + response_serializer=router__pb2.BuildRouteResponse.SerializeToString, + ), + 'SubscribeHtlcEvents': grpc.unary_stream_rpc_method_handler( + servicer.SubscribeHtlcEvents, + request_deserializer=router__pb2.SubscribeHtlcEventsRequest.FromString, + response_serializer=router__pb2.HtlcEvent.SerializeToString, + ), + 'SendPayment': grpc.unary_stream_rpc_method_handler( + servicer.SendPayment, + request_deserializer=router__pb2.SendPaymentRequest.FromString, + response_serializer=router__pb2.PaymentStatus.SerializeToString, + ), + 'TrackPayment': grpc.unary_stream_rpc_method_handler( + servicer.TrackPayment, + request_deserializer=router__pb2.TrackPaymentRequest.FromString, + response_serializer=router__pb2.PaymentStatus.SerializeToString, + ), + 'HtlcInterceptor': grpc.stream_stream_rpc_method_handler( + servicer.HtlcInterceptor, + request_deserializer=router__pb2.ForwardHtlcInterceptResponse.FromString, + response_serializer=router__pb2.ForwardHtlcInterceptRequest.SerializeToString, + ), + 'UpdateChanStatus': grpc.unary_unary_rpc_method_handler( + servicer.UpdateChanStatus, + request_deserializer=router__pb2.UpdateChanStatusRequest.FromString, + response_serializer=router__pb2.UpdateChanStatusResponse.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'routerrpc.Router', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + # This class is part of an EXPERIMENTAL API. +class Router(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. + + 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 + + Router is a service that offers advanced interaction with the router + subsystem of the daemon. + """ + + @staticmethod + def SendPaymentV2(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_stream( + request, + target, + '/routerrpc.Router/SendPaymentV2', + router__pb2.SendPaymentRequest.SerializeToString, + lightning__pb2.Payment.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def TrackPaymentV2(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_stream( + request, + target, + '/routerrpc.Router/TrackPaymentV2', + router__pb2.TrackPaymentRequest.SerializeToString, + lightning__pb2.Payment.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def TrackPayments(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_stream( + request, + target, + '/routerrpc.Router/TrackPayments', + router__pb2.TrackPaymentsRequest.SerializeToString, + lightning__pb2.Payment.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def EstimateRouteFee(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/routerrpc.Router/EstimateRouteFee', + router__pb2.RouteFeeRequest.SerializeToString, + router__pb2.RouteFeeResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SendToRoute(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/routerrpc.Router/SendToRoute', + router__pb2.SendToRouteRequest.SerializeToString, + router__pb2.SendToRouteResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SendToRouteV2(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/routerrpc.Router/SendToRouteV2', + router__pb2.SendToRouteRequest.SerializeToString, + lightning__pb2.HTLCAttempt.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def ResetMissionControl(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/routerrpc.Router/ResetMissionControl', + router__pb2.ResetMissionControlRequest.SerializeToString, + router__pb2.ResetMissionControlResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def QueryMissionControl(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/routerrpc.Router/QueryMissionControl', + router__pb2.QueryMissionControlRequest.SerializeToString, + router__pb2.QueryMissionControlResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def XImportMissionControl(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/routerrpc.Router/XImportMissionControl', + router__pb2.XImportMissionControlRequest.SerializeToString, + router__pb2.XImportMissionControlResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def GetMissionControlConfig(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/routerrpc.Router/GetMissionControlConfig', + router__pb2.GetMissionControlConfigRequest.SerializeToString, + router__pb2.GetMissionControlConfigResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SetMissionControlConfig(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/routerrpc.Router/SetMissionControlConfig', + router__pb2.SetMissionControlConfigRequest.SerializeToString, + router__pb2.SetMissionControlConfigResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def QueryProbability(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/routerrpc.Router/QueryProbability', + router__pb2.QueryProbabilityRequest.SerializeToString, + router__pb2.QueryProbabilityResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def BuildRoute(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/routerrpc.Router/BuildRoute', + router__pb2.BuildRouteRequest.SerializeToString, + router__pb2.BuildRouteResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SubscribeHtlcEvents(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_stream( + request, + target, + '/routerrpc.Router/SubscribeHtlcEvents', + router__pb2.SubscribeHtlcEventsRequest.SerializeToString, + router__pb2.HtlcEvent.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def SendPayment(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_stream( + request, + target, + '/routerrpc.Router/SendPayment', + router__pb2.SendPaymentRequest.SerializeToString, + router__pb2.PaymentStatus.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def TrackPayment(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_stream( + request, + target, + '/routerrpc.Router/TrackPayment', + router__pb2.TrackPaymentRequest.SerializeToString, + router__pb2.PaymentStatus.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def HtlcInterceptor(request_iterator, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.stream_stream( + request_iterator, + target, + '/routerrpc.Router/HtlcInterceptor', + router__pb2.ForwardHtlcInterceptResponse.SerializeToString, + router__pb2.ForwardHtlcInterceptRequest.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) + + @staticmethod + def UpdateChanStatus(request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None): + return grpc.experimental.unary_unary( + request, + target, + '/routerrpc.Router/UpdateChanStatus', + router__pb2.UpdateChanStatusRequest.SerializeToString, + router__pb2.UpdateChanStatusResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + _registered_method=True) diff --git a/cashu/lightning/lnd_grpc/protos/router_pb2_grpc.pyi b/cashu/lightning/lnd_grpc/protos/router_pb2_grpc.pyi new file mode 100644 index 00000000..b520b8ef --- /dev/null +++ b/cashu/lightning/lnd_grpc/protos/router_pb2_grpc.pyi @@ -0,0 +1,693 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import abc +import collections.abc +import typing + +import grpc +import grpc.aio + +import cashu.lightning.lnd_grpc.protos.lightning_pb2 +import cashu.lightning.lnd_grpc.protos.router_pb2 + +_T = typing.TypeVar("_T") + +class _MaybeAsyncIterator(collections.abc.AsyncIterator[_T], collections.abc.Iterator[_T], metaclass=abc.ABCMeta): ... + +class _ServicerContext(grpc.ServicerContext, grpc.aio.ServicerContext): # type: ignore[misc, type-arg] + ... + +class RouterStub: + """ + 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. + + 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 + + Router is a service that offers advanced interaction with the router + subsystem of the daemon. + """ + + def __init__(self, channel: typing.Union[grpc.Channel, grpc.aio.Channel]) -> None: ... + SendPaymentV2: grpc.UnaryStreamMultiCallable[ + cashu.lightning.lnd_grpc.protos.router_pb2.SendPaymentRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.Payment, + ] + """ + SendPaymentV2 attempts to route a payment described by the passed + PaymentRequest to the final destination. The call returns a stream of + payment updates. When using this RPC, make sure to set a fee limit, as the + default routing fee limit is 0 sats. Without a non-zero fee limit only + routes without fees will be attempted which often fails with + FAILURE_REASON_NO_ROUTE. + """ + + TrackPaymentV2: grpc.UnaryStreamMultiCallable[ + cashu.lightning.lnd_grpc.protos.router_pb2.TrackPaymentRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.Payment, + ] + """lncli: `trackpayment` + TrackPaymentV2 returns an update stream for the payment identified by the + payment hash. + """ + + TrackPayments: grpc.UnaryStreamMultiCallable[ + cashu.lightning.lnd_grpc.protos.router_pb2.TrackPaymentsRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.Payment, + ] + """ + TrackPayments returns an update stream for every payment that is not in a + terminal state. Note that if payments are in-flight while starting a new + subscription, the start of the payment stream could produce out-of-order + and/or duplicate events. In order to get updates for every in-flight + payment attempt make sure to subscribe to this method before initiating any + payments. + """ + + EstimateRouteFee: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.router_pb2.RouteFeeRequest, + cashu.lightning.lnd_grpc.protos.router_pb2.RouteFeeResponse, + ] + """ + EstimateRouteFee allows callers to obtain a lower bound w.r.t how much it + may cost to send an HTLC to the target end destination. + """ + + SendToRoute: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.router_pb2.SendToRouteRequest, + cashu.lightning.lnd_grpc.protos.router_pb2.SendToRouteResponse, + ] + """ + Deprecated, use SendToRouteV2. SendToRoute attempts to make a payment via + the specified route. 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. It differs from the newer + SendToRouteV2 in that it doesn't return the full HTLC information. + """ + + SendToRouteV2: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.router_pb2.SendToRouteRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.HTLCAttempt, + ] + """ + SendToRouteV2 attempts to make a payment via the specified route. 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. + """ + + ResetMissionControl: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.router_pb2.ResetMissionControlRequest, + cashu.lightning.lnd_grpc.protos.router_pb2.ResetMissionControlResponse, + ] + """lncli: `resetmc` + ResetMissionControl clears all mission control state and starts with a clean + slate. + """ + + QueryMissionControl: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.router_pb2.QueryMissionControlRequest, + cashu.lightning.lnd_grpc.protos.router_pb2.QueryMissionControlResponse, + ] + """lncli: `querymc` + QueryMissionControl exposes the internal mission control state to callers. + It is a development feature. + """ + + XImportMissionControl: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.router_pb2.XImportMissionControlRequest, + cashu.lightning.lnd_grpc.protos.router_pb2.XImportMissionControlResponse, + ] + """lncli: `importmc` + XImportMissionControl is an experimental API that imports the state provided + to the internal mission control's state, using all results which are more + recent than our existing values. These values will only be imported + in-memory, and will not be persisted across restarts. + """ + + GetMissionControlConfig: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.router_pb2.GetMissionControlConfigRequest, + cashu.lightning.lnd_grpc.protos.router_pb2.GetMissionControlConfigResponse, + ] + """lncli: `getmccfg` + GetMissionControlConfig returns mission control's current config. + """ + + SetMissionControlConfig: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.router_pb2.SetMissionControlConfigRequest, + cashu.lightning.lnd_grpc.protos.router_pb2.SetMissionControlConfigResponse, + ] + """lncli: `setmccfg` + SetMissionControlConfig will set mission control's config, if the config + provided is valid. + """ + + QueryProbability: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.router_pb2.QueryProbabilityRequest, + cashu.lightning.lnd_grpc.protos.router_pb2.QueryProbabilityResponse, + ] + """lncli: `queryprob` + Deprecated. QueryProbability returns the current success probability + estimate for a given node pair and amount. The call returns a zero success + probability if no channel is available or if the amount violates min/max + HTLC constraints. + """ + + BuildRoute: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.router_pb2.BuildRouteRequest, + cashu.lightning.lnd_grpc.protos.router_pb2.BuildRouteResponse, + ] + """lncli: `buildroute` + BuildRoute builds a fully specified route based on a list of hop public + keys. It retrieves the relevant channel policies from the graph in order to + calculate the correct fees and time locks. + Note that LND will use its default final_cltv_delta if no value is supplied. + Make sure to add the correct final_cltv_delta depending on the invoice + restriction. Moreover the caller has to make sure to provide the + payment_addr if the route is paying an invoice which signaled it. + """ + + SubscribeHtlcEvents: grpc.UnaryStreamMultiCallable[ + cashu.lightning.lnd_grpc.protos.router_pb2.SubscribeHtlcEventsRequest, + cashu.lightning.lnd_grpc.protos.router_pb2.HtlcEvent, + ] + """ + SubscribeHtlcEvents creates a uni-directional stream from the server to + the client which delivers a stream of htlc events. + """ + + SendPayment: grpc.UnaryStreamMultiCallable[ + cashu.lightning.lnd_grpc.protos.router_pb2.SendPaymentRequest, + cashu.lightning.lnd_grpc.protos.router_pb2.PaymentStatus, + ] + """ + Deprecated, use SendPaymentV2. SendPayment attempts to route a payment + described by the passed PaymentRequest to the final destination. The call + returns a stream of payment status updates. + """ + + TrackPayment: grpc.UnaryStreamMultiCallable[ + cashu.lightning.lnd_grpc.protos.router_pb2.TrackPaymentRequest, + cashu.lightning.lnd_grpc.protos.router_pb2.PaymentStatus, + ] + """ + Deprecated, use TrackPaymentV2. TrackPayment returns an update stream for + the payment identified by the payment hash. + """ + + HtlcInterceptor: grpc.StreamStreamMultiCallable[ + cashu.lightning.lnd_grpc.protos.router_pb2.ForwardHtlcInterceptResponse, + cashu.lightning.lnd_grpc.protos.router_pb2.ForwardHtlcInterceptRequest, + ] + """* + HtlcInterceptor dispatches a bi-directional streaming RPC in which + Forwarded HTLC requests are sent to the client and the client responds with + a boolean that tells LND if this htlc should be intercepted. + In case of interception, the htlc can be either settled, cancelled or + resumed later by using the ResolveHoldForward endpoint. + """ + + UpdateChanStatus: grpc.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.router_pb2.UpdateChanStatusRequest, + cashu.lightning.lnd_grpc.protos.router_pb2.UpdateChanStatusResponse, + ] + """lncli: `updatechanstatus` + UpdateChanStatus attempts to manually set the state of a channel + (enabled, disabled, or auto). A manual "disable" request will cause the + channel to stay disabled until a subsequent manual request of either + "enable" or "auto". + """ + +class RouterAsyncStub: + """ + 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. + + 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 + + Router is a service that offers advanced interaction with the router + subsystem of the daemon. + """ + + SendPaymentV2: grpc.aio.UnaryStreamMultiCallable[ + cashu.lightning.lnd_grpc.protos.router_pb2.SendPaymentRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.Payment, + ] + """ + SendPaymentV2 attempts to route a payment described by the passed + PaymentRequest to the final destination. The call returns a stream of + payment updates. When using this RPC, make sure to set a fee limit, as the + default routing fee limit is 0 sats. Without a non-zero fee limit only + routes without fees will be attempted which often fails with + FAILURE_REASON_NO_ROUTE. + """ + + TrackPaymentV2: grpc.aio.UnaryStreamMultiCallable[ + cashu.lightning.lnd_grpc.protos.router_pb2.TrackPaymentRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.Payment, + ] + """lncli: `trackpayment` + TrackPaymentV2 returns an update stream for the payment identified by the + payment hash. + """ + + TrackPayments: grpc.aio.UnaryStreamMultiCallable[ + cashu.lightning.lnd_grpc.protos.router_pb2.TrackPaymentsRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.Payment, + ] + """ + TrackPayments returns an update stream for every payment that is not in a + terminal state. Note that if payments are in-flight while starting a new + subscription, the start of the payment stream could produce out-of-order + and/or duplicate events. In order to get updates for every in-flight + payment attempt make sure to subscribe to this method before initiating any + payments. + """ + + EstimateRouteFee: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.router_pb2.RouteFeeRequest, + cashu.lightning.lnd_grpc.protos.router_pb2.RouteFeeResponse, + ] + """ + EstimateRouteFee allows callers to obtain a lower bound w.r.t how much it + may cost to send an HTLC to the target end destination. + """ + + SendToRoute: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.router_pb2.SendToRouteRequest, + cashu.lightning.lnd_grpc.protos.router_pb2.SendToRouteResponse, + ] + """ + Deprecated, use SendToRouteV2. SendToRoute attempts to make a payment via + the specified route. 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. It differs from the newer + SendToRouteV2 in that it doesn't return the full HTLC information. + """ + + SendToRouteV2: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.router_pb2.SendToRouteRequest, + cashu.lightning.lnd_grpc.protos.lightning_pb2.HTLCAttempt, + ] + """ + SendToRouteV2 attempts to make a payment via the specified route. 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. + """ + + ResetMissionControl: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.router_pb2.ResetMissionControlRequest, + cashu.lightning.lnd_grpc.protos.router_pb2.ResetMissionControlResponse, + ] + """lncli: `resetmc` + ResetMissionControl clears all mission control state and starts with a clean + slate. + """ + + QueryMissionControl: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.router_pb2.QueryMissionControlRequest, + cashu.lightning.lnd_grpc.protos.router_pb2.QueryMissionControlResponse, + ] + """lncli: `querymc` + QueryMissionControl exposes the internal mission control state to callers. + It is a development feature. + """ + + XImportMissionControl: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.router_pb2.XImportMissionControlRequest, + cashu.lightning.lnd_grpc.protos.router_pb2.XImportMissionControlResponse, + ] + """lncli: `importmc` + XImportMissionControl is an experimental API that imports the state provided + to the internal mission control's state, using all results which are more + recent than our existing values. These values will only be imported + in-memory, and will not be persisted across restarts. + """ + + GetMissionControlConfig: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.router_pb2.GetMissionControlConfigRequest, + cashu.lightning.lnd_grpc.protos.router_pb2.GetMissionControlConfigResponse, + ] + """lncli: `getmccfg` + GetMissionControlConfig returns mission control's current config. + """ + + SetMissionControlConfig: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.router_pb2.SetMissionControlConfigRequest, + cashu.lightning.lnd_grpc.protos.router_pb2.SetMissionControlConfigResponse, + ] + """lncli: `setmccfg` + SetMissionControlConfig will set mission control's config, if the config + provided is valid. + """ + + QueryProbability: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.router_pb2.QueryProbabilityRequest, + cashu.lightning.lnd_grpc.protos.router_pb2.QueryProbabilityResponse, + ] + """lncli: `queryprob` + Deprecated. QueryProbability returns the current success probability + estimate for a given node pair and amount. The call returns a zero success + probability if no channel is available or if the amount violates min/max + HTLC constraints. + """ + + BuildRoute: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.router_pb2.BuildRouteRequest, + cashu.lightning.lnd_grpc.protos.router_pb2.BuildRouteResponse, + ] + """lncli: `buildroute` + BuildRoute builds a fully specified route based on a list of hop public + keys. It retrieves the relevant channel policies from the graph in order to + calculate the correct fees and time locks. + Note that LND will use its default final_cltv_delta if no value is supplied. + Make sure to add the correct final_cltv_delta depending on the invoice + restriction. Moreover the caller has to make sure to provide the + payment_addr if the route is paying an invoice which signaled it. + """ + + SubscribeHtlcEvents: grpc.aio.UnaryStreamMultiCallable[ + cashu.lightning.lnd_grpc.protos.router_pb2.SubscribeHtlcEventsRequest, + cashu.lightning.lnd_grpc.protos.router_pb2.HtlcEvent, + ] + """ + SubscribeHtlcEvents creates a uni-directional stream from the server to + the client which delivers a stream of htlc events. + """ + + SendPayment: grpc.aio.UnaryStreamMultiCallable[ + cashu.lightning.lnd_grpc.protos.router_pb2.SendPaymentRequest, + cashu.lightning.lnd_grpc.protos.router_pb2.PaymentStatus, + ] + """ + Deprecated, use SendPaymentV2. SendPayment attempts to route a payment + described by the passed PaymentRequest to the final destination. The call + returns a stream of payment status updates. + """ + + TrackPayment: grpc.aio.UnaryStreamMultiCallable[ + cashu.lightning.lnd_grpc.protos.router_pb2.TrackPaymentRequest, + cashu.lightning.lnd_grpc.protos.router_pb2.PaymentStatus, + ] + """ + Deprecated, use TrackPaymentV2. TrackPayment returns an update stream for + the payment identified by the payment hash. + """ + + HtlcInterceptor: grpc.aio.StreamStreamMultiCallable[ + cashu.lightning.lnd_grpc.protos.router_pb2.ForwardHtlcInterceptResponse, + cashu.lightning.lnd_grpc.protos.router_pb2.ForwardHtlcInterceptRequest, + ] + """* + HtlcInterceptor dispatches a bi-directional streaming RPC in which + Forwarded HTLC requests are sent to the client and the client responds with + a boolean that tells LND if this htlc should be intercepted. + In case of interception, the htlc can be either settled, cancelled or + resumed later by using the ResolveHoldForward endpoint. + """ + + UpdateChanStatus: grpc.aio.UnaryUnaryMultiCallable[ + cashu.lightning.lnd_grpc.protos.router_pb2.UpdateChanStatusRequest, + cashu.lightning.lnd_grpc.protos.router_pb2.UpdateChanStatusResponse, + ] + """lncli: `updatechanstatus` + UpdateChanStatus attempts to manually set the state of a channel + (enabled, disabled, or auto). A manual "disable" request will cause the + channel to stay disabled until a subsequent manual request of either + "enable" or "auto". + """ + +class RouterServicer(metaclass=abc.ABCMeta): + """ + 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. + + 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 + + Router is a service that offers advanced interaction with the router + subsystem of the daemon. + """ + + @abc.abstractmethod + def SendPaymentV2( + self, + request: cashu.lightning.lnd_grpc.protos.router_pb2.SendPaymentRequest, + context: _ServicerContext, + ) -> typing.Union[collections.abc.Iterator[cashu.lightning.lnd_grpc.protos.lightning_pb2.Payment], collections.abc.AsyncIterator[cashu.lightning.lnd_grpc.protos.lightning_pb2.Payment]]: + """ + SendPaymentV2 attempts to route a payment described by the passed + PaymentRequest to the final destination. The call returns a stream of + payment updates. When using this RPC, make sure to set a fee limit, as the + default routing fee limit is 0 sats. Without a non-zero fee limit only + routes without fees will be attempted which often fails with + FAILURE_REASON_NO_ROUTE. + """ + + @abc.abstractmethod + def TrackPaymentV2( + self, + request: cashu.lightning.lnd_grpc.protos.router_pb2.TrackPaymentRequest, + context: _ServicerContext, + ) -> typing.Union[collections.abc.Iterator[cashu.lightning.lnd_grpc.protos.lightning_pb2.Payment], collections.abc.AsyncIterator[cashu.lightning.lnd_grpc.protos.lightning_pb2.Payment]]: + """lncli: `trackpayment` + TrackPaymentV2 returns an update stream for the payment identified by the + payment hash. + """ + + @abc.abstractmethod + def TrackPayments( + self, + request: cashu.lightning.lnd_grpc.protos.router_pb2.TrackPaymentsRequest, + context: _ServicerContext, + ) -> typing.Union[collections.abc.Iterator[cashu.lightning.lnd_grpc.protos.lightning_pb2.Payment], collections.abc.AsyncIterator[cashu.lightning.lnd_grpc.protos.lightning_pb2.Payment]]: + """ + TrackPayments returns an update stream for every payment that is not in a + terminal state. Note that if payments are in-flight while starting a new + subscription, the start of the payment stream could produce out-of-order + and/or duplicate events. In order to get updates for every in-flight + payment attempt make sure to subscribe to this method before initiating any + payments. + """ + + @abc.abstractmethod + def EstimateRouteFee( + self, + request: cashu.lightning.lnd_grpc.protos.router_pb2.RouteFeeRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.router_pb2.RouteFeeResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.router_pb2.RouteFeeResponse]]: + """ + EstimateRouteFee allows callers to obtain a lower bound w.r.t how much it + may cost to send an HTLC to the target end destination. + """ + + @abc.abstractmethod + def SendToRoute( + self, + request: cashu.lightning.lnd_grpc.protos.router_pb2.SendToRouteRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.router_pb2.SendToRouteResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.router_pb2.SendToRouteResponse]]: + """ + Deprecated, use SendToRouteV2. SendToRoute attempts to make a payment via + the specified route. 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. It differs from the newer + SendToRouteV2 in that it doesn't return the full HTLC information. + """ + + @abc.abstractmethod + def SendToRouteV2( + self, + request: cashu.lightning.lnd_grpc.protos.router_pb2.SendToRouteRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.lightning_pb2.HTLCAttempt, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.lightning_pb2.HTLCAttempt]]: + """ + SendToRouteV2 attempts to make a payment via the specified route. 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. + """ + + @abc.abstractmethod + def ResetMissionControl( + self, + request: cashu.lightning.lnd_grpc.protos.router_pb2.ResetMissionControlRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.router_pb2.ResetMissionControlResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.router_pb2.ResetMissionControlResponse]]: + """lncli: `resetmc` + ResetMissionControl clears all mission control state and starts with a clean + slate. + """ + + @abc.abstractmethod + def QueryMissionControl( + self, + request: cashu.lightning.lnd_grpc.protos.router_pb2.QueryMissionControlRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.router_pb2.QueryMissionControlResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.router_pb2.QueryMissionControlResponse]]: + """lncli: `querymc` + QueryMissionControl exposes the internal mission control state to callers. + It is a development feature. + """ + + @abc.abstractmethod + def XImportMissionControl( + self, + request: cashu.lightning.lnd_grpc.protos.router_pb2.XImportMissionControlRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.router_pb2.XImportMissionControlResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.router_pb2.XImportMissionControlResponse]]: + """lncli: `importmc` + XImportMissionControl is an experimental API that imports the state provided + to the internal mission control's state, using all results which are more + recent than our existing values. These values will only be imported + in-memory, and will not be persisted across restarts. + """ + + @abc.abstractmethod + def GetMissionControlConfig( + self, + request: cashu.lightning.lnd_grpc.protos.router_pb2.GetMissionControlConfigRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.router_pb2.GetMissionControlConfigResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.router_pb2.GetMissionControlConfigResponse]]: + """lncli: `getmccfg` + GetMissionControlConfig returns mission control's current config. + """ + + @abc.abstractmethod + def SetMissionControlConfig( + self, + request: cashu.lightning.lnd_grpc.protos.router_pb2.SetMissionControlConfigRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.router_pb2.SetMissionControlConfigResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.router_pb2.SetMissionControlConfigResponse]]: + """lncli: `setmccfg` + SetMissionControlConfig will set mission control's config, if the config + provided is valid. + """ + + @abc.abstractmethod + def QueryProbability( + self, + request: cashu.lightning.lnd_grpc.protos.router_pb2.QueryProbabilityRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.router_pb2.QueryProbabilityResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.router_pb2.QueryProbabilityResponse]]: + """lncli: `queryprob` + Deprecated. QueryProbability returns the current success probability + estimate for a given node pair and amount. The call returns a zero success + probability if no channel is available or if the amount violates min/max + HTLC constraints. + """ + + @abc.abstractmethod + def BuildRoute( + self, + request: cashu.lightning.lnd_grpc.protos.router_pb2.BuildRouteRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.router_pb2.BuildRouteResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.router_pb2.BuildRouteResponse]]: + """lncli: `buildroute` + BuildRoute builds a fully specified route based on a list of hop public + keys. It retrieves the relevant channel policies from the graph in order to + calculate the correct fees and time locks. + Note that LND will use its default final_cltv_delta if no value is supplied. + Make sure to add the correct final_cltv_delta depending on the invoice + restriction. Moreover the caller has to make sure to provide the + payment_addr if the route is paying an invoice which signaled it. + """ + + @abc.abstractmethod + def SubscribeHtlcEvents( + self, + request: cashu.lightning.lnd_grpc.protos.router_pb2.SubscribeHtlcEventsRequest, + context: _ServicerContext, + ) -> typing.Union[collections.abc.Iterator[cashu.lightning.lnd_grpc.protos.router_pb2.HtlcEvent], collections.abc.AsyncIterator[cashu.lightning.lnd_grpc.protos.router_pb2.HtlcEvent]]: + """ + SubscribeHtlcEvents creates a uni-directional stream from the server to + the client which delivers a stream of htlc events. + """ + + @abc.abstractmethod + def SendPayment( + self, + request: cashu.lightning.lnd_grpc.protos.router_pb2.SendPaymentRequest, + context: _ServicerContext, + ) -> typing.Union[collections.abc.Iterator[cashu.lightning.lnd_grpc.protos.router_pb2.PaymentStatus], collections.abc.AsyncIterator[cashu.lightning.lnd_grpc.protos.router_pb2.PaymentStatus]]: + """ + Deprecated, use SendPaymentV2. SendPayment attempts to route a payment + described by the passed PaymentRequest to the final destination. The call + returns a stream of payment status updates. + """ + + @abc.abstractmethod + def TrackPayment( + self, + request: cashu.lightning.lnd_grpc.protos.router_pb2.TrackPaymentRequest, + context: _ServicerContext, + ) -> typing.Union[collections.abc.Iterator[cashu.lightning.lnd_grpc.protos.router_pb2.PaymentStatus], collections.abc.AsyncIterator[cashu.lightning.lnd_grpc.protos.router_pb2.PaymentStatus]]: + """ + Deprecated, use TrackPaymentV2. TrackPayment returns an update stream for + the payment identified by the payment hash. + """ + + @abc.abstractmethod + def HtlcInterceptor( + self, + request_iterator: _MaybeAsyncIterator[cashu.lightning.lnd_grpc.protos.router_pb2.ForwardHtlcInterceptResponse], + context: _ServicerContext, + ) -> typing.Union[collections.abc.Iterator[cashu.lightning.lnd_grpc.protos.router_pb2.ForwardHtlcInterceptRequest], collections.abc.AsyncIterator[cashu.lightning.lnd_grpc.protos.router_pb2.ForwardHtlcInterceptRequest]]: + """* + HtlcInterceptor dispatches a bi-directional streaming RPC in which + Forwarded HTLC requests are sent to the client and the client responds with + a boolean that tells LND if this htlc should be intercepted. + In case of interception, the htlc can be either settled, cancelled or + resumed later by using the ResolveHoldForward endpoint. + """ + + @abc.abstractmethod + def UpdateChanStatus( + self, + request: cashu.lightning.lnd_grpc.protos.router_pb2.UpdateChanStatusRequest, + context: _ServicerContext, + ) -> typing.Union[cashu.lightning.lnd_grpc.protos.router_pb2.UpdateChanStatusResponse, collections.abc.Awaitable[cashu.lightning.lnd_grpc.protos.router_pb2.UpdateChanStatusResponse]]: + """lncli: `updatechanstatus` + UpdateChanStatus attempts to manually set the state of a channel + (enabled, disabled, or auto). A manual "disable" request will cause the + channel to stay disabled until a subsequent manual request of either + "enable" or "auto". + """ + +def add_RouterServicer_to_server(servicer: RouterServicer, server: typing.Union[grpc.Server, grpc.aio.Server]) -> None: ... diff --git a/poetry.lock b/poetry.lock index 42edf8d4..a488b045 100644 --- a/poetry.lock +++ b/poetry.lock @@ -1,4 +1,4 @@ -# This file is automatically @generated by Poetry 1.7.1 and should not be changed by hand. +# This file is automatically @generated by Poetry 1.8.3 and should not be changed by hand. [[package]] name = "aiosqlite" @@ -172,13 +172,13 @@ files = [ [[package]] name = "bolt11" -version = "2.0.6" +version = "2.1.0" description = "A library for encoding and decoding BOLT11 payment requests." optional = false python-versions = ">=3.8.1" files = [ - {file = "bolt11-2.0.6-py3-none-any.whl", hash = "sha256:5a1b4d33e028ce110bd3e5a2b8a95d8a2c5221f2e0dd64cbccb8c70153e7d643"}, - {file = "bolt11-2.0.6.tar.gz", hash = "sha256:02d7e6273a8869911504dbcb732894d58e1d8c96b53ed0e968a9c5f90ab5c5a7"}, + {file = "bolt11-2.1.0-py3-none-any.whl", hash = "sha256:1535e441233414a9d8031a99fd3be07de4674bffda948033579404d44a42f614"}, + {file = "bolt11-2.1.0.tar.gz", hash = "sha256:177c63cd88d1eaba669eddb5937364676226253f2e9e5b77e8fe317ef32e62dd"}, ] [package.dependencies] @@ -186,8 +186,7 @@ base58 = "*" bech32 = "*" bitstring = "*" click = "*" -ecdsa = "*" -secp256k1 = "*" +coincurve = "*" [[package]] name = "cbor2" @@ -408,63 +407,63 @@ files = [ [[package]] name = "coverage" -version = "7.5.4" +version = "7.6.0" description = "Code coverage measurement for Python" optional = false python-versions = ">=3.8" files = [ - {file = "coverage-7.5.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:6cfb5a4f556bb51aba274588200a46e4dd6b505fb1a5f8c5ae408222eb416f99"}, - {file = "coverage-7.5.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:2174e7c23e0a454ffe12267a10732c273243b4f2d50d07544a91198f05c48f47"}, - {file = "coverage-7.5.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2214ee920787d85db1b6a0bd9da5f8503ccc8fcd5814d90796c2f2493a2f4d2e"}, - {file = "coverage-7.5.4-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1137f46adb28e3813dec8c01fefadcb8c614f33576f672962e323b5128d9a68d"}, - {file = "coverage-7.5.4-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b385d49609f8e9efc885790a5a0e89f2e3ae042cdf12958b6034cc442de428d3"}, - {file = "coverage-7.5.4-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:b4a474f799456e0eb46d78ab07303286a84a3140e9700b9e154cfebc8f527016"}, - {file = "coverage-7.5.4-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:5cd64adedf3be66f8ccee418473c2916492d53cbafbfcff851cbec5a8454b136"}, - {file = "coverage-7.5.4-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:e564c2cf45d2f44a9da56f4e3a26b2236504a496eb4cb0ca7221cd4cc7a9aca9"}, - {file = "coverage-7.5.4-cp310-cp310-win32.whl", hash = "sha256:7076b4b3a5f6d2b5d7f1185fde25b1e54eb66e647a1dfef0e2c2bfaf9b4c88c8"}, - {file = "coverage-7.5.4-cp310-cp310-win_amd64.whl", hash = "sha256:018a12985185038a5b2bcafab04ab833a9a0f2c59995b3cec07e10074c78635f"}, - {file = "coverage-7.5.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:db14f552ac38f10758ad14dd7b983dbab424e731588d300c7db25b6f89e335b5"}, - {file = "coverage-7.5.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:3257fdd8e574805f27bb5342b77bc65578e98cbc004a92232106344053f319ba"}, - {file = "coverage-7.5.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3a6612c99081d8d6134005b1354191e103ec9705d7ba2754e848211ac8cacc6b"}, - {file = "coverage-7.5.4-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d45d3cbd94159c468b9b8c5a556e3f6b81a8d1af2a92b77320e887c3e7a5d080"}, - {file = "coverage-7.5.4-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ed550e7442f278af76d9d65af48069f1fb84c9f745ae249c1a183c1e9d1b025c"}, - {file = "coverage-7.5.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7a892be37ca35eb5019ec85402c3371b0f7cda5ab5056023a7f13da0961e60da"}, - {file = "coverage-7.5.4-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:8192794d120167e2a64721d88dbd688584675e86e15d0569599257566dec9bf0"}, - {file = "coverage-7.5.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:820bc841faa502e727a48311948e0461132a9c8baa42f6b2b84a29ced24cc078"}, - {file = "coverage-7.5.4-cp311-cp311-win32.whl", hash = "sha256:6aae5cce399a0f065da65c7bb1e8abd5c7a3043da9dceb429ebe1b289bc07806"}, - {file = "coverage-7.5.4-cp311-cp311-win_amd64.whl", hash = "sha256:d2e344d6adc8ef81c5a233d3a57b3c7d5181f40e79e05e1c143da143ccb6377d"}, - {file = "coverage-7.5.4-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:54317c2b806354cbb2dc7ac27e2b93f97096912cc16b18289c5d4e44fc663233"}, - {file = "coverage-7.5.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:042183de01f8b6d531e10c197f7f0315a61e8d805ab29c5f7b51a01d62782747"}, - {file = "coverage-7.5.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a6bb74ed465d5fb204b2ec41d79bcd28afccf817de721e8a807d5141c3426638"}, - {file = "coverage-7.5.4-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b3d45ff86efb129c599a3b287ae2e44c1e281ae0f9a9bad0edc202179bcc3a2e"}, - {file = "coverage-7.5.4-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5013ed890dc917cef2c9f765c4c6a8ae9df983cd60dbb635df8ed9f4ebc9f555"}, - {file = "coverage-7.5.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1014fbf665fef86cdfd6cb5b7371496ce35e4d2a00cda501cf9f5b9e6fced69f"}, - {file = "coverage-7.5.4-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:3684bc2ff328f935981847082ba4fdc950d58906a40eafa93510d1b54c08a66c"}, - {file = "coverage-7.5.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:581ea96f92bf71a5ec0974001f900db495488434a6928a2ca7f01eee20c23805"}, - {file = "coverage-7.5.4-cp312-cp312-win32.whl", hash = "sha256:73ca8fbc5bc622e54627314c1a6f1dfdd8db69788f3443e752c215f29fa87a0b"}, - {file = "coverage-7.5.4-cp312-cp312-win_amd64.whl", hash = "sha256:cef4649ec906ea7ea5e9e796e68b987f83fa9a718514fe147f538cfeda76d7a7"}, - {file = "coverage-7.5.4-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:cdd31315fc20868c194130de9ee6bfd99755cc9565edff98ecc12585b90be882"}, - {file = "coverage-7.5.4-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:02ff6e898197cc1e9fa375581382b72498eb2e6d5fc0b53f03e496cfee3fac6d"}, - {file = "coverage-7.5.4-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d05c16cf4b4c2fc880cb12ba4c9b526e9e5d5bb1d81313d4d732a5b9fe2b9d53"}, - {file = "coverage-7.5.4-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c5986ee7ea0795a4095ac4d113cbb3448601efca7f158ec7f7087a6c705304e4"}, - {file = "coverage-7.5.4-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5df54843b88901fdc2f598ac06737f03d71168fd1175728054c8f5a2739ac3e4"}, - {file = "coverage-7.5.4-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:ab73b35e8d109bffbda9a3e91c64e29fe26e03e49addf5b43d85fc426dde11f9"}, - {file = "coverage-7.5.4-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:aea072a941b033813f5e4814541fc265a5c12ed9720daef11ca516aeacd3bd7f"}, - {file = "coverage-7.5.4-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:16852febd96acd953b0d55fc842ce2dac1710f26729b31c80b940b9afcd9896f"}, - {file = "coverage-7.5.4-cp38-cp38-win32.whl", hash = "sha256:8f894208794b164e6bd4bba61fc98bf6b06be4d390cf2daacfa6eca0a6d2bb4f"}, - {file = "coverage-7.5.4-cp38-cp38-win_amd64.whl", hash = "sha256:e2afe743289273209c992075a5a4913e8d007d569a406ffed0bd080ea02b0633"}, - {file = "coverage-7.5.4-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:b95c3a8cb0463ba9f77383d0fa8c9194cf91f64445a63fc26fb2327e1e1eb088"}, - {file = "coverage-7.5.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:3d7564cc09dd91b5a6001754a5b3c6ecc4aba6323baf33a12bd751036c998be4"}, - {file = "coverage-7.5.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:44da56a2589b684813f86d07597fdf8a9c6ce77f58976727329272f5a01f99f7"}, - {file = "coverage-7.5.4-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e16f3d6b491c48c5ae726308e6ab1e18ee830b4cdd6913f2d7f77354b33f91c8"}, - {file = "coverage-7.5.4-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dbc5958cb471e5a5af41b0ddaea96a37e74ed289535e8deca404811f6cb0bc3d"}, - {file = "coverage-7.5.4-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:a04e990a2a41740b02d6182b498ee9796cf60eefe40cf859b016650147908029"}, - {file = "coverage-7.5.4-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:ddbd2f9713a79e8e7242d7c51f1929611e991d855f414ca9996c20e44a895f7c"}, - {file = "coverage-7.5.4-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:b1ccf5e728ccf83acd313c89f07c22d70d6c375a9c6f339233dcf792094bcbf7"}, - {file = "coverage-7.5.4-cp39-cp39-win32.whl", hash = "sha256:56b4eafa21c6c175b3ede004ca12c653a88b6f922494b023aeb1e836df953ace"}, - {file = "coverage-7.5.4-cp39-cp39-win_amd64.whl", hash = "sha256:65e528e2e921ba8fd67d9055e6b9f9e34b21ebd6768ae1c1723f4ea6ace1234d"}, - {file = "coverage-7.5.4-pp38.pp39.pp310-none-any.whl", hash = "sha256:79b356f3dd5b26f3ad23b35c75dbdaf1f9e2450b6bcefc6d0825ea0aa3f86ca5"}, - {file = "coverage-7.5.4.tar.gz", hash = "sha256:a44963520b069e12789d0faea4e9fdb1e410cdc4aab89d94f7f55cbb7fef0353"}, + {file = "coverage-7.6.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:dff044f661f59dace805eedb4a7404c573b6ff0cdba4a524141bc63d7be5c7fd"}, + {file = "coverage-7.6.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a8659fd33ee9e6ca03950cfdcdf271d645cf681609153f218826dd9805ab585c"}, + {file = "coverage-7.6.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7792f0ab20df8071d669d929c75c97fecfa6bcab82c10ee4adb91c7a54055463"}, + {file = "coverage-7.6.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d4b3cd1ca7cd73d229487fa5caca9e4bc1f0bca96526b922d61053ea751fe791"}, + {file = "coverage-7.6.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e7e128f85c0b419907d1f38e616c4f1e9f1d1b37a7949f44df9a73d5da5cd53c"}, + {file = "coverage-7.6.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:a94925102c89247530ae1dab7dc02c690942566f22e189cbd53579b0693c0783"}, + {file = "coverage-7.6.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:dcd070b5b585b50e6617e8972f3fbbee786afca71b1936ac06257f7e178f00f6"}, + {file = "coverage-7.6.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:d50a252b23b9b4dfeefc1f663c568a221092cbaded20a05a11665d0dbec9b8fb"}, + {file = "coverage-7.6.0-cp310-cp310-win32.whl", hash = "sha256:0e7b27d04131c46e6894f23a4ae186a6a2207209a05df5b6ad4caee6d54a222c"}, + {file = "coverage-7.6.0-cp310-cp310-win_amd64.whl", hash = "sha256:54dece71673b3187c86226c3ca793c5f891f9fc3d8aa183f2e3653da18566169"}, + {file = "coverage-7.6.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c7b525ab52ce18c57ae232ba6f7010297a87ced82a2383b1afd238849c1ff933"}, + {file = "coverage-7.6.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4bea27c4269234e06f621f3fac3925f56ff34bc14521484b8f66a580aacc2e7d"}, + {file = "coverage-7.6.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ed8d1d1821ba5fc88d4a4f45387b65de52382fa3ef1f0115a4f7a20cdfab0e94"}, + {file = "coverage-7.6.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:01c322ef2bbe15057bc4bf132b525b7e3f7206f071799eb8aa6ad1940bcf5fb1"}, + {file = "coverage-7.6.0-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:03cafe82c1b32b770a29fd6de923625ccac3185a54a5e66606da26d105f37dac"}, + {file = "coverage-7.6.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0d1b923fc4a40c5832be4f35a5dab0e5ff89cddf83bb4174499e02ea089daf57"}, + {file = "coverage-7.6.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:4b03741e70fb811d1a9a1d75355cf391f274ed85847f4b78e35459899f57af4d"}, + {file = "coverage-7.6.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a73d18625f6a8a1cbb11eadc1d03929f9510f4131879288e3f7922097a429f63"}, + {file = "coverage-7.6.0-cp311-cp311-win32.whl", hash = "sha256:65fa405b837060db569a61ec368b74688f429b32fa47a8929a7a2f9b47183713"}, + {file = "coverage-7.6.0-cp311-cp311-win_amd64.whl", hash = "sha256:6379688fb4cfa921ae349c76eb1a9ab26b65f32b03d46bb0eed841fd4cb6afb1"}, + {file = "coverage-7.6.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:f7db0b6ae1f96ae41afe626095149ecd1b212b424626175a6633c2999eaad45b"}, + {file = "coverage-7.6.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:bbdf9a72403110a3bdae77948b8011f644571311c2fb35ee15f0f10a8fc082e8"}, + {file = "coverage-7.6.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9cc44bf0315268e253bf563f3560e6c004efe38f76db03a1558274a6e04bf5d5"}, + {file = "coverage-7.6.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:da8549d17489cd52f85a9829d0e1d91059359b3c54a26f28bec2c5d369524807"}, + {file = "coverage-7.6.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0086cd4fc71b7d485ac93ca4239c8f75732c2ae3ba83f6be1c9be59d9e2c6382"}, + {file = "coverage-7.6.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1fad32ee9b27350687035cb5fdf9145bc9cf0a094a9577d43e909948ebcfa27b"}, + {file = "coverage-7.6.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:044a0985a4f25b335882b0966625270a8d9db3d3409ddc49a4eb00b0ef5e8cee"}, + {file = "coverage-7.6.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:76d5f82213aa78098b9b964ea89de4617e70e0d43e97900c2778a50856dac605"}, + {file = "coverage-7.6.0-cp312-cp312-win32.whl", hash = "sha256:3c59105f8d58ce500f348c5b56163a4113a440dad6daa2294b5052a10db866da"}, + {file = "coverage-7.6.0-cp312-cp312-win_amd64.whl", hash = "sha256:ca5d79cfdae420a1d52bf177de4bc2289c321d6c961ae321503b2ca59c17ae67"}, + {file = "coverage-7.6.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:d39bd10f0ae453554798b125d2f39884290c480f56e8a02ba7a6ed552005243b"}, + {file = "coverage-7.6.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:beb08e8508e53a568811016e59f3234d29c2583f6b6e28572f0954a6b4f7e03d"}, + {file = "coverage-7.6.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b2e16f4cd2bc4d88ba30ca2d3bbf2f21f00f382cf4e1ce3b1ddc96c634bc48ca"}, + {file = "coverage-7.6.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6616d1c9bf1e3faea78711ee42a8b972367d82ceae233ec0ac61cc7fec09fa6b"}, + {file = "coverage-7.6.0-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ad4567d6c334c46046d1c4c20024de2a1c3abc626817ae21ae3da600f5779b44"}, + {file = "coverage-7.6.0-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:d17c6a415d68cfe1091d3296ba5749d3d8696e42c37fca5d4860c5bf7b729f03"}, + {file = "coverage-7.6.0-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:9146579352d7b5f6412735d0f203bbd8d00113a680b66565e205bc605ef81bc6"}, + {file = "coverage-7.6.0-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:cdab02a0a941af190df8782aafc591ef3ad08824f97850b015c8c6a8b3877b0b"}, + {file = "coverage-7.6.0-cp38-cp38-win32.whl", hash = "sha256:df423f351b162a702c053d5dddc0fc0ef9a9e27ea3f449781ace5f906b664428"}, + {file = "coverage-7.6.0-cp38-cp38-win_amd64.whl", hash = "sha256:f2501d60d7497fd55e391f423f965bbe9e650e9ffc3c627d5f0ac516026000b8"}, + {file = "coverage-7.6.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:7221f9ac9dad9492cecab6f676b3eaf9185141539d5c9689d13fd6b0d7de840c"}, + {file = "coverage-7.6.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:ddaaa91bfc4477d2871442bbf30a125e8fe6b05da8a0015507bfbf4718228ab2"}, + {file = "coverage-7.6.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c4cbe651f3904e28f3a55d6f371203049034b4ddbce65a54527a3f189ca3b390"}, + {file = "coverage-7.6.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:831b476d79408ab6ccfadaaf199906c833f02fdb32c9ab907b1d4aa0713cfa3b"}, + {file = "coverage-7.6.0-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:46c3d091059ad0b9c59d1034de74a7f36dcfa7f6d3bde782c49deb42438f2450"}, + {file = "coverage-7.6.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:4d5fae0a22dc86259dee66f2cc6c1d3e490c4a1214d7daa2a93d07491c5c04b6"}, + {file = "coverage-7.6.0-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:07ed352205574aad067482e53dd606926afebcb5590653121063fbf4e2175166"}, + {file = "coverage-7.6.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:49c76cdfa13015c4560702574bad67f0e15ca5a2872c6a125f6327ead2b731dd"}, + {file = "coverage-7.6.0-cp39-cp39-win32.whl", hash = "sha256:482855914928c8175735a2a59c8dc5806cf7d8f032e4820d52e845d1f731dca2"}, + {file = "coverage-7.6.0-cp39-cp39-win_amd64.whl", hash = "sha256:543ef9179bc55edfd895154a51792b01c017c87af0ebaae092720152e19e42ca"}, + {file = "coverage-7.6.0-pp38.pp39.pp310-none-any.whl", hash = "sha256:6fe885135c8a479d3e37a7aae61cbd3a0fb2deccb4dda3c25f92a49189f766d6"}, + {file = "coverage-7.6.0.tar.gz", hash = "sha256:289cc803fa1dc901f84701ac10c9ee873619320f2f9aff38794db4a4a0268d51"}, ] [package.dependencies] @@ -587,13 +586,13 @@ tests = ["dj-database-url", "dj-email-url", "django-cache-url", "pytest"] [[package]] name = "exceptiongroup" -version = "1.2.1" +version = "1.2.2" description = "Backport of PEP 654 (exception groups)" optional = false python-versions = ">=3.7" files = [ - {file = "exceptiongroup-1.2.1-py3-none-any.whl", hash = "sha256:5258b9ed329c5bbdd31a309f53cbfb0b155341807f6ff7606a1e801a891b29ad"}, - {file = "exceptiongroup-1.2.1.tar.gz", hash = "sha256:a4785e48b045528f5bfe627b6ad554ff32def154f42372786903b7abcfe1aa16"}, + {file = "exceptiongroup-1.2.2-py3-none-any.whl", hash = "sha256:3111b9d131c238bec2f8f516e123e14ba243563fb135d3fe885990585aa7795b"}, + {file = "exceptiongroup-1.2.2.tar.gz", hash = "sha256:47c2edf7c6738fafb49fd34290706d1a1a2f4d1c6df275526b62cbb4aa5393cc"}, ] [package.extras] @@ -649,6 +648,23 @@ docs = ["furo (>=2023.9.10)", "sphinx (>=7.2.6)", "sphinx-autodoc-typehints (>=1 testing = ["covdefaults (>=2.3)", "coverage (>=7.3.2)", "diff-cover (>=8.0.1)", "pytest (>=7.4.3)", "pytest-asyncio (>=0.21)", "pytest-cov (>=4.1)", "pytest-mock (>=3.12)", "pytest-timeout (>=2.2)", "virtualenv (>=20.26.2)"] typing = ["typing-extensions (>=4.8)"] +[[package]] +name = "googleapis-common-protos" +version = "1.63.2" +description = "Common protobufs used in Google APIs" +optional = false +python-versions = ">=3.7" +files = [ + {file = "googleapis-common-protos-1.63.2.tar.gz", hash = "sha256:27c5abdffc4911f28101e635de1533fb4cfd2c37fbaa9174587c799fac90aa87"}, + {file = "googleapis_common_protos-1.63.2-py2.py3-none-any.whl", hash = "sha256:27a2499c7e8aff199665b22741997e485eccc8645aa9176c7c988e6fae507945"}, +] + +[package.dependencies] +protobuf = ">=3.20.2,<4.21.1 || >4.21.1,<4.21.2 || >4.21.2,<4.21.3 || >4.21.3,<4.21.4 || >4.21.4,<4.21.5 || >4.21.5,<6.0.0.dev0" + +[package.extras] +grpc = ["grpcio (>=1.44.0,<2.0.0.dev0)"] + [[package]] name = "greenlet" version = "3.0.3" @@ -720,6 +736,124 @@ files = [ docs = ["Sphinx", "furo"] test = ["objgraph", "psutil"] +[[package]] +name = "grpcio" +version = "1.65.1" +description = "HTTP/2-based RPC framework" +optional = false +python-versions = ">=3.8" +files = [ + {file = "grpcio-1.65.1-cp310-cp310-linux_armv7l.whl", hash = "sha256:3dc5f928815b8972fb83b78d8db5039559f39e004ec93ebac316403fe031a062"}, + {file = "grpcio-1.65.1-cp310-cp310-macosx_12_0_universal2.whl", hash = "sha256:8333ca46053c35484c9f2f7e8d8ec98c1383a8675a449163cea31a2076d93de8"}, + {file = "grpcio-1.65.1-cp310-cp310-manylinux_2_17_aarch64.whl", hash = "sha256:7af64838b6e615fff0ec711960ed9b6ee83086edfa8c32670eafb736f169d719"}, + {file = "grpcio-1.65.1-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:dbb64b4166362d9326f7efbf75b1c72106c1aa87f13a8c8b56a1224fac152f5c"}, + {file = "grpcio-1.65.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a8422dc13ad93ec8caa2612b5032a2b9cd6421c13ed87f54db4a3a2c93afaf77"}, + {file = "grpcio-1.65.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:4effc0562b6c65d4add6a873ca132e46ba5e5a46f07c93502c37a9ae7f043857"}, + {file = "grpcio-1.65.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:a6c71575a2fedf259724981fd73a18906513d2f306169c46262a5bae956e6364"}, + {file = "grpcio-1.65.1-cp310-cp310-win32.whl", hash = "sha256:34966cf526ef0ea616e008d40d989463e3db157abb213b2f20c6ce0ae7928875"}, + {file = "grpcio-1.65.1-cp310-cp310-win_amd64.whl", hash = "sha256:ca931de5dd6d9eb94ff19a2c9434b23923bce6f767179fef04dfa991f282eaad"}, + {file = "grpcio-1.65.1-cp311-cp311-linux_armv7l.whl", hash = "sha256:bbb46330cc643ecf10bd9bd4ca8e7419a14b6b9dedd05f671c90fb2c813c6037"}, + {file = "grpcio-1.65.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:d827a6fb9215b961eb73459ad7977edb9e748b23e3407d21c845d1d8ef6597e5"}, + {file = "grpcio-1.65.1-cp311-cp311-manylinux_2_17_aarch64.whl", hash = "sha256:6e71aed8835f8d9fbcb84babc93a9da95955d1685021cceb7089f4f1e717d719"}, + {file = "grpcio-1.65.1-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9a1c84560b3b2d34695c9ba53ab0264e2802721c530678a8f0a227951f453462"}, + {file = "grpcio-1.65.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:27adee2338d697e71143ed147fe286c05810965d5d30ec14dd09c22479bfe48a"}, + {file = "grpcio-1.65.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:f62652ddcadc75d0e7aa629e96bb61658f85a993e748333715b4ab667192e4e8"}, + {file = "grpcio-1.65.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:71a05fd814700dd9cb7d9a507f2f6a1ef85866733ccaf557eedacec32d65e4c2"}, + {file = "grpcio-1.65.1-cp311-cp311-win32.whl", hash = "sha256:b590f1ad056294dfaeac0b7e1b71d3d5ace638d8dd1f1147ce4bd13458783ba8"}, + {file = "grpcio-1.65.1-cp311-cp311-win_amd64.whl", hash = "sha256:12e9bdf3b5fd48e5fbe5b3da382ad8f97c08b47969f3cca81dd9b36b86ed39e2"}, + {file = "grpcio-1.65.1-cp312-cp312-linux_armv7l.whl", hash = "sha256:54cb822e177374b318b233e54b6856c692c24cdbd5a3ba5335f18a47396bac8f"}, + {file = "grpcio-1.65.1-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:aaf3c54419a28d45bd1681372029f40e5bfb58e5265e3882eaf21e4a5f81a119"}, + {file = "grpcio-1.65.1-cp312-cp312-manylinux_2_17_aarch64.whl", hash = "sha256:557de35bdfbe8bafea0a003dbd0f4da6d89223ac6c4c7549d78e20f92ead95d9"}, + {file = "grpcio-1.65.1-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8bfd95ef3b097f0cc86ade54eafefa1c8ed623aa01a26fbbdcd1a3650494dd11"}, + {file = "grpcio-1.65.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9e6a8f3d6c41e6b642870afe6cafbaf7b61c57317f9ec66d0efdaf19db992b90"}, + {file = "grpcio-1.65.1-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:1faaf7355ceed07ceaef0b9dcefa4c98daf1dd8840ed75c2de128c3f4a4d859d"}, + {file = "grpcio-1.65.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:60f1f38eed830488ad2a1b11579ef0f345ff16fffdad1d24d9fbc97ba31804ff"}, + {file = "grpcio-1.65.1-cp312-cp312-win32.whl", hash = "sha256:e75acfa52daf5ea0712e8aa82f0003bba964de7ae22c26d208cbd7bc08500177"}, + {file = "grpcio-1.65.1-cp312-cp312-win_amd64.whl", hash = "sha256:ff5a84907e51924973aa05ed8759210d8cdae7ffcf9e44fd17646cf4a902df59"}, + {file = "grpcio-1.65.1-cp38-cp38-linux_armv7l.whl", hash = "sha256:1fbd6331f18c3acd7e09d17fd840c096f56eaf0ef830fbd50af45ae9dc8dfd83"}, + {file = "grpcio-1.65.1-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:de5b6be29116e094c5ef9d9e4252e7eb143e3d5f6bd6d50a78075553ab4930b0"}, + {file = "grpcio-1.65.1-cp38-cp38-manylinux_2_17_aarch64.whl", hash = "sha256:e4a3cdba62b2d6aeae6027ae65f350de6dc082b72e6215eccf82628e79efe9ba"}, + {file = "grpcio-1.65.1-cp38-cp38-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:941c4869aa229d88706b78187d60d66aca77fe5c32518b79e3c3e03fc26109a2"}, + {file = "grpcio-1.65.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f40cebe5edb518d78b8131e87cb83b3ee688984de38a232024b9b44e74ee53d3"}, + {file = "grpcio-1.65.1-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:2ca684ba331fb249d8a1ce88db5394e70dbcd96e58d8c4b7e0d7b141a453dce9"}, + {file = "grpcio-1.65.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:8558f0083ddaf5de64a59c790bffd7568e353914c0c551eae2955f54ee4b857f"}, + {file = "grpcio-1.65.1-cp38-cp38-win32.whl", hash = "sha256:8d8143a3e3966f85dce6c5cc45387ec36552174ba5712c5dc6fcc0898fb324c0"}, + {file = "grpcio-1.65.1-cp38-cp38-win_amd64.whl", hash = "sha256:76e81a86424d6ca1ce7c16b15bdd6a964a42b40544bf796a48da241fdaf61153"}, + {file = "grpcio-1.65.1-cp39-cp39-linux_armv7l.whl", hash = "sha256:cb5175f45c980ff418998723ea1b3869cce3766d2ab4e4916fbd3cedbc9d0ed3"}, + {file = "grpcio-1.65.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:b12c1aa7b95abe73b3e04e052c8b362655b41c7798da69f1eaf8d186c7d204df"}, + {file = "grpcio-1.65.1-cp39-cp39-manylinux_2_17_aarch64.whl", hash = "sha256:3019fb50128b21a5e018d89569ffaaaa361680e1346c2f261bb84a91082eb3d3"}, + {file = "grpcio-1.65.1-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7ae15275ed98ea267f64ee9ddedf8ecd5306a5b5bb87972a48bfe24af24153e8"}, + {file = "grpcio-1.65.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5f096ffb881f37e8d4f958b63c74bfc400c7cebd7a944b027357cd2fb8d91a57"}, + {file = "grpcio-1.65.1-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:2f56b5a68fdcf17a0a1d524bf177218c3c69b3947cb239ea222c6f1867c3ab68"}, + {file = "grpcio-1.65.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:941596d419b9736ab548aa0feb5bbba922f98872668847bf0720b42d1d227b9e"}, + {file = "grpcio-1.65.1-cp39-cp39-win32.whl", hash = "sha256:5fd7337a823b890215f07d429f4f193d24b80d62a5485cf88ee06648591a0c57"}, + {file = "grpcio-1.65.1-cp39-cp39-win_amd64.whl", hash = "sha256:1bceeec568372cbebf554eae1b436b06c2ff24cfaf04afade729fb9035408c6c"}, + {file = "grpcio-1.65.1.tar.gz", hash = "sha256:3c492301988cd720cd145d84e17318d45af342e29ef93141228f9cd73222368b"}, +] + +[package.extras] +protobuf = ["grpcio-tools (>=1.65.1)"] + +[[package]] +name = "grpcio-tools" +version = "1.65.1" +description = "Protobuf code generator for gRPC" +optional = false +python-versions = ">=3.8" +files = [ + {file = "grpcio_tools-1.65.1-cp310-cp310-linux_armv7l.whl", hash = "sha256:16f2f49048c76a68a8171507c39652c8be9ed4e7408deb9877002813aea4c396"}, + {file = "grpcio_tools-1.65.1-cp310-cp310-macosx_12_0_universal2.whl", hash = "sha256:6f75bf562057723818dff7bf4e05884c220653ead3db19effe5873ce88c7cfd2"}, + {file = "grpcio_tools-1.65.1-cp310-cp310-manylinux_2_17_aarch64.whl", hash = "sha256:e859001e20d4199ac90979e11d0d0ecb83f6b0235b08f8bfae93c2bd1401795a"}, + {file = "grpcio_tools-1.65.1-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:257decc1782b9adca422a2625663529be64018c056d7346d8bbc7c9bf0fe3b80"}, + {file = "grpcio_tools-1.65.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ac8cc2684bcde43296cf5a350b80b73713610f0789ff912c88f898ef065a0b6c"}, + {file = "grpcio_tools-1.65.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:b8ef108fceabb12ed29f750f2cb4827d7bad5033dc13596ad0de092f015f5123"}, + {file = "grpcio_tools-1.65.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:32fa16e64f4b1684ed634155af9b03fdeabdf641d484e53c453e592e0f574f03"}, + {file = "grpcio_tools-1.65.1-cp310-cp310-win32.whl", hash = "sha256:d4afb3e74c7a567eabda3c447421eb8fb5c6cbf19bb9292319056beff4ab49a1"}, + {file = "grpcio_tools-1.65.1-cp310-cp310-win_amd64.whl", hash = "sha256:edb4731b4ad068c3c48d52bbfa1404236cbcdd2524eb01a655e8adfadc2f0034"}, + {file = "grpcio_tools-1.65.1-cp311-cp311-linux_armv7l.whl", hash = "sha256:fabbc0698cf0c614059c3e103b06c74d07190e9c7518f457703e98617ed467c0"}, + {file = "grpcio_tools-1.65.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:ee1353c741f8f2fcf4fcce8764d4570e2d7c3025cc4c918a0c6532c18b6cbac5"}, + {file = "grpcio_tools-1.65.1-cp311-cp311-manylinux_2_17_aarch64.whl", hash = "sha256:f49acf17ae7b1a35b5e0e5907ed9b70c042b3e7ab8769ea9fd26f20b2b888743"}, + {file = "grpcio_tools-1.65.1-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c50895d383d41a379f9a235ce6d14c6639f36d43bf71c7148bf8a114a8f0936a"}, + {file = "grpcio_tools-1.65.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c394cf5b77eb71ff5c0ab857877f59dfee080cc95fb24d47e97d3965aaaf3c64"}, + {file = "grpcio_tools-1.65.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:e24819f8d11fc9e6bad1e13a1d7fddd6027ed2a1aad583f093cfe027852ff3f9"}, + {file = "grpcio_tools-1.65.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:2ec7e376f3f53e7ab90614d5a2404c19c7902750bcc5bed8219ab864f9bc1c4b"}, + {file = "grpcio_tools-1.65.1-cp311-cp311-win32.whl", hash = "sha256:9b6dbddca8e399ad96d263b786d0803acc67194cb80d01117691a9f239ac8dc9"}, + {file = "grpcio_tools-1.65.1-cp311-cp311-win_amd64.whl", hash = "sha256:3135888461888dcc7b358c17d60f32654cb36daf02bb805c84c0f8ab550743eb"}, + {file = "grpcio_tools-1.65.1-cp312-cp312-linux_armv7l.whl", hash = "sha256:b8fe0bd8e63a4dd84c022ccbb6057e9f3c338e036a1b95c2a6dbcc928c35b4f9"}, + {file = "grpcio_tools-1.65.1-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:bfb1a5e429756cdc9ce7183cca24a90bd7e68626379c83ea065bb30125d7aca4"}, + {file = "grpcio_tools-1.65.1-cp312-cp312-manylinux_2_17_aarch64.whl", hash = "sha256:4dde0d90f96e29670c58a08aeeac61da49792f71602cb7421943be8918857a2a"}, + {file = "grpcio_tools-1.65.1-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a89203d864dd024c4a13032f2df792eb465c63c224f9b82460d53f0cf30a3d16"}, + {file = "grpcio_tools-1.65.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7813a67cb427847e1a88d4fd4cbabfd2ed272455bd78b4f417377361d3b8edbd"}, + {file = "grpcio_tools-1.65.1-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:33e4c602221f91c1d87c4574c496621f11826d4f8867f31f4c4c2ff1b144a777"}, + {file = "grpcio_tools-1.65.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:fd2fe61d40e7421dc64c90912e29c05f1c419dd7a90452c84a1b456e06bd8530"}, + {file = "grpcio_tools-1.65.1-cp312-cp312-win32.whl", hash = "sha256:013017df92d6165e1556a17c618cf22471ef131fb614b428683730968b54b46d"}, + {file = "grpcio_tools-1.65.1-cp312-cp312-win_amd64.whl", hash = "sha256:1ab64a9af7ce0aeb639a77423fa99de91863a0b8ce0e43fc50f57fc460a0d30e"}, + {file = "grpcio_tools-1.65.1-cp38-cp38-linux_armv7l.whl", hash = "sha256:a95fd13dc17b065a934f00a0b99078de7773d4743772312efc8e75521ab62f7b"}, + {file = "grpcio_tools-1.65.1-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:e44c69c029614fc61da2701587299fe19e52031aa1fba2a69a02c2dd77f903fe"}, + {file = "grpcio_tools-1.65.1-cp38-cp38-manylinux_2_17_aarch64.whl", hash = "sha256:196e12c18f0ebe5ac7f5446fc1daef8d9c69ba40a987a1f8379bfdf6c32e54af"}, + {file = "grpcio_tools-1.65.1-cp38-cp38-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:881ccc523a171235bb6b1d8e965c2f11e525b54eb1d66aeb8fea5a72f84d6e02"}, + {file = "grpcio_tools-1.65.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8d5a12e0bd2a0f33af11e11d89f19cddea66568716b53b77f3f5dc605ceb32e0"}, + {file = "grpcio_tools-1.65.1-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:1d8671d82449206ef040756a14484b0c5189615a0aac5f4734ad3d023d07d4b1"}, + {file = "grpcio_tools-1.65.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:dc904f0de72eecbd024c111caa3e3165522349ff3c89361e4cbf06035c93061a"}, + {file = "grpcio_tools-1.65.1-cp38-cp38-win32.whl", hash = "sha256:b6e45377dbe50c7a737d81620841b8c3f3a1650c76cb56a87b5b0414d10f9987"}, + {file = "grpcio_tools-1.65.1-cp38-cp38-win_amd64.whl", hash = "sha256:5c9b4d95d2623b8b9435103305c3d375f8b4a266ee6fbbf29b5f4a57a8405047"}, + {file = "grpcio_tools-1.65.1-cp39-cp39-linux_armv7l.whl", hash = "sha256:4b0714458a6a3a1ed587271f3e7c301b735ccbdd7946071a1d85a6d0aabcb57a"}, + {file = "grpcio_tools-1.65.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:1ece34ebb677a869606200812653f274757844754f0b684e59d61244b194f002"}, + {file = "grpcio_tools-1.65.1-cp39-cp39-manylinux_2_17_aarch64.whl", hash = "sha256:4887af67ff130174fa7fb420ee985d38659a7c960053639de28980003fe710eb"}, + {file = "grpcio_tools-1.65.1-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d99945dc53daa7987ae8c33227f96697ccc4d0a4a1ca6c366e28fcc9fc1c55fb"}, + {file = "grpcio_tools-1.65.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:68d14cbd135541366bbef18c1d463f5d560878629f1901cae03777dad87755d9"}, + {file = "grpcio_tools-1.65.1-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:bc55edf7a0af0ad7384887845b6498fdb1a75d3633d11807f953cac531a34588"}, + {file = "grpcio_tools-1.65.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:074fce3b96a5c59ed526bdd07c04c6243c07b13278388837a0540840ae10bf5b"}, + {file = "grpcio_tools-1.65.1-cp39-cp39-win32.whl", hash = "sha256:004232fa8ef82298eeb01b391d708b3a89317910e2f7c623b566aea0448c8dcc"}, + {file = "grpcio_tools-1.65.1-cp39-cp39-win_amd64.whl", hash = "sha256:9cc6f342b8e8a2aa801d2d1640290a47563d8bb1a802671191dc3fc218747da3"}, + {file = "grpcio_tools-1.65.1.tar.gz", hash = "sha256:24cffe8bc90fb8237f0bcf240bd6c70304255fe27b69db32601499a043f871be"}, +] + +[package.dependencies] +grpcio = ">=1.65.1" +protobuf = ">=5.26.1,<6.0dev" +setuptools = "*" + [[package]] name = "h11" version = "0.14.0" @@ -929,44 +1063,44 @@ files = [ [[package]] name = "mypy" -version = "1.10.1" +version = "1.11.0" description = "Optional static typing for Python" optional = false python-versions = ">=3.8" files = [ - {file = "mypy-1.10.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e36f229acfe250dc660790840916eb49726c928e8ce10fbdf90715090fe4ae02"}, - {file = "mypy-1.10.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:51a46974340baaa4145363b9e051812a2446cf583dfaeba124af966fa44593f7"}, - {file = "mypy-1.10.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:901c89c2d67bba57aaaca91ccdb659aa3a312de67f23b9dfb059727cce2e2e0a"}, - {file = "mypy-1.10.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:0cd62192a4a32b77ceb31272d9e74d23cd88c8060c34d1d3622db3267679a5d9"}, - {file = "mypy-1.10.1-cp310-cp310-win_amd64.whl", hash = "sha256:a2cbc68cb9e943ac0814c13e2452d2046c2f2b23ff0278e26599224cf164e78d"}, - {file = "mypy-1.10.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:bd6f629b67bb43dc0d9211ee98b96d8dabc97b1ad38b9b25f5e4c4d7569a0c6a"}, - {file = "mypy-1.10.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a1bbb3a6f5ff319d2b9d40b4080d46cd639abe3516d5a62c070cf0114a457d84"}, - {file = "mypy-1.10.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b8edd4e9bbbc9d7b79502eb9592cab808585516ae1bcc1446eb9122656c6066f"}, - {file = "mypy-1.10.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:6166a88b15f1759f94a46fa474c7b1b05d134b1b61fca627dd7335454cc9aa6b"}, - {file = "mypy-1.10.1-cp311-cp311-win_amd64.whl", hash = "sha256:5bb9cd11c01c8606a9d0b83ffa91d0b236a0e91bc4126d9ba9ce62906ada868e"}, - {file = "mypy-1.10.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:d8681909f7b44d0b7b86e653ca152d6dff0eb5eb41694e163c6092124f8246d7"}, - {file = "mypy-1.10.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:378c03f53f10bbdd55ca94e46ec3ba255279706a6aacaecac52ad248f98205d3"}, - {file = "mypy-1.10.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6bacf8f3a3d7d849f40ca6caea5c055122efe70e81480c8328ad29c55c69e93e"}, - {file = "mypy-1.10.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:701b5f71413f1e9855566a34d6e9d12624e9e0a8818a5704d74d6b0402e66c04"}, - {file = "mypy-1.10.1-cp312-cp312-win_amd64.whl", hash = "sha256:3c4c2992f6ea46ff7fce0072642cfb62af7a2484efe69017ed8b095f7b39ef31"}, - {file = "mypy-1.10.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:604282c886497645ffb87b8f35a57ec773a4a2721161e709a4422c1636ddde5c"}, - {file = "mypy-1.10.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:37fd87cab83f09842653f08de066ee68f1182b9b5282e4634cdb4b407266bade"}, - {file = "mypy-1.10.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8addf6313777dbb92e9564c5d32ec122bf2c6c39d683ea64de6a1fd98b90fe37"}, - {file = "mypy-1.10.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:5cc3ca0a244eb9a5249c7c583ad9a7e881aa5d7b73c35652296ddcdb33b2b9c7"}, - {file = "mypy-1.10.1-cp38-cp38-win_amd64.whl", hash = "sha256:1b3a2ffce52cc4dbaeee4df762f20a2905aa171ef157b82192f2e2f368eec05d"}, - {file = "mypy-1.10.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:fe85ed6836165d52ae8b88f99527d3d1b2362e0cb90b005409b8bed90e9059b3"}, - {file = "mypy-1.10.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:c2ae450d60d7d020d67ab440c6e3fae375809988119817214440033f26ddf7bf"}, - {file = "mypy-1.10.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6be84c06e6abd72f960ba9a71561c14137a583093ffcf9bbfaf5e613d63fa531"}, - {file = "mypy-1.10.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:2189ff1e39db399f08205e22a797383613ce1cb0cb3b13d8bcf0170e45b96cc3"}, - {file = "mypy-1.10.1-cp39-cp39-win_amd64.whl", hash = "sha256:97a131ee36ac37ce9581f4220311247ab6cba896b4395b9c87af0675a13a755f"}, - {file = "mypy-1.10.1-py3-none-any.whl", hash = "sha256:71d8ac0b906354ebda8ef1673e5fde785936ac1f29ff6987c7483cfbd5a4235a"}, - {file = "mypy-1.10.1.tar.gz", hash = "sha256:1f8f492d7db9e3593ef42d4f115f04e556130f2819ad33ab84551403e97dd4c0"}, + {file = "mypy-1.11.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:a3824187c99b893f90c845bab405a585d1ced4ff55421fdf5c84cb7710995229"}, + {file = "mypy-1.11.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:96f8dbc2c85046c81bcddc246232d500ad729cb720da4e20fce3b542cab91287"}, + {file = "mypy-1.11.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1a5d8d8dd8613a3e2be3eae829ee891b6b2de6302f24766ff06cb2875f5be9c6"}, + {file = "mypy-1.11.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:72596a79bbfb195fd41405cffa18210af3811beb91ff946dbcb7368240eed6be"}, + {file = "mypy-1.11.0-cp310-cp310-win_amd64.whl", hash = "sha256:35ce88b8ed3a759634cb4eb646d002c4cef0a38f20565ee82b5023558eb90c00"}, + {file = "mypy-1.11.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:98790025861cb2c3db8c2f5ad10fc8c336ed2a55f4daf1b8b3f877826b6ff2eb"}, + {file = "mypy-1.11.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:25bcfa75b9b5a5f8d67147a54ea97ed63a653995a82798221cca2a315c0238c1"}, + {file = "mypy-1.11.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0bea2a0e71c2a375c9fa0ede3d98324214d67b3cbbfcbd55ac8f750f85a414e3"}, + {file = "mypy-1.11.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:d2b3d36baac48e40e3064d2901f2fbd2a2d6880ec6ce6358825c85031d7c0d4d"}, + {file = "mypy-1.11.0-cp311-cp311-win_amd64.whl", hash = "sha256:d8e2e43977f0e09f149ea69fd0556623919f816764e26d74da0c8a7b48f3e18a"}, + {file = "mypy-1.11.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:1d44c1e44a8be986b54b09f15f2c1a66368eb43861b4e82573026e04c48a9e20"}, + {file = "mypy-1.11.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:cea3d0fb69637944dd321f41bc896e11d0fb0b0aa531d887a6da70f6e7473aba"}, + {file = "mypy-1.11.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a83ec98ae12d51c252be61521aa5731f5512231d0b738b4cb2498344f0b840cd"}, + {file = "mypy-1.11.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:c7b73a856522417beb78e0fb6d33ef89474e7a622db2653bc1285af36e2e3e3d"}, + {file = "mypy-1.11.0-cp312-cp312-win_amd64.whl", hash = "sha256:f2268d9fcd9686b61ab64f077be7ffbc6fbcdfb4103e5dd0cc5eaab53a8886c2"}, + {file = "mypy-1.11.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:940bfff7283c267ae6522ef926a7887305945f716a7704d3344d6d07f02df850"}, + {file = "mypy-1.11.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:14f9294528b5f5cf96c721f231c9f5b2733164e02c1c018ed1a0eff8a18005ac"}, + {file = "mypy-1.11.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d7b54c27783991399046837df5c7c9d325d921394757d09dbcbf96aee4649fe9"}, + {file = "mypy-1.11.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:65f190a6349dec29c8d1a1cd4aa71284177aee5949e0502e6379b42873eddbe7"}, + {file = "mypy-1.11.0-cp38-cp38-win_amd64.whl", hash = "sha256:dbe286303241fea8c2ea5466f6e0e6a046a135a7e7609167b07fd4e7baf151bf"}, + {file = "mypy-1.11.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:104e9c1620c2675420abd1f6c44bab7dd33cc85aea751c985006e83dcd001095"}, + {file = "mypy-1.11.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:f006e955718ecd8d159cee9932b64fba8f86ee6f7728ca3ac66c3a54b0062abe"}, + {file = "mypy-1.11.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:becc9111ca572b04e7e77131bc708480cc88a911adf3d0239f974c034b78085c"}, + {file = "mypy-1.11.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:6801319fe76c3f3a3833f2b5af7bd2c17bb93c00026a2a1b924e6762f5b19e13"}, + {file = "mypy-1.11.0-cp39-cp39-win_amd64.whl", hash = "sha256:c1a184c64521dc549324ec6ef7cbaa6b351912be9cb5edb803c2808a0d7e85ac"}, + {file = "mypy-1.11.0-py3-none-any.whl", hash = "sha256:56913ec8c7638b0091ef4da6fcc9136896914a9d60d54670a75880c3e5b99ace"}, + {file = "mypy-1.11.0.tar.gz", hash = "sha256:93743608c7348772fdc717af4aeee1997293a1ad04bc0ea6efa15bf65385c538"}, ] [package.dependencies] mypy-extensions = ">=1.0.0" tomli = {version = ">=1.1.0", markers = "python_version < \"3.11\""} -typing-extensions = ">=4.1.0" +typing-extensions = ">=4.6.0" [package.extras] dmypy = ["psutil (>=4.0)"] @@ -985,6 +1119,21 @@ files = [ {file = "mypy_extensions-1.0.0.tar.gz", hash = "sha256:75dbf8955dc00442a438fc4d0666508a9a97b6bd41aa2f0ffe9d2f2725af0782"}, ] +[[package]] +name = "mypy-protobuf" +version = "3.6.0" +description = "Generate mypy stub files from protobuf specs" +optional = false +python-versions = ">=3.8" +files = [ + {file = "mypy-protobuf-3.6.0.tar.gz", hash = "sha256:02f242eb3409f66889f2b1a3aa58356ec4d909cdd0f93115622e9e70366eca3c"}, + {file = "mypy_protobuf-3.6.0-py3-none-any.whl", hash = "sha256:56176e4d569070e7350ea620262478b49b7efceba4103d468448f1d21492fd6c"}, +] + +[package.dependencies] +protobuf = ">=4.25.3" +types-protobuf = ">=4.24" + [[package]] name = "nodeenv" version = "1.9.1" @@ -1056,6 +1205,26 @@ nodeenv = ">=0.11.1" pyyaml = ">=5.1" virtualenv = ">=20.10.0" +[[package]] +name = "protobuf" +version = "5.27.2" +description = "" +optional = false +python-versions = ">=3.8" +files = [ + {file = "protobuf-5.27.2-cp310-abi3-win32.whl", hash = "sha256:354d84fac2b0d76062e9b3221f4abbbacdfd2a4d8af36bab0474f3a0bb30ab38"}, + {file = "protobuf-5.27.2-cp310-abi3-win_amd64.whl", hash = "sha256:0e341109c609749d501986b835f667c6e1e24531096cff9d34ae411595e26505"}, + {file = "protobuf-5.27.2-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:a109916aaac42bff84702fb5187f3edadbc7c97fc2c99c5ff81dd15dcce0d1e5"}, + {file = "protobuf-5.27.2-cp38-abi3-manylinux2014_aarch64.whl", hash = "sha256:176c12b1f1c880bf7a76d9f7c75822b6a2bc3db2d28baa4d300e8ce4cde7409b"}, + {file = "protobuf-5.27.2-cp38-abi3-manylinux2014_x86_64.whl", hash = "sha256:b848dbe1d57ed7c191dfc4ea64b8b004a3f9ece4bf4d0d80a367b76df20bf36e"}, + {file = "protobuf-5.27.2-cp38-cp38-win32.whl", hash = "sha256:4fadd8d83e1992eed0248bc50a4a6361dc31bcccc84388c54c86e530b7f58863"}, + {file = "protobuf-5.27.2-cp38-cp38-win_amd64.whl", hash = "sha256:610e700f02469c4a997e58e328cac6f305f649826853813177e6290416e846c6"}, + {file = "protobuf-5.27.2-cp39-cp39-win32.whl", hash = "sha256:9e8f199bf7f97bd7ecebffcae45ebf9527603549b2b562df0fbc6d4d688f14ca"}, + {file = "protobuf-5.27.2-cp39-cp39-win_amd64.whl", hash = "sha256:7fc3add9e6003e026da5fc9e59b131b8f22b428b991ccd53e2af8071687b4fce"}, + {file = "protobuf-5.27.2-py3-none-any.whl", hash = "sha256:54330f07e4949d09614707c48b06d1a22f8ffb5763c159efd5c0928326a91470"}, + {file = "protobuf-5.27.2.tar.gz", hash = "sha256:f3ecdef226b9af856075f28227ff2c90ce3a594d092c39bee5513573f25e2714"}, +] + [[package]] name = "pycparser" version = "2.22" @@ -1327,6 +1496,7 @@ files = [ {file = "PyYAML-6.0.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:69b023b2b4daa7548bcfbd4aa3da05b3a74b772db9e23b982788168117739938"}, {file = "PyYAML-6.0.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:81e0b275a9ecc9c0c0c07b4b90ba548307583c125f54d5b6946cfee6360c733d"}, {file = "PyYAML-6.0.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba336e390cd8e4d1739f42dfe9bb83a3cc2e80f567d8805e11b46f4a943f5515"}, + {file = "PyYAML-6.0.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:326c013efe8048858a6d312ddd31d56e468118ad4cdeda36c719bf5bb6192290"}, {file = "PyYAML-6.0.1-cp310-cp310-win32.whl", hash = "sha256:bd4af7373a854424dabd882decdc5579653d7868b8fb26dc7d0e99f823aa5924"}, {file = "PyYAML-6.0.1-cp310-cp310-win_amd64.whl", hash = "sha256:fd1592b3fdf65fff2ad0004b5e363300ef59ced41c2e6b3a99d4089fa8c5435d"}, {file = "PyYAML-6.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6965a7bc3cf88e5a1c3bd2e0b5c22f8d677dc88a455344035f03399034eb3007"}, @@ -1334,8 +1504,16 @@ files = [ {file = "PyYAML-6.0.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:42f8152b8dbc4fe7d96729ec2b99c7097d656dc1213a3229ca5383f973a5ed6d"}, {file = "PyYAML-6.0.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:062582fca9fabdd2c8b54a3ef1c978d786e0f6b3a1510e0ac93ef59e0ddae2bc"}, {file = "PyYAML-6.0.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d2b04aac4d386b172d5b9692e2d2da8de7bfb6c387fa4f801fbf6fb2e6ba4673"}, + {file = "PyYAML-6.0.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:e7d73685e87afe9f3b36c799222440d6cf362062f78be1013661b00c5c6f678b"}, {file = "PyYAML-6.0.1-cp311-cp311-win32.whl", hash = "sha256:1635fd110e8d85d55237ab316b5b011de701ea0f29d07611174a1b42f1444741"}, {file = "PyYAML-6.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:bf07ee2fef7014951eeb99f56f39c9bb4af143d8aa3c21b1677805985307da34"}, + {file = "PyYAML-6.0.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:855fb52b0dc35af121542a76b9a84f8d1cd886ea97c84703eaa6d88e37a2ad28"}, + {file = "PyYAML-6.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:40df9b996c2b73138957fe23a16a4f0ba614f4c0efce1e9406a184b6d07fa3a9"}, + {file = "PyYAML-6.0.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a08c6f0fe150303c1c6b71ebcd7213c2858041a7e01975da3a99aed1e7a378ef"}, + {file = "PyYAML-6.0.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6c22bec3fbe2524cde73d7ada88f6566758a8f7227bfbf93a408a9d86bcc12a0"}, + {file = "PyYAML-6.0.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8d4e9c88387b0f5c7d5f281e55304de64cf7f9c0021a3525bd3b1c542da3b0e4"}, + {file = "PyYAML-6.0.1-cp312-cp312-win32.whl", hash = "sha256:d483d2cdf104e7c9fa60c544d92981f12ad66a457afae824d146093b8c294c54"}, + {file = "PyYAML-6.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:0d3304d8c0adc42be59c5f8a4d9e3d7379e6955ad754aa9d6ab7a398b59dd1df"}, {file = "PyYAML-6.0.1-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:50550eb667afee136e9a77d6dc71ae76a44df8b3e51e41b77f6de2932bfe0f47"}, {file = "PyYAML-6.0.1-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1fe35611261b29bd1de0070f0b2f47cb6ff71fa6595c077e42bd0c419fa27b98"}, {file = "PyYAML-6.0.1-cp36-cp36m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:704219a11b772aea0d8ecd7058d0082713c3562b4e271b849ad7dc4a5c90c13c"}, @@ -1352,6 +1530,7 @@ files = [ {file = "PyYAML-6.0.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a0cd17c15d3bb3fa06978b4e8958dcdc6e0174ccea823003a106c7d4d7899ac5"}, {file = "PyYAML-6.0.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:28c119d996beec18c05208a8bd78cbe4007878c6dd15091efb73a30e90539696"}, {file = "PyYAML-6.0.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7e07cbde391ba96ab58e532ff4803f79c4129397514e1413a7dc761ccd755735"}, + {file = "PyYAML-6.0.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:49a183be227561de579b4a36efbb21b3eab9651dd81b1858589f796549873dd6"}, {file = "PyYAML-6.0.1-cp38-cp38-win32.whl", hash = "sha256:184c5108a2aca3c5b3d3bf9395d50893a7ab82a38004c8f61c258d4428e80206"}, {file = "PyYAML-6.0.1-cp38-cp38-win_amd64.whl", hash = "sha256:1e2722cc9fbb45d9b87631ac70924c11d3a401b2d7f410cc0e3bbf249f2dca62"}, {file = "PyYAML-6.0.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:9eb6caa9a297fc2c2fb8862bc5370d0303ddba53ba97e71f08023b6cd73d16a8"}, @@ -1359,6 +1538,7 @@ files = [ {file = "PyYAML-6.0.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5773183b6446b2c99bb77e77595dd486303b4faab2b086e7b17bc6bef28865f6"}, {file = "PyYAML-6.0.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b786eecbdf8499b9ca1d697215862083bd6d2a99965554781d0d8d1ad31e13a0"}, {file = "PyYAML-6.0.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc1bf2925a1ecd43da378f4db9e4f799775d6367bdb94671027b73b393a7c42c"}, + {file = "PyYAML-6.0.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:04ac92ad1925b2cff1db0cfebffb6ffc43457495c9b3c39d3fcae417d7125dc5"}, {file = "PyYAML-6.0.1-cp39-cp39-win32.whl", hash = "sha256:faca3bdcf85b2fc05d06ff3fbc1f83e1391b3e724afa3feba7d13eeab355484c"}, {file = "PyYAML-6.0.1-cp39-cp39-win_amd64.whl", hash = "sha256:510c9deebc5c0225e8c96813043e62b680ba2f9c50a08d3724c7f28a747d1486"}, {file = "PyYAML-6.0.1.tar.gz", hash = "sha256:bfdf460b1736c775f2ba9f6a92bca30bc2095067b8a9d77876d1fad6cc3b4a43"}, @@ -1613,6 +1793,17 @@ files = [ {file = "tomli-2.0.1.tar.gz", hash = "sha256:de526c12914f0c550d15924c62d72abc48d6fe7364aa87328337a31007fe8a4f"}, ] +[[package]] +name = "types-protobuf" +version = "5.27.0.20240626" +description = "Typing stubs for protobuf" +optional = false +python-versions = ">=3.8" +files = [ + {file = "types-protobuf-5.27.0.20240626.tar.gz", hash = "sha256:683ba14043bade6785e3f937a7498f243b37881a91ac8d81b9202ecf8b191e9c"}, + {file = "types_protobuf-5.27.0.20240626-py3-none-any.whl", hash = "sha256:688e8f7e8d9295db26bc560df01fb731b27a25b77cbe4c1ce945647f7024f5c1"}, +] + [[package]] name = "typing-extensions" version = "4.12.2" @@ -1885,4 +2076,4 @@ test = ["big-O", "importlib-resources", "jaraco.functools", "jaraco.itertools", [metadata] lock-version = "2.0" python-versions = "^3.8.1" -content-hash = "d312a7a7c367a8c7f3664f4691e8e39aae6bc9aaf2e116abaf9e7fa1f28fe479" +content-hash = "54e4b2461b7a222dc287c8e9da19edaa3a18268a2f0da4230b7613fa6ef884ec" diff --git a/pyproject.toml b/pyproject.toml index ca700550..1bf7810a 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -35,6 +35,11 @@ slowapi = "^0.1.9" cbor2 = "^5.6.2" asyncpg = "^0.29.0" aiosqlite = "^0.20.0" +grpcio = "^1.65.1" +googleapis-common-protos = "^1.63.2" +mypy-protobuf = "^3.6.0" +types-protobuf = "^5.27.0.20240626" +grpcio-tools = "^1.65.1" [tool.poetry.group.dev.dependencies] pytest-asyncio = "^0.21.1"