mirrors/lnd
1
0
Fork 0
mirror of https://github.com/lightningnetwork/lnd.git synced 2024-11-19 09:53:54 +01:00
Code Issues Projects Releases Wiki Activity

Merge pull request #3749 from joostjager/extended-routing-failures

Browse Source 
routing: local balance check before path finding
This commit is contained in:
Joost Jager 2019-12-04 12:17:17 +01:00 committed by GitHub
commit 883f9e5f9a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
9 changed files with 307 additions and 186 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
channeldb/payments.go
View File

@ -105,6 +105,10 @@ const (
// or the final cltv delta or amount is incorrect.
FailureReasonPaymentDetails FailureReason = 3
// FailureReasonInsufficientBalance indicates that we didn't have enough
// balance to complete the payment.
FailureReasonInsufficientBalance FailureReason = 4
// TODO(halseth): cancel state.
// TODO(joostjager): Add failure reasons for:
@ -122,6 +126,8 @@ func (r FailureReason) String() string {
return "error"
case FailureReasonPaymentDetails:
return "incorrect_payment_details"
case FailureReasonInsufficientBalance:
return "insufficient_balance"
}
return "unknown"

264
lnrpc/routerrpc/router.pb.go
View File

@ -46,6 +46,9 @@ const (
//Payment details incorrect (unknown hash, invalid amt or
//invalid final cltv delta)
PaymentState_FAILED_INCORRECT_PAYMENT_DETAILS PaymentState = 5
//*
//Insufficient local balance.
PaymentState_FAILED_INSUFFICIENT_BALANCE PaymentState = 6
)
var PaymentState_name = map[int32]string{
@ -55,6 +58,7 @@ var PaymentState_name = map[int32]string{
3: "FAILED_NO_ROUTE",
4: "FAILED_ERROR",
5: "FAILED_INCORRECT_PAYMENT_DETAILS",
6: "FAILED_INSUFFICIENT_BALANCE",
}
var PaymentState_value = map[string]int32{
@ -64,6 +68,7 @@ var PaymentState_value = map[string]int32{
"FAILED_NO_ROUTE": 3,
"FAILED_ERROR": 4,
"FAILED_INCORRECT_PAYMENT_DETAILS": 5,
"FAILED_INSUFFICIENT_BALANCE": 6,
}
func (x PaymentState) String() string {
@ -1505,135 +1510,136 @@ func init() {
func init() { proto.RegisterFile("routerrpc/router.proto", fileDescriptor_7a0613f69d37b0a5) }
var fileDescriptor_7a0613f69d37b0a5 = []byte{
// 2038 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x58, 0x51, 0x73, 0x1a, 0xc9,
0x11, 0xbe, 0x15, 0x20, 0x50, 0x03, 0x62, 0x35, 0xd2, 0xc9, 0x6b, 0x64, 0x9d, 0x75, 0x6b, 0xc7,
0x47, 0xb9, 0x7c, 0x92, 0xa3, 0xd4, 0x5d, 0xb9, 0xee, 0x21, 0x29, 0x0c, 0xcb, 0x69, 0x65, 0x58,
0xe4, 0x01, 0x7c, 0xe7, 0xdc, 0xc3, 0xd4, 0x08, 0x46, 0x62, 0x4b, 0xcb, 0x2e, 0xb7, 0x3b, 0xf8,
0xac, 0xff, 0x90, 0xbc, 0xe7, 0x1f, 0x24, 0x0f, 0xc9, 0x53, 0xfe, 0x53, 0xf2, 0x9e, 0xaa, 0xbc,
0xa7, 0x66, 0x66, 0x17, 0x16, 0x84, 0x7c, 0x79, 0x62, 0xe7, 0xeb, 0x9e, 0xee, 0x99, 0xe9, 0x9e,
0xaf, 0x7b, 0x80, 0xfd, 0x30, 0x98, 0x71, 0x16, 0x86, 0xd3, 0xe1, 0x89, 0xfa, 0x3a, 0x9e, 0x86,
0x01, 0x0f, 0xd0, 0xd6, 0x1c, 0xaf, 0x6e, 0x85, 0xd3, 0xa1, 0x42, 0xcd, 0xbf, 0xe4, 0x00, 0xf5,
0x98, 0x3f, 0xba, 0xa0, 0xb7, 0x13, 0xe6, 0x73, 0xcc, 0x7e, 0x9e, 0xb1, 0x88, 0x23, 0x04, 0xd9,
0x11, 0x8b, 0xb8, 0xa1, 0x1d, 0x69, 0xb5, 0x12, 0x96, 0xdf, 0x48, 0x87, 0x0c, 0x9d, 0x70, 0x63,
0xe3, 0x48, 0xab, 0x65, 0xb0, 0xf8, 0x44, 0x0f, 0xa1, 0x40, 0x27, 0x9c, 0x4c, 0x22, 0xca, 0x8d,
0x92, 0x84, 0xf3, 0x74, 0xc2, 0x3b, 0x11, 0xe5, 0xe8, 0x4b, 0x28, 0x4d, 0x95, 0x49, 0x32, 0xa6,
0xd1, 0xd8, 0xc8, 0x48, 0x43, 0xc5, 0x18, 0x3b, 0xa3, 0xd1, 0x18, 0xd5, 0x40, 0xbf, 0x72, 0x7d,
0xea, 0x91, 0xa1, 0xc7, 0x3f, 0x90, 0x11, 0xf3, 0x38, 0x35, 0xb2, 0x47, 0x5a, 0x2d, 0x87, 0xb7,
0x25, 0xde, 0xf0, 0xf8, 0x87, 0xa6, 0x40, 0xd1, 0x57, 0x50, 0x49, 0x8c, 0x85, 0x6a, 0x81, 0x46,
0xee, 0x48, 0xab, 0x6d, 0xe1, 0xed, 0xe9, 0xf2, 0xb2, 0xbf, 0x82, 0x0a, 0x77, 0x27, 0x2c, 0x98,
0x71, 0x12, 0xb1, 0x61, 0xe0, 0x8f, 0x22, 0x63, 0x53, 0x59, 0x8c, 0xe1, 0x9e, 0x42, 0x91, 0x09,
0xe5, 0x2b, 0xc6, 0x88, 0xe7, 0x4e, 0x5c, 0x4e, 0xc4, 0xf2, 0xf3, 0x72, 0xf9, 0xc5, 0x2b, 0xc6,
0xda, 0x02, 0xeb, 0x51, 0x8e, 0x9e, 0xc2, 0xf6, 0x42, 0x47, 0xee, 0xb1, 0x2c, 0x95, 0x4a, 0x89,
0x92, 0xdc, 0xe8, 0x0b, 0xd0, 0x83, 0x19, 0xbf, 0x0e, 0x5c, 0xff, 0x9a, 0x0c, 0xc7, 0xd4, 0x27,
0xee, 0xc8, 0x28, 0x1c, 0x69, 0xb5, 0xec, 0xeb, 0x8d, 0x97, 0x1a, 0xde, 0x4e, 0x64, 0x8d, 0x31,
0xf5, 0xed, 0x11, 0x7a, 0x06, 0x15, 0x8f, 0x46, 0x9c, 0x8c, 0x83, 0x29, 0x99, 0xce, 0x2e, 0x6f,
0xd8, 0xad, 0xb1, 0x2d, 0x4f, 0xa6, 0x2c, 0xe0, 0xb3, 0x60, 0x7a, 0x21, 0x41, 0x74, 0x08, 0x20,
0x4f, 0x45, 0x3a, 0x37, 0xb6, 0xe4, 0x1e, 0xb6, 0x04, 0x22, 0x1d, 0xa3, 0x53, 0x28, 0xca, 0x68,
0x92, 0xb1, 0xeb, 0xf3, 0xc8, 0x80, 0xa3, 0x4c, 0xad, 0x78, 0xaa, 0x1f, 0x7b, 0xbe, 0x08, 0x2c,
0x16, 0x92, 0x33, 0xd7, 0xe7, 0x38, 0xad, 0x84, 0x2c, 0x28, 0x88, 0x30, 0x12, 0xee, 0x7d, 0x30,
0x8a, 0x72, 0xc2, 0xf3, 0xe3, 0x79, 0x4a, 0x1c, 0xdf, 0xcd, 0x81, 0xe3, 0x26, 0x8b, 0x78, 0xdf,
0xfb, 0x60, 0xf9, 0x3c, 0xbc, 0xc5, 0xf9, 0x91, 0x1a, 0xa1, 0x17, 0x80, 0xa8, 0xe7, 0x05, 0xbf,
0x90, 0x88, 0x79, 0x57, 0x24, 0x3e, 0x7f, 0xa3, 0x72, 0xa4, 0xd5, 0x0a, 0x58, 0x97, 0x92, 0x1e,
0xf3, 0xae, 0x62, 0x53, 0xd5, 0xef, 0xa0, 0x94, 0x36, 0x23, 0x72, 0x48, 0xec, 0x59, 0xa4, 0x55,
0x16, 0x8b, 0x4f, 0xb4, 0x07, 0xb9, 0x0f, 0xd4, 0x9b, 0x31, 0x99, 0x57, 0x25, 0xac, 0x06, 0xdf,
0x6d, 0xbc, 0xd2, 0xcc, 0x57, 0xb0, 0xdb, 0x0f, 0xe9, 0xf0, 0x66, 0x25, 0x35, 0x57, 0x33, 0x4b,
0xbb, 0x93, 0x59, 0xe6, 0xdf, 0x34, 0x28, 0xc7, 0xb3, 0x7a, 0x9c, 0xf2, 0x59, 0x84, 0xbe, 0x86,
0x5c, 0xc4, 0x29, 0x67, 0x52, 0x7b, 0xfb, 0xf4, 0x41, 0x6a, 0xe7, 0x29, 0x45, 0x86, 0x95, 0x16,
0xaa, 0x42, 0x61, 0x1a, 0x32, 0x77, 0x42, 0xaf, 0x93, 0x75, 0xcd, 0xc7, 0xc8, 0x84, 0x9c, 0x9c,
0x2c, 0x53, 0xba, 0x78, 0x5a, 0x4a, 0x9f, 0x3a, 0x56, 0x22, 0x54, 0x83, 0xdc, 0x98, 0x7b, 0xc3,
0xc8, 0xc8, 0xca, 0x83, 0x46, 0xb1, 0xce, 0x59, 0xbf, 0xdd, 0xa8, 0x73, 0xce, 0x26, 0x53, 0x8e,
0x95, 0x82, 0xf9, 0x7b, 0xa8, 0xc8, 0x99, 0x2d, 0xc6, 0x3e, 0x75, 0xf7, 0x1e, 0x80, 0xb8, 0x59,
0x32, 0x53, 0xd5, 0xfd, 0xdb, 0xa4, 0x13, 0x91, 0xa4, 0xe6, 0x08, 0xf4, 0xc5, 0xfc, 0x68, 0x1a,
0xf8, 0x91, 0xf0, 0xae, 0x8b, 0x65, 0x88, 0x8c, 0x14, 0x09, 0x2c, 0x53, 0x57, 0x93, 0xb3, 0xb6,
0x63, 0xbc, 0xc5, 0x98, 0x4c, 0xde, 0x67, 0xea, 0xbe, 0x10, 0x2f, 0x18, 0xde, 0x88, 0x1b, 0x48,
0x6f, 0x63, 0xf3, 0x65, 0x01, 0xb7, 0x83, 0xe1, 0x4d, 0x53, 0x80, 0xe6, 0x4f, 0x8a, 0x24, 0xfa,
0x81, 0xda, 0xe5, 0xff, 0x1d, 0x89, 0xc5, 0x61, 0x6d, 0xdc, 0x7b, 0x58, 0x26, 0x81, 0xdd, 0x25,
0xe3, 0xf1, 0x2e, 0xd2, 0x31, 0xd0, 0x56, 0x62, 0xf0, 0x02, 0xf2, 0x57, 0xd4, 0xf5, 0x66, 0x61,
0x62, 0x18, 0xa5, 0x02, 0xda, 0x52, 0x12, 0x9c, 0xa8, 0x98, 0xff, 0xcd, 0x43, 0x3e, 0x06, 0xd1,
0x29, 0x64, 0x87, 0xc1, 0x28, 0xc9, 0x83, 0x2f, 0xee, 0x4e, 0x4b, 0x7e, 0x1b, 0xc1, 0x88, 0x61,
0xa9, 0x8b, 0xfe, 0x00, 0xdb, 0xe2, 0x66, 0xfb, 0xcc, 0x23, 0xb3, 0xe9, 0x88, 0xce, 0x43, 0x6f,
0xa4, 0x66, 0x37, 0x94, 0xc2, 0x40, 0xca, 0x71, 0x79, 0x98, 0x1e, 0xa2, 0x03, 0xd8, 0x12, 0xd1,
0x56, 0x91, 0xc8, 0xca, 0xdc, 0x2f, 0x08, 0x40, 0xc6, 0xc0, 0x84, 0x72, 0xe0, 0xbb, 0x81, 0x4f,
0xa2, 0x31, 0x25, 0xa7, 0xdf, 0x7c, 0x2b, 0xa9, 0xad, 0x84, 0x8b, 0x12, 0xec, 0x8d, 0xe9, 0xe9,
0x37, 0xdf, 0xa2, 0xc7, 0x50, 0x94, 0x74, 0xc0, 0x3e, 0x4e, 0xdd, 0xf0, 0x56, 0x72, 0x5a, 0x19,
0x4b, 0x86, 0xb0, 0x24, 0x22, 0x6e, 0xd1, 0x95, 0x47, 0xaf, 0x23, 0xc9, 0x63, 0x65, 0xac, 0x06,
0xe8, 0x25, 0xec, 0xc5, 0x67, 0x40, 0xa2, 0x60, 0x16, 0x0e, 0x19, 0x71, 0xfd, 0x11, 0xfb, 0x28,
0xf9, 0xa9, 0x8c, 0x51, 0x2c, 0xeb, 0x49, 0x91, 0x2d, 0x24, 0x68, 0x1f, 0x36, 0xc7, 0xcc, 0xbd,
0x1e, 0x2b, 0xce, 0x29, 0xe3, 0x78, 0x64, 0xfe, 0x3d, 0x07, 0xc5, 0xd4, 0xc1, 0xa0, 0x12, 0x14,
0xb0, 0xd5, 0xb3, 0xf0, 0x3b, 0xab, 0xa9, 0x7f, 0x86, 0x6a, 0xf0, 0xd4, 0x76, 0x1a, 0x5d, 0x8c,
0xad, 0x46, 0x9f, 0x74, 0x31, 0x19, 0x38, 0x6f, 0x9c, 0xee, 0x0f, 0x0e, 0xb9, 0xa8, 0xbf, 0xef,
0x58, 0x4e, 0x9f, 0x34, 0xad, 0x7e, 0xdd, 0x6e, 0xf7, 0x74, 0x0d, 0x3d, 0x02, 0x63, 0xa1, 0x99,
0x88, 0xeb, 0x9d, 0xee, 0xc0, 0xe9, 0xeb, 0x1b, 0xe8, 0x31, 0x1c, 0xb4, 0x6c, 0xa7, 0xde, 0x26,
0x0b, 0x9d, 0x46, 0xbb, 0xff, 0x8e, 0x58, 0x3f, 0x5e, 0xd8, 0xf8, 0xbd, 0x9e, 0x59, 0xa7, 0x20,
0xee, 0x54, 0x62, 0x21, 0x8b, 0x1e, 0xc2, 0xe7, 0x4a, 0x41, 0x4d, 0x21, 0xfd, 0x6e, 0x97, 0xf4,
0xba, 0x5d, 0x47, 0xcf, 0xa1, 0x1d, 0x28, 0xdb, 0xce, 0xbb, 0x7a, 0xdb, 0x6e, 0x12, 0x6c, 0xd5,
0xdb, 0x1d, 0x7d, 0x13, 0xed, 0x42, 0x65, 0x55, 0x2f, 0x2f, 0x4c, 0x24, 0x7a, 0x5d, 0xc7, 0xee,
0x3a, 0xe4, 0x9d, 0x85, 0x7b, 0x76, 0xd7, 0xd1, 0x0b, 0x68, 0x1f, 0xd0, 0xb2, 0xe8, 0xac, 0x53,
0x6f, 0xe8, 0x5b, 0xe8, 0x73, 0xd8, 0x59, 0xc6, 0xdf, 0x58, 0xef, 0x75, 0x40, 0x06, 0xec, 0xa9,
0x85, 0x91, 0xd7, 0x56, 0xbb, 0xfb, 0x03, 0xe9, 0xd8, 0x8e, 0xdd, 0x19, 0x74, 0xf4, 0x22, 0xda,
0x03, 0xbd, 0x65, 0x59, 0xc4, 0x76, 0x7a, 0x83, 0x56, 0xcb, 0x6e, 0xd8, 0x96, 0xd3, 0xd7, 0x4b,
0xca, 0xf3, 0xba, 0x8d, 0x97, 0xc5, 0x84, 0xc6, 0x59, 0xdd, 0x71, 0xac, 0x36, 0x69, 0xda, 0xbd,
0xfa, 0xeb, 0xb6, 0xd5, 0xd4, 0xb7, 0xd1, 0x21, 0x3c, 0xec, 0x5b, 0x9d, 0x8b, 0x2e, 0xae, 0xe3,
0xf7, 0x24, 0x91, 0xb7, 0xea, 0x76, 0x7b, 0x80, 0x2d, 0xbd, 0x82, 0xbe, 0x84, 0x43, 0x6c, 0xbd,
0x1d, 0xd8, 0xd8, 0x6a, 0x12, 0xa7, 0xdb, 0xb4, 0x48, 0xcb, 0xaa, 0xf7, 0x07, 0xd8, 0x22, 0x1d,
0xbb, 0xd7, 0xb3, 0x9d, 0xef, 0x75, 0x1d, 0x3d, 0x85, 0xa3, 0xb9, 0xca, 0xdc, 0xc0, 0x8a, 0xd6,
0x8e, 0xd8, 0x5f, 0x12, 0x52, 0xc7, 0xfa, 0xb1, 0x4f, 0x2e, 0x2c, 0x0b, 0xeb, 0x08, 0x55, 0x61,
0x7f, 0xe1, 0x5e, 0x39, 0x88, 0x7d, 0xef, 0x0a, 0xd9, 0x85, 0x85, 0x3b, 0x75, 0x47, 0x04, 0x78,
0x49, 0xb6, 0x27, 0x96, 0xbd, 0x90, 0xad, 0x2e, 0xfb, 0x73, 0x84, 0x60, 0x3b, 0x15, 0x95, 0x56,
0x1d, 0xeb, 0xfb, 0x68, 0x0f, 0x2a, 0xc9, 0x0a, 0x12, 0xc5, 0x7f, 0xe5, 0xd1, 0x03, 0x40, 0x03,
0x07, 0x5b, 0xf5, 0xa6, 0x38, 0x90, 0xb9, 0xe0, 0xdf, 0xf9, 0xf3, 0x6c, 0x61, 0x43, 0xcf, 0x98,
0xff, 0xcc, 0x40, 0x79, 0xe9, 0x5e, 0xa2, 0x47, 0xb0, 0x15, 0xb9, 0xd7, 0x3e, 0xe5, 0x82, 0x39,
0x14, 0xa9, 0x2c, 0x00, 0x59, 0x74, 0xc7, 0xd4, 0xf5, 0x15, 0x9b, 0x29, 0xde, 0xdf, 0x92, 0x88,
0xe4, 0xb2, 0x03, 0xc8, 0x27, 0x05, 0x3e, 0x33, 0x2f, 0xf0, 0x9b, 0x43, 0x55, 0xd8, 0x1f, 0xc1,
0x96, 0xa0, 0xcc, 0x88, 0xd3, 0xc9, 0x54, 0x5e, 0xf1, 0x32, 0x5e, 0x00, 0xe8, 0x09, 0x94, 0x27,
0x2c, 0x8a, 0xe8, 0x35, 0x23, 0xea, 0x9a, 0x82, 0xd4, 0x28, 0xc5, 0x60, 0x4b, 0xde, 0xd6, 0x27,
0x90, 0xd0, 0x46, 0xac, 0x94, 0x53, 0x4a, 0x31, 0xa8, 0x94, 0x56, 0x19, 0x9b, 0xd3, 0x98, 0x0d,
0xd2, 0x8c, 0xcd, 0x29, 0x7a, 0x0e, 0x3b, 0x8a, 0x72, 0x5c, 0xdf, 0x9d, 0xcc, 0x26, 0x8a, 0x7a,
0xf2, 0x92, 0x7a, 0x2a, 0x92, 0x7a, 0x14, 0x2e, 0x19, 0xe8, 0x21, 0x14, 0x2e, 0x69, 0xc4, 0x44,
0xb1, 0x88, 0xa9, 0x21, 0x2f, 0xc6, 0x2d, 0xc6, 0x84, 0x48, 0x94, 0x90, 0x50, 0x90, 0x9e, 0x62,
0x84, 0xfc, 0x15, 0x63, 0x58, 0x9c, 0xe5, 0xdc, 0x03, 0xfd, 0xb8, 0xf0, 0x50, 0x4c, 0x79, 0x50,
0xb8, 0xf4, 0xf0, 0x1c, 0x76, 0xd8, 0x47, 0x1e, 0x52, 0x12, 0x4c, 0xe9, 0xcf, 0x33, 0x46, 0x46,
0x94, 0x53, 0xd9, 0x31, 0x96, 0x70, 0x45, 0x0a, 0xba, 0x12, 0x6f, 0x52, 0x4e, 0xcd, 0x47, 0x50,
0xc5, 0x2c, 0x62, 0xbc, 0xe3, 0x46, 0x91, 0x1b, 0xf8, 0x8d, 0xc0, 0xe7, 0x61, 0xe0, 0xc5, 0x35,
0xc7, 0x3c, 0x84, 0x83, 0xb5, 0x52, 0x55, 0x34, 0xc4, 0xe4, 0xb7, 0x33, 0x16, 0xde, 0xae, 0x9f,
0xfc, 0x16, 0x0e, 0xd6, 0x4a, 0xe3, 0x8a, 0xf3, 0x02, 0x72, 0x53, 0xea, 0x86, 0x91, 0xb1, 0x21,
0xab, 0xf6, 0xfe, 0x52, 0x93, 0xe0, 0x86, 0x67, 0x6e, 0xc4, 0x83, 0xf0, 0x16, 0x2b, 0xa5, 0xf3,
0x6c, 0x41, 0xd3, 0x37, 0xcc, 0x3f, 0x69, 0x50, 0x4c, 0x09, 0x45, 0x1e, 0xf8, 0xc1, 0x88, 0x91,
0xab, 0x30, 0x98, 0x24, 0x19, 0x36, 0x07, 0x90, 0x01, 0x79, 0x39, 0xe0, 0x41, 0x9c, 0x5e, 0xc9,
0x10, 0x7d, 0x0d, 0xf9, 0xb1, 0x32, 0x21, 0xa3, 0x54, 0x3c, 0xdd, 0x5d, 0xf1, 0x2e, 0xce, 0x06,
0x27, 0x3a, 0xe7, 0xd9, 0x42, 0x46, 0xcf, 0x9e, 0x67, 0x0b, 0x59, 0x3d, 0x77, 0x9e, 0x2d, 0xe4,
0xf4, 0xcd, 0xf3, 0x6c, 0x61, 0x53, 0xcf, 0x9b, 0xff, 0xd1, 0xa0, 0x90, 0x68, 0x8b, 0xb5, 0x08,
0x8a, 0x27, 0x22, 0x33, 0xe2, 0x06, 0x60, 0x01, 0x20, 0x13, 0x4a, 0x72, 0xb0, 0xdc, 0x57, 0x2c,
0x61, 0xe8, 0x29, 0x94, 0xe7, 0xe3, 0x79, 0xf1, 0xca, 0xe0, 0x65, 0x50, 0x58, 0x8a, 0x66, 0xc3,
0x21, 0x8b, 0x22, 0xe5, 0x2a, 0xa7, 0x2c, 0xa5, 0x31, 0x54, 0x83, 0x4a, 0x32, 0x4e, 0x1c, 0x6e,
0x4a, 0xb5, 0x55, 0x18, 0x3d, 0x07, 0x3d, 0x0d, 0x4d, 0x16, 0xdd, 0xf9, 0x1d, 0x5c, 0x1d, 0x83,
0x39, 0x81, 0x07, 0x32, 0xac, 0x17, 0x61, 0x70, 0x49, 0x2f, 0x5d, 0xcf, 0xe5, 0xb7, 0x49, 0x8b,
0x22, 0x8e, 0x20, 0x0c, 0x26, 0xc4, 0x4f, 0x6a, 0x7e, 0x09, 0x2f, 0x00, 0x11, 0x0e, 0x1e, 0x28,
0x59, 0x1c, 0x8e, 0x78, 0x28, 0x9a, 0x8f, 0xb9, 0xf3, 0x8c, 0x74, 0x3e, 0x1f, 0x9b, 0x37, 0x60,
0xdc, 0x75, 0x17, 0xa7, 0xd0, 0x11, 0x14, 0xa7, 0x0b, 0x58, 0x7a, 0xd4, 0x70, 0x1a, 0x4a, 0x07,
0x7a, 0xe3, 0xd7, 0x03, 0x6d, 0xfe, 0x55, 0x83, 0x9d, 0xd7, 0x33, 0xd7, 0x1b, 0x2d, 0x75, 0x5e,
0xe9, 0x87, 0x97, 0xb6, 0xfc, 0xf0, 0x5a, 0xf7, 0xaa, 0xda, 0x58, 0xfb, 0xaa, 0x5a, 0xf7, 0x72,
0xc9, 0xdc, 0xfb, 0x72, 0x79, 0x0c, 0xc5, 0xc5, 0xa3, 0x45, 0x35, 0xb6, 0x25, 0x0c, 0xe3, 0xe4,
0xc5, 0x12, 0x99, 0xaf, 0x00, 0xa5, 0x17, 0x1a, 0x1f, 0xc8, 0xbc, 0x01, 0xd4, 0xee, 0x6d, 0x00,
0x9f, 0xff, 0x59, 0x83, 0x52, 0xba, 0x0b, 0x47, 0x65, 0xd8, 0xb2, 0x1d, 0xd2, 0x6a, 0xdb, 0xdf,
0x9f, 0xf5, 0xf5, 0xcf, 0xc4, 0xb0, 0x37, 0x68, 0x34, 0x2c, 0xab, 0x69, 0x35, 0x75, 0x4d, 0xd4,
0x07, 0x41, 0xf5, 0x56, 0x93, 0xf4, 0xed, 0x8e, 0xd5, 0x1d, 0x88, 0xce, 0x61, 0x17, 0x2a, 0x31,
0xe6, 0x74, 0x09, 0xee, 0x0e, 0xfa, 0x96, 0x9e, 0x41, 0x3a, 0x94, 0x62, 0xd0, 0xc2, 0xb8, 0x8b,
0xf5, 0xac, 0x28, 0x77, 0x31, 0x72, 0xb7, 0x0b, 0x49, 0x9a, 0x94, 0xdc, 0xe9, 0x3f, 0x72, 0xb0,
0x29, 0x17, 0x18, 0xa2, 0x33, 0x28, 0xa6, 0x5e, 0x46, 0xe8, 0xf0, 0x93, 0x2f, 0xa6, 0xaa, 0xb1,
0xfe, 0x59, 0x31, 0x8b, 0x5e, 0x6a, 0xe8, 0x1c, 0x4a, 0xe9, 0xd7, 0x0c, 0x4a, 0xb7, 0x9e, 0x6b,
0x9e, 0x39, 0x9f, 0xb4, 0xf5, 0x06, 0x74, 0x2b, 0xe2, 0xee, 0x44, 0xb4, 0x9a, 0x71, 0xf3, 0x8f,
0xaa, 0x29, 0xfd, 0x95, 0x17, 0x45, 0xf5, 0x60, 0xad, 0x2c, 0x8e, 0x50, 0x5b, 0x6d, 0x31, 0x6e,
0xbf, 0xef, 0x6c, 0x71, 0xb9, 0xe7, 0xaf, 0x7e, 0x71, 0x9f, 0x38, 0xb6, 0x36, 0x82, 0xdd, 0x35,
0xfc, 0x8c, 0x7e, 0x93, 0x5e, 0xc1, 0xbd, 0xec, 0x5e, 0x7d, 0xf6, 0x6b, 0x6a, 0x0b, 0x2f, 0x6b,
0x88, 0x7c, 0xc9, 0xcb, 0xfd, 0x65, 0x60, 0xc9, 0xcb, 0xa7, 0xea, 0xc1, 0x4f, 0xa0, 0xaf, 0x5e,
0x74, 0x64, 0xae, 0xce, 0xbd, 0x4b, 0x3a, 0xd5, 0x27, 0x9f, 0xd4, 0x89, 0x8d, 0xdb, 0x00, 0x8b,
0xeb, 0x82, 0x1e, 0xa5, 0xa6, 0xdc, 0xb9, 0xee, 0xd5, 0xc3, 0x7b, 0xa4, 0xca, 0xd4, 0xeb, 0xdf,
0xfe, 0xf1, 0xe4, 0xda, 0xe5, 0xe3, 0xd9, 0xe5, 0xf1, 0x30, 0x98, 0x9c, 0x78, 0xa2, 0x61, 0xf7,
0x5d, 0xff, 0xda, 0x67, 0xfc, 0x97, 0x20, 0xbc, 0x39, 0xf1, 0xfc, 0xd1, 0x89, 0xbc, 0x75, 0x27,
0x73, 0x2b, 0x97, 0x9b, 0xf2, 0xdf, 0x9f, 0xdf, 0xfd, 0x2f, 0x00, 0x00, 0xff, 0xff, 0x28, 0xbb,
0xdd, 0x1c, 0x2d, 0x12, 0x00, 0x00,
// 2053 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x58, 0x5f, 0x73, 0xdb, 0xc6,
0x11, 0x0f, 0xc4, 0xff, 0x4b, 0x52, 0x84, 0x4e, 0x8a, 0x4c, 0x53, 0x56, 0xa2, 0x20, 0xae, 0xc3,
0xf1, 0x38, 0x92, 0xab, 0x4e, 0x32, 0x9e, 0x3c, 0xb4, 0x43, 0x91, 0x60, 0x04, 0x99, 0x04, 0xe5,
0x23, 0xe9, 0xc4, 0xcd, 0xc3, 0xcd, 0x89, 0x3c, 0x89, 0x18, 0x81, 0x00, 0x03, 0x1c, 0x1d, 0xeb,
0x3b, 0xf4, 0x03, 0xf4, 0x1b, 0xb4, 0x0f, 0x6d, 0x5f, 0xfa, 0x9d, 0xda, 0xf7, 0xce, 0xf4, 0xbd,
0x73, 0x77, 0x00, 0x09, 0x52, 0x94, 0xd3, 0x27, 0xe2, 0x7e, 0xbb, 0xb7, 0x7b, 0x77, 0xbb, 0xf7,
0xdb, 0x3d, 0xc2, 0x7e, 0xe0, 0xcf, 0x39, 0x0b, 0x82, 0xd9, 0xe8, 0x44, 0x7d, 0x1d, 0xcf, 0x02,
0x9f, 0xfb, 0xa8, 0xb0, 0xc0, 0x6b, 0x85, 0x60, 0x36, 0x52, 0xa8, 0xf1, 0xe7, 0x0c, 0xa0, 0x3e,
0xf3, 0xc6, 0x97, 0xf4, 0x6e, 0xca, 0x3c, 0x8e, 0xd9, 0xcf, 0x73, 0x16, 0x72, 0x84, 0x20, 0x3d,
0x66, 0x21, 0xaf, 0x6a, 0x47, 0x5a, 0xbd, 0x84, 0xe5, 0x37, 0xd2, 0x21, 0x45, 0xa7, 0xbc, 0xba,
0x75, 0xa4, 0xd5, 0x53, 0x58, 0x7c, 0xa2, 0xc7, 0x90, 0xa7, 0x53, 0x4e, 0xa6, 0x21, 0xe5, 0xd5,
0x92, 0x84, 0x73, 0x74, 0xca, 0xbb, 0x21, 0xe5, 0xe8, 0x0b, 0x28, 0xcd, 0x94, 0x49, 0x32, 0xa1,
0xe1, 0xa4, 0x9a, 0x92, 0x86, 0x8a, 0x11, 0x76, 0x4e, 0xc3, 0x09, 0xaa, 0x83, 0x7e, 0xed, 0x78,
0xd4, 0x25, 0x23, 0x97, 0xbf, 0x27, 0x63, 0xe6, 0x72, 0x5a, 0x4d, 0x1f, 0x69, 0xf5, 0x0c, 0xde,
0x96, 0x78, 0xd3, 0xe5, 0xef, 0x5b, 0x02, 0x45, 0x5f, 0x41, 0x25, 0x36, 0x16, 0xa8, 0x05, 0x56,
0x33, 0x47, 0x5a, 0xbd, 0x80, 0xb7, 0x67, 0xab, 0xcb, 0xfe, 0x0a, 0x2a, 0xdc, 0x99, 0x32, 0x7f,
0xce, 0x49, 0xc8, 0x46, 0xbe, 0x37, 0x0e, 0xab, 0x59, 0x65, 0x31, 0x82, 0xfb, 0x0a, 0x45, 0x06,
0x94, 0xaf, 0x19, 0x23, 0xae, 0x33, 0x75, 0x38, 0x11, 0xcb, 0xcf, 0xc9, 0xe5, 0x17, 0xaf, 0x19,
0xeb, 0x08, 0xac, 0x4f, 0x39, 0x7a, 0x0a, 0xdb, 0x4b, 0x1d, 0xb9, 0xc7, 0xb2, 0x54, 0x2a, 0xc5,
0x4a, 0x72, 0xa3, 0x2f, 0x40, 0xf7, 0xe7, 0xfc, 0xc6, 0x77, 0xbc, 0x1b, 0x32, 0x9a, 0x50, 0x8f,
0x38, 0xe3, 0x6a, 0xfe, 0x48, 0xab, 0xa7, 0xcf, 0xb6, 0x5e, 0x6a, 0x78, 0x3b, 0x96, 0x35, 0x27,
0xd4, 0xb3, 0xc6, 0xe8, 0x19, 0x54, 0x5c, 0x1a, 0x72, 0x32, 0xf1, 0x67, 0x64, 0x36, 0xbf, 0xba,
0x65, 0x77, 0xd5, 0x6d, 0x79, 0x32, 0x65, 0x01, 0x9f, 0xfb, 0xb3, 0x4b, 0x09, 0xa2, 0x43, 0x00,
0x79, 0x2a, 0xd2, 0x79, 0xb5, 0x20, 0xf7, 0x50, 0x10, 0x88, 0x74, 0x8c, 0x4e, 0xa1, 0x28, 0xa3,
0x49, 0x26, 0x8e, 0xc7, 0xc3, 0x2a, 0x1c, 0xa5, 0xea, 0xc5, 0x53, 0xfd, 0xd8, 0xf5, 0x44, 0x60,
0xb1, 0x90, 0x9c, 0x3b, 0x1e, 0xc7, 0x49, 0x25, 0x64, 0x42, 0x5e, 0x84, 0x91, 0x70, 0xf7, 0x7d,
0xb5, 0x28, 0x27, 0x3c, 0x3f, 0x5e, 0xa4, 0xc4, 0xf1, 0xfd, 0x1c, 0x38, 0x6e, 0xb1, 0x90, 0x0f,
0xdc, 0xf7, 0xa6, 0xc7, 0x83, 0x3b, 0x9c, 0x1b, 0xab, 0x11, 0x7a, 0x01, 0x88, 0xba, 0xae, 0xff,
0x0b, 0x09, 0x99, 0x7b, 0x4d, 0xa2, 0xf3, 0xaf, 0x56, 0x8e, 0xb4, 0x7a, 0x1e, 0xeb, 0x52, 0xd2,
0x67, 0xee, 0x75, 0x64, 0xaa, 0xf6, 0x1d, 0x94, 0x92, 0x66, 0x44, 0x0e, 0x89, 0x3d, 0x8b, 0xb4,
0x4a, 0x63, 0xf1, 0x89, 0xf6, 0x20, 0xf3, 0x9e, 0xba, 0x73, 0x26, 0xf3, 0xaa, 0x84, 0xd5, 0xe0,
0xbb, 0xad, 0x57, 0x9a, 0xf1, 0x0a, 0x76, 0x07, 0x01, 0x1d, 0xdd, 0xae, 0xa5, 0xe6, 0x7a, 0x66,
0x69, 0xf7, 0x32, 0xcb, 0xf8, 0xab, 0x06, 0xe5, 0x68, 0x56, 0x9f, 0x53, 0x3e, 0x0f, 0xd1, 0xd7,
0x90, 0x09, 0x39, 0xe5, 0x4c, 0x6a, 0x6f, 0x9f, 0x3e, 0x4a, 0xec, 0x3c, 0xa1, 0xc8, 0xb0, 0xd2,
0x42, 0x35, 0xc8, 0xcf, 0x02, 0xe6, 0x4c, 0xe9, 0x4d, 0xbc, 0xae, 0xc5, 0x18, 0x19, 0x90, 0x91,
0x93, 0x65, 0x4a, 0x17, 0x4f, 0x4b, 0xc9, 0x53, 0xc7, 0x4a, 0x84, 0xea, 0x90, 0x99, 0x70, 0x77,
0x14, 0x56, 0xd3, 0xf2, 0xa0, 0x51, 0xa4, 0x73, 0x3e, 0xe8, 0x34, 0x1b, 0x9c, 0xb3, 0xe9, 0x8c,
0x63, 0xa5, 0x60, 0xfc, 0x1e, 0x2a, 0x72, 0x66, 0x9b, 0xb1, 0x8f, 0xdd, 0xbd, 0x47, 0x20, 0x6e,
0x96, 0xcc, 0x54, 0x75, 0xff, 0xb2, 0x74, 0x2a, 0x92, 0xd4, 0x18, 0x83, 0xbe, 0x9c, 0x1f, 0xce,
0x7c, 0x2f, 0x14, 0xde, 0x75, 0xb1, 0x0c, 0x91, 0x91, 0x22, 0x81, 0x65, 0xea, 0x6a, 0x72, 0xd6,
0x76, 0x84, 0xb7, 0x19, 0x93, 0xc9, 0xfb, 0x4c, 0xdd, 0x17, 0xe2, 0xfa, 0xa3, 0x5b, 0x71, 0x03,
0xe9, 0x5d, 0x64, 0xbe, 0x2c, 0xe0, 0x8e, 0x3f, 0xba, 0x6d, 0x09, 0xd0, 0xf8, 0x49, 0x91, 0xc4,
0xc0, 0x57, 0xbb, 0xfc, 0xbf, 0x23, 0xb1, 0x3c, 0xac, 0xad, 0x07, 0x0f, 0xcb, 0x20, 0xb0, 0xbb,
0x62, 0x3c, 0xda, 0x45, 0x32, 0x06, 0xda, 0x5a, 0x0c, 0x5e, 0x40, 0xee, 0x9a, 0x3a, 0xee, 0x3c,
0x88, 0x0d, 0xa3, 0x44, 0x40, 0xdb, 0x4a, 0x82, 0x63, 0x15, 0xe3, 0xbf, 0x39, 0xc8, 0x45, 0x20,
0x3a, 0x85, 0xf4, 0xc8, 0x1f, 0xc7, 0x79, 0xf0, 0xd9, 0xfd, 0x69, 0xf1, 0x6f, 0xd3, 0x1f, 0x33,
0x2c, 0x75, 0xd1, 0x1f, 0x60, 0x5b, 0xdc, 0x6c, 0x8f, 0xb9, 0x64, 0x3e, 0x1b, 0xd3, 0x45, 0xe8,
0xab, 0x89, 0xd9, 0x4d, 0xa5, 0x30, 0x94, 0x72, 0x5c, 0x1e, 0x25, 0x87, 0xe8, 0x00, 0x0a, 0x22,
0xda, 0x2a, 0x12, 0x69, 0x99, 0xfb, 0x79, 0x01, 0xc8, 0x18, 0x18, 0x50, 0xf6, 0x3d, 0xc7, 0xf7,
0x48, 0x38, 0xa1, 0xe4, 0xf4, 0x9b, 0x6f, 0x25, 0xb5, 0x95, 0x70, 0x51, 0x82, 0xfd, 0x09, 0x3d,
0xfd, 0xe6, 0x5b, 0xf4, 0x39, 0x14, 0x25, 0x1d, 0xb0, 0x0f, 0x33, 0x27, 0xb8, 0x93, 0x9c, 0x56,
0xc6, 0x92, 0x21, 0x4c, 0x89, 0x88, 0x5b, 0x74, 0xed, 0xd2, 0x9b, 0x50, 0xf2, 0x58, 0x19, 0xab,
0x01, 0x7a, 0x09, 0x7b, 0xd1, 0x19, 0x90, 0xd0, 0x9f, 0x07, 0x23, 0x46, 0x1c, 0x6f, 0xcc, 0x3e,
0x48, 0x7e, 0x2a, 0x63, 0x14, 0xc9, 0xfa, 0x52, 0x64, 0x09, 0x09, 0xda, 0x87, 0xec, 0x84, 0x39,
0x37, 0x13, 0xc5, 0x39, 0x65, 0x1c, 0x8d, 0x8c, 0xbf, 0x65, 0xa0, 0x98, 0x38, 0x18, 0x54, 0x82,
0x3c, 0x36, 0xfb, 0x26, 0x7e, 0x6b, 0xb6, 0xf4, 0x4f, 0x50, 0x1d, 0x9e, 0x5a, 0x76, 0xb3, 0x87,
0xb1, 0xd9, 0x1c, 0x90, 0x1e, 0x26, 0x43, 0xfb, 0xb5, 0xdd, 0xfb, 0xc1, 0x26, 0x97, 0x8d, 0x77,
0x5d, 0xd3, 0x1e, 0x90, 0x96, 0x39, 0x68, 0x58, 0x9d, 0xbe, 0xae, 0xa1, 0x27, 0x50, 0x5d, 0x6a,
0xc6, 0xe2, 0x46, 0xb7, 0x37, 0xb4, 0x07, 0xfa, 0x16, 0xfa, 0x1c, 0x0e, 0xda, 0x96, 0xdd, 0xe8,
0x90, 0xa5, 0x4e, 0xb3, 0x33, 0x78, 0x4b, 0xcc, 0x1f, 0x2f, 0x2d, 0xfc, 0x4e, 0x4f, 0x6d, 0x52,
0x10, 0x77, 0x2a, 0xb6, 0x90, 0x46, 0x8f, 0xe1, 0x53, 0xa5, 0xa0, 0xa6, 0x90, 0x41, 0xaf, 0x47,
0xfa, 0xbd, 0x9e, 0xad, 0x67, 0xd0, 0x0e, 0x94, 0x2d, 0xfb, 0x6d, 0xa3, 0x63, 0xb5, 0x08, 0x36,
0x1b, 0x9d, 0xae, 0x9e, 0x45, 0xbb, 0x50, 0x59, 0xd7, 0xcb, 0x09, 0x13, 0xb1, 0x5e, 0xcf, 0xb6,
0x7a, 0x36, 0x79, 0x6b, 0xe2, 0xbe, 0xd5, 0xb3, 0xf5, 0x3c, 0xda, 0x07, 0xb4, 0x2a, 0x3a, 0xef,
0x36, 0x9a, 0x7a, 0x01, 0x7d, 0x0a, 0x3b, 0xab, 0xf8, 0x6b, 0xf3, 0x9d, 0x0e, 0xa8, 0x0a, 0x7b,
0x6a, 0x61, 0xe4, 0xcc, 0xec, 0xf4, 0x7e, 0x20, 0x5d, 0xcb, 0xb6, 0xba, 0xc3, 0xae, 0x5e, 0x44,
0x7b, 0xa0, 0xb7, 0x4d, 0x93, 0x58, 0x76, 0x7f, 0xd8, 0x6e, 0x5b, 0x4d, 0xcb, 0xb4, 0x07, 0x7a,
0x49, 0x79, 0xde, 0xb4, 0xf1, 0xb2, 0x98, 0xd0, 0x3c, 0x6f, 0xd8, 0xb6, 0xd9, 0x21, 0x2d, 0xab,
0xdf, 0x38, 0xeb, 0x98, 0x2d, 0x7d, 0x1b, 0x1d, 0xc2, 0xe3, 0x81, 0xd9, 0xbd, 0xec, 0xe1, 0x06,
0x7e, 0x47, 0x62, 0x79, 0xbb, 0x61, 0x75, 0x86, 0xd8, 0xd4, 0x2b, 0xe8, 0x0b, 0x38, 0xc4, 0xe6,
0x9b, 0xa1, 0x85, 0xcd, 0x16, 0xb1, 0x7b, 0x2d, 0x93, 0xb4, 0xcd, 0xc6, 0x60, 0x88, 0x4d, 0xd2,
0xb5, 0xfa, 0x7d, 0xcb, 0xfe, 0x5e, 0xd7, 0xd1, 0x53, 0x38, 0x5a, 0xa8, 0x2c, 0x0c, 0xac, 0x69,
0xed, 0x88, 0xfd, 0xc5, 0x21, 0xb5, 0xcd, 0x1f, 0x07, 0xe4, 0xd2, 0x34, 0xb1, 0x8e, 0x50, 0x0d,
0xf6, 0x97, 0xee, 0x95, 0x83, 0xc8, 0xf7, 0xae, 0x90, 0x5d, 0x9a, 0xb8, 0xdb, 0xb0, 0x45, 0x80,
0x57, 0x64, 0x7b, 0x62, 0xd9, 0x4b, 0xd9, 0xfa, 0xb2, 0x3f, 0x45, 0x08, 0xb6, 0x13, 0x51, 0x69,
0x37, 0xb0, 0xbe, 0x8f, 0xf6, 0xa0, 0x12, 0xaf, 0x20, 0x56, 0xfc, 0x57, 0x0e, 0x3d, 0x02, 0x34,
0xb4, 0xb1, 0xd9, 0x68, 0x89, 0x03, 0x59, 0x08, 0xfe, 0x9d, 0xbb, 0x48, 0xe7, 0xb7, 0xf4, 0x94,
0xf1, 0xcf, 0x14, 0x94, 0x57, 0xee, 0x25, 0x7a, 0x02, 0x85, 0xd0, 0xb9, 0xf1, 0x28, 0x17, 0xcc,
0xa1, 0x48, 0x65, 0x09, 0xc8, 0xa2, 0x3b, 0xa1, 0x8e, 0xa7, 0xd8, 0x4c, 0xf1, 0x7e, 0x41, 0x22,
0x92, 0xcb, 0x0e, 0x20, 0x17, 0x17, 0xf8, 0xd4, 0xa2, 0xc0, 0x67, 0x47, 0xaa, 0xb0, 0x3f, 0x81,
0x82, 0xa0, 0xcc, 0x90, 0xd3, 0xe9, 0x4c, 0x5e, 0xf1, 0x32, 0x5e, 0x02, 0xe8, 0x4b, 0x28, 0x4f,
0x59, 0x18, 0xd2, 0x1b, 0x46, 0xd4, 0x35, 0x05, 0xa9, 0x51, 0x8a, 0xc0, 0xb6, 0xbc, 0xad, 0x5f,
0x42, 0x4c, 0x1b, 0x91, 0x52, 0x46, 0x29, 0x45, 0xa0, 0x52, 0x5a, 0x67, 0x6c, 0x4e, 0x23, 0x36,
0x48, 0x32, 0x36, 0xa7, 0xe8, 0x39, 0xec, 0x28, 0xca, 0x71, 0x3c, 0x67, 0x3a, 0x9f, 0x2a, 0xea,
0xc9, 0x49, 0xea, 0xa9, 0x48, 0xea, 0x51, 0xb8, 0x64, 0xa0, 0xc7, 0x90, 0xbf, 0xa2, 0x21, 0x13,
0xc5, 0x22, 0xa2, 0x86, 0x9c, 0x18, 0xb7, 0x19, 0x13, 0x22, 0x51, 0x42, 0x02, 0x41, 0x7a, 0x8a,
0x11, 0x72, 0xd7, 0x8c, 0x61, 0x71, 0x96, 0x0b, 0x0f, 0xf4, 0xc3, 0xd2, 0x43, 0x31, 0xe1, 0x41,
0xe1, 0xd2, 0xc3, 0x73, 0xd8, 0x61, 0x1f, 0x78, 0x40, 0x89, 0x3f, 0xa3, 0x3f, 0xcf, 0x19, 0x19,
0x53, 0x4e, 0x65, 0xc7, 0x58, 0xc2, 0x15, 0x29, 0xe8, 0x49, 0xbc, 0x45, 0x39, 0x35, 0x9e, 0x40,
0x0d, 0xb3, 0x90, 0xf1, 0xae, 0x13, 0x86, 0x8e, 0xef, 0x35, 0x7d, 0x8f, 0x07, 0xbe, 0x1b, 0xd5,
0x1c, 0xe3, 0x10, 0x0e, 0x36, 0x4a, 0x55, 0xd1, 0x10, 0x93, 0xdf, 0xcc, 0x59, 0x70, 0xb7, 0x79,
0xf2, 0x1b, 0x38, 0xd8, 0x28, 0x8d, 0x2a, 0xce, 0x0b, 0xc8, 0xcc, 0xa8, 0x13, 0x84, 0xd5, 0x2d,
0x59, 0xb5, 0xf7, 0x57, 0x9a, 0x04, 0x27, 0x38, 0x77, 0x42, 0xee, 0x07, 0x77, 0x58, 0x29, 0x5d,
0xa4, 0xf3, 0x9a, 0xbe, 0x65, 0xfc, 0x49, 0x83, 0x62, 0x42, 0x28, 0xf2, 0xc0, 0xf3, 0xc7, 0x8c,
0x5c, 0x07, 0xfe, 0x34, 0xce, 0xb0, 0x05, 0x80, 0xaa, 0x90, 0x93, 0x03, 0xee, 0x47, 0xe9, 0x15,
0x0f, 0xd1, 0xd7, 0x90, 0x9b, 0x28, 0x13, 0x32, 0x4a, 0xc5, 0xd3, 0xdd, 0x35, 0xef, 0xe2, 0x6c,
0x70, 0xac, 0x73, 0x91, 0xce, 0xa7, 0xf4, 0xf4, 0x45, 0x3a, 0x9f, 0xd6, 0x33, 0x17, 0xe9, 0x7c,
0x46, 0xcf, 0x5e, 0xa4, 0xf3, 0x59, 0x3d, 0x67, 0xfc, 0x47, 0x83, 0x7c, 0xac, 0x2d, 0xd6, 0x22,
0x28, 0x9e, 0x88, 0xcc, 0x88, 0x1a, 0x80, 0x25, 0x80, 0x0c, 0x28, 0xc9, 0xc1, 0x6a, 0x5f, 0xb1,
0x82, 0xa1, 0xa7, 0x50, 0x5e, 0x8c, 0x17, 0xc5, 0x2b, 0x85, 0x57, 0x41, 0x61, 0x29, 0x9c, 0x8f,
0x46, 0x2c, 0x0c, 0x95, 0xab, 0x8c, 0xb2, 0x94, 0xc4, 0x50, 0x1d, 0x2a, 0xf1, 0x38, 0x76, 0x98,
0x95, 0x6a, 0xeb, 0x30, 0x7a, 0x0e, 0x7a, 0x12, 0x9a, 0x2e, 0xbb, 0xf3, 0x7b, 0xb8, 0x3a, 0x06,
0x63, 0x0a, 0x8f, 0x64, 0x58, 0x2f, 0x03, 0xff, 0x8a, 0x5e, 0x39, 0xae, 0xc3, 0xef, 0xe2, 0x16,
0x45, 0x1c, 0x41, 0xe0, 0x4f, 0x89, 0x17, 0xd7, 0xfc, 0x12, 0x5e, 0x02, 0x22, 0x1c, 0xdc, 0x57,
0xb2, 0x28, 0x1c, 0xd1, 0x50, 0x34, 0x1f, 0x0b, 0xe7, 0x29, 0xe9, 0x7c, 0x31, 0x36, 0x6e, 0xa1,
0x7a, 0xdf, 0x5d, 0x94, 0x42, 0x47, 0x50, 0x9c, 0x2d, 0x61, 0xe9, 0x51, 0xc3, 0x49, 0x28, 0x19,
0xe8, 0xad, 0x5f, 0x0f, 0xb4, 0xf1, 0x17, 0x0d, 0x76, 0xce, 0xe6, 0x8e, 0x3b, 0x5e, 0xe9, 0xbc,
0x92, 0x0f, 0x2f, 0x6d, 0xf5, 0xe1, 0xb5, 0xe9, 0x55, 0xb5, 0xb5, 0xf1, 0x55, 0xb5, 0xe9, 0xe5,
0x92, 0x7a, 0xf0, 0xe5, 0xf2, 0x39, 0x14, 0x97, 0x8f, 0x16, 0xd5, 0xd8, 0x96, 0x30, 0x4c, 0xe2,
0x17, 0x4b, 0x68, 0xbc, 0x02, 0x94, 0x5c, 0x68, 0x74, 0x20, 0x8b, 0x06, 0x50, 0x7b, 0xb0, 0x01,
0x7c, 0xfe, 0x0f, 0x0d, 0x4a, 0xc9, 0x2e, 0x1c, 0x95, 0xa1, 0x60, 0xd9, 0xa4, 0xdd, 0xb1, 0xbe,
0x3f, 0x1f, 0xe8, 0x9f, 0x88, 0x61, 0x7f, 0xd8, 0x6c, 0x9a, 0x66, 0xcb, 0x6c, 0xe9, 0x9a, 0xa8,
0x0f, 0x82, 0xea, 0xcd, 0x16, 0x19, 0x58, 0x5d, 0xb3, 0x37, 0x14, 0x9d, 0xc3, 0x2e, 0x54, 0x22,
0xcc, 0xee, 0x11, 0xdc, 0x1b, 0x0e, 0x4c, 0x3d, 0x85, 0x74, 0x28, 0x45, 0xa0, 0x89, 0x71, 0x0f,
0xeb, 0x69, 0x51, 0xee, 0x22, 0xe4, 0x7e, 0x17, 0x12, 0x37, 0x29, 0x19, 0xd9, 0x65, 0xc4, 0x5a,
0xcb, 0x02, 0x4d, 0xce, 0x1a, 0x9d, 0x86, 0xdd, 0x34, 0xf5, 0xec, 0xe9, 0xdf, 0x33, 0x90, 0x95,
0x3b, 0x08, 0xd0, 0x39, 0x14, 0x13, 0x4f, 0x27, 0x74, 0xf8, 0xd1, 0x27, 0x55, 0xad, 0xba, 0xf9,
0xdd, 0x31, 0x0f, 0x5f, 0x6a, 0xe8, 0x02, 0x4a, 0xc9, 0xe7, 0x0e, 0x4a, 0xf6, 0xa6, 0x1b, 0xde,
0x41, 0x1f, 0xb5, 0xf5, 0x1a, 0x74, 0x33, 0xe4, 0xce, 0x54, 0xf4, 0xa2, 0xd1, 0xeb, 0x00, 0xd5,
0x12, 0xfa, 0x6b, 0x4f, 0x8e, 0xda, 0xc1, 0x46, 0x59, 0x14, 0xc2, 0x8e, 0xda, 0x62, 0xd4, 0x9f,
0xdf, 0xdb, 0xe2, 0xea, 0xa3, 0xa0, 0xf6, 0xd9, 0x43, 0xe2, 0xc8, 0xda, 0x18, 0x76, 0x37, 0x10,
0x38, 0xfa, 0x4d, 0x72, 0x05, 0x0f, 0xd2, 0x7f, 0xed, 0xd9, 0xaf, 0xa9, 0x2d, 0xbd, 0x6c, 0x60,
0xfa, 0x15, 0x2f, 0x0f, 0xd7, 0x89, 0x15, 0x2f, 0x1f, 0x2b, 0x18, 0x3f, 0x81, 0xbe, 0xce, 0x04,
0xc8, 0x58, 0x9f, 0x7b, 0x9f, 0x95, 0x6a, 0x5f, 0x7e, 0x54, 0x27, 0x32, 0x6e, 0x01, 0x2c, 0xef,
0x13, 0x7a, 0x92, 0x98, 0x72, 0x8f, 0x0f, 0x6a, 0x87, 0x0f, 0x48, 0x95, 0xa9, 0xb3, 0xdf, 0xfe,
0xf1, 0xe4, 0xc6, 0xe1, 0x93, 0xf9, 0xd5, 0xf1, 0xc8, 0x9f, 0x9e, 0xb8, 0xa2, 0xa3, 0xf7, 0x1c,
0xef, 0xc6, 0x63, 0xfc, 0x17, 0x3f, 0xb8, 0x3d, 0x71, 0xbd, 0xf1, 0x89, 0xbc, 0x96, 0x27, 0x0b,
0x2b, 0x57, 0x59, 0xf9, 0xf7, 0xd0, 0xef, 0xfe, 0x17, 0x00, 0x00, 0xff, 0xff, 0xbc, 0x2d, 0x5b,
0xa8, 0x4e, 0x12, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.

5
lnrpc/routerrpc/router.proto
View File

@ -142,6 +142,11 @@ enum PaymentState {
invalid final cltv delta)
*/
FAILED_INCORRECT_PAYMENT_DETAILS = 5;
/**
Insufficient local balance.
*/
FAILED_INSUFFICIENT_BALANCE = 6;
}

3
lnrpc/routerrpc/router_server.go
View File

@ -678,6 +678,9 @@ func marshallFailureReason(reason channeldb.FailureReason) (
case channeldb.FailureReasonPaymentDetails:
return PaymentState_FAILED_INCORRECT_PAYMENT_DETAILS, nil
case channeldb.FailureReasonInsufficientBalance:
return PaymentState_FAILED_INSUFFICIENT_BALANCE, nil
}
return 0, errors.New("unknown failure reason")

29
routing/errors.go
View File

@ -7,28 +7,10 @@ import "github.com/go-errors/errors"
type errorCode uint8
const (
// ErrNoPathFound is returned when a path to the target destination
// does not exist in the graph.
ErrNoPathFound errorCode = iota
// ErrNoRouteFound is returned when the router is unable to find a
// valid route to the target destination after fees and time-lock
// limitations are factored in.
ErrNoRouteFound
// ErrInsufficientCapacity is returned when a path if found, yet the
// capacity of one of the channels in the path is insufficient to carry
// the payment.
ErrInsufficientCapacity
// ErrMaxHopsExceeded is returned when a candidate path is found, but
// the length of that path exceeds HopLimit.
ErrMaxHopsExceeded
// ErrTargetNotInNetwork is returned when the target of a path-finding
// or payment attempt isn't known to be within the current version of
// the channel graph.
ErrTargetNotInNetwork
ErrTargetNotInNetwork errorCode = iota
// ErrOutdated is returned when the routing update already have
// been applied, or a newer update is already known.
@ -39,18 +21,9 @@ const (
// announcement was given for node not found in any channel.
ErrIgnored
// ErrRejected is returned if the update is for a channel ID that was
// previously added to the reject cache because of an invalid update
// was attempted to be processed.
ErrRejected
// ErrPaymentAttemptTimeout is an error that indicates that a payment
// attempt timed out before we were able to successfully route an HTLC.
ErrPaymentAttemptTimeout
// ErrFeeLimitExceeded is returned when the total fees of a route exceed
// the user-specified fee limit.
ErrFeeLimitExceeded
)
// routerError is a structure that represent the error inside the routing package,

95
routing/pathfind.go
View File

@ -2,13 +2,13 @@ package routing
import (
"container/heap"
"errors"
"fmt"
"math"
"time"
"github.com/btcsuite/btcd/btcec"
"github.com/coreos/bbolt"
"github.com/lightningnetwork/lnd/channeldb"
"github.com/lightningnetwork/lnd/lnwire"
"github.com/lightningnetwork/lnd/routing/route"
@ -63,6 +63,23 @@ var (
// DefaultAprioriHopProbability is the default a priori probability for
// a hop.
DefaultAprioriHopProbability = float64(0.6)
// errNoTlvPayload is returned when the destination hop does not support
// a tlv payload.
errNoTlvPayload = errors.New("destination hop doesn't " +
"understand new TLV payloads")
// errNoPathFound is returned when a path to the target destination does
// not exist in the graph.
errNoPathFound = errors.New("unable to find a path to destination")
// errMaxHopsExceeded is returned when a candidate path is found, but
// the length of that path exceeds HopLimit.
errMaxHopsExceeded = errors.New("potential path has too many hops")
// errInsufficientLocalBalance is returned when none of the local
// channels have enough balance for the payment.
errInsufficientBalance = errors.New("insufficient local balance")
)
// edgePolicyWithSource is a helper struct to keep track of the source node
@ -292,6 +309,50 @@ type PathFindingConfig struct {
MinProbability float64
}
// getMaxOutgoingAmt returns the maximum available balance in any of the
// channels of the given node.
func getMaxOutgoingAmt(node route.Vertex, outgoingChan *uint64,
g *graphParams, tx *bbolt.Tx) (lnwire.MilliSatoshi, error) {
var max lnwire.MilliSatoshi
cb := func(_ *bbolt.Tx, edgeInfo *channeldb.ChannelEdgeInfo, outEdge,
_ *channeldb.ChannelEdgePolicy) error {
if outEdge == nil {
return nil
}
chanID := outEdge.ChannelID
// Enforce outgoing channel restriction.
if outgoingChan != nil && chanID != *outgoingChan {
return nil
}
bandwidth, ok := g.bandwidthHints[chanID]
// If the bandwidth is not available for whatever reason, don't
// fail the pathfinding early.
if !ok {
max = lnwire.MaxMilliSatoshi
return nil
}
if bandwidth > max {
max = bandwidth
}
return nil
}
// Iterate over all channels of the to node.
err := g.graph.ForEachNodeChannel(tx, node[:], cb)
if err != nil {
return 0, err
}
return max, err
}
// findPath attempts to find a path from the source node within the
// ChannelGraph to the target node that's capable of supporting a payment of
// `amt` value. The current approach implemented is modified version of
@ -319,7 +380,13 @@ func findPath(g *graphParams, r *RestrictParams, cfg *PathFindingConfig,
"time=%v", nodesVisited, edgesExpanded, timeElapsed)
}()
var err error
// Get source node outside of the pathfinding tx, to prevent a deadlock.
selfNode, err := g.graph.SourceNode()
if err != nil {
return nil, err
}
self := selfNode.PubKeyBytes
tx := g.tx
if tx == nil {
tx, err = g.graph.Database().Begin(false)
@ -347,12 +414,23 @@ func findPath(g *graphParams, r *RestrictParams, cfg *PathFindingConfig,
lnwire.TLVOnionPayloadOptional,
)
if !supportsTLV {
return nil, fmt.Errorf("destination hop doesn't " +
"understand new TLV paylods")
return nil, errNoTlvPayload
}
}
}
// If we are routing from ourselves, check that we have enough local
// balance available.
if source == self {
max, err := getMaxOutgoingAmt(self, r.OutgoingChannelID, g, tx)
if err != nil {
return nil, err
}
if max < amt {
return nil, errInsufficientBalance
}
}
// First we'll initialize an empty heap which'll help us to quickly
// locate the next edge we should visit next during our graph
// traversal.
@ -363,7 +441,6 @@ func findPath(g *graphParams, r *RestrictParams, cfg *PathFindingConfig,
additionalEdgesWithSrc := make(map[route.Vertex][]*edgePolicyWithSource)
for vertex, outgoingEdgePolicies := range g.additionalEdges {
// Build reverse lookup to find incoming edges. Needed because
// search is taken place from target to source.
for _, outgoingEdgePolicy := range outgoingEdgePolicies {
@ -552,7 +629,7 @@ func findPath(g *graphParams, r *RestrictParams, cfg *PathFindingConfig,
pivot := partialPath.node
// Create unified policies for all incoming connections.
u := newUnifiedPolicies(source, pivot, r.OutgoingChannelID)
u := newUnifiedPolicies(self, pivot, r.OutgoingChannelID)
err := u.addGraphPolicies(g.graph, tx)
if err != nil {
@ -622,8 +699,7 @@ func findPath(g *graphParams, r *RestrictParams, cfg *PathFindingConfig,
currentNodeWithDist, ok := distance[currentNode]
if !ok {
// If the node doesnt have a next hop it means we didn't find a path.
return nil, newErrf(ErrNoPathFound, "unable to find a "+
"path to destination")
return nil, errNoPathFound
}
// Add the next hop to the list of path edges.
@ -646,8 +722,7 @@ func findPath(g *graphParams, r *RestrictParams, cfg *PathFindingConfig,
// hops, then it's invalid.
numEdges := len(pathEdges)
if numEdges > HopLimit {
return nil, newErr(ErrMaxHopsExceeded, "potential path has "+
"too many hops")
return nil, errMaxHopsExceeded
}
log.Debugf("Found route: probability=%v, hops=%v, fee=%v\n",

60
routing/pathfind_test.go
View File

@ -1269,7 +1269,7 @@ func TestPathNotAvailable(t *testing.T) {
noRestrictions, testPathFindingConfig,
sourceNode.PubKeyBytes, unknownNode, 100,
)
if !IsError(err, ErrNoPathFound) {
if err != errNoPathFound {
t.Fatalf("path shouldn't have been found: %v", err)
}
}
@ -1306,7 +1306,7 @@ func TestPathInsufficientCapacity(t *testing.T) {
noRestrictions, testPathFindingConfig,
sourceNode.PubKeyBytes, target, payAmt,
)
if !IsError(err, ErrNoPathFound) {
if err != errNoPathFound {
t.Fatalf("graph shouldn't be able to support payment: %v", err)
}
}
@ -1339,7 +1339,7 @@ func TestRouteFailMinHTLC(t *testing.T) {
noRestrictions, testPathFindingConfig,
sourceNode.PubKeyBytes, target, payAmt,
)
if !IsError(err, ErrNoPathFound) {
if err != errNoPathFound {
t.Fatalf("graph shouldn't be able to support payment: %v", err)
}
}
@ -1403,7 +1403,7 @@ func TestRouteFailMaxHTLC(t *testing.T) {
// We'll now attempt to route through that edge with a payment above
// 100k msat, which should fail.
_, err = ctx.findPath(target, payAmt)
if !IsError(err, ErrNoPathFound) {
if err != errNoPathFound {
t.Fatalf("graph shouldn't be able to support payment: %v", err)
}
}
@ -1491,7 +1491,7 @@ func TestRouteFailDisabledEdge(t *testing.T) {
noRestrictions, testPathFindingConfig,
sourceNode.PubKeyBytes, target, payAmt,
)
if !IsError(err, ErrNoPathFound) {
if err != errNoPathFound {
t.Fatalf("graph shouldn't be able to support payment: %v", err)
}
}
@ -1549,7 +1549,7 @@ func TestPathSourceEdgesBandwidth(t *testing.T) {
noRestrictions, testPathFindingConfig,
sourceNode.PubKeyBytes, target, payAmt,
)
if !IsError(err, ErrNoPathFound) {
if err != errNoPathFound {
t.Fatalf("graph shouldn't be able to support payment: %v", err)
}
@ -1971,7 +1971,7 @@ func testCltvLimit(t *testing.T, limit uint32, expectedChannel uint64) {
path, err := ctx.findPath(target, paymentAmt)
if expectedChannel == 0 {
// Finish test if we expect no route.
if IsError(err, ErrNoPathFound) {
if err == errNoPathFound {
return
}
t.Fatal("expected no path to be found")
@ -2137,7 +2137,7 @@ func testProbabilityRouting(t *testing.T, p10, p11, p20, minProbability float64,
path, err := ctx.findPath(target, paymentAmt)
if expectedChan == 0 {
if err == nil || !IsError(err, ErrNoPathFound) {
if err != errNoPathFound {
t.Fatalf("expected no path found, but got %v", err)
}
return
@ -2337,6 +2337,37 @@ func TestRouteToSelf(t *testing.T) {
ctx.assertPath(path, []uint64{1, 3, 2})
}
// TestInsufficientBalance tests that a dedicated error is returned for
// insufficient local balance.
func TestInsufficientBalance(t *testing.T) {
t.Parallel()
testChannels := []*testChannel{
symmetricTestChannel("source", "target", 100000, &testChannelPolicy{
Expiry: 144,
FeeBaseMsat: 500,
}, 1),
}
ctx := newPathFindingTestContext(t, testChannels, "source")
defer ctx.cleanup()
paymentAmt := lnwire.NewMSatFromSatoshis(100)
target := ctx.keyFromAlias("target")
ctx.graphParams.bandwidthHints = map[uint64]lnwire.MilliSatoshi{
1: lnwire.NewMSatFromSatoshis(50),
}
// Find the best path to self. We expect this to be source->a->source,
// because a charges the lowest forwarding fee.
_, err := ctx.findPath(target, paymentAmt)
if err != errInsufficientBalance {
t.Fatalf("expected insufficient balance error, but got: %v",
err)
}
}
type pathFindingTestContext struct {
t *testing.T
graphParams graphParams
@ -2365,16 +2396,13 @@ func newPathFindingTestContext(t *testing.T, testChannels []*testChannel,
t: t,
testGraphInstance: testGraphInstance,
source: route.Vertex(sourceNode.PubKeyBytes),
pathFindingConfig: *testPathFindingConfig,
graphParams: graphParams{
graph: testGraphInstance.graph,
},
restrictParams: *noRestrictions,
}
ctx.pathFindingConfig = *testPathFindingConfig
ctx.graphParams.graph = testGraphInstance.graph
ctx.restrictParams.FeeLimit = noFeeLimit
ctx.restrictParams.ProbabilitySource = noProbabilitySource
ctx.restrictParams.CltvLimit = math.MaxUint32
return ctx
}

21
routing/payment_lifecycle.go
View File

@ -186,6 +186,22 @@ func (p *paymentLifecycle) resumePayment() ([32]byte, *route.Route, error) {
}
// errorToPaymentFailure takes a path finding error and converts it into a
// payment-level failure.
func errorToPaymentFailure(err error) channeldb.FailureReason {
switch err {
case errNoTlvPayload, errNoPathFound, errMaxHopsExceeded,
errPrebuiltRouteTried:
return channeldb.FailureReasonNoRoute
case errInsufficientBalance:
return channeldb.FailureReasonInsufficientBalance
}
return channeldb.FailureReasonError
}
// createNewPaymentAttempt creates and stores a new payment attempt to the
// database.
func (p *paymentLifecycle) createNewPaymentAttempt() (lnwire.ShortChannelID,
@ -230,11 +246,14 @@ func (p *paymentLifecycle) createNewPaymentAttempt() (lnwire.ShortChannelID,
log.Warnf("Failed to find route for payment %x: %v",
p.payment.PaymentHash, err)
// Convert error to payment-level failure.
failure := errorToPaymentFailure(err)
// If we're unable to successfully make a payment using
// any of the routes we've found, then mark the payment
// as permanently failed.
saveErr := p.router.cfg.Control.Fail(
p.payment.PaymentHash, channeldb.FailureReasonNoRoute,
p.payment.PaymentHash, failure,
)
if saveErr != nil {
return lnwire.ShortChannelID{}, nil, saveErr

10
routing/payment_session.go
View File

@ -1,7 +1,7 @@
package routing
import (
"fmt"
"errors"
"github.com/lightningnetwork/lnd/channeldb"
"github.com/lightningnetwork/lnd/lnwire"
@ -12,6 +12,12 @@ import (
// to prevent an HTLC being failed if some blocks are mined while it's in-flight.
const BlockPadding uint16 = 3
var (
// errPrebuiltRouteTried is returned when the single pre-built route
// failed and there is nothing more we can do.
errPrebuiltRouteTried = errors.New("pre-built route already tried")
)
// PaymentSession is used during SendPayment attempts to provide routes to
// attempt. It also defines methods to give the PaymentSession additional
// information learned during the previous attempts.
@ -66,7 +72,7 @@ func (p *paymentSession) RequestRoute(payment *LightningPayment,
// If the pre-built route has been tried already, the payment session is
// over.
case p.preBuiltRoute != nil:
return nil, fmt.Errorf("pre-built route already tried")
return nil, errPrebuiltRouteTried
}
// Add BlockPadding to the finalCltvDelta so that the receiving node