akovalenko/lnd.xprv
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

routing: track amt ranges in mc

Browse Source
This commit is contained in:
Joost Jager 2019-09-26 17:04:02 +02:00
parent 62f8cca75b
commit cdf1aa5bc1
No known key found for this signature in database
GPG Key ID: A61B9D4C393C59C7
8 changed files with 320 additions and 229 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
cmd/lncli/cmd_query_mission_control.go
View File

@ -32,10 +32,10 @@ func queryMissionControl(ctx *cli.Context) error {
} }
type displayPairHistory struct { type displayPairHistory struct {
NodeFrom, NodeTo string NodeFrom, NodeTo string
LastAttemptSuccessful bool SuccessTime, FailTime int64
Timestamp int64 FailAmtSat, FailAmtMsat int64
AmtSat, AmtMsat int64 SuccessAmtSat, SuccessAmtMsat int64
} }
displayResp := struct { displayResp := struct {
@ -46,12 +46,14 @@ func queryMissionControl(ctx *cli.Context) error {
displayResp.Pairs = append( displayResp.Pairs = append(
displayResp.Pairs, displayResp.Pairs,
displayPairHistory{ displayPairHistory{
NodeFrom: hex.EncodeToString(n.NodeFrom), NodeFrom: hex.EncodeToString(n.NodeFrom),
NodeTo: hex.EncodeToString(n.NodeTo), NodeTo: hex.EncodeToString(n.NodeTo),
LastAttemptSuccessful: n.History.LastAttemptSuccessful, FailTime: n.History.FailTime,
Timestamp: n.History.Timestamp, SuccessTime: n.History.SuccessTime,
AmtMsat: n.History.AmtMsat, FailAmtSat: n.History.FailAmtSat,
AmtSat: n.History.AmtSat, FailAmtMsat: n.History.FailAmtMsat,
SuccessAmtSat: n.History.SuccessAmtSat,
SuccessAmtMsat: n.History.SuccessAmtMsat,
}, },
) )
} }

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

@ -1157,17 +1157,25 @@ func (m *PairHistory) GetHistory() *PairData {
} }
type PairData struct { type PairData struct {
/// Time stamp of last result. /// Time of last failure.
Timestamp int64 `protobuf:"varint,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"` FailTime int64 `protobuf:"varint,1,opt,name=fail_time,proto3" json:"fail_time,omitempty"`
/// Last amount that was forwarded rounded to whole satoshis. //*
AmtSat int64 `protobuf:"varint,2,opt,name=amt_sat,proto3" json:"amt_sat,omitempty"` //Lowest amount that failed to forward rounded to whole sats. This may be
/// Last amount that was forwarded in millisatoshis. //set to zero if the failure is independent of amount.
AmtMsat int64 `protobuf:"varint,4,opt,name=amt_msat,proto3" json:"amt_msat,omitempty"` FailAmtSat int64 `protobuf:"varint,2,opt,name=fail_amt_sat,proto3" json:"fail_amt_sat,omitempty"`
/// Whether the last payment attempt through this pair was successful. //*
LastAttemptSuccessful bool `protobuf:"varint,3,opt,name=last_attempt_successful,proto3" json:"last_attempt_successful,omitempty"` //Lowest amount that failed to forward in millisats. This may be
XXX_NoUnkeyedLiteral struct{} `json:"-"` //set to zero if the failure is independent of amount.
XXX_unrecognized []byte `json:"-"` FailAmtMsat int64 `protobuf:"varint,4,opt,name=fail_amt_msat,proto3" json:"fail_amt_msat,omitempty"`
XXX_sizecache int32 `json:"-"` /// Time of last success.
SuccessTime int64 `protobuf:"varint,5,opt,name=success_time,proto3" json:"success_time,omitempty"`
/// Highest amount that we could successfully forward rounded to whole sats.
SuccessAmtSat int64 `protobuf:"varint,6,opt,name=success_amt_sat,proto3" json:"success_amt_sat,omitempty"`
/// Highest amount that we could successfully forward in millisats.
SuccessAmtMsat int64 `protobuf:"varint,7,opt,name=success_amt_msat,proto3" json:"success_amt_msat,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
} }
func (m *PairData) Reset() { *m = PairData{} } func (m *PairData) Reset() { *m = PairData{} }
@ -1195,32 +1203,46 @@ func (m *PairData) XXX_DiscardUnknown() {
var xxx_messageInfo_PairData proto.InternalMessageInfo var xxx_messageInfo_PairData proto.InternalMessageInfo
func (m *PairData) GetTimestamp() int64 { func (m *PairData) GetFailTime() int64 {
if m != nil { if m != nil {
return m.Timestamp return m.FailTime
} }
return 0 return 0
} }
func (m *PairData) GetAmtSat() int64 { func (m *PairData) GetFailAmtSat() int64 {
if m != nil { if m != nil {
return m.AmtSat return m.FailAmtSat
} }
return 0 return 0
} }
func (m *PairData) GetAmtMsat() int64 { func (m *PairData) GetFailAmtMsat() int64 {
if m != nil { if m != nil {
return m.AmtMsat return m.FailAmtMsat
} }
return 0 return 0
} }
func (m *PairData) GetLastAttemptSuccessful() bool { func (m *PairData) GetSuccessTime() int64 {
if m != nil { if m != nil {
return m.LastAttemptSuccessful return m.SuccessTime
} }
return false return 0
}
func (m *PairData) GetSuccessAmtSat() int64 {
if m != nil {
return m.SuccessAmtSat
}
return 0
}
func (m *PairData) GetSuccessAmtMsat() int64 {
if m != nil {
return m.SuccessAmtMsat
}
return 0
} }
type QueryProbabilityRequest struct { type QueryProbabilityRequest struct {
@ -1474,132 +1496,133 @@ func init() {
func init() { proto.RegisterFile("routerrpc/router.proto", fileDescriptor_7a0613f69d37b0a5) } func init() { proto.RegisterFile("routerrpc/router.proto", fileDescriptor_7a0613f69d37b0a5) }
var fileDescriptor_7a0613f69d37b0a5 = []byte{ var fileDescriptor_7a0613f69d37b0a5 = []byte{
// 1986 bytes of a gzipped FileDescriptorProto // 2011 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x58, 0x51, 0x73, 0x1a, 0xc9, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x58, 0x5d, 0x73, 0x1a, 0xc9,
0xf1, 0xbf, 0x15, 0x20, 0xa0, 0x01, 0x69, 0x35, 0x92, 0xe5, 0x35, 0x92, 0xce, 0xba, 0xb5, 0xff, 0xd5, 0xde, 0x11, 0x20, 0xe0, 0x00, 0x62, 0xd4, 0x92, 0x65, 0x8c, 0xac, 0xb5, 0x76, 0xec, 0xd7,
0x3e, 0x95, 0xcb, 0x27, 0xf9, 0xaf, 0xd4, 0x5d, 0xb9, 0xee, 0x21, 0x29, 0x0c, 0xcb, 0x69, 0x65, 0xab, 0x72, 0x79, 0x25, 0xbf, 0x4a, 0xed, 0x96, 0x6b, 0x2f, 0x92, 0xc2, 0x30, 0xac, 0x46, 0x86,
0x58, 0xe4, 0x01, 0x7c, 0xe7, 0xdc, 0xc3, 0xd4, 0x08, 0x46, 0x62, 0x4b, 0xcb, 0x2e, 0xb7, 0x3b, 0x41, 0x6e, 0xc0, 0xbb, 0xce, 0x5e, 0x74, 0xb5, 0xa0, 0x25, 0xa6, 0x34, 0x1f, 0xec, 0x4c, 0xe3,
0x38, 0xd6, 0x77, 0x48, 0xde, 0xf3, 0x0d, 0x92, 0x87, 0xe4, 0x29, 0xdf, 0x29, 0xa9, 0xca, 0x7b, 0x58, 0xff, 0x21, 0xf9, 0x1d, 0xc9, 0x45, 0x72, 0x95, 0xff, 0x94, 0x54, 0xe5, 0x32, 0x55, 0xb9,
0xde, 0x53, 0x33, 0xb3, 0x0b, 0x0b, 0x42, 0xba, 0x3c, 0xb1, 0xf3, 0xeb, 0x9e, 0xe9, 0x9e, 0xe9, 0x4f, 0x75, 0xf7, 0x0c, 0x0c, 0x08, 0x79, 0x73, 0xc5, 0xf4, 0x73, 0x9e, 0x3e, 0xa7, 0xbb, 0xcf,
0xee, 0xdf, 0xf4, 0x00, 0xbb, 0x61, 0x30, 0xe5, 0x2c, 0x0c, 0x27, 0x83, 0x13, 0xf5, 0x75, 0x3c, 0x47, 0x9f, 0x06, 0xf6, 0xc2, 0x60, 0xc6, 0x59, 0x18, 0x4e, 0x47, 0x27, 0xea, 0xeb, 0x78, 0x1a,
0x09, 0x03, 0x1e, 0xa0, 0xe2, 0x0c, 0xaf, 0x16, 0xc3, 0xc9, 0x40, 0xa1, 0xe6, 0xbf, 0xb3, 0x80, 0x06, 0x3c, 0x40, 0xc5, 0x39, 0x5e, 0x2f, 0x86, 0xd3, 0x91, 0x42, 0x8d, 0x7f, 0x65, 0x01, 0xf5,
0xba, 0xcc, 0x1f, 0x5e, 0xd0, 0xdb, 0x31, 0xf3, 0x39, 0x66, 0xbf, 0x4c, 0x59, 0xc4, 0x11, 0x82, 0x99, 0x3f, 0xbe, 0xa0, 0xb7, 0x1e, 0xf3, 0x39, 0x66, 0xbf, 0xcc, 0x58, 0xc4, 0x11, 0x82, 0xec,
0xec, 0x90, 0x45, 0xdc, 0xd0, 0x0e, 0xb5, 0xa3, 0x32, 0x96, 0xdf, 0x48, 0x87, 0x0c, 0x1d, 0x73, 0x98, 0x45, 0xbc, 0xa6, 0x1d, 0x6a, 0x47, 0x65, 0x2c, 0xbf, 0x91, 0x0e, 0x19, 0xea, 0xf1, 0xda,
0x63, 0xed, 0x50, 0x3b, 0xca, 0x60, 0xf1, 0x89, 0x9e, 0x40, 0x81, 0x8e, 0x39, 0x19, 0x47, 0x94, 0xc6, 0xa1, 0x76, 0x94, 0xc1, 0xe2, 0x13, 0x3d, 0x82, 0x02, 0xf5, 0x38, 0xf1, 0x22, 0xca, 0x6b,
0x1b, 0x65, 0x09, 0xe7, 0xe9, 0x98, 0xb7, 0x23, 0xca, 0xd1, 0x57, 0x50, 0x9e, 0xa8, 0x25, 0xc9, 0x65, 0x09, 0xe7, 0xa9, 0xc7, 0xbb, 0x11, 0xe5, 0xe8, 0x2b, 0x28, 0x4f, 0x95, 0x4a, 0x32, 0xa1,
0x88, 0x46, 0x23, 0x23, 0x23, 0x17, 0x2a, 0xc5, 0xd8, 0x19, 0x8d, 0x46, 0xe8, 0x08, 0xf4, 0x2b, 0xd1, 0xa4, 0x96, 0x91, 0x8a, 0x4a, 0x31, 0x76, 0x46, 0xa3, 0x09, 0x3a, 0x02, 0xfd, 0xca, 0xf1,
0xd7, 0xa7, 0x1e, 0x19, 0x78, 0xfc, 0x13, 0x19, 0x32, 0x8f, 0x53, 0x23, 0x7b, 0xa8, 0x1d, 0xe5, 0xa9, 0x4b, 0x46, 0x2e, 0xff, 0x48, 0xc6, 0xcc, 0xe5, 0xb4, 0x96, 0x3d, 0xd4, 0x8e, 0x72, 0x78,
0xf0, 0x86, 0xc4, 0xeb, 0x1e, 0xff, 0xd4, 0x10, 0x28, 0xfa, 0x1a, 0x36, 0x93, 0xc5, 0x42, 0xe5, 0x4b, 0xe2, 0x4d, 0x97, 0x7f, 0x6c, 0x09, 0x14, 0x7d, 0x0d, 0xd5, 0x44, 0x59, 0xa8, 0x16, 0x58,
0xa0, 0x91, 0x3b, 0xd4, 0x8e, 0x8a, 0x78, 0x63, 0xb2, 0xe8, 0xf6, 0xd7, 0xb0, 0xc9, 0xdd, 0x31, 0xcb, 0x1d, 0x6a, 0x47, 0x45, 0xbc, 0x35, 0x5d, 0x5e, 0xf6, 0xd7, 0x50, 0xe5, 0x8e, 0xc7, 0x82,
0x0b, 0xa6, 0x9c, 0x44, 0x6c, 0x10, 0xf8, 0xc3, 0xc8, 0x58, 0x57, 0x2b, 0xc6, 0x70, 0x57, 0xa1, 0x19, 0x27, 0x11, 0x1b, 0x05, 0xfe, 0x38, 0xaa, 0x6d, 0x2a, 0x8d, 0x31, 0xdc, 0x57, 0x28, 0x32,
0xc8, 0x84, 0xca, 0x15, 0x63, 0xc4, 0x73, 0xc7, 0x2e, 0x27, 0xc2, 0xfd, 0xbc, 0x74, 0xbf, 0x74, 0xa0, 0x72, 0xc5, 0x18, 0x71, 0x1d, 0xcf, 0xe1, 0x44, 0x2c, 0x3f, 0x2f, 0x97, 0x5f, 0xba, 0x62,
0xc5, 0x58, 0x4b, 0x60, 0x5d, 0xca, 0xd1, 0x73, 0xd8, 0x98, 0xeb, 0xc8, 0x3d, 0x56, 0xa4, 0x52, 0xac, 0x23, 0xb0, 0x3e, 0xe5, 0xe8, 0x19, 0x6c, 0x2d, 0x38, 0x72, 0x8f, 0x15, 0x49, 0x2a, 0x27,
0x39, 0x51, 0x92, 0x1b, 0x7d, 0x05, 0x7a, 0x30, 0xe5, 0xd7, 0x81, 0xeb, 0x5f, 0x93, 0xc1, 0x88, 0x24, 0xb9, 0xd1, 0x97, 0xa0, 0x07, 0x33, 0x7e, 0x1d, 0x38, 0xfe, 0x35, 0x19, 0x4d, 0xa8, 0x4f,
0xfa, 0xc4, 0x1d, 0x1a, 0x85, 0x43, 0xed, 0x28, 0xfb, 0x76, 0xed, 0xb5, 0x86, 0x37, 0x12, 0x59, 0x9c, 0x71, 0xad, 0x70, 0xa8, 0x1d, 0x65, 0xdf, 0x6c, 0xbc, 0xd2, 0xf0, 0x56, 0x22, 0x6b, 0x4e,
0x7d, 0x44, 0x7d, 0x7b, 0x88, 0x5e, 0xc0, 0xa6, 0x47, 0x23, 0x4e, 0x46, 0xc1, 0x84, 0x4c, 0xa6, 0xa8, 0x6f, 0x8d, 0xd1, 0x73, 0xa8, 0xba, 0x34, 0xe2, 0x64, 0x12, 0x4c, 0xc9, 0x74, 0x76, 0x79,
0x97, 0x37, 0xec, 0xd6, 0xd8, 0x90, 0x27, 0x53, 0x11, 0xf0, 0x59, 0x30, 0xb9, 0x90, 0x20, 0x3a, 0xc3, 0x6e, 0x6b, 0x5b, 0xf2, 0x64, 0x2a, 0x02, 0x3e, 0x0b, 0xa6, 0x17, 0x12, 0x44, 0x07, 0x00,
0x00, 0x90, 0xa7, 0x22, 0x8d, 0x1b, 0x45, 0xb9, 0x87, 0xa2, 0x40, 0xa4, 0x61, 0x74, 0x0a, 0x25, 0xf2, 0x54, 0xa4, 0xf1, 0x5a, 0x51, 0xee, 0xa1, 0x28, 0x10, 0x69, 0x18, 0x9d, 0x42, 0x49, 0x7a,
0x19, 0x4d, 0x32, 0x72, 0x7d, 0x1e, 0x19, 0x70, 0x98, 0x39, 0x2a, 0x9d, 0xea, 0xc7, 0x9e, 0x2f, 0x93, 0x4c, 0x1c, 0x9f, 0x47, 0x35, 0x38, 0xcc, 0x1c, 0x95, 0x4e, 0xf5, 0x63, 0xd7, 0x17, 0x8e,
0x02, 0x8b, 0x85, 0xe4, 0xcc, 0xf5, 0x39, 0x4e, 0x2b, 0x21, 0x0b, 0x0a, 0x22, 0x8c, 0x84, 0x7b, 0xc5, 0x42, 0x72, 0xe6, 0xf8, 0x1c, 0xa7, 0x49, 0xc8, 0x84, 0x82, 0x70, 0x23, 0xe1, 0xee, 0xc7,
0x9f, 0x8c, 0x92, 0x9c, 0xf0, 0xf2, 0x78, 0x96, 0x12, 0xc7, 0x77, 0x73, 0xe0, 0xb8, 0xc1, 0x22, 0x5a, 0x49, 0x4e, 0x78, 0x71, 0x3c, 0x0f, 0x89, 0xe3, 0xbb, 0x31, 0x70, 0xdc, 0x62, 0x11, 0x1f,
0xde, 0xf3, 0x3e, 0x59, 0x3e, 0x0f, 0x6f, 0x71, 0x7e, 0xa8, 0x46, 0xd5, 0xef, 0xa1, 0x9c, 0x16, 0xb8, 0x1f, 0x4d, 0x9f, 0x87, 0xb7, 0x38, 0x3f, 0x56, 0xa3, 0xfa, 0xf7, 0x50, 0x4e, 0x0b, 0x44,
0x88, 0xac, 0x10, 0xbb, 0x10, 0x89, 0x92, 0xc5, 0xe2, 0x13, 0xed, 0x40, 0xee, 0x13, 0xf5, 0xa6, 0x54, 0x88, 0x5d, 0x88, 0x40, 0xc9, 0x62, 0xf1, 0x89, 0x76, 0x21, 0xf7, 0x91, 0xba, 0x33, 0x26,
0x4c, 0x66, 0x4a, 0x19, 0xab, 0xc1, 0xf7, 0x6b, 0x6f, 0x34, 0xf3, 0x0d, 0x6c, 0xf7, 0x42, 0x3a, 0x23, 0xa5, 0x8c, 0xd5, 0xe0, 0xfb, 0x8d, 0xd7, 0x9a, 0xf1, 0x1a, 0x76, 0x06, 0x21, 0x1d, 0xdd,
0xb8, 0x59, 0x4a, 0xb6, 0xe5, 0x5c, 0xd1, 0xee, 0xe4, 0x8a, 0xf9, 0x57, 0x0d, 0x2a, 0xf1, 0xac, 0xac, 0x04, 0xdb, 0x6a, 0xac, 0x68, 0x77, 0x62, 0xc5, 0xf8, 0x8b, 0x06, 0x95, 0x78, 0x56, 0x9f,
0x2e, 0xa7, 0x7c, 0x1a, 0xa1, 0x6f, 0x20, 0x17, 0x71, 0xca, 0x99, 0xd4, 0xde, 0x38, 0x7d, 0x9c, 0x53, 0x3e, 0x8b, 0xd0, 0x37, 0x90, 0x8b, 0x38, 0xe5, 0x4c, 0xb2, 0xb7, 0x4e, 0x1f, 0xa6, 0xf6,
0xda, 0x4b, 0x4a, 0x91, 0x61, 0xa5, 0x85, 0xaa, 0x50, 0x98, 0x84, 0xcc, 0x1d, 0xd3, 0xeb, 0xc4, 0x92, 0x22, 0x32, 0xac, 0x58, 0xa8, 0x0e, 0x85, 0x69, 0xc8, 0x1c, 0x8f, 0x5e, 0x27, 0xeb, 0x9a,
0xaf, 0xd9, 0x18, 0x99, 0x90, 0x93, 0x93, 0x65, 0x92, 0x96, 0x4e, 0xcb, 0xe9, 0x73, 0xc4, 0x4a, 0x8f, 0x91, 0x01, 0x39, 0x39, 0x59, 0x06, 0x69, 0xe9, 0xb4, 0x9c, 0x3e, 0x47, 0xac, 0x44, 0xe8,
0x84, 0x8e, 0x20, 0x37, 0xe2, 0xde, 0x20, 0x32, 0xb2, 0xf2, 0xe8, 0x50, 0xac, 0x73, 0xd6, 0x6b, 0x08, 0x72, 0x13, 0xee, 0x8e, 0xa2, 0x5a, 0x56, 0x1e, 0x1d, 0x8a, 0x39, 0x67, 0x83, 0x4e, 0xb3,
0xd5, 0x6b, 0x9c, 0xb3, 0xf1, 0x84, 0x63, 0xa5, 0x60, 0xfe, 0x16, 0x36, 0xe5, 0xcc, 0x26, 0x63, 0xc1, 0x39, 0xf3, 0xa6, 0x1c, 0x2b, 0x82, 0xf1, 0x5b, 0xa8, 0xca, 0x99, 0x6d, 0xc6, 0x3e, 0x97,
0x0f, 0x55, 0xd3, 0x63, 0x10, 0xb5, 0x22, 0x73, 0x4f, 0x55, 0xd4, 0x3a, 0x1d, 0x8b, 0xb4, 0x33, 0x4d, 0x0f, 0x41, 0xe4, 0x8a, 0x8c, 0x3d, 0x95, 0x51, 0x9b, 0xd4, 0x13, 0x61, 0x67, 0x8c, 0x41,
0x87, 0xa0, 0xcf, 0xe7, 0x47, 0x93, 0xc0, 0x8f, 0x84, 0x75, 0x5d, 0xb8, 0x21, 0x72, 0x4c, 0xa4, 0x5f, 0xcc, 0x8f, 0xa6, 0x81, 0x1f, 0x09, 0xeb, 0xba, 0x58, 0x86, 0x88, 0x31, 0x11, 0x92, 0x32,
0xa4, 0x4c, 0x46, 0x4d, 0xce, 0xda, 0x88, 0xf1, 0x26, 0x63, 0x32, 0x1d, 0x5f, 0xa8, 0x0a, 0x20, 0x18, 0x35, 0x39, 0x6b, 0x2b, 0xc6, 0xdb, 0x8c, 0xc9, 0x70, 0x7c, 0xae, 0x32, 0x80, 0xb8, 0xc1,
0x5e, 0x30, 0xb8, 0x11, 0x35, 0x45, 0x6f, 0xe3, 0xe5, 0x2b, 0x02, 0x6e, 0x05, 0x83, 0x9b, 0x86, 0xe8, 0x46, 0xe4, 0x14, 0xbd, 0x8d, 0xd5, 0x57, 0x04, 0xdc, 0x09, 0x46, 0x37, 0x2d, 0x01, 0x1a,
0x00, 0xcd, 0x9f, 0x55, 0xd9, 0xf7, 0x02, 0xb5, 0xcb, 0xff, 0x39, 0x12, 0xf3, 0xc3, 0x5a, 0xbb, 0x3f, 0xab, 0xb4, 0x1f, 0x04, 0x6a, 0x97, 0xff, 0xb3, 0x27, 0x16, 0x87, 0xb5, 0x71, 0xef, 0x61,
0xf7, 0xb0, 0x4c, 0x02, 0xdb, 0x0b, 0x8b, 0xc7, 0xbb, 0x48, 0xc7, 0x40, 0x5b, 0x8a, 0xc1, 0x2b, 0x19, 0x04, 0x76, 0x96, 0x94, 0xc7, 0xbb, 0x48, 0xfb, 0x40, 0x5b, 0xf1, 0xc1, 0x4b, 0xc8, 0x5f,
0xc8, 0x5f, 0x51, 0xd7, 0x9b, 0x86, 0xc9, 0xc2, 0x28, 0x15, 0xd0, 0xa6, 0x92, 0xe0, 0x44, 0xc5, 0x51, 0xc7, 0x9d, 0x85, 0x89, 0x62, 0x94, 0x72, 0x68, 0x5b, 0x49, 0x70, 0x42, 0x31, 0xfe, 0x93,
0xfc, 0x4f, 0x1e, 0xf2, 0x31, 0x88, 0x4e, 0x21, 0x3b, 0x08, 0x86, 0x49, 0x1e, 0x7c, 0x79, 0x77, 0x87, 0x7c, 0x0c, 0xa2, 0x53, 0xc8, 0x8e, 0x82, 0x71, 0x12, 0x07, 0x5f, 0xde, 0x9d, 0x96, 0xfc,
0x5a, 0xf2, 0x5b, 0x0f, 0x86, 0x0c, 0x4b, 0x5d, 0xf4, 0x3b, 0xd8, 0x10, 0xb5, 0xea, 0x33, 0x8f, 0x36, 0x83, 0x31, 0xc3, 0x92, 0x8b, 0x7e, 0x07, 0x5b, 0x22, 0x57, 0x7d, 0xe6, 0x92, 0xd9, 0x74,
0x4c, 0x27, 0x43, 0x3a, 0x0b, 0xbd, 0x91, 0x9a, 0x5d, 0x57, 0x0a, 0x7d, 0x29, 0xc7, 0x95, 0x41, 0x4c, 0xe7, 0xae, 0xaf, 0xa5, 0x66, 0x37, 0x15, 0x61, 0x28, 0xe5, 0xb8, 0x32, 0x4a, 0x0f, 0xd1,
0x7a, 0x88, 0xf6, 0xa0, 0x28, 0xa2, 0xad, 0x22, 0x91, 0x95, 0xb9, 0x5f, 0x10, 0x80, 0x8c, 0x81, 0x3e, 0x14, 0x85, 0xb7, 0x95, 0x27, 0xb2, 0x32, 0xf6, 0x0b, 0x02, 0x90, 0x3e, 0x30, 0xa0, 0x12,
0x09, 0x95, 0xc0, 0x77, 0x03, 0x9f, 0x44, 0x23, 0x4a, 0x4e, 0xbf, 0xfd, 0x4e, 0x92, 0x55, 0x19, 0xf8, 0x4e, 0xe0, 0x93, 0x68, 0x42, 0xc9, 0xe9, 0xb7, 0xdf, 0xc9, 0x62, 0x55, 0xc6, 0x25, 0x09,
0x97, 0x24, 0xd8, 0x1d, 0xd1, 0xd3, 0x6f, 0xbf, 0x43, 0x4f, 0xa1, 0x24, 0x0b, 0x9c, 0x7d, 0x9e, 0xf6, 0x27, 0xf4, 0xf4, 0xdb, 0xef, 0xd0, 0x13, 0x28, 0xc9, 0x04, 0x67, 0x9f, 0xa6, 0x4e, 0x78,
0xb8, 0xe1, 0xad, 0x64, 0xa9, 0x0a, 0x96, 0x35, 0x6f, 0x49, 0x44, 0x54, 0xd1, 0x95, 0x47, 0xaf, 0x2b, 0xab, 0x54, 0x05, 0xcb, 0x9c, 0x37, 0x25, 0x22, 0xb2, 0xe8, 0xca, 0xa5, 0xd7, 0x91, 0xac,
0x23, 0xc9, 0x4c, 0x15, 0xac, 0x06, 0xe8, 0x35, 0xec, 0xc4, 0x67, 0x40, 0xa2, 0x60, 0x1a, 0x0e, 0x4c, 0x15, 0xac, 0x06, 0xe8, 0x15, 0xec, 0xc6, 0x67, 0x40, 0xa2, 0x60, 0x16, 0x8e, 0x18, 0x71,
0x18, 0x71, 0xfd, 0x21, 0xfb, 0x2c, 0x19, 0xa7, 0x82, 0x51, 0x2c, 0xeb, 0x4a, 0x91, 0x2d, 0x24, 0xfc, 0x31, 0xfb, 0x24, 0x2b, 0x4e, 0x05, 0xa3, 0x58, 0xd6, 0x97, 0x22, 0x4b, 0x48, 0xd0, 0x1e,
0x68, 0x17, 0xd6, 0x47, 0xcc, 0xbd, 0x1e, 0x29, 0x16, 0xa9, 0xe0, 0x78, 0x64, 0xfe, 0x2d, 0x07, 0x6c, 0x4e, 0x98, 0x73, 0x3d, 0x51, 0x55, 0xa4, 0x82, 0xe3, 0x91, 0xf1, 0xd7, 0x1c, 0x94, 0x52,
0xa5, 0xd4, 0xc1, 0xa0, 0x32, 0x14, 0xb0, 0xd5, 0xb5, 0xf0, 0x07, 0xab, 0xa1, 0x7f, 0x81, 0x8e, 0x07, 0x83, 0xca, 0x50, 0xc0, 0x66, 0xdf, 0xc4, 0xef, 0xcd, 0x96, 0xfe, 0x05, 0x3a, 0x82, 0x67,
0xe0, 0xb9, 0xed, 0xd4, 0x3b, 0x18, 0x5b, 0xf5, 0x1e, 0xe9, 0x60, 0xd2, 0x77, 0xde, 0x39, 0x9d, 0x96, 0xdd, 0xec, 0x61, 0x6c, 0x36, 0x07, 0xa4, 0x87, 0xc9, 0xd0, 0x7e, 0x6b, 0xf7, 0x7e, 0xb4,
0x1f, 0x1d, 0x72, 0x51, 0xfb, 0xd8, 0xb6, 0x9c, 0x1e, 0x69, 0x58, 0xbd, 0x9a, 0xdd, 0xea, 0xea, 0xc9, 0x45, 0xe3, 0x43, 0xd7, 0xb4, 0x07, 0xa4, 0x65, 0x0e, 0x1a, 0x56, 0xa7, 0xaf, 0x6b, 0xe8,
0x1a, 0xda, 0x07, 0x63, 0xae, 0x99, 0x88, 0x6b, 0xed, 0x4e, 0xdf, 0xe9, 0xe9, 0x6b, 0xe8, 0x29, 0x31, 0xd4, 0x16, 0xcc, 0x44, 0xdc, 0xe8, 0xf6, 0x86, 0xf6, 0x40, 0xdf, 0x40, 0x4f, 0x60, 0xbf,
0xec, 0x35, 0x6d, 0xa7, 0xd6, 0x22, 0x73, 0x9d, 0x7a, 0xab, 0xf7, 0x81, 0x58, 0x3f, 0x5d, 0xd8, 0x6d, 0xd9, 0x8d, 0x0e, 0x59, 0x70, 0x9a, 0x9d, 0xc1, 0x7b, 0x62, 0xfe, 0x74, 0x61, 0xe1, 0x0f,
0xf8, 0xa3, 0x9e, 0x59, 0xa5, 0x20, 0x6a, 0x2a, 0x59, 0x21, 0x8b, 0x9e, 0xc0, 0x23, 0xa5, 0xa0, 0x7a, 0x66, 0x1d, 0x41, 0xe4, 0x54, 0xa2, 0x21, 0x8b, 0x1e, 0xc1, 0x03, 0x45, 0x50, 0x53, 0xc8,
0xa6, 0x90, 0x5e, 0xa7, 0x43, 0xba, 0x9d, 0x8e, 0xa3, 0xe7, 0xd0, 0x16, 0x54, 0x6c, 0xe7, 0x43, 0xa0, 0xd7, 0x23, 0xfd, 0x5e, 0xcf, 0xd6, 0x73, 0x68, 0x1b, 0x2a, 0x96, 0xfd, 0xbe, 0xd1, 0xb1,
0xad, 0x65, 0x37, 0x08, 0xb6, 0x6a, 0xad, 0xb6, 0xbe, 0x8e, 0xb6, 0x61, 0x73, 0x59, 0x2f, 0x2f, 0x5a, 0x04, 0x9b, 0x8d, 0x4e, 0x57, 0xdf, 0x44, 0x3b, 0x50, 0x5d, 0xe5, 0xe5, 0x85, 0x8a, 0x84,
0x96, 0x48, 0xf4, 0x3a, 0x8e, 0xdd, 0x71, 0xc8, 0x07, 0x0b, 0x77, 0xed, 0x8e, 0xa3, 0x17, 0xd0, 0xd7, 0xb3, 0xad, 0x9e, 0x4d, 0xde, 0x9b, 0xb8, 0x6f, 0xf5, 0x6c, 0xbd, 0x80, 0xf6, 0x00, 0x2d,
0x2e, 0xa0, 0x45, 0xd1, 0x59, 0xbb, 0x56, 0xd7, 0x8b, 0xe8, 0x11, 0x6c, 0x2d, 0xe2, 0xef, 0xac, 0x8b, 0xce, 0xba, 0x8d, 0xa6, 0x5e, 0x44, 0x0f, 0x60, 0x7b, 0x19, 0x7f, 0x6b, 0x7e, 0xd0, 0x01,
0x8f, 0x3a, 0x20, 0x03, 0x76, 0x94, 0x63, 0xe4, 0xad, 0xd5, 0xea, 0xfc, 0x48, 0xda, 0xb6, 0x63, 0xd5, 0x60, 0x57, 0x2d, 0x8c, 0xbc, 0x31, 0x3b, 0xbd, 0x1f, 0x49, 0xd7, 0xb2, 0xad, 0xee, 0xb0,
0xb7, 0xfb, 0x6d, 0xbd, 0x84, 0x76, 0x40, 0x6f, 0x5a, 0x16, 0xb1, 0x9d, 0x6e, 0xbf, 0xd9, 0xb4, 0xab, 0x97, 0xd0, 0x2e, 0xe8, 0x6d, 0xd3, 0x24, 0x96, 0xdd, 0x1f, 0xb6, 0xdb, 0x56, 0xd3, 0x32,
0xeb, 0xb6, 0xe5, 0xf4, 0xf4, 0xb2, 0xb2, 0xbc, 0x6a, 0xe3, 0x15, 0x31, 0xa1, 0x7e, 0x56, 0x73, 0xed, 0x81, 0x5e, 0x56, 0x96, 0xd7, 0x6d, 0xbc, 0x22, 0x26, 0x34, 0xcf, 0x1a, 0xb6, 0x6d, 0x76,
0x1c, 0xab, 0x45, 0x1a, 0x76, 0xb7, 0xf6, 0xb6, 0x65, 0x35, 0xf4, 0x0d, 0x74, 0x00, 0x4f, 0x7a, 0x48, 0xcb, 0xea, 0x37, 0xde, 0x74, 0xcc, 0x96, 0xbe, 0x85, 0x0e, 0xe0, 0xd1, 0xc0, 0xec, 0x5e,
0x56, 0xfb, 0xa2, 0x83, 0x6b, 0xf8, 0x23, 0x49, 0xe4, 0xcd, 0x9a, 0xdd, 0xea, 0x63, 0x4b, 0xdf, 0xf4, 0x70, 0x03, 0x7f, 0x20, 0x89, 0xbc, 0xdd, 0xb0, 0x3a, 0x43, 0x6c, 0xea, 0x55, 0xf4, 0x15,
0x44, 0x5f, 0xc1, 0x01, 0xb6, 0xde, 0xf7, 0x6d, 0x6c, 0x35, 0x88, 0xd3, 0x69, 0x58, 0xa4, 0x69, 0x1c, 0x60, 0xf3, 0xdd, 0xd0, 0xc2, 0x66, 0x8b, 0xd8, 0xbd, 0x96, 0x49, 0xda, 0x66, 0x63, 0x30,
0xd5, 0x7a, 0x7d, 0x6c, 0x91, 0xb6, 0xdd, 0xed, 0xda, 0xce, 0x0f, 0xba, 0x8e, 0x9e, 0xc3, 0xe1, 0xc4, 0x26, 0xe9, 0x5a, 0xfd, 0xbe, 0x65, 0xff, 0xa0, 0xeb, 0xe8, 0x19, 0x1c, 0xce, 0x29, 0x73,
0x4c, 0x65, 0xb6, 0xc0, 0x92, 0xd6, 0x96, 0xd8, 0x5f, 0x12, 0x52, 0xc7, 0xfa, 0xa9, 0x47, 0x2e, 0x05, 0x2b, 0xac, 0x6d, 0xb1, 0xbf, 0xc4, 0xa5, 0xb6, 0xf9, 0xd3, 0x80, 0x5c, 0x98, 0x26, 0xd6,
0x2c, 0x0b, 0xeb, 0x08, 0x55, 0x61, 0x77, 0x6e, 0x5e, 0x19, 0x88, 0x6d, 0x6f, 0x0b, 0xd9, 0x85, 0x11, 0xaa, 0xc3, 0xde, 0xc2, 0xbc, 0x32, 0x10, 0xdb, 0xde, 0x11, 0xb2, 0x0b, 0x13, 0x77, 0x1b,
0x85, 0xdb, 0x35, 0x47, 0x04, 0x78, 0x41, 0xb6, 0x23, 0xdc, 0x9e, 0xcb, 0x96, 0xdd, 0x7e, 0x84, 0xb6, 0x70, 0xf0, 0x92, 0x6c, 0x57, 0x2c, 0x7b, 0x21, 0x5b, 0x5d, 0xf6, 0x03, 0x84, 0x60, 0x2b,
0x10, 0x6c, 0xa4, 0xa2, 0xd2, 0xac, 0x61, 0x7d, 0x17, 0xed, 0xc0, 0x66, 0xe2, 0x41, 0xa2, 0xf8, 0xe5, 0x95, 0x76, 0x03, 0xeb, 0x7b, 0x68, 0x17, 0xaa, 0xc9, 0x0a, 0x12, 0xe2, 0x3f, 0xf2, 0xe8,
0xcf, 0x3c, 0x7a, 0x0c, 0xa8, 0xef, 0x60, 0xab, 0xd6, 0x10, 0x07, 0x32, 0x13, 0xfc, 0x2b, 0x7f, 0x21, 0xa0, 0xa1, 0x8d, 0xcd, 0x46, 0x4b, 0x1c, 0xc8, 0x5c, 0xf0, 0xcf, 0xfc, 0x79, 0xb6, 0xb0,
0x9e, 0x2d, 0xac, 0xe9, 0x19, 0xf3, 0x1f, 0x19, 0xa8, 0x2c, 0xd4, 0x25, 0xda, 0x87, 0x62, 0xe4, 0xa1, 0x67, 0x8c, 0xbf, 0x67, 0xa0, 0xb2, 0x94, 0x97, 0xe8, 0x31, 0x14, 0x23, 0xe7, 0xda, 0xa7,
0x5e, 0xfb, 0x94, 0x0b, 0xe6, 0x50, 0xa4, 0x32, 0x07, 0xe4, 0x35, 0x3a, 0xa2, 0xae, 0xaf, 0xd8, 0x5c, 0x54, 0x0e, 0x55, 0x54, 0x16, 0x80, 0xbc, 0x46, 0x27, 0xd4, 0xf1, 0x55, 0x35, 0x53, 0x75,
0x4c, 0xf1, 0x7e, 0x51, 0x22, 0x92, 0xcb, 0xf6, 0x20, 0x9f, 0x5c, 0xd9, 0x99, 0xd9, 0x95, 0xbd, 0xbf, 0x28, 0x11, 0x59, 0xcb, 0xf6, 0x21, 0x9f, 0x5c, 0xd9, 0x99, 0xf9, 0x95, 0xbd, 0x39, 0x52,
0x3e, 0x50, 0x57, 0xf5, 0x3e, 0x14, 0x05, 0x65, 0x46, 0x9c, 0x8e, 0x27, 0xb2, 0xc4, 0x2b, 0x78, 0x57, 0xf5, 0x63, 0x28, 0x8a, 0x92, 0x19, 0x71, 0xea, 0x4d, 0x65, 0x8a, 0x57, 0xf0, 0x02, 0x40,
0x0e, 0xa0, 0x67, 0x50, 0x19, 0xb3, 0x28, 0xa2, 0xd7, 0x8c, 0xa8, 0x32, 0x05, 0xa9, 0x51, 0x8e, 0x4f, 0xa1, 0xe2, 0xb1, 0x28, 0xa2, 0xd7, 0x8c, 0xa8, 0x34, 0x05, 0xc9, 0x28, 0xc7, 0x60, 0x5b,
0xc1, 0xa6, 0xac, 0xd6, 0x67, 0x90, 0xd0, 0x46, 0xac, 0x94, 0x53, 0x4a, 0x31, 0xa8, 0x94, 0x96, 0x66, 0xeb, 0x53, 0x48, 0xca, 0x46, 0x4c, 0xca, 0x29, 0x52, 0x0c, 0x2a, 0xd2, 0x6a, 0xc5, 0xe6,
0x19, 0x9b, 0xd3, 0x98, 0x0d, 0xd2, 0x8c, 0xcd, 0x29, 0x7a, 0x09, 0x5b, 0x8a, 0x72, 0x5c, 0xdf, 0x34, 0xae, 0x06, 0xe9, 0x8a, 0xcd, 0x29, 0x7a, 0x01, 0xdb, 0xaa, 0xe4, 0x38, 0xbe, 0xe3, 0xcd,
0x1d, 0x4f, 0xc7, 0x8a, 0x7a, 0xf2, 0x92, 0x7a, 0x36, 0x25, 0xf5, 0x28, 0x5c, 0x32, 0xd0, 0x13, 0x3c, 0x55, 0x7a, 0xf2, 0xb2, 0xf4, 0x54, 0x65, 0xe9, 0x51, 0xb8, 0xac, 0x40, 0x8f, 0xa0, 0x70,
0x28, 0x5c, 0xd2, 0x88, 0x89, 0xcb, 0x22, 0xa6, 0x86, 0xbc, 0x18, 0x37, 0x19, 0x13, 0x22, 0x71, 0x49, 0x23, 0x26, 0x2e, 0x8b, 0xb8, 0x34, 0xe4, 0xc5, 0xb8, 0xcd, 0x98, 0x10, 0x89, 0x2b, 0x24,
0x85, 0x84, 0x82, 0xf4, 0x14, 0x23, 0xe4, 0xaf, 0x18, 0xc3, 0xe2, 0x2c, 0x67, 0x16, 0xe8, 0xe7, 0x14, 0x45, 0x4f, 0x55, 0x84, 0xfc, 0x15, 0x63, 0x58, 0x9c, 0xe5, 0xdc, 0x02, 0xfd, 0xb4, 0xb0,
0xb9, 0x85, 0x52, 0xca, 0x82, 0xc2, 0xa5, 0x85, 0x97, 0xb0, 0xc5, 0x3e, 0xf3, 0x90, 0x92, 0x60, 0x50, 0x4a, 0x59, 0x50, 0xb8, 0xb4, 0xf0, 0x02, 0xb6, 0xd9, 0x27, 0x1e, 0x52, 0x12, 0x4c, 0xe9,
0x42, 0x7f, 0x99, 0x32, 0x32, 0xa4, 0x9c, 0xca, 0x1e, 0xb0, 0x8c, 0x37, 0xa5, 0xa0, 0x23, 0xf1, 0x2f, 0x33, 0x46, 0xc6, 0x94, 0x53, 0xd9, 0x03, 0x96, 0x71, 0x55, 0x0a, 0x7a, 0x12, 0x6f, 0x51,
0x06, 0xe5, 0xd4, 0xdc, 0x87, 0x2a, 0x66, 0x11, 0xe3, 0x6d, 0x37, 0x8a, 0xdc, 0xc0, 0xaf, 0x07, 0x4e, 0x8d, 0xc7, 0x50, 0xc7, 0x2c, 0x62, 0xbc, 0xeb, 0x44, 0x91, 0x13, 0xf8, 0xcd, 0xc0, 0xe7,
0x3e, 0x0f, 0x03, 0x2f, 0xbe, 0x73, 0xcc, 0x03, 0xd8, 0x5b, 0x29, 0x55, 0x97, 0x86, 0x98, 0xfc, 0x61, 0xe0, 0xc6, 0x77, 0x8e, 0x71, 0x00, 0xfb, 0x6b, 0xa5, 0xea, 0xd2, 0x10, 0x93, 0xdf, 0xcd,
0x7e, 0xca, 0xc2, 0xdb, 0xd5, 0x93, 0xdf, 0xc3, 0xde, 0x4a, 0x69, 0x7c, 0xe3, 0xbc, 0x82, 0xdc, 0x58, 0x78, 0xbb, 0x7e, 0xf2, 0x3b, 0xd8, 0x5f, 0x2b, 0x8d, 0x6f, 0x9c, 0x97, 0x90, 0x9b, 0x52,
0x84, 0xba, 0x61, 0x64, 0xac, 0xc9, 0x5b, 0x7b, 0x77, 0xa1, 0x49, 0x70, 0xc3, 0x33, 0x37, 0xe2, 0x27, 0x8c, 0x6a, 0x1b, 0xf2, 0xd6, 0xde, 0x5b, 0x6a, 0x12, 0x9c, 0xf0, 0xcc, 0x89, 0x78, 0x10,
0x41, 0x78, 0x8b, 0x95, 0xd2, 0x79, 0xb6, 0xa0, 0xe9, 0x6b, 0xe6, 0x1f, 0x35, 0x28, 0xa5, 0x84, 0xde, 0x62, 0x45, 0x3a, 0xcf, 0x16, 0x34, 0x7d, 0xc3, 0xf8, 0xa3, 0x06, 0xa5, 0x94, 0x50, 0xc4,
0x22, 0x0f, 0xfc, 0x60, 0xc8, 0xc8, 0x55, 0x18, 0x8c, 0x93, 0x0c, 0x9b, 0x01, 0xc8, 0x80, 0xbc, 0x81, 0x1f, 0x8c, 0x19, 0xb9, 0x0a, 0x03, 0x2f, 0x89, 0xb0, 0x39, 0x80, 0x6a, 0x90, 0x97, 0x03,
0x1c, 0xf0, 0x20, 0x4e, 0xaf, 0x64, 0x88, 0xbe, 0x81, 0xfc, 0x48, 0x2d, 0x21, 0xa3, 0x54, 0x3a, 0x1e, 0xc4, 0xe1, 0x95, 0x0c, 0xd1, 0x37, 0x90, 0x9f, 0x28, 0x15, 0xd2, 0x4b, 0xa5, 0xd3, 0x9d,
0xdd, 0x5e, 0xb2, 0x2e, 0xce, 0x06, 0x27, 0x3a, 0xe7, 0xd9, 0x42, 0x46, 0xcf, 0x9e, 0x67, 0x0b, 0x15, 0xeb, 0xe2, 0x6c, 0x70, 0xc2, 0x39, 0xcf, 0x16, 0x32, 0x7a, 0xf6, 0x3c, 0x5b, 0xc8, 0xea,
0x59, 0x3d, 0x77, 0x9e, 0x2d, 0xe4, 0xf4, 0xf5, 0xf3, 0x6c, 0x61, 0x5d, 0xcf, 0x9b, 0x7f, 0xd6, 0xb9, 0xf3, 0x6c, 0x21, 0xa7, 0x6f, 0x9e, 0x67, 0x0b, 0x9b, 0x7a, 0xde, 0xf8, 0xb7, 0x06, 0x85,
0xa0, 0x90, 0x68, 0x2f, 0xe6, 0xa4, 0x6a, 0x00, 0x52, 0x39, 0x69, 0x2c, 0xb7, 0x14, 0xc9, 0x50, 0x84, 0x2d, 0xd6, 0x22, 0x4a, 0x3c, 0x11, 0x91, 0x11, 0x37, 0x00, 0x0b, 0x00, 0x19, 0x50, 0x96,
0xdc, 0xbc, 0xb3, 0x46, 0x3d, 0x2b, 0x45, 0xb3, 0x31, 0x7a, 0x03, 0x8f, 0x65, 0x4b, 0x4a, 0x55, 0x83, 0xe5, 0xbe, 0x62, 0x09, 0x43, 0xcf, 0xa0, 0x32, 0x1f, 0xcf, 0x2f, 0xaf, 0x0c, 0x5e, 0x06,
0x1b, 0x43, 0xa2, 0xe9, 0x60, 0xc0, 0xa2, 0xe8, 0x6a, 0xea, 0xc9, 0xa2, 0x28, 0xe0, 0xfb, 0xc4, 0x85, 0xa6, 0x68, 0x36, 0x1a, 0xb1, 0x28, 0x52, 0xa6, 0x72, 0x4a, 0x53, 0x1a, 0x43, 0x47, 0x50,
0xe6, 0x18, 0x1e, 0xcb, 0xc3, 0xbf, 0x08, 0x83, 0x4b, 0x7a, 0xe9, 0x7a, 0x2e, 0xbf, 0x4d, 0x1a, 0x4d, 0xc6, 0x89, 0xc1, 0x4d, 0x49, 0x5b, 0x85, 0xd1, 0x0b, 0xd0, 0xd3, 0x90, 0xb7, 0xe8, 0xb7,
0x89, 0x7d, 0x28, 0x8a, 0xe3, 0x21, 0x7e, 0x72, 0x33, 0x97, 0xf1, 0x1c, 0x10, 0x8e, 0xf2, 0x40, 0xef, 0xe0, 0xea, 0x18, 0x0c, 0x0f, 0x1e, 0x4a, 0xb7, 0x5e, 0x84, 0xc1, 0x25, 0xbd, 0x74, 0x5c,
0xc9, 0xe2, 0x43, 0x8b, 0x87, 0x0b, 0x8e, 0x66, 0x16, 0x1d, 0x35, 0x6f, 0xc0, 0xb8, 0x6b, 0x2e, 0x87, 0xdf, 0x26, 0x2d, 0x8a, 0x38, 0x82, 0x30, 0xf0, 0x88, 0x9f, 0xdc, 0xf9, 0x65, 0xbc, 0x00,
0x0e, 0xf4, 0x21, 0x94, 0x26, 0x73, 0x58, 0x5a, 0xd4, 0x70, 0x1a, 0x4a, 0x87, 0x63, 0xed, 0xd7, 0x84, 0x3b, 0x78, 0xa0, 0x64, 0xb1, 0x3b, 0xe2, 0xa1, 0x68, 0x3e, 0xe6, 0xc6, 0x33, 0xd2, 0xf8,
0xc3, 0x61, 0xfe, 0x45, 0x83, 0xad, 0xb7, 0x53, 0xd7, 0x1b, 0x2e, 0xf4, 0x47, 0xe9, 0x07, 0x8f, 0x7c, 0x6c, 0xdc, 0x40, 0xed, 0xae, 0xb9, 0x38, 0x84, 0x0e, 0xa1, 0x34, 0x5d, 0xc0, 0xd2, 0xa2,
0xb6, 0xf8, 0xe0, 0x59, 0xf5, 0x9a, 0x59, 0x5b, 0xf9, 0x9a, 0x59, 0xf5, 0x62, 0xc8, 0xdc, 0xfb, 0x86, 0xd3, 0x50, 0xda, 0xd1, 0x1b, 0xbf, 0xee, 0x68, 0xe3, 0xcf, 0x1a, 0x6c, 0xbf, 0x99, 0x39,
0x62, 0x78, 0x0a, 0xa5, 0xf9, 0x63, 0x41, 0xb5, 0x9f, 0x65, 0x0c, 0xa3, 0xe4, 0xa5, 0x10, 0x99, 0xee, 0x78, 0xa9, 0xf3, 0x4a, 0x3f, 0xa5, 0xb4, 0xe5, 0xa7, 0xd4, 0xba, 0x77, 0xd2, 0xc6, 0xda,
0x6f, 0x00, 0xa5, 0x1d, 0x8d, 0x0f, 0x64, 0xd6, 0xa6, 0x69, 0xf7, 0xb6, 0x69, 0x2f, 0xff, 0xa4, 0x77, 0xd2, 0xba, 0xb7, 0x48, 0xe6, 0xde, 0xb7, 0xc8, 0x13, 0x28, 0x2d, 0x9e, 0x21, 0xaa, 0xb1,
0x41, 0x39, 0xdd, 0x2b, 0xa3, 0x0a, 0x14, 0x6d, 0x87, 0x34, 0x5b, 0xf6, 0x0f, 0x67, 0x3d, 0xfd, 0x2d, 0x63, 0x98, 0x24, 0x6f, 0x90, 0xc8, 0x78, 0x0d, 0x28, 0xbd, 0xd0, 0xf8, 0x40, 0xe6, 0x0d,
0x0b, 0x31, 0xec, 0xf6, 0xeb, 0x75, 0xcb, 0x6a, 0x58, 0x0d, 0x5d, 0x13, 0x2c, 0x2e, 0x08, 0xd9, 0xa0, 0x76, 0x6f, 0x03, 0xf8, 0xe2, 0x4f, 0x1a, 0x94, 0xd3, 0x5d, 0x38, 0xaa, 0x40, 0xd1, 0xb2,
0x6a, 0x90, 0x9e, 0xdd, 0xb6, 0x3a, 0x7d, 0x71, 0xbf, 0x6f, 0xc3, 0x66, 0x8c, 0x39, 0x1d, 0x82, 0x49, 0xbb, 0x63, 0xfd, 0x70, 0x36, 0xd0, 0xbf, 0x10, 0xc3, 0xfe, 0xb0, 0xd9, 0x34, 0xcd, 0x96,
0x3b, 0xfd, 0x9e, 0xa5, 0x67, 0x90, 0x0e, 0xe5, 0x18, 0xb4, 0x30, 0xee, 0x60, 0x3d, 0x2b, 0x2e, 0xd9, 0xd2, 0x35, 0x71, 0x3f, 0x88, 0x52, 0x6f, 0xb6, 0xc8, 0xc0, 0xea, 0x9a, 0xbd, 0xa1, 0xe8,
0xa5, 0x18, 0xb9, 0xdb, 0x2b, 0x24, 0xad, 0x44, 0xee, 0xf4, 0xef, 0x39, 0x58, 0x97, 0x0e, 0x86, 0x1c, 0x76, 0xa0, 0x1a, 0x63, 0x76, 0x8f, 0xe0, 0xde, 0x70, 0x60, 0xea, 0x19, 0xa4, 0x43, 0x39,
0xe8, 0x0c, 0x4a, 0xa9, 0x17, 0x09, 0x3a, 0x78, 0xf0, 0xa5, 0x52, 0x35, 0x56, 0x37, 0xff, 0xd3, 0x06, 0x4d, 0x8c, 0x7b, 0x58, 0xcf, 0x8a, 0xeb, 0x2e, 0x46, 0xee, 0x76, 0x21, 0x49, 0x93, 0x92,
0xe8, 0xb5, 0x86, 0xce, 0xa1, 0x9c, 0x7e, 0x73, 0xa0, 0x74, 0x83, 0xb8, 0xe2, 0x31, 0xf2, 0xe0, 0x3b, 0xfd, 0x5b, 0x0e, 0x36, 0xe5, 0x02, 0x43, 0x74, 0x06, 0xa5, 0xd4, 0x5b, 0x07, 0x1d, 0x7c,
0x5a, 0xef, 0x40, 0xb7, 0x22, 0xee, 0x8e, 0x45, 0x43, 0x18, 0xb7, 0xe8, 0xa8, 0x9a, 0xd2, 0x5f, 0xf6, 0x0d, 0x54, 0xaf, 0xad, 0x7f, 0x56, 0xcc, 0xa2, 0x57, 0x1a, 0x3a, 0x87, 0x72, 0xfa, 0x35,
0xea, 0xfb, 0xab, 0x7b, 0x2b, 0x65, 0x71, 0x84, 0x5a, 0x6a, 0x8b, 0x71, 0x93, 0x7c, 0x67, 0x8b, 0x83, 0xd2, 0xad, 0xe7, 0x9a, 0x67, 0xce, 0x67, 0x75, 0xbd, 0x05, 0xdd, 0x8c, 0xb8, 0xe3, 0x89,
0x8b, 0x9d, 0x79, 0xf5, 0xcb, 0xfb, 0xc4, 0xf1, 0x6a, 0x43, 0xd8, 0x5e, 0xc1, 0xa2, 0xe8, 0xff, 0x56, 0x33, 0x6e, 0xfe, 0x51, 0x3d, 0xc5, 0x5f, 0x79, 0x51, 0xd4, 0xf7, 0xd7, 0xca, 0x62, 0x0f,
0xd2, 0x1e, 0xdc, 0xcb, 0xc1, 0xd5, 0x17, 0xbf, 0xa6, 0x36, 0xb7, 0xb2, 0x82, 0x6e, 0x17, 0xac, 0x75, 0xd4, 0x16, 0xe3, 0xf6, 0xfb, 0xce, 0x16, 0x97, 0x7b, 0xfe, 0xfa, 0x97, 0xf7, 0x89, 0x63,
0xdc, 0x4f, 0xd6, 0x0b, 0x56, 0x1e, 0x62, 0xed, 0x9f, 0x41, 0x5f, 0x2e, 0x74, 0x64, 0x2e, 0xcf, 0x6d, 0x63, 0xd8, 0x59, 0x53, 0x9f, 0xd1, 0xff, 0xa5, 0x57, 0x70, 0x6f, 0x75, 0xaf, 0x3f, 0xff,
0xbd, 0x4b, 0x3a, 0xd5, 0x67, 0x0f, 0xea, 0xc4, 0x8b, 0xdb, 0x00, 0xf3, 0x72, 0x41, 0xfb, 0xa9, 0x35, 0xda, 0xc2, 0xca, 0x9a, 0x42, 0xbe, 0x64, 0xe5, 0xfe, 0x6b, 0x60, 0xc9, 0xca, 0xe7, 0xee,
0x29, 0x77, 0xca, 0xbd, 0x7a, 0x70, 0x8f, 0x54, 0x2d, 0xf5, 0xf6, 0xff, 0x7f, 0x7f, 0x72, 0xed, 0x83, 0x9f, 0x41, 0x5f, 0x4d, 0x74, 0x64, 0xac, 0xce, 0xbd, 0x5b, 0x74, 0xea, 0x4f, 0x3f, 0xcb,
0xf2, 0xd1, 0xf4, 0xf2, 0x78, 0x10, 0x8c, 0x4f, 0x3c, 0xd1, 0x56, 0xfb, 0xae, 0x7f, 0xed, 0x33, 0x89, 0x95, 0x5b, 0x00, 0x8b, 0x74, 0x41, 0x8f, 0x53, 0x53, 0xee, 0xa4, 0x7b, 0xfd, 0xe0, 0x1e,
0xfe, 0x87, 0x20, 0xbc, 0x39, 0xf1, 0xfc, 0xe1, 0x89, 0xac, 0xba, 0x93, 0xd9, 0x2a, 0x97, 0xeb, 0xa9, 0x52, 0xf5, 0xe6, 0xff, 0x7f, 0x7f, 0x72, 0xed, 0xf0, 0xc9, 0xec, 0xf2, 0x78, 0x14, 0x78,
0xf2, 0x5f, 0x97, 0xdf, 0xfc, 0x37, 0x00, 0x00, 0xff, 0xff, 0x40, 0x5c, 0x73, 0x19, 0xa5, 0x11, 0x27, 0xae, 0x68, 0xd8, 0x7d, 0xc7, 0xbf, 0xf6, 0x19, 0xff, 0x43, 0x10, 0xde, 0x9c, 0xb8, 0xfe,
0x00, 0x00, 0xf8, 0x44, 0x66, 0xdd, 0xc9, 0x5c, 0xcb, 0xe5, 0xa6, 0xfc, 0x3f, 0xe7, 0x37, 0xff, 0x0d, 0x00,
0x00, 0xff, 0xff, 0x7d, 0xd4, 0x80, 0xa8, 0xff, 0x11, 0x00, 0x00,
} }
// Reference imports to suppress errors if they are not otherwise used. // Reference imports to suppress errors if they are not otherwise used.

30
lnrpc/routerrpc/router.proto
View File

@ -391,17 +391,31 @@ message PairHistory {
} }
message PairData { message PairData {
/// Time stamp of last result. /// Time of last failure.
int64 timestamp = 1 [json_name = "timestamp"]; int64 fail_time = 1 [json_name = "fail_time"];
/// Last amount that was forwarded rounded to whole satoshis. /**
int64 amt_sat = 2 [json_name = "amt_sat"]; 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 [json_name = "fail_amt_sat"];
/// Last amount that was forwarded in millisatoshis. /**
int64 amt_msat = 4 [json_name = "amt_msat"]; 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 [json_name = "fail_amt_msat"];
/// Whether the last payment attempt through this pair was successful. reserved 3;
bool last_attempt_successful = 3 [json_name = "last_attempt_successful"];
/// Time of last success.
int64 success_time = 5 [json_name = "success_time"];
/// Highest amount that we could successfully forward rounded to whole sats.
int64 success_amt_sat = 6 [json_name = "success_amt_sat"];
/// Highest amount that we could successfully forward in millisats.
int64 success_amt_msat = 7 [json_name = "success_amt_msat"];
} }
message QueryProbabilityRequest{ message QueryProbabilityRequest{

15
lnrpc/routerrpc/router_server.go
View File

@ -494,13 +494,18 @@ func (s *Server) QueryMissionControl(ctx context.Context,
// toRPCPairData marshalls mission control pair data to the rpc struct. // toRPCPairData marshalls mission control pair data to the rpc struct.
func toRPCPairData(data *routing.TimedPairResult) *PairData { func toRPCPairData(data *routing.TimedPairResult) *PairData {
rpcData := PairData{ rpcData := PairData{
AmtSat: int64(data.Amt.ToSatoshis()), FailAmtSat: int64(data.FailAmt.ToSatoshis()),
AmtMsat: int64(data.Amt), FailAmtMsat: int64(data.FailAmt),
LastAttemptSuccessful: data.Success, SuccessAmtSat: int64(data.SuccessAmt.ToSatoshis()),
SuccessAmtMsat: int64(data.SuccessAmt),
} }
if !data.Timestamp.IsZero() { if !data.FailTime.IsZero() {
rpcData.Timestamp = data.Timestamp.Unix() rpcData.FailTime = data.FailTime.Unix()
}
if !data.SuccessTime.IsZero() {
rpcData.SuccessTime = data.SuccessTime.Unix()
} }
return &rpcData return &rpcData

103
routing/missioncontrol.go
View File

@ -125,26 +125,22 @@ type MissionControlConfig struct {
// TimedPairResult describes a timestamped pair result. // TimedPairResult describes a timestamped pair result.
type TimedPairResult struct { type TimedPairResult struct {
// timestamp is the time when this result was obtained. // FailTime is the time of the last failure.
Timestamp time.Time FailTime time.Time
// Amt is the amount that was forwarded in the last payment attempt. // FailAmt is the amount of the last failure. This amount may be pushed
Amt lnwire.MilliSatoshi // up if a later success is higher than the last failed amount.
FailAmt lnwire.MilliSatoshi
// Success indicates whether the payment attempt was successful through // SuccessTime is the time of the last success.
// this pair. SuccessTime time.Time
Success bool
}
// newTimedPairResult wraps a pair result with a timestamp. // SuccessAmt is the highest amount that successfully forwarded. This
func newTimedPairResult(timestamp time.Time, // isn't necessarily the last success amount. The value of this field
result pairResult) TimedPairResult { // may also be pushed down if a later failure is lower than the highest
// success amount. Because of this, SuccessAmt may not match
return TimedPairResult{ // SuccessTime.
Timestamp: timestamp, SuccessAmt lnwire.MilliSatoshi
Amt: result.amt,
Success: result.success,
}
} }
// MissionControlSnapshot contains a snapshot of the current state of mission // MissionControlSnapshot contains a snapshot of the current state of mission
@ -272,8 +268,8 @@ func (m *MissionControl) GetProbability(fromNode, toNode route.Vertex,
} }
// setLastPairResult stores a result for a node pair. // setLastPairResult stores a result for a node pair.
func (m *MissionControl) setLastPairResult(fromNode, func (m *MissionControl) setLastPairResult(fromNode, toNode route.Vertex,
toNode route.Vertex, result TimedPairResult) { timestamp time.Time, result *pairResult) {
nodePairs, ok := m.lastPairResult[fromNode] nodePairs, ok := m.lastPairResult[fromNode]
if !ok { if !ok {
@ -281,7 +277,60 @@ func (m *MissionControl) setLastPairResult(fromNode,
m.lastPairResult[fromNode] = nodePairs m.lastPairResult[fromNode] = nodePairs
} }
nodePairs[toNode] = result current := nodePairs[toNode]
// Apply the new result to the existing data for this pair. If there is
// no existing data, apply it to the default values for TimedPairResult.
if result.success {
successAmt := result.amt
current.SuccessTime = timestamp
// Only update the success amount if this amount is higher. This
// prevents the success range from shrinking when there is no
// reason to do so. For example: small amount probes shouldn't
// affect a previous success for a much larger amount.
if successAmt > current.SuccessAmt {
current.SuccessAmt = successAmt
}
// If the success amount goes into the failure range, move the
// failure range up. Future attempts up to the success amount
// are likely to succeed. We don't want to clear the failure
// completely, because we haven't learnt much for amounts above
// the current success amount.
if !current.FailTime.IsZero() && successAmt >= current.FailAmt {
current.FailAmt = successAmt + 1
}
} else {
// For failures we always want to update both the amount and the
// time. Those need to relate to the same result, because the
// time is used to gradually diminish the penality for that
// specific result. Updating the timestamp but not the amount
// could cause a failure for a lower amount (a more severe
// condition) to be revived as if it just happened.
failAmt := result.amt
current.FailTime = timestamp
current.FailAmt = failAmt
switch {
// The failure amount is set to zero when the failure is
// amount-independent, meaning that the attempt would have
// failed regardless of the amount. This should also reset the
// success amount to zero.
case failAmt == 0:
current.SuccessAmt = 0
// If the failure range goes into the success range, move the
// success range down.
case failAmt <= current.SuccessAmt:
current.SuccessAmt = failAmt - 1
}
}
log.Debugf("Setting %v->%v range to [%v-%v]",
fromNode, toNode, current.SuccessAmt, current.FailAmt)
nodePairs[toNode] = current
} }
// setAllFail stores a fail result for all known connection of the given node. // setAllFail stores a fail result for all known connection of the given node.
@ -294,9 +343,9 @@ func (m *MissionControl) setAllFail(fromNode route.Vertex,
} }
for connection := range nodePairs { for connection := range nodePairs {
nodePairs[connection] = newTimedPairResult( nodePairs[connection] = TimedPairResult{
timestamp, failPairResult(0), FailTime: timestamp,
) }
} }
} }
@ -491,6 +540,8 @@ func (m *MissionControl) applyPaymentResult(
} }
for pair, pairResult := range i.pairResults { for pair, pairResult := range i.pairResults {
pairResult := pairResult
if pairResult.success { if pairResult.success {
log.Debugf("Reporting pair success to Mission "+ log.Debugf("Reporting pair success to Mission "+
"Control: pair=%v", pair) "Control: pair=%v", pair)
@ -501,11 +552,7 @@ func (m *MissionControl) applyPaymentResult(
} }
m.setLastPairResult( m.setLastPairResult(
pair.From, pair.To, pair.From, pair.To, result.timeReply, &pairResult,
newTimedPairResult(
result.timeReply,
pairResult,
),
) )
} }

4
routing/missioncontrol_test.go
View File

@ -204,12 +204,12 @@ func TestMissionControlChannelUpdate(t *testing.T) {
ctx.reportFailure( ctx.reportFailure(
0, lnwire.NewFeeInsufficient(0, lnwire.ChannelUpdate{}), 0, lnwire.NewFeeInsufficient(0, lnwire.ChannelUpdate{}),
) )
ctx.expectP(0, testAprioriHopProbability) ctx.expectP(100, testAprioriHopProbability)
// Report another failure for the same channel. We expect it to be // Report another failure for the same channel. We expect it to be
// pruned. // pruned.
ctx.reportFailure( ctx.reportFailure(
0, lnwire.NewFeeInsufficient(0, lnwire.ChannelUpdate{}), 0, lnwire.NewFeeInsufficient(0, lnwire.ChannelUpdate{}),
) )
ctx.expectP(0, 0) ctx.expectP(100, 0)
} }

22
routing/probability_estimator.go
View File

@ -80,19 +80,20 @@ func (p *probabilityEstimator) getNodeProbability(now time.Time,
totalWeight := aprioriFactor totalWeight := aprioriFactor
for _, result := range results { for _, result := range results {
age := now.Sub(result.Timestamp)
switch { switch {
// Weigh success with a constant high weight of 1. There is no // Weigh success with a constant high weight of 1. There is no
// decay. // decay. Amt is never zero, so this clause is never executed
case result.Success: // when result.SuccessAmt is zero.
case amt <= result.SuccessAmt:
totalWeight++ totalWeight++
probabilitiesTotal += p.prevSuccessProbability probabilitiesTotal += p.prevSuccessProbability
// Weigh failures in accordance with their age. The base // Weigh failures in accordance with their age. The base
// probability of a failure is considered zero, so nothing needs // probability of a failure is considered zero, so nothing needs
// to be added to probabilitiesTotal. // to be added to probabilitiesTotal.
case amt >= result.Amt: case !result.FailTime.IsZero() && amt >= result.FailAmt:
age := now.Sub(result.FailTime)
totalWeight += p.getWeight(age) totalWeight += p.getWeight(age)
} }
} }
@ -155,9 +156,10 @@ func (p *probabilityEstimator) calculateProbability(
return nodeProbability return nodeProbability
} }
// For successes, we have a fixed (high) probability. Those pairs // For successes, we have a fixed (high) probability. Those pairs will
// will be assumed good until proven otherwise. // be assumed good until proven otherwise. Amt is never zero, so this
if lastPairResult.Success { // clause is never executed when lastPairResult.SuccessAmt is zero.
if amt <= lastPairResult.SuccessAmt {
return p.prevSuccessProbability return p.prevSuccessProbability
} }
@ -166,11 +168,11 @@ func (p *probabilityEstimator) calculateProbability(
// penalization. If the current amount is smaller than the amount that // penalization. If the current amount is smaller than the amount that
// previously triggered a failure, we act as if this is an untried // previously triggered a failure, we act as if this is an untried
// channel. // channel.
if amt < lastPairResult.Amt { if lastPairResult.FailTime.IsZero() || amt < lastPairResult.FailAmt {
return nodeProbability return nodeProbability
} }
timeSinceLastFailure := now.Sub(lastPairResult.Timestamp) timeSinceLastFailure := now.Sub(lastPairResult.FailTime)
// Calculate success probability based on the weight of the last // Calculate success probability based on the weight of the last
// failure. When the failure is fresh, its weight is 1 and we'll return // failure. When the failure is fresh, its weight is 1 and we'll return

38
routing/probability_estimator_test.go
View File

@ -84,10 +84,9 @@ func TestProbabilityEstimatorOneSuccess(t *testing.T) {
ctx := newEstimatorTestContext(t) ctx := newEstimatorTestContext(t)
ctx.results = map[int]TimedPairResult{ ctx.results = map[int]TimedPairResult{
node1: newTimedPairResult( node1: {
testTime.Add(-time.Hour), SuccessAmt: lnwire.MilliSatoshi(1000),
successPairResult(100), },
),
} }
// Because of the previous success, this channel keep reporting a high // Because of the previous success, this channel keep reporting a high
@ -108,10 +107,10 @@ func TestProbabilityEstimatorOneFailure(t *testing.T) {
ctx := newEstimatorTestContext(t) ctx := newEstimatorTestContext(t)
ctx.results = map[int]TimedPairResult{ ctx.results = map[int]TimedPairResult{
node1: newTimedPairResult( node1: {
testTime.Add(-time.Hour), FailTime: testTime.Add(-time.Hour),
failPairResult(0), FailAmt: lnwire.MilliSatoshi(50),
), },
} }
// For an untried node, we expected the node probability. The weight for // For an untried node, we expected the node probability. The weight for
@ -131,18 +130,17 @@ func TestProbabilityEstimatorMix(t *testing.T) {
ctx := newEstimatorTestContext(t) ctx := newEstimatorTestContext(t)
ctx.results = map[int]TimedPairResult{ ctx.results = map[int]TimedPairResult{
node1: newTimedPairResult( node1: {
testTime.Add(-time.Hour), SuccessAmt: lnwire.MilliSatoshi(1000),
successPairResult(100), },
), node2: {
node2: newTimedPairResult( FailTime: testTime.Add(-2 * time.Hour),
testTime.Add(-2*time.Hour), FailAmt: lnwire.MilliSatoshi(50),
failPairResult(0), },
), node3: {
node3: newTimedPairResult( FailTime: testTime.Add(-3 * time.Hour),
testTime.Add(-3*time.Hour), FailAmt: lnwire.MilliSatoshi(50),
failPairResult(0), },
),
} }
// We expect the probability for a previously successful channel to // We expect the probability for a previously successful channel to