Archives
/
loop
mirror of https://github.com/lightninglabs/loop
2
0
Fork 0
Code Issues Releases Wiki Activity

looprpc: split quote message

Browse Source
pull/249/head
Joost Jager 4 years ago
parent 24099aa4f9
commit 8d1ec50fa7
No known key found for this signature in database
GPG Key ID: A61B9D4C393C59C7
8 changed files with 387 additions and 265 deletions
Show Stats Download Patch File Download Diff File

21
cmd/loop/loopin.go
Unescape Escape View File

@ -7,7 +7,6 @@ import (
"github.com/btcsuite/btcutil"
"github.com/lightninglabs/loop"
"github.com/lightninglabs/loop/looprpc"
"github.com/lightninglabs/loop/swap"
"github.com/lightningnetwork/lnd/routing/route"
"github.com/urfave/cli"
)
@ -111,17 +110,18 @@ func loopIn(ctx *cli.Context) error {
// HTLC. If the wallet doesn't have enough funds to create this TX, we
// know it won't have enough to pay the real transaction either. It
// makes sense to abort the loop in this case.
if !external && quote.MinerFee == int64(loop.MinerFeeEstimationFailed) {
if !external && quote.HtlcPublishFeeSat ==
int64(loop.MinerFeeEstimationFailed) {
return fmt.Errorf("miner fee estimation not " +
"possible, lnd has insufficient funds to " +
"create a sample transaction for selected " +
"amount")
}
limits := getInLimits(amt, quote)
err = displayLimits(
swap.TypeIn, amt, btcutil.Amount(quote.MinerFee), limits,
external, "",
limits := getInLimits(quote)
err = displayInLimits(
amt, btcutil.Amount(quote.HtlcPublishFeeSat), limits, external,
)
if err != nil {
return err
@ -165,12 +165,3 @@ func loopIn(ctx *cli.Context) error {
return nil
}
func getInLimits(amt btcutil.Amount, quote *looprpc.QuoteResponse) *limits {
return &limits{
// Apply a multiplier to the estimated miner fee, to not get
// the swap canceled because fees increased in the mean time.
maxMinerFee: btcutil.Amount(quote.MinerFee) * 3,
maxSwapFee: btcutil.Amount(quote.SwapFee),
}
}

16
cmd/loop/loopout.go
Unescape Escape View File

@ -10,7 +10,6 @@ import (
"github.com/btcsuite/btcutil"
"github.com/lightninglabs/loop"
"github.com/lightninglabs/loop/looprpc"
"github.com/lightninglabs/loop/swap"
"github.com/urfave/cli"
)
@ -148,16 +147,15 @@ func loopOut(ctx *cli.Context) error {
defaultSwapWaitTime)
}
limits := getLimits(amt, quote)
limits := getOutLimits(amt, quote)
// If configured, use the specified maximum swap routing fee.
if ctx.IsSet("max_swap_routing_fee") {
*limits.maxSwapRoutingFee = btcutil.Amount(
limits.maxSwapRoutingFee = btcutil.Amount(
ctx.Int64("max_swap_routing_fee"),
)
}
err = displayLimits(
swap.TypeOut, amt, btcutil.Amount(quote.MinerFee), limits,
false, warning,
err = displayOutLimits(
amt, btcutil.Amount(quote.HtlcSweepFeeSat), limits, warning,
)
if err != nil {
return err
@ -167,10 +165,10 @@ func loopOut(ctx *cli.Context) error {
Amt: int64(amt),
Dest: destAddr,
MaxMinerFee: int64(limits.maxMinerFee),
MaxPrepayAmt: int64(*limits.maxPrepayAmt),
MaxPrepayAmt: int64(limits.maxPrepayAmt),
MaxSwapFee: int64(limits.maxSwapFee),
MaxPrepayRoutingFee: int64(*limits.maxPrepayRoutingFee),
MaxSwapRoutingFee: int64(*limits.maxSwapRoutingFee),
MaxPrepayRoutingFee: int64(limits.maxPrepayRoutingFee),
MaxSwapRoutingFee: int64(limits.maxSwapRoutingFee),
OutgoingChanSet: outgoingChanSet,
SweepConfTarget: sweepConfTarget,
SwapPublicationDeadline: uint64(swapDeadline.Unix()),

125
cmd/loop/main.go
Unescape Escape View File

@ -136,59 +136,65 @@ func getMaxRoutingFee(amt btcutil.Amount) btcutil.Amount {
return swap.CalcFee(amt, maxRoutingFeeBase, maxRoutingFeeRate)
}
type limits struct {
maxSwapRoutingFee *btcutil.Amount
maxPrepayRoutingFee *btcutil.Amount
type inLimits struct {
maxMinerFee btcutil.Amount
maxSwapFee btcutil.Amount
}
func getInLimits(quote *looprpc.InQuoteResponse) *inLimits {
return &inLimits{
// Apply a multiplier to the estimated miner fee, to not get
// the swap canceled because fees increased in the mean time.
maxMinerFee: btcutil.Amount(quote.HtlcPublishFeeSat) * 3,
maxSwapFee: btcutil.Amount(quote.SwapFeeSat),
}
}
type outLimits struct {
maxSwapRoutingFee btcutil.Amount
maxPrepayRoutingFee btcutil.Amount
maxMinerFee btcutil.Amount
maxSwapFee btcutil.Amount
maxPrepayAmt *btcutil.Amount
maxPrepayAmt btcutil.Amount
}
func getLimits(amt btcutil.Amount, quote *looprpc.QuoteResponse) *limits {
func getOutLimits(amt btcutil.Amount,
quote *looprpc.OutQuoteResponse) *outLimits {
maxSwapRoutingFee := getMaxRoutingFee(amt)
maxPrepayRoutingFee := getMaxRoutingFee(btcutil.Amount(
quote.PrepayAmt,
quote.PrepayAmtSat,
))
maxPrepayAmt := btcutil.Amount(quote.PrepayAmt)
maxPrepayAmt := btcutil.Amount(quote.PrepayAmtSat)
return &limits{
maxSwapRoutingFee: &maxSwapRoutingFee,
maxPrepayRoutingFee: &maxPrepayRoutingFee,
return &outLimits{
maxSwapRoutingFee: maxSwapRoutingFee,
maxPrepayRoutingFee: maxPrepayRoutingFee,
// Apply a multiplier to the estimated miner fee, to not get
// the swap canceled because fees increased in the mean time.
maxMinerFee: btcutil.Amount(quote.MinerFee) * 100,
maxMinerFee: btcutil.Amount(quote.HtlcSweepFeeSat) * 100,
maxSwapFee: btcutil.Amount(quote.SwapFee),
maxPrepayAmt: &maxPrepayAmt,
maxSwapFee: btcutil.Amount(quote.SwapFeeSat),
maxPrepayAmt: maxPrepayAmt,
}
}
func displayLimits(swapType swap.Type, amt, minerFees btcutil.Amount, l *limits,
externalHtlc bool, warning string) error {
func displayInLimits(amt, minerFees btcutil.Amount, l *inLimits,
externalHtlc bool) error {
totalSuccessMax := l.maxMinerFee + l.maxSwapFee
if l.maxSwapRoutingFee != nil {
totalSuccessMax += *l.maxSwapRoutingFee
}
if l.maxPrepayRoutingFee != nil {
totalSuccessMax += *l.maxPrepayRoutingFee
}
if swapType == swap.TypeIn && externalHtlc {
if externalHtlc {
fmt.Printf("On-chain fee for external loop in is not " +
"included.\nSufficient fees will need to be paid " +
"when constructing the transaction in the external " +
"wallet.\n\n")
}
fmt.Printf("Max swap fees for %d sat Loop %v: %d sat\n", amt, swapType,
fmt.Printf("Max swap fees for %d sat Loop %v: %d sat\n", amt, swap.TypeIn,
totalSuccessMax)
if warning != "" {
fmt.Println(warning)
}
fmt.Printf("CONTINUE SWAP? (y/n), expand fee detail (x): ")
var answer string
@ -201,32 +207,55 @@ func displayLimits(swapType swap.Type, amt, minerFees btcutil.Amount, l *limits,
fmt.Println()
f := "%-36s %d sat\n"
switch swapType {
case swap.TypeOut:
fmt.Printf(f, "Estimated on-chain sweep fee:",
if !externalHtlc {
fmt.Printf(f, "Estimated on-chain HTLC fee:",
minerFees)
fmt.Printf(f, "Max on-chain sweep fee:", l.maxMinerFee)
case swap.TypeIn:
if !externalHtlc {
fmt.Printf(f, "Estimated on-chain HTLC fee:",
minerFees)
}
}
if l.maxSwapRoutingFee != nil {
fmt.Printf(f, "Max off-chain swap routing fee:",
*l.maxSwapRoutingFee)
}
fmt.Printf(f, "Max swap fee:", l.maxSwapFee)
if l.maxPrepayAmt != nil {
fmt.Printf(f, "Max no show penalty (prepay):",
*l.maxPrepayAmt)
}
if l.maxPrepayRoutingFee != nil {
fmt.Printf(f, "Max off-chain prepay routing fee:",
*l.maxPrepayRoutingFee)
fmt.Printf("CONTINUE SWAP? (y/n): ")
fmt.Scanln(&answer)
if answer == "y" {
return nil
}
}
return errors.New("swap canceled")
}
func displayOutLimits(amt, minerFees btcutil.Amount, l *outLimits,
warning string) error {
totalSuccessMax := l.maxMinerFee + l.maxSwapFee + l.maxSwapRoutingFee +
l.maxPrepayRoutingFee
fmt.Printf("Max swap fees for %d sat Loop %v: %d sat\n", amt, swap.TypeOut,
totalSuccessMax)
if warning != "" {
fmt.Println(warning)
}
fmt.Printf("CONTINUE SWAP? (y/n), expand fee detail (x): ")
var answer string
fmt.Scanln(&answer)
switch answer {
case "y":
return nil
case "x":
fmt.Println()
f := "%-36s %d sat\n"
fmt.Printf(f, "Estimated on-chain sweep fee:", minerFees)
fmt.Printf(f, "Max on-chain sweep fee:", l.maxMinerFee)
fmt.Printf(f, "Max off-chain swap routing fee:",
l.maxSwapRoutingFee)
fmt.Printf(f, "Max no show penalty (prepay):", l.maxPrepayAmt)
fmt.Printf(f, "Max off-chain prepay routing fee:",
l.maxPrepayRoutingFee)
fmt.Printf(f, "Max swap fee:", l.maxSwapFee)
fmt.Printf("CONTINUE SWAP? (y/n): ")

2
cmd/loop/quote.go
Unescape Escape View File

@ -59,7 +59,7 @@ func quoteIn(ctx *cli.Context) error {
// HTLC. If the wallet doesn't have enough funds to create this TX, we
// don't want to fail the quote. But the user should still be informed
// why the fee shows as -1.
if quoteResp.MinerFee == int64(loop.MinerFeeEstimationFailed) {
if quoteResp.HtlcPublishFeeSat == int64(loop.MinerFeeEstimationFailed) {
_, _ = fmt.Fprintf(os.Stderr, "Warning: Miner fee estimation "+
"not possible, lnd has insufficient funds to "+
"create a sample transaction for selected "+

18
loopd/swapclient_server.go
Unescape Escape View File

@ -347,7 +347,7 @@ func (s *swapClientServer) LoopOutTerms(ctx context.Context,
// LoopOutQuote returns a quote for a loop out swap with the provided
// parameters.
func (s *swapClientServer) LoopOutQuote(ctx context.Context,
req *looprpc.QuoteRequest) (*looprpc.QuoteResponse, error) {
req *looprpc.QuoteRequest) (*looprpc.OutQuoteResponse, error) {
confTarget, err := validateConfTarget(
req.ConfTarget, loop.DefaultSweepConfTarget,
@ -366,10 +366,10 @@ func (s *swapClientServer) LoopOutQuote(ctx context.Context,
return nil, err
}
return &looprpc.QuoteResponse{
MinerFee: int64(quote.MinerFee),
PrepayAmt: int64(quote.PrepayAmount),
SwapFee: int64(quote.SwapFee),
return &looprpc.OutQuoteResponse{
HtlcSweepFeeSat: int64(quote.MinerFee),
PrepayAmtSat: int64(quote.PrepayAmount),
SwapFeeSat: int64(quote.SwapFee),
SwapPaymentDest: quote.SwapPaymentDest[:],
CltvDelta: quote.CltvDelta,
}, nil
@ -395,7 +395,7 @@ func (s *swapClientServer) GetLoopInTerms(ctx context.Context,
// GetQuote returns a quote for a swap with the provided parameters.
func (s *swapClientServer) GetLoopInQuote(ctx context.Context,
req *looprpc.QuoteRequest) (*looprpc.QuoteResponse, error) {
req *looprpc.QuoteRequest) (*looprpc.InQuoteResponse, error) {
log.Infof("Loop in quote request received")
@ -414,9 +414,9 @@ func (s *swapClientServer) GetLoopInQuote(ctx context.Context,
if err != nil {
return nil, err
}
return &looprpc.QuoteResponse{
MinerFee: int64(quote.MinerFee),
SwapFee: int64(quote.SwapFee),
return &looprpc.InQuoteResponse{
HtlcPublishFeeSat: int64(quote.MinerFee),
SwapFeeSat: int64(quote.SwapFee),
}, nil
}

361
looprpc/client.pb.go
Unescape Escape View File

@ -1014,22 +1014,83 @@ func (m *QuoteRequest) GetSwapPublicationDeadline() uint64 {
return 0
}
type QuoteResponse struct {
type InQuoteResponse struct {
//*
//The fee that the swap server is charging for the swap.
SwapFee int64 `protobuf:"varint,1,opt,name=swap_fee,json=swapFee,proto3" json:"swap_fee,omitempty"`
SwapFeeSat int64 `protobuf:"varint,1,opt,name=swap_fee_sat,json=swapFeeSat,proto3" json:"swap_fee_sat,omitempty"`
//
//An estimate of the on-chain fee that needs to be paid to publish the HTLC
//If a miner fee of 0 is returned, it means the external_htlc flag was set for
//a loop in and the fee estimation was skipped. If a miner fee of -1 is
//returned, it means lnd's wallet tried to estimate the fee but was unable to
//create a sample estimation transaction because not enough funds are
//available. An information message should be shown to the user in this case.
HtlcPublishFeeSat int64 `protobuf:"varint,3,opt,name=htlc_publish_fee_sat,json=htlcPublishFeeSat,proto3" json:"htlc_publish_fee_sat,omitempty"`
//*
//On-chain cltv expiry delta
CltvDelta int32 `protobuf:"varint,5,opt,name=cltv_delta,json=cltvDelta,proto3" json:"cltv_delta,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *InQuoteResponse) Reset() { *m = InQuoteResponse{} }
func (m *InQuoteResponse) String() string { return proto.CompactTextString(m) }
func (*InQuoteResponse) ProtoMessage() {}
func (*InQuoteResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_014de31d7ac8c57c, []int{12}
}
func (m *InQuoteResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_InQuoteResponse.Unmarshal(m, b)
}
func (m *InQuoteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_InQuoteResponse.Marshal(b, m, deterministic)
}
func (m *InQuoteResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_InQuoteResponse.Merge(m, src)
}
func (m *InQuoteResponse) XXX_Size() int {
return xxx_messageInfo_InQuoteResponse.Size(m)
}
func (m *InQuoteResponse) XXX_DiscardUnknown() {
xxx_messageInfo_InQuoteResponse.DiscardUnknown(m)
}
var xxx_messageInfo_InQuoteResponse proto.InternalMessageInfo
func (m *InQuoteResponse) GetSwapFeeSat() int64 {
if m != nil {
return m.SwapFeeSat
}
return 0
}
func (m *InQuoteResponse) GetHtlcPublishFeeSat() int64 {
if m != nil {
return m.HtlcPublishFeeSat
}
return 0
}
func (m *InQuoteResponse) GetCltvDelta() int32 {
if m != nil {
return m.CltvDelta
}
return 0
}
type OutQuoteResponse struct {
//*
//The fee that the swap server is charging for the swap.
SwapFeeSat int64 `protobuf:"varint,1,opt,name=swap_fee_sat,json=swapFeeSat,proto3" json:"swap_fee_sat,omitempty"`
//*
//The part of the swap fee that is requested as a prepayment.
PrepayAmt int64 `protobuf:"varint,2,opt,name=prepay_amt,json=prepayAmt,proto3" json:"prepay_amt,omitempty"`
PrepayAmtSat int64 `protobuf:"varint,2,opt,name=prepay_amt_sat,json=prepayAmtSat,proto3" json:"prepay_amt_sat,omitempty"`
//*
//An estimate of the on-chain fee that needs to be paid to sweep the HTLC for
//a loop out or to pay to the HTLC for loop in. If a miner fee of 0 is
//returned, it means the external_htlc flag was set for a loop in and the fee
//estimation was skipped. If a miner fee of -1 is returned, it means lnd's
//wallet tried to estimate the fee but was unable to create a sample
//estimation transaction because not enough funds are available. An
//information message should be shown to the user in this case.
MinerFee int64 `protobuf:"varint,3,opt,name=miner_fee,json=minerFee,proto3" json:"miner_fee,omitempty"`
//a loop out.
HtlcSweepFeeSat int64 `protobuf:"varint,3,opt,name=htlc_sweep_fee_sat,json=htlcSweepFeeSat,proto3" json:"htlc_sweep_fee_sat,omitempty"`
//*
//The node pubkey where the swap payment needs to be paid
//to. This can be used to test connectivity before initiating the swap.
@ -1042,60 +1103,60 @@ type QuoteResponse struct {
XXX_sizecache int32 `json:"-"`
}
func (m *QuoteResponse) Reset() { *m = QuoteResponse{} }
func (m *QuoteResponse) String() string { return proto.CompactTextString(m) }
func (*QuoteResponse) ProtoMessage() {}
func (*QuoteResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_014de31d7ac8c57c, []int{12}
func (m *OutQuoteResponse) Reset() { *m = OutQuoteResponse{} }
func (m *OutQuoteResponse) String() string { return proto.CompactTextString(m) }
func (*OutQuoteResponse) ProtoMessage() {}
func (*OutQuoteResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_014de31d7ac8c57c, []int{13}
}
func (m *QuoteResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_QuoteResponse.Unmarshal(m, b)
func (m *OutQuoteResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_OutQuoteResponse.Unmarshal(m, b)
}
func (m *QuoteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_QuoteResponse.Marshal(b, m, deterministic)
func (m *OutQuoteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_OutQuoteResponse.Marshal(b, m, deterministic)
}
func (m *QuoteResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_QuoteResponse.Merge(m, src)
func (m *OutQuoteResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_OutQuoteResponse.Merge(m, src)
}
func (m *QuoteResponse) XXX_Size() int {
return xxx_messageInfo_QuoteResponse.Size(m)
func (m *OutQuoteResponse) XXX_Size() int {
return xxx_messageInfo_OutQuoteResponse.Size(m)
}
func (m *QuoteResponse) XXX_DiscardUnknown() {
xxx_messageInfo_QuoteResponse.DiscardUnknown(m)
func (m *OutQuoteResponse) XXX_DiscardUnknown() {
xxx_messageInfo_OutQuoteResponse.DiscardUnknown(m)
}
var xxx_messageInfo_QuoteResponse proto.InternalMessageInfo
var xxx_messageInfo_OutQuoteResponse proto.InternalMessageInfo
func (m *QuoteResponse) GetSwapFee() int64 {
func (m *OutQuoteResponse) GetSwapFeeSat() int64 {
if m != nil {
return m.SwapFee
return m.SwapFeeSat
}
return 0
}
func (m *QuoteResponse) GetPrepayAmt() int64 {
func (m *OutQuoteResponse) GetPrepayAmtSat() int64 {
if m != nil {
return m.PrepayAmt
return m.PrepayAmtSat
}
return 0
}
func (m *QuoteResponse) GetMinerFee() int64 {
func (m *OutQuoteResponse) GetHtlcSweepFeeSat() int64 {
if m != nil {
return m.MinerFee
return m.HtlcSweepFeeSat
}
return 0
}
func (m *QuoteResponse) GetSwapPaymentDest() []byte {
func (m *OutQuoteResponse) GetSwapPaymentDest() []byte {
if m != nil {
return m.SwapPaymentDest
}
return nil
}
func (m *QuoteResponse) GetCltvDelta() int32 {
func (m *OutQuoteResponse) GetCltvDelta() int32 {
if m != nil {
return m.CltvDelta
}
@ -1112,7 +1173,7 @@ func (m *TokensRequest) Reset() { *m = TokensRequest{} }
func (m *TokensRequest) String() string { return proto.CompactTextString(m) }
func (*TokensRequest) ProtoMessage() {}
func (*TokensRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_014de31d7ac8c57c, []int{13}
return fileDescriptor_014de31d7ac8c57c, []int{14}
}
func (m *TokensRequest) XXX_Unmarshal(b []byte) error {
@ -1146,7 +1207,7 @@ func (m *TokensResponse) Reset() { *m = TokensResponse{} }
func (m *TokensResponse) String() string { return proto.CompactTextString(m) }
func (*TokensResponse) ProtoMessage() {}
func (*TokensResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_014de31d7ac8c57c, []int{14}
return fileDescriptor_014de31d7ac8c57c, []int{15}
}
func (m *TokensResponse) XXX_Unmarshal(b []byte) error {
@ -1211,7 +1272,7 @@ func (m *LsatToken) Reset() { *m = LsatToken{} }
func (m *LsatToken) String() string { return proto.CompactTextString(m) }
func (*LsatToken) ProtoMessage() {}
func (*LsatToken) Descriptor() ([]byte, []int) {
return fileDescriptor_014de31d7ac8c57c, []int{15}
return fileDescriptor_014de31d7ac8c57c, []int{16}
}
func (m *LsatToken) XXX_Unmarshal(b []byte) error {
@ -1303,7 +1364,8 @@ func init() {
proto.RegisterType((*InTermsResponse)(nil), "looprpc.InTermsResponse")
proto.RegisterType((*OutTermsResponse)(nil), "looprpc.OutTermsResponse")
proto.RegisterType((*QuoteRequest)(nil), "looprpc.QuoteRequest")
proto.RegisterType((*QuoteResponse)(nil), "looprpc.QuoteResponse")
proto.RegisterType((*InQuoteResponse)(nil), "looprpc.InQuoteResponse")
proto.RegisterType((*OutQuoteResponse)(nil), "looprpc.OutQuoteResponse")
proto.RegisterType((*TokensRequest)(nil), "looprpc.TokensRequest")
proto.RegisterType((*TokensResponse)(nil), "looprpc.TokensResponse")
proto.RegisterType((*LsatToken)(nil), "looprpc.LsatToken")
@ -1312,106 +1374,109 @@ func init() {
func init() { proto.RegisterFile("client.proto", fileDescriptor_014de31d7ac8c57c) }
var fileDescriptor_014de31d7ac8c57c = []byte{
// 1570 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x57, 0xcd, 0x6e, 0xdb, 0xca,
0x15, 0x0e, 0xf5, 0xaf, 0x23, 0x8a, 0xa2, 0xc6, 0x89, 0x2d, 0xab, 0x0d, 0xa2, 0xb0, 0x4d, 0xab,
0x18, 0x81, 0xd5, 0x38, 0xab, 0x06, 0x45, 0x01, 0x47, 0x56, 0x62, 0x19, 0xb6, 0xa5, 0x52, 0x72,
0x80, 0x16, 0x05, 0xd8, 0xb1, 0x38, 0xb6, 0x88, 0x8a, 0x1c, 0x86, 0x33, 0x8a, 0x6d, 0x04, 0x45,
0x8b, 0xbe, 0x42, 0xdf, 0xa0, 0x6f, 0xd0, 0x75, 0xdf, 0xa0, 0xbb, 0xa2, 0x0f, 0xd0, 0xcd, 0xdd,
0xdc, 0x47, 0xb8, 0xbb, 0x8b, 0x99, 0xa1, 0x28, 0x4a, 0x96, 0xb3, 0xb8, 0x9b, 0xbb, 0x13, 0xbf,
0xf9, 0xe6, 0x9b, 0x33, 0xe7, 0x9c, 0xf9, 0x66, 0x04, 0xfa, 0x64, 0xe6, 0x91, 0x80, 0xef, 0x87,
0x11, 0xe5, 0x14, 0x15, 0x67, 0x94, 0x86, 0x51, 0x38, 0x69, 0xfe, 0xf4, 0x9a, 0xd2, 0xeb, 0x19,
0xe9, 0xe0, 0xd0, 0xeb, 0xe0, 0x20, 0xa0, 0x1c, 0x73, 0x8f, 0x06, 0x4c, 0xd1, 0xac, 0xff, 0x64,
0xc1, 0x38, 0xa5, 0x34, 0x1c, 0xcc, 0xb9, 0x4d, 0x3e, 0xcd, 0x09, 0xe3, 0xc8, 0x84, 0x2c, 0xf6,
0x79, 0x43, 0x6b, 0x69, 0xed, 0xac, 0x2d, 0x7e, 0x22, 0x04, 0x39, 0x97, 0x30, 0xde, 0xc8, 0xb4,
0xb4, 0x76, 0xd9, 0x96, 0xbf, 0x51, 0x07, 0x1e, 0xfb, 0xf8, 0xd6, 0x61, 0x37, 0x38, 0x74, 0x22,
0x3a, 0xe7, 0x5e, 0x70, 0xed, 0x5c, 0x11, 0xd2, 0xc8, 0xca, 0x69, 0x75, 0x1f, 0xdf, 0x8e, 0x6e,
0x70, 0x68, 0xab, 0x91, 0xf7, 0x84, 0xa0, 0x37, 0xb0, 0x2d, 0x26, 0x84, 0x11, 0x09, 0xf1, 0xdd,
0xca, 0x94, 0x9c, 0x9c, 0xb2, 0xe5, 0xe3, 0xdb, 0xa1, 0x1c, 0x4c, 0x4d, 0x6a, 0x81, 0x9e, 0xac,
0x22, 0xa8, 0x79, 0x49, 0x85, 0x58, 0x5d, 0x30, 0x7e, 0x0e, 0x46, 0x4a, 0x56, 0x04, 0x5e, 0x90,
0x1c, 0x3d, 0x91, 0x3b, 0xf4, 0x39, 0xb2, 0xa0, 0x2a, 0x58, 0xbe, 0x17, 0x90, 0x48, 0x0a, 0x15,
0x25, 0xa9, 0xe2, 0xe3, 0xdb, 0x33, 0x81, 0x09, 0xa5, 0x57, 0x60, 0x8a, 0x9c, 0x39, 0x74, 0xce,
0x9d, 0xc9, 0x14, 0x07, 0x01, 0x99, 0x35, 0x4a, 0x2d, 0xad, 0x9d, 0x7b, 0x97, 0x69, 0x68, 0xb6,
0x31, 0x53, 0x59, 0xea, 0xaa, 0x11, 0xb4, 0x07, 0x75, 0x3a, 0xe7, 0xd7, 0x54, 0x6c, 0x42, 0xb0,
0x1d, 0x46, 0x78, 0xa3, 0xd2, 0xca, 0xb6, 0x73, 0x76, 0x6d, 0x31, 0x20, 0xb8, 0x23, 0xc2, 0x05,
0x97, 0xdd, 0x10, 0x12, 0x3a, 0x13, 0x1a, 0x5c, 0x39, 0x1c, 0x47, 0xd7, 0x84, 0x37, 0xca, 0x2d,
0xad, 0x9d, 0xb7, 0x6b, 0x72, 0xa0, 0x4b, 0x83, 0xab, 0xb1, 0x84, 0xd1, 0x5b, 0xd8, 0x95, 0xbb,
0x0d, 0xe7, 0x97, 0x33, 0x6f, 0x22, 0x6b, 0xe5, 0xb8, 0x04, 0xbb, 0x33, 0x2f, 0x20, 0x0d, 0x10,
0xe1, 0xd8, 0x3b, 0x82, 0x30, 0x5c, 0x8e, 0x1f, 0xc5, 0xc3, 0xd6, 0x7f, 0x35, 0xa8, 0x8a, 0x62,
0xf6, 0x83, 0x87, 0x6b, 0xb9, 0x9e, 0xd1, 0xcc, 0xbd, 0x8c, 0xde, 0xcb, 0x55, 0xf6, 0x7e, 0xae,
0x76, 0xa1, 0x34, 0xc3, 0x8c, 0x3b, 0x53, 0x1a, 0xca, 0xf2, 0xe9, 0x76, 0x51, 0x7c, 0x1f, 0xd3,
0x10, 0xfd, 0x0c, 0xaa, 0xe4, 0x96, 0x93, 0x28, 0xc0, 0x33, 0x67, 0xca, 0x67, 0x13, 0x59, 0xb3,
0x92, 0xad, 0x2f, 0xc0, 0x63, 0x3e, 0x9b, 0xa0, 0x36, 0x98, 0x62, 0x6c, 0x25, 0x21, 0x05, 0x99,
0x10, 0x43, 0xe0, 0xcb, 0x7c, 0x58, 0xdf, 0x6a, 0xa0, 0xcb, 0x4e, 0x22, 0x2c, 0xa4, 0x01, 0x23,
0x08, 0x41, 0xc6, 0x73, 0xe5, 0x8e, 0xca, 0xb2, 0x30, 0x19, 0xcf, 0x15, 0xe1, 0x78, 0xae, 0x73,
0x79, 0xc7, 0x09, 0x93, 0xd1, 0xea, 0x76, 0xd1, 0x73, 0xdf, 0x89, 0x4f, 0xf4, 0x02, 0x74, 0xb9,
0x12, 0x76, 0xdd, 0x88, 0x30, 0xa6, 0x7a, 0x58, 0x4e, 0xac, 0x08, 0xfc, 0x50, 0xc1, 0x68, 0x1f,
0xb6, 0xd2, 0x34, 0x27, 0x08, 0x0f, 0x6e, 0xd8, 0x54, 0xee, 0xad, 0x6c, 0xd7, 0x53, 0xcc, 0x73,
0x39, 0x80, 0x5e, 0x01, 0x5a, 0xe1, 0x2b, 0x7a, 0x5e, 0xd2, 0xcd, 0x14, 0x7d, 0x28, 0xd9, 0x2f,
0xc0, 0x60, 0x24, 0xfa, 0x4c, 0x22, 0xc7, 0x27, 0x8c, 0xe1, 0x6b, 0x22, 0x37, 0x5b, 0xb6, 0xab,
0x0a, 0x3d, 0x53, 0xa0, 0x65, 0x82, 0x71, 0x46, 0x03, 0x8f, 0xd3, 0x28, 0xae, 0x9f, 0xf5, 0xff,
0x2c, 0x80, 0xd8, 0xfd, 0x88, 0x63, 0x3e, 0x67, 0x1b, 0x8f, 0xa6, 0xc8, 0x46, 0xe6, 0xc1, 0x6c,
0x54, 0xd6, 0xb3, 0x91, 0xe3, 0x77, 0xa1, 0x2a, 0xa9, 0x71, 0x50, 0xdf, 0x8f, 0x4d, 0x62, 0x5f,
0xac, 0x31, 0xbe, 0x0b, 0x89, 0x2d, 0x87, 0x51, 0x1b, 0xf2, 0x8c, 0x63, 0xae, 0x8e, 0xa6, 0x71,
0x80, 0x56, 0x78, 0x22, 0x16, 0x62, 0x2b, 0x02, 0xfa, 0x25, 0xd4, 0xbc, 0xc0, 0xe3, 0x9e, 0x6a,
0x54, 0xee, 0xf9, 0x8b, 0x33, 0x6a, 0x2c, 0xe1, 0xb1, 0xe7, 0x0b, 0x49, 0x53, 0x76, 0xcc, 0x3c,
0x74, 0x31, 0x27, 0x8a, 0xa9, 0x4e, 0xaa, 0x21, 0xf0, 0x0b, 0x09, 0x4b, 0xe6, 0x7a, 0xc5, 0x8a,
0x9b, 0x2b, 0xb6, 0xb9, 0x02, 0xfa, 0x03, 0x15, 0x78, 0xa0, 0xbe, 0xd5, 0x87, 0xea, 0xfb, 0x0c,
0x2a, 0x13, 0xca, 0xb8, 0xa3, 0x0a, 0x24, 0x7d, 0x20, 0x6b, 0x83, 0x80, 0x46, 0x12, 0x41, 0xcf,
0x41, 0x97, 0x04, 0x1a, 0x4c, 0xa6, 0xd8, 0x0b, 0xe4, 0x71, 0xce, 0xda, 0x72, 0xd2, 0x40, 0x41,
0xe2, 0x24, 0x28, 0xca, 0xd5, 0x95, 0xe2, 0x80, 0x72, 0x26, 0xc9, 0x89, 0x31, 0x0b, 0x81, 0x79,
0xea, 0x31, 0x2e, 0x12, 0xcb, 0x16, 0x55, 0xff, 0x2d, 0xd4, 0x53, 0x58, 0xdc, 0xf7, 0x2f, 0x21,
0x2f, 0x0e, 0x2d, 0x6b, 0x68, 0xad, 0x6c, 0xbb, 0x72, 0xb0, 0x75, 0xaf, 0x26, 0x73, 0x66, 0x2b,
0x86, 0xf5, 0x1c, 0x6a, 0x02, 0xec, 0x07, 0x57, 0x74, 0x61, 0x04, 0x46, 0x72, 0x6a, 0x74, 0xd1,
0x23, 0x96, 0x01, 0xfa, 0x98, 0x44, 0x7e, 0xb2, 0xe4, 0x5f, 0xa1, 0xd6, 0x0f, 0x62, 0x24, 0x5e,
0xf0, 0x17, 0x50, 0xf3, 0xbd, 0x40, 0x39, 0x05, 0xf6, 0xe9, 0x3c, 0xe0, 0x71, 0x69, 0xab, 0xbe,
0x17, 0x08, 0xfd, 0x43, 0x09, 0x4a, 0xde, 0xc2, 0x51, 0x62, 0x5e, 0x21, 0xe6, 0x29, 0x53, 0x51,
0xbc, 0x93, 0x5c, 0x49, 0x33, 0x33, 0x27, 0xb9, 0x52, 0xc6, 0xcc, 0x9e, 0xe4, 0x4a, 0x59, 0x33,
0x77, 0x92, 0x2b, 0xe5, 0xcc, 0xfc, 0x49, 0xae, 0x54, 0x34, 0x4b, 0xd6, 0xdf, 0x34, 0x30, 0x07,
0x73, 0xfe, 0x63, 0x86, 0xf0, 0x4f, 0x0d, 0xf4, 0xdf, 0xcd, 0x29, 0x27, 0x0f, 0xbb, 0xa7, 0x6c,
0x8b, 0xa5, 0x65, 0x65, 0xa4, 0x65, 0xc1, 0x64, 0x69, 0xdf, 0xf7, 0xdc, 0x2f, 0xbb, 0xc1, 0xfd,
0xbe, 0xea, 0xf1, 0xb9, 0xaf, 0x7b, 0xfc, 0xbf, 0x34, 0xa8, 0xc6, 0x41, 0xc6, 0x49, 0xda, 0x85,
0x52, 0xe2, 0xe6, 0x2a, 0xd4, 0x22, 0x8b, 0xad, 0xfc, 0x29, 0x40, 0xea, 0x62, 0x54, 0x56, 0x5f,
0x0e, 0x93, 0x5b, 0xf1, 0x27, 0x50, 0x5e, 0x77, 0xf9, 0x92, 0xbf, 0xb0, 0x78, 0x79, 0x69, 0x89,
0x20, 0xf1, 0x9d, 0x4f, 0x02, 0xee, 0xc8, 0x17, 0x80, 0xf2, 0xfa, 0x9a, 0x0c, 0x4e, 0xe1, 0x47,
0x22, 0x51, 0x4f, 0x01, 0x26, 0x33, 0xfe, 0xd9, 0x71, 0xc9, 0x8c, 0x63, 0x59, 0xa2, 0xbc, 0x5d,
0x16, 0xc8, 0x91, 0x00, 0xac, 0x1a, 0x54, 0xc7, 0xf4, 0xcf, 0x24, 0x48, 0xba, 0xed, 0x37, 0x60,
0x2c, 0x80, 0x78, 0x13, 0x7b, 0x50, 0xe0, 0x12, 0x89, 0xdb, 0x7b, 0x69, 0x39, 0xa7, 0x0c, 0x73,
0x49, 0xb6, 0x63, 0x86, 0xf5, 0xef, 0x0c, 0x94, 0x13, 0x54, 0x64, 0xfc, 0x12, 0x33, 0xe2, 0xf8,
0x78, 0x82, 0x23, 0x4a, 0x83, 0xb8, 0xc9, 0x75, 0x01, 0x9e, 0xc5, 0x98, 0x38, 0xad, 0x8b, 0x7d,
0x4c, 0x31, 0x9b, 0xca, 0x54, 0xe8, 0x76, 0x25, 0xc6, 0x8e, 0x31, 0x9b, 0xa2, 0x97, 0x60, 0x2e,
0x28, 0x61, 0x44, 0x3c, 0x5f, 0xb8, 0xb4, 0xba, 0x4b, 0x6a, 0x31, 0x3e, 0x8c, 0x61, 0xe1, 0x65,
0xaa, 0xcb, 0x9c, 0x10, 0x7b, 0xae, 0xe3, 0x33, 0xcc, 0xe3, 0x47, 0x8c, 0xa1, 0xf0, 0x21, 0xf6,
0xdc, 0x33, 0x86, 0x39, 0x7a, 0x0d, 0x4f, 0x52, 0x2f, 0x9d, 0x14, 0x5d, 0xb5, 0x31, 0x8a, 0x92,
0xa7, 0x4e, 0x32, 0xe5, 0x39, 0xe8, 0xc2, 0x1c, 0x9d, 0x49, 0x44, 0x30, 0x27, 0x6e, 0xdc, 0xc8,
0x15, 0x81, 0x75, 0x15, 0x84, 0x1a, 0x50, 0x24, 0xb7, 0xa1, 0x17, 0x11, 0x57, 0x9a, 0x63, 0xc9,
0x5e, 0x7c, 0x8a, 0xc9, 0x8c, 0xd3, 0x08, 0x5f, 0x13, 0x27, 0xc0, 0x3e, 0x91, 0xbe, 0x55, 0xb6,
0x2b, 0x31, 0x76, 0x8e, 0x7d, 0xb2, 0xf7, 0x02, 0x4a, 0x0b, 0xb7, 0x47, 0x3a, 0x94, 0x4e, 0x07,
0x83, 0xa1, 0x33, 0xb8, 0x18, 0x9b, 0x8f, 0x50, 0x05, 0x8a, 0xf2, 0xab, 0x7f, 0x6e, 0x6a, 0x7b,
0x0c, 0xca, 0x89, 0xd9, 0xa3, 0x2a, 0x94, 0xfb, 0xe7, 0xfd, 0x71, 0xff, 0x70, 0xdc, 0x3b, 0x32,
0x1f, 0xa1, 0x27, 0x50, 0x1f, 0xda, 0xbd, 0xfe, 0xd9, 0xe1, 0x87, 0x9e, 0x63, 0xf7, 0x3e, 0xf6,
0x0e, 0x4f, 0x7b, 0x47, 0xa6, 0x86, 0x10, 0x18, 0xc7, 0xe3, 0xd3, 0xae, 0x33, 0xbc, 0x78, 0x77,
0xda, 0x1f, 0x1d, 0xf7, 0x8e, 0xcc, 0x8c, 0xd0, 0x1c, 0x5d, 0x74, 0xbb, 0xbd, 0xd1, 0xc8, 0xcc,
0x22, 0x80, 0xc2, 0xfb, 0xc3, 0xbe, 0x20, 0xe7, 0xd0, 0x16, 0xd4, 0xfa, 0xe7, 0x1f, 0x07, 0xfd,
0x6e, 0xcf, 0x19, 0xf5, 0xc6, 0x63, 0x01, 0xe6, 0x0f, 0xbe, 0x2b, 0xa8, 0xeb, 0xae, 0x2b, 0x5f,
0xb2, 0xc8, 0x86, 0x62, 0xfc, 0x36, 0x45, 0x3b, 0xcb, 0x7e, 0x58, 0x79, 0xad, 0x36, 0x9f, 0xac,
0xf8, 0xe0, 0xa2, 0x9f, 0xac, 0x9d, 0xbf, 0xff, 0xef, 0x9b, 0x7f, 0x64, 0xea, 0x96, 0xde, 0xf9,
0xfc, 0xba, 0x23, 0x18, 0x1d, 0x3a, 0xe7, 0x6f, 0xb5, 0x3d, 0x34, 0x80, 0x82, 0x7a, 0x22, 0xa1,
0xed, 0x15, 0xc9, 0xe4, 0xcd, 0xf4, 0x90, 0xe2, 0xb6, 0x54, 0x34, 0xad, 0x4a, 0xa2, 0xe8, 0x05,
0x42, 0xf0, 0xd7, 0x50, 0x8c, 0x2f, 0xed, 0x54, 0x90, 0xab, 0xd7, 0x78, 0x73, 0x93, 0x59, 0xff,
0x4a, 0x43, 0x7f, 0x80, 0x72, 0xe2, 0xf3, 0x68, 0x77, 0x19, 0xce, 0xda, 0x7d, 0xd0, 0x6c, 0x6e,
0x1a, 0x5a, 0x0d, 0x0b, 0x19, 0x49, 0x58, 0xf2, 0x0e, 0x40, 0x17, 0xaa, 0xcc, 0xe2, 0x0e, 0x40,
0x8d, 0x95, 0xe5, 0x53, 0xd7, 0xc2, 0xc6, 0xc0, 0xac, 0xa6, 0x94, 0x7c, 0x8c, 0xd0, 0x8a, 0x64,
0xe7, 0x8b, 0xe7, 0xfe, 0x05, 0xfd, 0x11, 0xf4, 0xb8, 0x00, 0xd2, 0xa9, 0xd1, 0x32, 0x59, 0xe9,
0xeb, 0xa4, 0xb9, 0xdc, 0xcc, 0xba, 0xa7, 0x6f, 0x50, 0xa7, 0x73, 0xde, 0xe1, 0x52, 0xcd, 0x49,
0xd4, 0xa5, 0xc5, 0xa5, 0xd4, 0xd3, 0xbe, 0xdc, 0xdc, 0x5e, 0x87, 0x63, 0xe9, 0x96, 0x94, 0x6e,
0xa2, 0xc6, 0x8a, 0xf4, 0x27, 0xc1, 0xe9, 0x7c, 0xc1, 0x3e, 0x17, 0xe1, 0x1b, 0x1f, 0x08, 0x57,
0xf5, 0xfe, 0xea, 0x06, 0x96, 0x29, 0x5b, 0xbb, 0x16, 0xad, 0x5d, 0xb9, 0xc8, 0x16, 0xaa, 0xa7,
0xfa, 0x20, 0x0e, 0xff, 0x4f, 0x29, 0xf5, 0x1f, 0xb4, 0x81, 0x67, 0x52, 0x7b, 0x17, 0xed, 0xa4,
0xb5, 0xd3, 0xf1, 0xff, 0x1e, 0xaa, 0x62, 0x85, 0x85, 0xf9, 0xb1, 0x54, 0x13, 0xaf, 0x38, 0x6c,
0x73, 0xe7, 0x1e, 0xbe, 0x7a, 0x30, 0x50, 0x4d, 0x2e, 0xc1, 0x30, 0xef, 0x28, 0x57, 0xbd, 0x2c,
0xc8, 0x3f, 0x84, 0x6f, 0xbe, 0x0f, 0x00, 0x00, 0xff, 0xff, 0xfc, 0x3d, 0x7d, 0xf8, 0x47, 0x0e,
0x00, 0x00,
// 1619 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x57, 0xdd, 0x6e, 0x23, 0x49,
0x15, 0xde, 0xf6, 0x4f, 0x6c, 0x1f, 0xb7, 0xdb, 0x9d, 0xca, 0xce, 0xc4, 0xb1, 0x40, 0xeb, 0x69,
0x76, 0x20, 0x1b, 0x56, 0x63, 0x36, 0x7b, 0xc5, 0x0a, 0x21, 0x65, 0x12, 0xef, 0xc6, 0x51, 0x7e,
0x4c, 0xdb, 0x59, 0x09, 0x84, 0xd4, 0xaa, 0xb8, 0x2b, 0x71, 0x0b, 0x77, 0x57, 0x6f, 0x57, 0x79,
0x26, 0xd1, 0x08, 0x81, 0x78, 0x01, 0x2e, 0x78, 0x03, 0x5e, 0x83, 0x37, 0xe0, 0x0e, 0x78, 0x00,
0x6e, 0xb8, 0xe1, 0x25, 0x10, 0xaa, 0x53, 0xdd, 0xed, 0xee, 0xfc, 0x49, 0x5c, 0x71, 0xe7, 0xfe,
0xea, 0xab, 0x53, 0xe7, 0xa7, 0xce, 0x77, 0xca, 0x60, 0xce, 0x97, 0x01, 0x8b, 0xe4, 0x9b, 0x38,
0xe1, 0x92, 0x93, 0xc6, 0x92, 0xf3, 0x38, 0x89, 0xe7, 0xfd, 0xef, 0xdd, 0x70, 0x7e, 0xb3, 0x64,
0x43, 0x1a, 0x07, 0x43, 0x1a, 0x45, 0x5c, 0x52, 0x19, 0xf0, 0x48, 0x68, 0x9a, 0xf3, 0xd7, 0x2a,
0x58, 0xa7, 0x9c, 0xc7, 0x17, 0x2b, 0xe9, 0xb2, 0xef, 0x56, 0x4c, 0x48, 0x62, 0x43, 0x95, 0x86,
0xb2, 0x67, 0x0c, 0x8c, 0xdd, 0xaa, 0xab, 0x7e, 0x12, 0x02, 0x35, 0x9f, 0x09, 0xd9, 0xab, 0x0c,
0x8c, 0xdd, 0x96, 0x8b, 0xbf, 0xc9, 0x10, 0x3e, 0x0e, 0xe9, 0xad, 0x27, 0xde, 0xd3, 0xd8, 0x4b,
0xf8, 0x4a, 0x06, 0xd1, 0x8d, 0x77, 0xcd, 0x58, 0xaf, 0x8a, 0xdb, 0x36, 0x43, 0x7a, 0x3b, 0x7d,
0x4f, 0x63, 0x57, 0xaf, 0x7c, 0xcd, 0x18, 0xf9, 0x12, 0x5e, 0xaa, 0x0d, 0x71, 0xc2, 0x62, 0x7a,
0x57, 0xda, 0x52, 0xc3, 0x2d, 0x5b, 0x21, 0xbd, 0x9d, 0xe0, 0x62, 0x61, 0xd3, 0x00, 0xcc, 0xfc,
0x14, 0x45, 0xad, 0x23, 0x15, 0x52, 0xeb, 0x8a, 0xf1, 0x29, 0x58, 0x05, 0xb3, 0xca, 0xf1, 0x0d,
0xe4, 0x98, 0xb9, 0xb9, 0x83, 0x50, 0x12, 0x07, 0x3a, 0x8a, 0x15, 0x06, 0x11, 0x4b, 0xd0, 0x50,
0x03, 0x49, 0xed, 0x90, 0xde, 0x9e, 0x29, 0x4c, 0x59, 0xfa, 0x1c, 0x6c, 0x95, 0x33, 0x8f, 0xaf,
0xa4, 0x37, 0x5f, 0xd0, 0x28, 0x62, 0xcb, 0x5e, 0x73, 0x60, 0xec, 0xd6, 0xde, 0x56, 0x7a, 0x86,
0x6b, 0x2d, 0x75, 0x96, 0x0e, 0xf5, 0x0a, 0xd9, 0x83, 0x4d, 0xbe, 0x92, 0x37, 0x5c, 0x05, 0xa1,
0xd8, 0x9e, 0x60, 0xb2, 0xd7, 0x1e, 0x54, 0x77, 0x6b, 0x6e, 0x37, 0x5b, 0x50, 0xdc, 0x29, 0x93,
0x8a, 0x2b, 0xde, 0x33, 0x16, 0x7b, 0x73, 0x1e, 0x5d, 0x7b, 0x92, 0x26, 0x37, 0x4c, 0xf6, 0x5a,
0x03, 0x63, 0xb7, 0xee, 0x76, 0x71, 0xe1, 0x90, 0x47, 0xd7, 0x33, 0x84, 0xc9, 0x57, 0xb0, 0x83,
0xd1, 0xc6, 0xab, 0xab, 0x65, 0x30, 0xc7, 0x5a, 0x79, 0x3e, 0xa3, 0xfe, 0x32, 0x88, 0x58, 0x0f,
0x94, 0x3b, 0xee, 0xb6, 0x22, 0x4c, 0xd6, 0xeb, 0x47, 0xe9, 0xb2, 0xf3, 0x37, 0x03, 0x3a, 0xaa,
0x98, 0xe3, 0xe8, 0xe9, 0x5a, 0xde, 0xcf, 0x68, 0xe5, 0x41, 0x46, 0x1f, 0xe4, 0xaa, 0xfa, 0x30,
0x57, 0x3b, 0xd0, 0x5c, 0x52, 0x21, 0xbd, 0x05, 0x8f, 0xb1, 0x7c, 0xa6, 0xdb, 0x50, 0xdf, 0xc7,
0x3c, 0x26, 0x3f, 0x80, 0x0e, 0xbb, 0x95, 0x2c, 0x89, 0xe8, 0xd2, 0x5b, 0xc8, 0xe5, 0x1c, 0x6b,
0xd6, 0x74, 0xcd, 0x0c, 0x3c, 0x96, 0xcb, 0x39, 0xd9, 0x05, 0x5b, 0xad, 0x95, 0x12, 0xb2, 0x81,
0x09, 0xb1, 0x14, 0xbe, 0xce, 0x87, 0xf3, 0x6f, 0x03, 0x4c, 0xbc, 0x49, 0x4c, 0xc4, 0x3c, 0x12,
0x8c, 0x10, 0xa8, 0x04, 0x3e, 0x46, 0xd4, 0xc2, 0xc2, 0x54, 0x02, 0x5f, 0xb9, 0x13, 0xf8, 0xde,
0xd5, 0x9d, 0x64, 0x02, 0xbd, 0x35, 0xdd, 0x46, 0xe0, 0xbf, 0x55, 0x9f, 0xe4, 0x35, 0x98, 0x78,
0x12, 0xf5, 0xfd, 0x84, 0x09, 0xa1, 0xef, 0x30, 0x6e, 0x6c, 0x2b, 0xfc, 0x40, 0xc3, 0xe4, 0x0d,
0x6c, 0x15, 0x69, 0x5e, 0x14, 0xef, 0xbf, 0x17, 0x0b, 0x8c, 0xad, 0xe5, 0x6e, 0x16, 0x98, 0xe7,
0xb8, 0x40, 0x3e, 0x07, 0x52, 0xe2, 0x6b, 0x7a, 0x1d, 0xe9, 0x76, 0x81, 0x3e, 0x41, 0xf6, 0x6b,
0xb0, 0x04, 0x4b, 0xde, 0xb1, 0xc4, 0x0b, 0x99, 0x10, 0xf4, 0x86, 0x61, 0xb0, 0x2d, 0xb7, 0xa3,
0xd1, 0x33, 0x0d, 0x3a, 0x36, 0x58, 0x67, 0x3c, 0x0a, 0x24, 0x4f, 0xd2, 0xfa, 0x39, 0xff, 0xac,
0x02, 0xa8, 0xe8, 0xa7, 0x92, 0xca, 0x95, 0x78, 0xb4, 0x35, 0x55, 0x36, 0x2a, 0x4f, 0x66, 0xa3,
0x7d, 0x3f, 0x1b, 0x35, 0x79, 0x17, 0xeb, 0x92, 0x5a, 0xfb, 0x9b, 0x6f, 0x52, 0x91, 0x78, 0xa3,
0xce, 0x98, 0xdd, 0xc5, 0xcc, 0xc5, 0x65, 0xb2, 0x0b, 0x75, 0x21, 0xa9, 0xd4, 0xad, 0x69, 0xed,
0x93, 0x12, 0x4f, 0xf9, 0xc2, 0x5c, 0x4d, 0x20, 0x3f, 0x82, 0x6e, 0x10, 0x05, 0x32, 0xd0, 0x17,
0x55, 0x06, 0x61, 0xd6, 0xa3, 0xd6, 0x1a, 0x9e, 0x05, 0xa1, 0x32, 0x69, 0xe3, 0x8d, 0x59, 0xc5,
0x3e, 0x95, 0x4c, 0x33, 0x75, 0xa7, 0x5a, 0x0a, 0xbf, 0x44, 0x18, 0x99, 0xf7, 0x2b, 0xd6, 0x78,
0xbc, 0x62, 0x8f, 0x57, 0xc0, 0x7c, 0xa2, 0x02, 0x4f, 0xd4, 0xb7, 0xf3, 0x54, 0x7d, 0x3f, 0x81,
0xf6, 0x9c, 0x0b, 0xe9, 0xe9, 0x02, 0xa1, 0x0e, 0x54, 0x5d, 0x50, 0xd0, 0x14, 0x11, 0xf2, 0x0a,
0x4c, 0x24, 0xf0, 0x68, 0xbe, 0xa0, 0x41, 0x84, 0xed, 0x5c, 0x75, 0x71, 0xd3, 0x85, 0x86, 0x54,
0x27, 0x68, 0xca, 0xf5, 0xb5, 0xe6, 0x80, 0x56, 0x26, 0xe4, 0xa4, 0x98, 0x43, 0xc0, 0x3e, 0x0d,
0x84, 0x54, 0x89, 0x15, 0x59, 0xd5, 0x7f, 0x0e, 0x9b, 0x05, 0x2c, 0xbd, 0xf7, 0x9f, 0x41, 0x5d,
0x35, 0xad, 0xe8, 0x19, 0x83, 0xea, 0x6e, 0x7b, 0x7f, 0xeb, 0x41, 0x4d, 0x56, 0xc2, 0xd5, 0x0c,
0xe7, 0x15, 0x74, 0x15, 0x38, 0x8e, 0xae, 0x79, 0x26, 0x04, 0x56, 0xde, 0x35, 0xa6, 0xba, 0x23,
0x8e, 0x05, 0xe6, 0x8c, 0x25, 0x61, 0x7e, 0xe4, 0xef, 0xa0, 0x3b, 0x8e, 0x52, 0x24, 0x3d, 0xf0,
0x87, 0xd0, 0x0d, 0x83, 0x48, 0x2b, 0x05, 0x0d, 0xf9, 0x2a, 0x92, 0x69, 0x69, 0x3b, 0x61, 0x10,
0x29, 0xfb, 0x07, 0x08, 0x22, 0x2f, 0x53, 0x94, 0x94, 0xb7, 0x91, 0xf2, 0xb4, 0xa8, 0x68, 0xde,
0x49, 0xad, 0x69, 0xd8, 0x95, 0x93, 0x5a, 0xb3, 0x62, 0x57, 0x4f, 0x6a, 0xcd, 0xaa, 0x5d, 0x3b,
0xa9, 0x35, 0x6b, 0x76, 0xfd, 0xa4, 0xd6, 0x6c, 0xd8, 0x4d, 0xe7, 0xf7, 0x06, 0xd8, 0x17, 0x2b,
0xf9, 0xff, 0x74, 0xe1, 0xcf, 0x06, 0x98, 0xbf, 0x58, 0x71, 0xc9, 0x9e, 0x56, 0x4f, 0xbc, 0x16,
0x6b, 0xc9, 0xaa, 0xa0, 0x64, 0xc1, 0x7c, 0x2d, 0xdf, 0x0f, 0xd4, 0xaf, 0xfa, 0x88, 0xfa, 0x3d,
0xab, 0xf1, 0xb5, 0xe7, 0x35, 0xfe, 0x8f, 0x86, 0xaa, 0x54, 0xea, 0x66, 0x9a, 0xa6, 0x01, 0x98,
0x99, 0x9e, 0x7b, 0x82, 0x66, 0x0e, 0x83, 0xd0, 0x82, 0x3e, 0xa5, 0x38, 0xad, 0xf1, 0xfa, 0xe3,
0x89, 0x62, 0x91, 0x33, 0xd3, 0x69, 0xad, 0xd6, 0x26, 0x7a, 0x29, 0xdd, 0xf0, 0x7d, 0x80, 0xf9,
0x52, 0xbe, 0xf3, 0x7c, 0xb6, 0x94, 0x14, 0x93, 0x5e, 0x77, 0x5b, 0x0a, 0x39, 0x52, 0x40, 0x9e,
0xc2, 0x9a, 0x5d, 0x77, 0xfe, 0xae, 0x2b, 0xf7, 0xbf, 0xba, 0xf4, 0x29, 0x58, 0xeb, 0xa1, 0x8d,
0x1c, 0x3d, 0x8a, 0xcc, 0x38, 0x9b, 0xda, 0x8a, 0xf5, 0xe3, 0xb4, 0xcb, 0xf5, 0xfc, 0x2c, 0xbb,
0xdd, 0x55, 0x2b, 0x53, 0xb5, 0x90, 0x9a, 0xc4, 0x39, 0xab, 0xf2, 0x4a, 0xef, 0x42, 0x16, 0x49,
0x0f, 0x1f, 0x2d, 0x7a, 0x3c, 0x75, 0x31, 0x9f, 0x1a, 0x3f, 0x52, 0xb5, 0x7d, 0x3e, 0x40, 0xa7,
0x0b, 0x9d, 0x19, 0xff, 0x0d, 0x8b, 0xf2, 0x06, 0xf9, 0x19, 0x58, 0x19, 0x90, 0x86, 0xb8, 0x07,
0x1b, 0x12, 0x91, 0xb4, 0x23, 0xd7, 0x2a, 0x79, 0x2a, 0xa8, 0x44, 0xb2, 0x9b, 0x32, 0x9c, 0xbf,
0x54, 0xa0, 0x95, 0xa3, 0xea, 0x92, 0x5c, 0x51, 0xc1, 0xbc, 0x90, 0xce, 0x69, 0xc2, 0x79, 0x94,
0xf6, 0xa5, 0xa9, 0xc0, 0xb3, 0x14, 0x53, 0x02, 0x93, 0xc5, 0xb1, 0xa0, 0x62, 0x81, 0xd9, 0x31,
0xdd, 0x76, 0x8a, 0x1d, 0x53, 0xb1, 0x20, 0x9f, 0x81, 0x9d, 0x51, 0xe2, 0x84, 0x05, 0xa1, 0x1a,
0x2c, 0x7a, 0xfc, 0x75, 0x53, 0x7c, 0x92, 0xc2, 0x4a, 0x7e, 0x75, 0x63, 0x78, 0x31, 0x0d, 0x7c,
0x2f, 0x54, 0x59, 0xd4, 0xef, 0x2e, 0x4b, 0xe3, 0x13, 0x1a, 0xf8, 0x67, 0x82, 0x4a, 0xf2, 0x05,
0xbc, 0x28, 0x3c, 0xce, 0x0a, 0x74, 0xdd, 0x79, 0x24, 0xc9, 0x5f, 0x67, 0xf9, 0x96, 0x57, 0x60,
0x2a, 0x3d, 0xf7, 0xe6, 0x09, 0xa3, 0x92, 0xf9, 0x69, 0xef, 0xb5, 0x15, 0x76, 0xa8, 0x21, 0xd2,
0x83, 0x06, 0xbb, 0x8d, 0x83, 0x84, 0xf9, 0xa8, 0xe7, 0x4d, 0x37, 0xfb, 0x54, 0x9b, 0x85, 0xe4,
0x09, 0xbd, 0x61, 0x5e, 0x44, 0x43, 0x86, 0x52, 0xdb, 0x72, 0xdb, 0x29, 0x76, 0x4e, 0x43, 0xb6,
0xf7, 0x1a, 0x9a, 0xd9, 0x80, 0x22, 0x26, 0x34, 0x4f, 0x2f, 0x2e, 0x26, 0xde, 0xc5, 0xe5, 0xcc,
0xfe, 0x88, 0xb4, 0xa1, 0x81, 0x5f, 0xe3, 0x73, 0xdb, 0xd8, 0x13, 0xd0, 0xca, 0xe7, 0x13, 0xe9,
0x40, 0x6b, 0x7c, 0x3e, 0x9e, 0x8d, 0x0f, 0x66, 0xa3, 0x23, 0xfb, 0x23, 0xf2, 0x02, 0x36, 0x27,
0xee, 0x68, 0x7c, 0x76, 0xf0, 0xcd, 0xc8, 0x73, 0x47, 0xdf, 0x8e, 0x0e, 0x4e, 0x47, 0x47, 0xb6,
0x41, 0x08, 0x58, 0xc7, 0xb3, 0xd3, 0x43, 0x6f, 0x72, 0xf9, 0xf6, 0x74, 0x3c, 0x3d, 0x1e, 0x1d,
0xd9, 0x15, 0x65, 0x73, 0x7a, 0x79, 0x78, 0x38, 0x9a, 0x4e, 0xed, 0x2a, 0x01, 0xd8, 0xf8, 0xfa,
0x60, 0xac, 0xc8, 0x35, 0xb2, 0x05, 0xdd, 0xf1, 0xf9, 0xb7, 0x17, 0xe3, 0xc3, 0x91, 0x37, 0x1d,
0xcd, 0x66, 0x0a, 0xac, 0xef, 0xff, 0x67, 0x43, 0x4f, 0xe8, 0x43, 0x7c, 0x7c, 0x13, 0x17, 0x1a,
0xe9, 0x73, 0x9a, 0x6c, 0xaf, 0xef, 0x43, 0xe9, 0x81, 0xdd, 0x7f, 0x51, 0x92, 0xee, 0xec, 0x3e,
0x39, 0xdb, 0x7f, 0xf8, 0xc7, 0xbf, 0xfe, 0x54, 0xd9, 0x74, 0xcc, 0xe1, 0xbb, 0x2f, 0x86, 0x8a,
0x31, 0xe4, 0x2b, 0xf9, 0x95, 0xb1, 0x47, 0x2e, 0x60, 0x43, 0xbf, 0xea, 0xc8, 0xcb, 0x92, 0xc9,
0xfc, 0x99, 0xf7, 0x94, 0xc5, 0x97, 0x68, 0xd1, 0x76, 0xda, 0xb9, 0xc5, 0x20, 0x52, 0x06, 0x7f,
0x0a, 0x8d, 0xf4, 0x9d, 0x51, 0x70, 0xb2, 0xfc, 0xf2, 0xe8, 0x3f, 0x36, 0x5f, 0x7e, 0x62, 0x90,
0x5f, 0x41, 0x2b, 0x1f, 0x4d, 0x64, 0x67, 0xed, 0xce, 0xbd, 0x11, 0xd6, 0xef, 0x3f, 0xb6, 0x54,
0x76, 0x8b, 0x58, 0xb9, 0x5b, 0x38, 0xb6, 0xc8, 0xa5, 0x2e, 0xb3, 0x1a, 0x5b, 0xa4, 0x57, 0x3a,
0xbe, 0x30, 0xc9, 0x1e, 0x75, 0xcc, 0xe9, 0xa3, 0xc9, 0x8f, 0x09, 0x29, 0x99, 0x1c, 0x7e, 0x08,
0xfc, 0xdf, 0x92, 0x5f, 0x83, 0x99, 0x16, 0x00, 0x87, 0x0b, 0x59, 0x27, 0xab, 0x38, 0x01, 0xfb,
0xeb, 0x60, 0xee, 0x8f, 0xa1, 0x47, 0xac, 0xf3, 0x95, 0x1c, 0x4a, 0xb4, 0x76, 0x95, 0x5b, 0x47,
0x01, 0x2c, 0x58, 0x2f, 0x8e, 0x92, 0xb2, 0xf5, 0x92, 0x54, 0x3a, 0x03, 0xb4, 0xde, 0x27, 0xbd,
0x92, 0xf5, 0xef, 0x14, 0x67, 0xf8, 0x81, 0x86, 0x52, 0x45, 0x60, 0x7d, 0xc3, 0xa4, 0x2e, 0xf9,
0xb3, 0x31, 0xac, 0xb3, 0x76, 0x6f, 0x98, 0x3b, 0x3b, 0x78, 0xc8, 0x16, 0xd9, 0x2c, 0x5c, 0x85,
0x3c, 0x82, 0xb5, 0xf5, 0x67, 0x63, 0x28, 0x5a, 0x2f, 0x87, 0xf0, 0x09, 0x5a, 0xdf, 0x21, 0xdb,
0x45, 0xeb, 0xc5, 0x08, 0x7e, 0x09, 0x1d, 0x75, 0x46, 0xa6, 0x80, 0xa2, 0x70, 0x93, 0x4b, 0x32,
0xdb, 0xdf, 0x7e, 0x80, 0x97, 0xbb, 0x83, 0x74, 0xf1, 0x08, 0x41, 0xe5, 0x50, 0x4b, 0xeb, 0xd5,
0x06, 0xfe, 0x91, 0xfd, 0xf2, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x5f, 0x3e, 0x0d, 0x16, 0xff,
0x0e, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -1454,13 +1519,13 @@ type SwapClientClient interface {
//* loop: `quote`
//LoopOutQuote returns a quote for a loop out swap with the provided
//parameters.
LoopOutQuote(ctx context.Context, in *QuoteRequest, opts ...grpc.CallOption) (*QuoteResponse, error)
LoopOutQuote(ctx context.Context, in *QuoteRequest, opts ...grpc.CallOption) (*OutQuoteResponse, error)
//* loop: `terms`
//GetTerms returns the terms that the server enforces for swaps.
GetLoopInTerms(ctx context.Context, in *TermsRequest, opts ...grpc.CallOption) (*InTermsResponse, error)
//* loop: `quote`
//GetQuote returns a quote for a swap with the provided parameters.
GetLoopInQuote(ctx context.Context, in *QuoteRequest, opts ...grpc.CallOption) (*QuoteResponse, error)
GetLoopInQuote(ctx context.Context, in *QuoteRequest, opts ...grpc.CallOption) (*InQuoteResponse, error)
//* loop: `listauth`
//GetLsatTokens returns all LSAT tokens the daemon ever paid for.
GetLsatTokens(ctx context.Context, in *TokensRequest, opts ...grpc.CallOption) (*TokensResponse, error)
@ -1551,8 +1616,8 @@ func (c *swapClientClient) LoopOutTerms(ctx context.Context, in *TermsRequest, o
return out, nil
}
func (c *swapClientClient) LoopOutQuote(ctx context.Context, in *QuoteRequest, opts ...grpc.CallOption) (*QuoteResponse, error) {
out := new(QuoteResponse)
func (c *swapClientClient) LoopOutQuote(ctx context.Context, in *QuoteRequest, opts ...grpc.CallOption) (*OutQuoteResponse, error) {
out := new(OutQuoteResponse)
err := c.cc.Invoke(ctx, "/looprpc.SwapClient/LoopOutQuote", in, out, opts...)
if err != nil {
return nil, err
@ -1569,8 +1634,8 @@ func (c *swapClientClient) GetLoopInTerms(ctx context.Context, in *TermsRequest,
return out, nil
}
func (c *swapClientClient) GetLoopInQuote(ctx context.Context, in *QuoteRequest, opts ...grpc.CallOption) (*QuoteResponse, error) {
out := new(QuoteResponse)
func (c *swapClientClient) GetLoopInQuote(ctx context.Context, in *QuoteRequest, opts ...grpc.CallOption) (*InQuoteResponse, error) {
out := new(InQuoteResponse)
err := c.cc.Invoke(ctx, "/looprpc.SwapClient/GetLoopInQuote", in, out, opts...)
if err != nil {
return nil, err
@ -1617,13 +1682,13 @@ type SwapClientServer interface {
//* loop: `quote`
//LoopOutQuote returns a quote for a loop out swap with the provided
//parameters.
LoopOutQuote(context.Context, *QuoteRequest) (*QuoteResponse, error)
LoopOutQuote(context.Context, *QuoteRequest) (*OutQuoteResponse, error)
//* loop: `terms`
//GetTerms returns the terms that the server enforces for swaps.
GetLoopInTerms(context.Context, *TermsRequest) (*InTermsResponse, error)
//* loop: `quote`
//GetQuote returns a quote for a swap with the provided parameters.
GetLoopInQuote(context.Context, *QuoteRequest) (*QuoteResponse, error)
GetLoopInQuote(context.Context, *QuoteRequest) (*InQuoteResponse, error)
//* loop: `listauth`
//GetLsatTokens returns all LSAT tokens the daemon ever paid for.
GetLsatTokens(context.Context, *TokensRequest) (*TokensResponse, error)
@ -1651,13 +1716,13 @@ func (*UnimplementedSwapClientServer) SwapInfo(ctx context.Context, req *SwapInf
func (*UnimplementedSwapClientServer) LoopOutTerms(ctx context.Context, req *TermsRequest) (*OutTermsResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method LoopOutTerms not implemented")
}
func (*UnimplementedSwapClientServer) LoopOutQuote(ctx context.Context, req *QuoteRequest) (*QuoteResponse, error) {
func (*UnimplementedSwapClientServer) LoopOutQuote(ctx context.Context, req *QuoteRequest) (*OutQuoteResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method LoopOutQuote not implemented")
}
func (*UnimplementedSwapClientServer) GetLoopInTerms(ctx context.Context, req *TermsRequest) (*InTermsResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetLoopInTerms not implemented")
}
func (*UnimplementedSwapClientServer) GetLoopInQuote(ctx context.Context, req *QuoteRequest) (*QuoteResponse, error) {
func (*UnimplementedSwapClientServer) GetLoopInQuote(ctx context.Context, req *QuoteRequest) (*InQuoteResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetLoopInQuote not implemented")
}
func (*UnimplementedSwapClientServer) GetLsatTokens(ctx context.Context, req *TokensRequest) (*TokensResponse, error) {

45
looprpc/client.proto
Unescape Escape View File

@ -72,7 +72,7 @@ service SwapClient {
LoopOutQuote returns a quote for a loop out swap with the provided
parameters.
*/
rpc LoopOutQuote (QuoteRequest) returns (QuoteResponse) {
rpc LoopOutQuote (QuoteRequest) returns (OutQuoteResponse) {
option (google.api.http) = {
get: "/v1/loop/out/quote/{amt}"
};
@ -90,7 +90,7 @@ service SwapClient {
/** loop: `quote`
GetQuote returns a quote for a swap with the provided parameters.
*/
rpc GetLoopInQuote (QuoteRequest) returns (QuoteResponse) {
rpc GetLoopInQuote (QuoteRequest) returns (InQuoteResponse) {
option (google.api.http) = {
get: "/v1/loop/in/quote/{amt}"
};
@ -479,27 +479,46 @@ message QuoteRequest {
uint64 swap_publication_deadline = 4;
}
message QuoteResponse {
message InQuoteResponse {
reserved 2, 4;
/**
The fee that the swap server is charging for the swap.
*/
int64 swap_fee_sat = 1;
/*
An estimate of the on-chain fee that needs to be paid to publish the HTLC
If a miner fee of 0 is returned, it means the external_htlc flag was set for
a loop in and the fee estimation was skipped. If a miner fee of -1 is
returned, it means lnd's wallet tried to estimate the fee but was unable to
create a sample estimation transaction because not enough funds are
available. An information message should be shown to the user in this case.
*/
int64 htlc_publish_fee_sat = 3;
/**
On-chain cltv expiry delta
*/
int32 cltv_delta = 5;
}
message OutQuoteResponse {
/**
The fee that the swap server is charging for the swap.
*/
int64 swap_fee = 1;
int64 swap_fee_sat = 1;
/**
The part of the swap fee that is requested as a prepayment.
*/
int64 prepay_amt = 2;
int64 prepay_amt_sat = 2;
/**
An estimate of the on-chain fee that needs to be paid to sweep the HTLC for
a loop out or to pay to the HTLC for loop in. If a miner fee of 0 is
returned, it means the external_htlc flag was set for a loop in and the fee
estimation was skipped. If a miner fee of -1 is returned, it means lnd's
wallet tried to estimate the fee but was unable to create a sample
estimation transaction because not enough funds are available. An
information message should be shown to the user in this case.
*/
int64 miner_fee = 3;
a loop out.
*/
int64 htlc_sweep_fee_sat = 3;
/**
The node pubkey where the swap payment needs to be paid

64
looprpc/client.swagger.json
Unescape Escape View File

@ -52,7 +52,7 @@
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/looprpcQuoteResponse"
"$ref": "#/definitions/looprpcInQuoteResponse"
}
},
"default": {
@ -165,7 +165,7 @@
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/looprpcQuoteResponse"
"$ref": "#/definitions/looprpcOutQuoteResponse"
}
},
"default": {
@ -318,6 +318,26 @@
}
},
"definitions": {
"looprpcInQuoteResponse": {
"type": "object",
"properties": {
"swap_fee_sat": {
"type": "string",
"format": "int64",
"description": "*\nThe fee that the swap server is charging for the swap."
},
"htlc_publish_fee_sat": {
"type": "string",
"format": "int64",
"description": "An estimate of the on-chain fee that needs to be paid to publish the HTLC\nIf a miner fee of 0 is returned, it means the external_htlc flag was set for\na loop in and the fee estimation was skipped. If a miner fee of -1 is\nreturned, it means lnd's wallet tried to estimate the fee but was unable to\ncreate a sample estimation transaction because not enough funds are\navailable. An information message should be shown to the user in this case."
},
"cltv_delta": {
"type": "integer",
"format": "int32",
"title": "*\nOn-chain cltv expiry delta"
}
}
},
"looprpcInTermsResponse": {
"type": "object",
"properties": {
@ -486,38 +506,23 @@
}
}
},
"looprpcOutTermsResponse": {
"type": "object",
"properties": {
"min_swap_amount": {
"type": "string",
"format": "int64",
"title": "*\nMinimum swap amount (sat)"
},
"max_swap_amount": {
"type": "string",
"format": "int64",
"title": "*\nMaximum swap amount (sat)"
}
}
},
"looprpcQuoteResponse": {
"looprpcOutQuoteResponse": {
"type": "object",
"properties": {
"swap_fee": {
"swap_fee_sat": {
"type": "string",
"format": "int64",
"description": "*\nThe fee that the swap server is charging for the swap."
},
"prepay_amt": {
"prepay_amt_sat": {
"type": "string",
"format": "int64",
"description": "*\nThe part of the swap fee that is requested as a prepayment."
},
"miner_fee": {
"htlc_sweep_fee_sat": {
"type": "string",
"format": "int64",
"description": "*\nAn estimate of the on-chain fee that needs to be paid to sweep the HTLC for\na loop out or to pay to the HTLC for loop in. If a miner fee of 0 is\nreturned, it means the external_htlc flag was set for a loop in and the fee\nestimation was skipped. If a miner fee of -1 is returned, it means lnd's\nwallet tried to estimate the fee but was unable to create a sample\nestimation transaction because not enough funds are available. An\ninformation message should be shown to the user in this case."
"description": "*\nAn estimate of the on-chain fee that needs to be paid to sweep the HTLC for\na loop out."
},
"swap_payment_dest": {
"type": "string",
@ -531,6 +536,21 @@
}
}
},
"looprpcOutTermsResponse": {
"type": "object",
"properties": {
"min_swap_amount": {
"type": "string",
"format": "int64",
"title": "*\nMinimum swap amount (sat)"
},
"max_swap_amount": {
"type": "string",
"format": "int64",
"title": "*\nMaximum swap amount (sat)"
}
}
},
"looprpcSwapResponse": {
"type": "object",
"properties": {

Write Preview
Loading…
Cancel
Save