mirror/lnd
1
0 Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Merge pull request #1734 from joostjager/edgesets

Browse Source 
routing: prune based on channel sets instead of channels
This commit is contained in:
Olaoluwa Osuntokun authored and GitHub committed 2019-08-13 19:14:30 -07:00
2 parents 9f88577627 f1769c8c8c
commit d134e0362e
19 files changed
+1183 -1026
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

lnrpc/routerrpc/router.pb.go
+165 -152
View File
@@ -979,9 +979,12 @@ func (m *QueryMissionControlRequest) XXX_DiscardUnknown() {
var xxx_messageInfo_QueryMissionControlRequest proto.InternalMessageInfo
/// QueryMissionControlResponse contains mission control state per node.
/// QueryMissionControlResponse contains mission control state.
type QueryMissionControlResponse struct {
Nodes []*NodeHistory `protobuf:"bytes,1,rep,name=nodes,proto3" json:"nodes,omitempty"`
/// Node-level mission control state.
Nodes []*NodeHistory `protobuf:"bytes,1,rep,name=nodes,proto3" json:"nodes,omitempty"`
/// Node pair-level mission control state.
Pairs []*PairHistory `protobuf:"bytes,2,rep,name=pairs,proto3" json:"pairs,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@@ -1019,19 +1022,26 @@ func (m *QueryMissionControlResponse) GetNodes() []*NodeHistory {
return nil
}
func (m *QueryMissionControlResponse) GetPairs() []*PairHistory {
if m != nil {
return m.Pairs
}
return nil
}
/// NodeHistory contains the mission control state for a particular node.
type NodeHistory struct {
/// Node pubkey
Pubkey []byte `protobuf:"bytes,1,opt,name=pubkey,proto3" json:"pubkey,omitempty"`
/// Time stamp of last failure. Set to zero if no failure happened yet.
LastFailTime int64 `protobuf:"varint,2,opt,name=last_fail_time,proto3" json:"last_fail_time,omitempty"`
/// Estimation of success probability for channels not in the channel array.
OtherChanSuccessProb float32 `protobuf:"fixed32,3,opt,name=other_chan_success_prob,proto3" json:"other_chan_success_prob,omitempty"`
/// Historical information of particular channels.
Channels []*ChannelHistory `protobuf:"bytes,4,rep,name=channels,proto3" json:"channels,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
//*
//Estimation of success probability of forwarding towards peers of this node
//for which no specific history is available.
OtherSuccessProb float32 `protobuf:"fixed32,3,opt,name=other_success_prob,proto3" json:"other_success_prob,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *NodeHistory) Reset() { *m = NodeHistory{} }
@@ -1073,82 +1083,84 @@ func (m *NodeHistory) GetLastFailTime() int64 {
return 0
}
func (m *NodeHistory) GetOtherChanSuccessProb() float32 {
func (m *NodeHistory) GetOtherSuccessProb() float32 {
if m != nil {
return m.OtherChanSuccessProb
return m.OtherSuccessProb
}
return 0
}
func (m *NodeHistory) GetChannels() []*ChannelHistory {
if m != nil {
return m.Channels
}
return nil
}
/// NodeHistory contains the mission control state for a particular channel.
type ChannelHistory struct {
/// Short channel id
ChannelId uint64 `protobuf:"varint,1,opt,name=channel_id,proto3" json:"channel_id,omitempty"`
/// PairHistory contains the mission control state for a particular node pair.
type PairHistory struct {
/// The source node pubkey of the pair.
NodeFrom []byte `protobuf:"bytes,1,opt,name=node_from,proto3" json:"node_from,omitempty"`
/// The destination node pubkey of the pair.
NodeTo []byte `protobuf:"bytes,2,opt,name=node_to,proto3" json:"node_to,omitempty"`
/// Time stamp of last failure.
LastFailTime int64 `protobuf:"varint,2,opt,name=last_fail_time,proto3" json:"last_fail_time,omitempty"`
LastFailTime int64 `protobuf:"varint,3,opt,name=last_fail_time,proto3" json:"last_fail_time,omitempty"`
/// Minimum penalization amount.
MinPenalizeAmtSat int64 `protobuf:"varint,3,opt,name=min_penalize_amt_sat,proto3" json:"min_penalize_amt_sat,omitempty"`
/// Estimation of success probability for this channel.
SuccessProb float32 `protobuf:"fixed32,4,opt,name=success_prob,proto3" json:"success_prob,omitempty"`
MinPenalizeAmtSat int64 `protobuf:"varint,4,opt,name=min_penalize_amt_sat,proto3" json:"min_penalize_amt_sat,omitempty"`
/// Estimation of success probability for this pair.
SuccessProb float32 `protobuf:"fixed32,5,opt,name=success_prob,proto3" json:"success_prob,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ChannelHistory) Reset() { *m = ChannelHistory{} }
func (m *ChannelHistory) String() string { return proto.CompactTextString(m) }
func (*ChannelHistory) ProtoMessage() {}
func (*ChannelHistory) Descriptor() ([]byte, []int) {
func (m *PairHistory) Reset() { *m = PairHistory{} }
func (m *PairHistory) String() string { return proto.CompactTextString(m) }
func (*PairHistory) ProtoMessage() {}
func (*PairHistory) Descriptor() ([]byte, []int) {
return fileDescriptor_7a0613f69d37b0a5, []int{14}
}
func (m *ChannelHistory) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ChannelHistory.Unmarshal(m, b)
func (m *PairHistory) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_PairHistory.Unmarshal(m, b)
}
func (m *ChannelHistory) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ChannelHistory.Marshal(b, m, deterministic)
func (m *PairHistory) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_PairHistory.Marshal(b, m, deterministic)
}
func (m *ChannelHistory) XXX_Merge(src proto.Message) {
xxx_messageInfo_ChannelHistory.Merge(m, src)
func (m *PairHistory) XXX_Merge(src proto.Message) {
xxx_messageInfo_PairHistory.Merge(m, src)
}
func (m *ChannelHistory) XXX_Size() int {
return xxx_messageInfo_ChannelHistory.Size(m)
func (m *PairHistory) XXX_Size() int {
return xxx_messageInfo_PairHistory.Size(m)
}
func (m *ChannelHistory) XXX_DiscardUnknown() {
xxx_messageInfo_ChannelHistory.DiscardUnknown(m)
func (m *PairHistory) XXX_DiscardUnknown() {
xxx_messageInfo_PairHistory.DiscardUnknown(m)
}
var xxx_messageInfo_ChannelHistory proto.InternalMessageInfo
var xxx_messageInfo_PairHistory proto.InternalMessageInfo
func (m *ChannelHistory) GetChannelId() uint64 {
func (m *PairHistory) GetNodeFrom() []byte {
if m != nil {
return m.ChannelId
return m.NodeFrom
}
return 0
return nil
}
func (m *ChannelHistory) GetLastFailTime() int64 {
func (m *PairHistory) GetNodeTo() []byte {
if m != nil {
return m.NodeTo
}
return nil
}
func (m *PairHistory) GetLastFailTime() int64 {
if m != nil {
return m.LastFailTime
}
return 0
}
func (m *ChannelHistory) GetMinPenalizeAmtSat() int64 {
func (m *PairHistory) GetMinPenalizeAmtSat() int64 {
if m != nil {
return m.MinPenalizeAmtSat
}
return 0
}
func (m *ChannelHistory) GetSuccessProb() float32 {
func (m *PairHistory) GetSuccessProb() float32 {
if m != nil {
return m.SuccessProb
}
@@ -1172,117 +1184,118 @@ func init() {
proto.RegisterType((*QueryMissionControlRequest)(nil), "routerrpc.QueryMissionControlRequest")
proto.RegisterType((*QueryMissionControlResponse)(nil), "routerrpc.QueryMissionControlResponse")
proto.RegisterType((*NodeHistory)(nil), "routerrpc.NodeHistory")
proto.RegisterType((*ChannelHistory)(nil), "routerrpc.ChannelHistory")
proto.RegisterType((*PairHistory)(nil), "routerrpc.PairHistory")
}
func init() { proto.RegisterFile("routerrpc/router.proto", fileDescriptor_7a0613f69d37b0a5) }
var fileDescriptor_7a0613f69d37b0a5 = []byte{
// 1663 bytes of a gzipped FileDescriptorProto
// 1677 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x57, 0x4f, 0x77, 0x22, 0xc7,
0x11, 0x37, 0x02, 0x84, 0x28, 0xfe, 0x8d, 0x5a, 0x5a, 0x89, 0x45, 0xab, 0xb5, 0x8c, 0x9d, 0xb5,
0xde, 0x3e, 0x47, 0x72, 0xc8, 0x5b, 0x3f, 0x9f, 0x92, 0xc7, 0x42, 0x63, 0x8d, 0x17, 0x66, 0xe4,
0x06, 0xd6, 0xde, 0xe4, 0xd0, 0xaf, 0xc5, 0xb4, 0x60, 0x9e, 0x60, 0x06, 0xcf, 0x34, 0xce, 0x2a,
0x87, 0xdc, 0x72, 0xcc, 0x3d, 0xdf, 0x22, 0xf9, 0x04, 0xb9, 0xe7, 0x8b, 0x24, 0xdf, 0x21, 0xa7,
0xbc, 0xee, 0x9e, 0x81, 0x01, 0xa1, 0xb5, 0x4f, 0x62, 0x7e, 0xbf, 0x5f, 0x57, 0x75, 0x57, 0x75,
0x55, 0x97, 0xe0, 0x28, 0xf0, 0x17, 0x82, 0x07, 0xc1, 0x7c, 0x74, 0xa9, 0x7f, 0x5d, 0xcc, 0x03,
0x5f, 0xf8, 0x28, 0xbf, 0xc4, 0x6b, 0xf9, 0x60, 0x3e, 0xd2, 0x68, 0xfd, 0x7f, 0x3b, 0x80, 0xfa,
0xdc, 0x73, 0xae, 0xd9, 0xfd, 0x8c, 0x7b, 0x82, 0xf0, 0x1f, 0x17, 0x3c, 0x14, 0x08, 0x41, 0xc6,
0xe1, 0xa1, 0xa8, 0xa6, 0xce, 0x52, 0xe7, 0x45, 0xa2, 0x7e, 0x23, 0x03, 0xd2, 0x6c, 0x26, 0xaa,
0x3b, 0x67, 0xa9, 0xf3, 0x34, 0x91, 0x3f, 0xd1, 0x27, 0x50, 0x9c, 0xeb, 0x75, 0x74, 0xc2, 0xc2,
0x49, 0x35, 0xad, 0xd4, 0x85, 0x08, 0xbb, 0x62, 0xe1, 0x04, 0x9d, 0x83, 0x71, 0xeb, 0x7a, 0x6c,
0x4a, 0x47, 0x53, 0xf1, 0x13, 0x75, 0xf8, 0x54, 0xb0, 0x6a, 0xe6, 0x2c, 0x75, 0x9e, 0x25, 0x65,
0x85, 0xb7, 0xa6, 0xe2, 0xa7, 0xb6, 0x44, 0xd1, 0xe7, 0x50, 0x89, 0x8d, 0x05, 0x7a, 0x17, 0xd5,
0xec, 0x59, 0xea, 0x3c, 0x4f, 0xca, 0xf3, 0xf5, 0xbd, 0x7d, 0x0e, 0x15, 0xe1, 0xce, 0xb8, 0xbf,
0x10, 0x34, 0xe4, 0x23, 0xdf, 0x73, 0xc2, 0xea, 0xae, 0xb6, 0x18, 0xc1, 0x7d, 0x8d, 0xa2, 0x3a,
0x94, 0x6e, 0x39, 0xa7, 0x53, 0x77, 0xe6, 0x0a, 0x1a, 0x32, 0x51, 0xcd, 0xa9, 0xad, 0x17, 0x6e,
0x39, 0xef, 0x4a, 0xac, 0xcf, 0x84, 0xdc, 0x9f, 0xbf, 0x10, 0x63, 0xdf, 0xf5, 0xc6, 0x74, 0x34,
0x61, 0x1e, 0x75, 0x9d, 0xea, 0xde, 0x59, 0xea, 0x3c, 0x43, 0xca, 0x31, 0xde, 0x9a, 0x30, 0xcf,
0x74, 0xd0, 0x29, 0x80, 0x3a, 0x83, 0x32, 0x57, 0xcd, 0x2b, 0x8f, 0x79, 0x89, 0x28, 0x5b, 0xa8,
0x01, 0x05, 0x15, 0x60, 0x3a, 0x71, 0x3d, 0x11, 0x56, 0xe1, 0x2c, 0x7d, 0x5e, 0x68, 0x18, 0x17,
0x53, 0x4f, 0xc6, 0x9a, 0x48, 0xe6, 0xca, 0xf5, 0x04, 0x49, 0x8a, 0xea, 0x5f, 0xc3, 0xc1, 0x20,
0x60, 0xa3, 0xbb, 0x8d, 0xe0, 0x6f, 0x86, 0x35, 0xf5, 0x20, 0xac, 0xf5, 0xbf, 0x40, 0x29, 0x5a,
0xd4, 0x17, 0x4c, 0x2c, 0x42, 0xf4, 0x6b, 0xc8, 0x86, 0x82, 0x09, 0xae, 0xc4, 0xe5, 0xc6, 0xf1,
0xc5, 0x32, 0xdb, 0x17, 0x09, 0x21, 0x27, 0x5a, 0x85, 0x6a, 0xb0, 0x37, 0x0f, 0xb8, 0x3b, 0x63,
0x63, 0xae, 0x12, 0x5a, 0x24, 0xcb, 0x6f, 0x54, 0x87, 0xac, 0x5a, 0xac, 0xd2, 0x59, 0x68, 0x14,
0x93, 0x67, 0x20, 0x9a, 0xaa, 0xff, 0x0e, 0x2a, 0xea, 0xbb, 0xc3, 0xf9, 0x87, 0xae, 0xcc, 0x31,
0xe4, 0xd8, 0x4c, 0xc7, 0x5e, 0x5f, 0x9b, 0x5d, 0x36, 0x93, 0x61, 0xaf, 0x3b, 0x60, 0xac, 0xd6,
0x87, 0x73, 0xdf, 0x0b, 0xb9, 0x4c, 0x85, 0x34, 0x2e, 0x33, 0x21, 0xd3, 0x36, 0x93, 0xab, 0x52,
0x6a, 0x55, 0x39, 0xc2, 0x3b, 0x9c, 0xf7, 0x42, 0x26, 0xd0, 0x0b, 0x7d, 0x03, 0xe8, 0xd4, 0x1f,
0xdd, 0xc9, 0x3b, 0xc5, 0xee, 0x23, 0xf3, 0x25, 0x09, 0x77, 0xfd, 0xd1, 0x5d, 0x5b, 0x82, 0xf5,
0x3f, 0xea, 0xbb, 0x3d, 0xf0, 0xf5, 0xde, 0x7f, 0x71, 0x78, 0x57, 0x21, 0xd8, 0x79, 0x3c, 0x04,
0x14, 0x0e, 0xd6, 0x8c, 0x47, 0xa7, 0x48, 0x46, 0x36, 0xb5, 0x11, 0xd9, 0x2f, 0x20, 0x77, 0xcb,
0xdc, 0xe9, 0x22, 0x88, 0x0d, 0xa3, 0x44, 0x9a, 0x3a, 0x9a, 0x21, 0xb1, 0xa4, 0xfe, 0xef, 0x1c,
0xe4, 0x22, 0x10, 0x35, 0x20, 0x33, 0xf2, 0x9d, 0x38, 0xbb, 0xcf, 0x1f, 0x2e, 0x8b, 0xff, 0xb6,
0x7c, 0x87, 0x13, 0xa5, 0x45, 0xbf, 0x87, 0xb2, 0xbc, 0xd1, 0x1e, 0x9f, 0xd2, 0xc5, 0xdc, 0x61,
0xcb, 0x84, 0x56, 0x13, 0xab, 0x5b, 0x5a, 0x30, 0x54, 0x3c, 0x29, 0x8d, 0x92, 0x9f, 0xe8, 0x04,
0xf2, 0x13, 0x31, 0x1d, 0xe9, 0x4c, 0x64, 0x54, 0x51, 0xec, 0x49, 0x40, 0xe5, 0xa0, 0x0e, 0x25,
0xdf, 0x73, 0x7d, 0x8f, 0x86, 0x13, 0x46, 0x1b, 0xaf, 0xbe, 0x52, 0xc5, 0x5a, 0x24, 0x05, 0x05,
0xf6, 0x27, 0xac, 0xf1, 0xea, 0x2b, 0xf4, 0x31, 0x14, 0x54, 0xc9, 0xf0, 0xf7, 0x73, 0x37, 0xb8,
0x57, 0x55, 0x5a, 0x22, 0xaa, 0x8a, 0xb0, 0x42, 0xd0, 0x21, 0x64, 0x6f, 0xa7, 0x6c, 0x1c, 0xaa,
0xca, 0x2c, 0x11, 0xfd, 0x81, 0xbe, 0x84, 0xc3, 0x28, 0x06, 0x34, 0xf4, 0x17, 0xc1, 0x88, 0x53,
0xd7, 0x73, 0xf8, 0x7b, 0x55, 0x97, 0x25, 0x82, 0x22, 0xae, 0xaf, 0x28, 0x53, 0x32, 0xf5, 0xbf,
0x67, 0xa1, 0x90, 0x08, 0x00, 0x2a, 0xc2, 0x1e, 0xc1, 0x7d, 0x4c, 0xde, 0xe2, 0xb6, 0xf1, 0x11,
0x3a, 0x87, 0xcf, 0x4c, 0xab, 0x65, 0x13, 0x82, 0x5b, 0x03, 0x6a, 0x13, 0x3a, 0xb4, 0xde, 0x58,
0xf6, 0xf7, 0x16, 0xbd, 0x6e, 0xbe, 0xeb, 0x61, 0x6b, 0x40, 0xdb, 0x78, 0xd0, 0x34, 0xbb, 0x7d,
0x23, 0x85, 0x9e, 0x41, 0x75, 0xa5, 0x8c, 0xe9, 0x66, 0xcf, 0x1e, 0x5a, 0x03, 0x63, 0x07, 0x7d,
0x0c, 0x27, 0x1d, 0xd3, 0x6a, 0x76, 0xe9, 0x4a, 0xd3, 0xea, 0x0e, 0xde, 0x52, 0xfc, 0xc3, 0xb5,
0x49, 0xde, 0x19, 0xe9, 0x6d, 0x82, 0xab, 0x41, 0xb7, 0x15, 0x5b, 0xc8, 0xa0, 0xa7, 0xf0, 0x44,
0x0b, 0xf4, 0x12, 0x3a, 0xb0, 0x6d, 0xda, 0xb7, 0x6d, 0xcb, 0xc8, 0xa2, 0x7d, 0x28, 0x99, 0xd6,
0xdb, 0x66, 0xd7, 0x6c, 0x53, 0x82, 0x9b, 0xdd, 0x9e, 0xb1, 0x8b, 0x0e, 0xa0, 0xb2, 0xa9, 0xcb,
0x49, 0x13, 0xb1, 0xce, 0xb6, 0x4c, 0xdb, 0xa2, 0x6f, 0x31, 0xe9, 0x9b, 0xb6, 0x65, 0xec, 0xa1,
0x23, 0x40, 0xeb, 0xd4, 0x55, 0xaf, 0xd9, 0x32, 0xf2, 0xe8, 0x09, 0xec, 0xaf, 0xe3, 0x6f, 0xf0,
0x3b, 0x03, 0x50, 0x15, 0x0e, 0xf5, 0xc6, 0xe8, 0x6b, 0xdc, 0xb5, 0xbf, 0xa7, 0x3d, 0xd3, 0x32,
0x7b, 0xc3, 0x9e, 0x51, 0x40, 0x87, 0x60, 0x74, 0x30, 0xa6, 0xa6, 0xd5, 0x1f, 0x76, 0x3a, 0x66,
0xcb, 0xc4, 0xd6, 0xc0, 0x28, 0x6a, 0xcf, 0xdb, 0x0e, 0x5e, 0x92, 0x0b, 0x5a, 0x57, 0x4d, 0xcb,
0xc2, 0x5d, 0xda, 0x36, 0xfb, 0xcd, 0xd7, 0x5d, 0xdc, 0x36, 0xca, 0xe8, 0x14, 0x9e, 0x0e, 0x70,
0xef, 0xda, 0x26, 0x4d, 0xf2, 0x8e, 0xc6, 0x7c, 0xa7, 0x69, 0x76, 0x87, 0x04, 0x1b, 0x15, 0xf4,
0x09, 0x9c, 0x12, 0xfc, 0xdd, 0xd0, 0x24, 0xb8, 0x4d, 0x2d, 0xbb, 0x8d, 0x69, 0x07, 0x37, 0x07,
0x43, 0x82, 0x69, 0xcf, 0xec, 0xf7, 0x4d, 0xeb, 0x1b, 0xc3, 0x40, 0x9f, 0xc1, 0xd9, 0x52, 0xb2,
0x34, 0xb0, 0xa1, 0xda, 0x97, 0xe7, 0x8b, 0x53, 0x6a, 0xe1, 0x1f, 0x06, 0xf4, 0x1a, 0x63, 0x62,
0x20, 0x54, 0x83, 0xa3, 0x95, 0x7b, 0xed, 0x20, 0xf2, 0x7d, 0x20, 0xb9, 0x6b, 0x4c, 0x7a, 0x4d,
0x4b, 0x26, 0x78, 0x8d, 0x3b, 0x94, 0xdb, 0x5e, 0x71, 0x9b, 0xdb, 0x7e, 0x82, 0x0e, 0xa1, 0x12,
0x7b, 0x8b, 0xc1, 0xff, 0xe4, 0xd0, 0x31, 0xa0, 0xa1, 0x45, 0x70, 0xb3, 0x2d, 0x0f, 0xbf, 0x24,
0xfe, 0x9b, 0xfb, 0x36, 0xb3, 0xb7, 0x63, 0xa4, 0xeb, 0xff, 0x48, 0x43, 0x69, 0xad, 0xd6, 0xd0,
0x33, 0xc8, 0x87, 0xee, 0xd8, 0x63, 0x42, 0x76, 0x03, 0xdd, 0x28, 0x56, 0x80, 0x7a, 0x6c, 0x26,
0xcc, 0xf5, 0x74, 0x87, 0xd2, 0x1d, 0x3a, 0xaf, 0x10, 0xd5, 0x9f, 0x8e, 0x21, 0x17, 0x3f, 0x56,
0x69, 0x55, 0x97, 0xbb, 0x23, 0xfd, 0x48, 0x3d, 0x83, 0xbc, 0x6c, 0x81, 0xa1, 0x60, 0xb3, 0xb9,
0x2a, 0xd9, 0x12, 0x59, 0x01, 0xe8, 0x53, 0x28, 0xcd, 0x78, 0x18, 0xb2, 0x31, 0xa7, 0xba, 0xec,
0x40, 0x29, 0x8a, 0x11, 0xd8, 0x51, 0xd5, 0xf7, 0x29, 0xc4, 0x6d, 0x20, 0x12, 0x65, 0xb5, 0x28,
0x02, 0xb5, 0x68, 0xb3, 0x03, 0x0b, 0x16, 0x55, 0x77, 0xb2, 0x03, 0x0b, 0x86, 0x5e, 0xc2, 0xbe,
0x6e, 0x21, 0xae, 0xe7, 0xce, 0x16, 0x33, 0xdd, 0x4a, 0x72, 0x6a, 0xcb, 0x15, 0xd5, 0x4a, 0x34,
0xae, 0x3a, 0xca, 0x53, 0xd8, 0xbb, 0x61, 0x21, 0x97, 0xcd, 0x3f, 0x2a, 0xf5, 0x9c, 0xfc, 0xee,
0x70, 0x2e, 0x29, 0xf9, 0x24, 0x04, 0xb2, 0x89, 0xe5, 0x35, 0x75, 0xcb, 0x39, 0x91, 0x71, 0x5c,
0x7a, 0x60, 0xef, 0x57, 0x1e, 0x0a, 0x09, 0x0f, 0x1a, 0x57, 0x1e, 0x5e, 0xc2, 0x3e, 0x7f, 0x2f,
0x02, 0x46, 0xfd, 0x39, 0xfb, 0x71, 0xc1, 0xa9, 0xc3, 0x04, 0xab, 0x16, 0x55, 0x70, 0x2b, 0x8a,
0xb0, 0x15, 0xde, 0x66, 0x82, 0xd5, 0x9f, 0x41, 0x8d, 0xf0, 0x90, 0x8b, 0x9e, 0x1b, 0x86, 0xae,
0xef, 0xb5, 0x7c, 0x4f, 0x04, 0xfe, 0x34, 0x7a, 0x43, 0xea, 0xa7, 0x70, 0xb2, 0x95, 0xd5, 0x8f,
0x80, 0x5c, 0xfc, 0xdd, 0x82, 0x07, 0xf7, 0xdb, 0x17, 0xbf, 0x81, 0x93, 0xad, 0x6c, 0xf4, 0x82,
0x7c, 0x01, 0x59, 0xcf, 0x77, 0x78, 0x58, 0x4d, 0xa9, 0x19, 0xe2, 0x28, 0xd1, 0xae, 0x2d, 0xdf,
0xe1, 0x57, 0x6e, 0x28, 0xfc, 0xe0, 0x9e, 0x68, 0x51, 0xfd, 0x5f, 0x29, 0x28, 0x24, 0x60, 0x74,
0x04, 0xbb, 0xf3, 0xc5, 0xcd, 0x1d, 0xbf, 0x8f, 0x2e, 0x55, 0xf4, 0x85, 0x5e, 0x40, 0x79, 0xca,
0x42, 0x41, 0x65, 0xf7, 0xa4, 0x32, 0x49, 0xd1, 0x93, 0xb9, 0x81, 0xa2, 0xaf, 0xe1, 0xd8, 0x17,
0x13, 0x1e, 0xe8, 0x69, 0x28, 0x5c, 0x8c, 0x46, 0x3c, 0x0c, 0xe9, 0x3c, 0xf0, 0x6f, 0xd4, 0x55,
0xdb, 0x21, 0x8f, 0xd1, 0xe8, 0x15, 0xec, 0x45, 0x77, 0x24, 0xac, 0x66, 0xd4, 0xd6, 0x9f, 0x3e,
0x7c, 0x69, 0xe2, 0xdd, 0x2f, 0xa5, 0xf5, 0x7f, 0xa6, 0xa0, 0xbc, 0x4e, 0xa2, 0xe7, 0xea, 0xf6,
0xab, 0x2b, 0xe8, 0x3a, 0xea, 0x1c, 0x19, 0x92, 0x40, 0x7e, 0xf1, 0x59, 0x1a, 0x70, 0x38, 0x73,
0x3d, 0x3a, 0xe7, 0x1e, 0x9b, 0xba, 0x7f, 0xe6, 0x34, 0x9e, 0x45, 0xd2, 0x4a, 0xbd, 0x95, 0x43,
0x75, 0x28, 0xae, 0x1d, 0x3a, 0xa3, 0x0e, 0xbd, 0x86, 0xbd, 0xfc, 0x5b, 0x0a, 0x8a, 0xc9, 0xa9,
0x0a, 0x95, 0x20, 0x6f, 0x5a, 0xb4, 0xd3, 0x35, 0xbf, 0xb9, 0x1a, 0x18, 0x1f, 0xc9, 0xcf, 0xfe,
0xb0, 0xd5, 0xc2, 0xb8, 0x8d, 0xdb, 0x46, 0x0a, 0x21, 0x28, 0xcb, 0x86, 0x80, 0xdb, 0x74, 0x60,
0xf6, 0xb0, 0x3d, 0x94, 0x6f, 0xc9, 0x01, 0x54, 0x22, 0xcc, 0xb2, 0x29, 0xb1, 0x87, 0x03, 0x6c,
0xa4, 0x91, 0x01, 0xc5, 0x08, 0xc4, 0x84, 0xd8, 0xc4, 0xc8, 0xc8, 0x06, 0x18, 0x21, 0x0f, 0xdf,
0xa5, 0xf8, 0xd9, 0xca, 0x36, 0xfe, 0x9a, 0x81, 0x5d, 0x35, 0x85, 0x04, 0xe8, 0x0a, 0x0a, 0x89,
0x71, 0x1e, 0x9d, 0x26, 0x32, 0xf0, 0x70, 0xcc, 0xaf, 0x55, 0xb7, 0x8f, 0x89, 0x8b, 0xf0, 0xcb,
0x14, 0xfa, 0x16, 0x8a, 0xc9, 0xe1, 0x14, 0x25, 0x87, 0x8e, 0x2d, 0x53, 0xeb, 0x07, 0x6d, 0xbd,
0x01, 0x03, 0x87, 0xc2, 0x9d, 0xc9, 0x21, 0x23, 0x1a, 0xfb, 0x50, 0x2d, 0xa1, 0xdf, 0x98, 0x25,
0x6b, 0x27, 0x5b, 0xb9, 0xa8, 0x3e, 0xba, 0xfa, 0x88, 0xd1, 0xe0, 0xf5, 0xe0, 0x88, 0xeb, 0xd3,
0x5e, 0xed, 0xf9, 0x63, 0x74, 0x64, 0xcd, 0x81, 0x83, 0x2d, 0x95, 0x8c, 0x7e, 0x95, 0xdc, 0xc1,
0xa3, 0x7d, 0xa0, 0xf6, 0xe2, 0xe7, 0x64, 0x2b, 0x2f, 0x5b, 0x4a, 0x7e, 0xcd, 0xcb, 0xe3, 0x0d,
0x63, 0xcd, 0xcb, 0x07, 0x3a, 0xc7, 0xeb, 0xdf, 0xfc, 0xe1, 0x72, 0xec, 0x8a, 0xc9, 0xe2, 0xe6,
0x62, 0xe4, 0xcf, 0x2e, 0xa7, 0xee, 0x78, 0x22, 0x3c, 0xd7, 0x1b, 0x7b, 0x5c, 0xfc, 0xc9, 0x0f,
0xee, 0x2e, 0xa7, 0x9e, 0x73, 0xa9, 0x06, 0xd9, 0xcb, 0xa5, 0xb9, 0x9b, 0x5d, 0xf5, 0x6f, 0xe0,
0x6f, 0xff, 0x1f, 0x00, 0x00, 0xff, 0xff, 0x58, 0x80, 0x4d, 0xdb, 0x36, 0x0e, 0x00, 0x00,
0x11, 0x37, 0x02, 0x84, 0x28, 0xfe, 0xcd, 0xb6, 0xb4, 0xda, 0x59, 0xb4, 0xb2, 0xe5, 0xb1, 0xb3,
0xd6, 0xdb, 0xe7, 0x48, 0x0e, 0x79, 0xf6, 0xcb, 0x29, 0x79, 0x2c, 0x34, 0xd6, 0xec, 0xc2, 0x8c,
0xdc, 0xc0, 0xda, 0x9b, 0x1c, 0xfa, 0xb5, 0xa0, 0x05, 0xf3, 0x04, 0x33, 0x78, 0xa6, 0x71, 0x56,
0x39, 0xe4, 0x92, 0x97, 0x63, 0xee, 0xf9, 0x16, 0xf9, 0x14, 0x39, 0xe4, 0x8b, 0x24, 0xdf, 0x21,
0xa7, 0xbc, 0xee, 0x9e, 0x81, 0x01, 0xb1, 0x1b, 0x9f, 0x98, 0xfe, 0xd5, 0xaf, 0xab, 0xaa, 0xab,
0xba, 0xaa, 0x0b, 0x38, 0x0e, 0x83, 0xa5, 0xe0, 0x61, 0xb8, 0x18, 0x5d, 0xea, 0xaf, 0x8b, 0x45,
0x18, 0x88, 0x00, 0x15, 0x57, 0x78, 0xbd, 0x18, 0x2e, 0x46, 0x1a, 0xb5, 0xfe, 0xbb, 0x07, 0xa8,
0xcf, 0xfd, 0xf1, 0x35, 0xbb, 0x9f, 0x73, 0x5f, 0x10, 0xfe, 0xe3, 0x92, 0x47, 0x02, 0x21, 0xc8,
0x8d, 0x79, 0x24, 0xcc, 0xcc, 0x59, 0xe6, 0xbc, 0x4c, 0xd4, 0x37, 0x32, 0x20, 0xcb, 0xe6, 0xc2,
0xdc, 0x3b, 0xcb, 0x9c, 0x67, 0x89, 0xfc, 0x44, 0x9f, 0x42, 0x79, 0xa1, 0xf7, 0xd1, 0x29, 0x8b,
0xa6, 0x66, 0x56, 0xb1, 0x4b, 0x31, 0x76, 0xc5, 0xa2, 0x29, 0x3a, 0x07, 0xe3, 0xd6, 0xf3, 0xd9,
0x8c, 0x8e, 0x66, 0xe2, 0x27, 0x3a, 0xe6, 0x33, 0xc1, 0xcc, 0xdc, 0x59, 0xe6, 0x3c, 0x4f, 0xaa,
0x0a, 0x6f, 0xcd, 0xc4, 0x4f, 0x6d, 0x89, 0xa2, 0x2f, 0xa0, 0x96, 0x28, 0x0b, 0xb5, 0x17, 0x66,
0xfe, 0x2c, 0x73, 0x5e, 0x24, 0xd5, 0xc5, 0xa6, 0x6f, 0x5f, 0x40, 0x4d, 0x78, 0x73, 0x1e, 0x2c,
0x05, 0x8d, 0xf8, 0x28, 0xf0, 0xc7, 0x91, 0xb9, 0xaf, 0x35, 0xc6, 0x70, 0x5f, 0xa3, 0xc8, 0x82,
0xca, 0x2d, 0xe7, 0x74, 0xe6, 0xcd, 0x3d, 0x41, 0x23, 0x26, 0xcc, 0x82, 0x72, 0xbd, 0x74, 0xcb,
0x79, 0x57, 0x62, 0x7d, 0x26, 0xa4, 0x7f, 0xc1, 0x52, 0x4c, 0x02, 0xcf, 0x9f, 0xd0, 0xd1, 0x94,
0xf9, 0xd4, 0x1b, 0x9b, 0x07, 0x67, 0x99, 0xf3, 0x1c, 0xa9, 0x26, 0x78, 0x6b, 0xca, 0x7c, 0x7b,
0x8c, 0x4e, 0x01, 0xd4, 0x19, 0x94, 0x3a, 0xb3, 0xa8, 0x2c, 0x16, 0x25, 0xa2, 0x74, 0xa1, 0x06,
0x94, 0x54, 0x80, 0xe9, 0xd4, 0xf3, 0x45, 0x64, 0xc2, 0x59, 0xf6, 0xbc, 0xd4, 0x30, 0x2e, 0x66,
0xbe, 0x8c, 0x35, 0x91, 0x92, 0x2b, 0xcf, 0x17, 0x24, 0x4d, 0xb2, 0x7e, 0x03, 0x87, 0x83, 0x90,
0x8d, 0xee, 0xb6, 0x82, 0xbf, 0x1d, 0xd6, 0xcc, 0x83, 0xb0, 0x5a, 0x7f, 0x86, 0x4a, 0xbc, 0xa9,
0x2f, 0x98, 0x58, 0x46, 0xe8, 0x97, 0x90, 0x8f, 0x04, 0x13, 0x5c, 0x91, 0xab, 0x8d, 0x27, 0x17,
0xab, 0x6c, 0x5f, 0xa4, 0x88, 0x9c, 0x68, 0x16, 0xaa, 0xc3, 0xc1, 0x22, 0xe4, 0xde, 0x9c, 0x4d,
0xb8, 0x4a, 0x68, 0x99, 0xac, 0xd6, 0xc8, 0x82, 0xbc, 0xda, 0xac, 0xd2, 0x59, 0x6a, 0x94, 0xd3,
0x67, 0x20, 0x5a, 0x64, 0xfd, 0x16, 0x6a, 0x6a, 0xdd, 0xe1, 0xfc, 0x43, 0x57, 0xe6, 0x09, 0x14,
0xd8, 0x5c, 0xc7, 0x5e, 0x5f, 0x9b, 0x7d, 0x36, 0x97, 0x61, 0xb7, 0xc6, 0x60, 0xac, 0xf7, 0x47,
0x8b, 0xc0, 0x8f, 0xb8, 0x4c, 0x85, 0x54, 0x2e, 0x33, 0x21, 0xd3, 0x36, 0x97, 0xbb, 0x32, 0x6a,
0x57, 0x35, 0xc6, 0x3b, 0x9c, 0xf7, 0x22, 0x26, 0xd0, 0x73, 0x7d, 0x03, 0xe8, 0x2c, 0x18, 0xdd,
0xc9, 0x3b, 0xc5, 0xee, 0x63, 0xf5, 0x15, 0x09, 0x77, 0x83, 0xd1, 0x5d, 0x5b, 0x82, 0xd6, 0x1f,
0xf4, 0xdd, 0x1e, 0x04, 0xda, 0xf7, 0x9f, 0x1d, 0xde, 0x75, 0x08, 0xf6, 0xde, 0x1f, 0x02, 0x0a,
0x87, 0x1b, 0xca, 0xe3, 0x53, 0xa4, 0x23, 0x9b, 0xd9, 0x8a, 0xec, 0x97, 0x50, 0xb8, 0x65, 0xde,
0x6c, 0x19, 0x26, 0x8a, 0x51, 0x2a, 0x4d, 0x1d, 0x2d, 0x21, 0x09, 0xc5, 0xfa, 0x57, 0x01, 0x0a,
0x31, 0x88, 0x1a, 0x90, 0x1b, 0x05, 0xe3, 0x24, 0xbb, 0x1f, 0x3f, 0xdc, 0x96, 0xfc, 0xb6, 0x82,
0x31, 0x27, 0x8a, 0x8b, 0x7e, 0x07, 0x55, 0x79, 0xa3, 0x7d, 0x3e, 0xa3, 0xcb, 0xc5, 0x98, 0xad,
0x12, 0x6a, 0xa6, 0x76, 0xb7, 0x34, 0x61, 0xa8, 0xe4, 0xa4, 0x32, 0x4a, 0x2f, 0xd1, 0x09, 0x14,
0xa7, 0x62, 0x36, 0xd2, 0x99, 0xc8, 0xa9, 0xa2, 0x38, 0x90, 0x80, 0xca, 0x81, 0x05, 0x95, 0xc0,
0xf7, 0x02, 0x9f, 0x46, 0x53, 0x46, 0x1b, 0x5f, 0x7f, 0xa3, 0x8a, 0xb5, 0x4c, 0x4a, 0x0a, 0xec,
0x4f, 0x59, 0xe3, 0xeb, 0x6f, 0xd0, 0x27, 0x50, 0x52, 0x25, 0xc3, 0xdf, 0x2d, 0xbc, 0xf0, 0x5e,
0x55, 0x69, 0x85, 0xa8, 0x2a, 0xc2, 0x0a, 0x41, 0x47, 0x90, 0xbf, 0x9d, 0xb1, 0x49, 0xa4, 0x2a,
0xb3, 0x42, 0xf4, 0x02, 0x7d, 0x05, 0x47, 0x71, 0x0c, 0x68, 0x14, 0x2c, 0xc3, 0x11, 0xa7, 0x9e,
0x3f, 0xe6, 0xef, 0x54, 0x5d, 0x56, 0x08, 0x8a, 0x65, 0x7d, 0x25, 0xb2, 0xa5, 0xc4, 0xfa, 0x7b,
0x1e, 0x4a, 0xa9, 0x00, 0xa0, 0x32, 0x1c, 0x10, 0xdc, 0xc7, 0xe4, 0x0d, 0x6e, 0x1b, 0x1f, 0xa1,
0x73, 0xf8, 0xdc, 0x76, 0x5a, 0x2e, 0x21, 0xb8, 0x35, 0xa0, 0x2e, 0xa1, 0x43, 0xe7, 0xb5, 0xe3,
0x7e, 0xef, 0xd0, 0xeb, 0xe6, 0xdb, 0x1e, 0x76, 0x06, 0xb4, 0x8d, 0x07, 0x4d, 0xbb, 0xdb, 0x37,
0x32, 0xe8, 0x19, 0x98, 0x6b, 0x66, 0x22, 0x6e, 0xf6, 0xdc, 0xa1, 0x33, 0x30, 0xf6, 0xd0, 0x27,
0x70, 0xd2, 0xb1, 0x9d, 0x66, 0x97, 0xae, 0x39, 0xad, 0xee, 0xe0, 0x0d, 0xc5, 0x3f, 0x5c, 0xdb,
0xe4, 0xad, 0x91, 0xdd, 0x45, 0xb8, 0x1a, 0x74, 0x5b, 0x89, 0x86, 0x1c, 0x7a, 0x0a, 0x8f, 0x35,
0x41, 0x6f, 0xa1, 0x03, 0xd7, 0xa5, 0x7d, 0xd7, 0x75, 0x8c, 0x3c, 0x7a, 0x04, 0x15, 0xdb, 0x79,
0xd3, 0xec, 0xda, 0x6d, 0x4a, 0x70, 0xb3, 0xdb, 0x33, 0xf6, 0xd1, 0x21, 0xd4, 0xb6, 0x79, 0x05,
0xa9, 0x22, 0xe1, 0xb9, 0x8e, 0xed, 0x3a, 0xf4, 0x0d, 0x26, 0x7d, 0xdb, 0x75, 0x8c, 0x03, 0x74,
0x0c, 0x68, 0x53, 0x74, 0xd5, 0x6b, 0xb6, 0x8c, 0x22, 0x7a, 0x0c, 0x8f, 0x36, 0xf1, 0xd7, 0xf8,
0xad, 0x01, 0xc8, 0x84, 0x23, 0xed, 0x18, 0x7d, 0x89, 0xbb, 0xee, 0xf7, 0xb4, 0x67, 0x3b, 0x76,
0x6f, 0xd8, 0x33, 0x4a, 0xe8, 0x08, 0x8c, 0x0e, 0xc6, 0xd4, 0x76, 0xfa, 0xc3, 0x4e, 0xc7, 0x6e,
0xd9, 0xd8, 0x19, 0x18, 0x65, 0x6d, 0x79, 0xd7, 0xc1, 0x2b, 0x72, 0x43, 0xeb, 0xaa, 0xe9, 0x38,
0xb8, 0x4b, 0xdb, 0x76, 0xbf, 0xf9, 0xb2, 0x8b, 0xdb, 0x46, 0x15, 0x9d, 0xc2, 0xd3, 0x01, 0xee,
0x5d, 0xbb, 0xa4, 0x49, 0xde, 0xd2, 0x44, 0xde, 0x69, 0xda, 0xdd, 0x21, 0xc1, 0x46, 0x0d, 0x7d,
0x0a, 0xa7, 0x04, 0x7f, 0x37, 0xb4, 0x09, 0x6e, 0x53, 0xc7, 0x6d, 0x63, 0xda, 0xc1, 0xcd, 0xc1,
0x90, 0x60, 0xda, 0xb3, 0xfb, 0x7d, 0xdb, 0xf9, 0xd6, 0x30, 0xd0, 0xe7, 0x70, 0xb6, 0xa2, 0xac,
0x14, 0x6c, 0xb1, 0x1e, 0xc9, 0xf3, 0x25, 0x29, 0x75, 0xf0, 0x0f, 0x03, 0x7a, 0x8d, 0x31, 0x31,
0x10, 0xaa, 0xc3, 0xf1, 0xda, 0xbc, 0x36, 0x10, 0xdb, 0x3e, 0x94, 0xb2, 0x6b, 0x4c, 0x7a, 0x4d,
0x47, 0x26, 0x78, 0x43, 0x76, 0x24, 0xdd, 0x5e, 0xcb, 0xb6, 0xdd, 0x7e, 0x8c, 0x8e, 0xa0, 0x96,
0x58, 0x4b, 0xc0, 0x7f, 0x17, 0xd0, 0x13, 0x40, 0x43, 0x87, 0xe0, 0x66, 0x5b, 0x1e, 0x7e, 0x25,
0xf8, 0x4f, 0xe1, 0x55, 0xee, 0x60, 0xcf, 0xc8, 0x5a, 0xff, 0xc8, 0x42, 0x65, 0xa3, 0xd6, 0xd0,
0x33, 0x28, 0x46, 0xde, 0xc4, 0x67, 0x42, 0x76, 0x03, 0xdd, 0x28, 0xd6, 0x80, 0x7a, 0x6c, 0xa6,
0xcc, 0xf3, 0x75, 0x87, 0xd2, 0x1d, 0xba, 0xa8, 0x10, 0xd5, 0x9f, 0x9e, 0x40, 0x21, 0x79, 0xac,
0xb2, 0xaa, 0x2e, 0xf7, 0x47, 0xfa, 0x91, 0x7a, 0x06, 0x45, 0xd9, 0x02, 0x23, 0xc1, 0xe6, 0x0b,
0x55, 0xb2, 0x15, 0xb2, 0x06, 0xd0, 0x67, 0x50, 0x99, 0xf3, 0x28, 0x62, 0x13, 0x4e, 0x75, 0xd9,
0x81, 0x62, 0x94, 0x63, 0xb0, 0xa3, 0xaa, 0xef, 0x33, 0x48, 0xda, 0x40, 0x4c, 0xca, 0x6b, 0x52,
0x0c, 0x6a, 0xd2, 0x76, 0x07, 0x16, 0x2c, 0xae, 0xee, 0x74, 0x07, 0x16, 0x0c, 0xbd, 0x80, 0x47,
0xba, 0x85, 0x78, 0xbe, 0x37, 0x5f, 0xce, 0x75, 0x2b, 0x29, 0x28, 0x97, 0x6b, 0xaa, 0x95, 0x68,
0x5c, 0x75, 0x94, 0xa7, 0x70, 0x70, 0xc3, 0x22, 0x2e, 0x9b, 0x7f, 0x5c, 0xea, 0x05, 0xb9, 0xee,
0x70, 0x2e, 0x45, 0xf2, 0x49, 0x08, 0x65, 0x13, 0x2b, 0x6a, 0xd1, 0x2d, 0xe7, 0x44, 0xc6, 0x71,
0x65, 0x81, 0xbd, 0x5b, 0x5b, 0x28, 0xa5, 0x2c, 0x68, 0x5c, 0x59, 0x78, 0x01, 0x8f, 0xf8, 0x3b,
0x11, 0x32, 0x1a, 0x2c, 0xd8, 0x8f, 0x4b, 0x4e, 0xc7, 0x4c, 0x30, 0xb3, 0xac, 0x82, 0x5b, 0x53,
0x02, 0x57, 0xe1, 0x6d, 0x26, 0x98, 0xf5, 0x0c, 0xea, 0x84, 0x47, 0x5c, 0xf4, 0xbc, 0x28, 0xf2,
0x02, 0xbf, 0x15, 0xf8, 0x22, 0x0c, 0x66, 0xf1, 0x1b, 0x62, 0x9d, 0xc2, 0xc9, 0x4e, 0xa9, 0x7e,
0x04, 0xe4, 0xe6, 0xef, 0x96, 0x3c, 0xbc, 0xdf, 0xbd, 0xf9, 0x1e, 0x4e, 0x76, 0x4a, 0xe3, 0x17,
0xe4, 0x4b, 0xc8, 0xfb, 0xc1, 0x98, 0x47, 0x66, 0x46, 0xcd, 0x10, 0xc7, 0xa9, 0x76, 0xed, 0x04,
0x63, 0x7e, 0xe5, 0x45, 0x22, 0x08, 0xef, 0x89, 0x26, 0x49, 0xf6, 0x82, 0x79, 0x61, 0x64, 0xee,
0x3d, 0x60, 0x5f, 0x33, 0x2f, 0x5c, 0xb1, 0x15, 0xc9, 0xfa, 0x4b, 0x06, 0x4a, 0x29, 0x25, 0xe8,
0x18, 0xf6, 0x17, 0xcb, 0x9b, 0x3b, 0x7e, 0x1f, 0x5f, 0xc1, 0x78, 0x85, 0x9e, 0x43, 0x75, 0xc6,
0x22, 0x41, 0x65, 0xaf, 0xa5, 0x32, 0xa5, 0xf1, 0x03, 0xbb, 0x85, 0xa2, 0x0b, 0x40, 0x81, 0x98,
0xf2, 0x90, 0x46, 0xcb, 0xd1, 0x88, 0x47, 0x11, 0x5d, 0x84, 0xc1, 0x8d, 0xba, 0x93, 0x7b, 0x64,
0x87, 0xe4, 0x55, 0xee, 0x20, 0x67, 0xe4, 0xad, 0x7f, 0x66, 0xa0, 0x94, 0x72, 0x4e, 0xde, 0x5a,
0x79, 0x18, 0x7a, 0x1b, 0x06, 0xf3, 0xa4, 0x16, 0x56, 0x00, 0x32, 0xa1, 0xa0, 0x16, 0x22, 0x88,
0x0b, 0x21, 0x59, 0xee, 0xf0, 0x32, 0xbb, 0xd3, 0xcb, 0x06, 0x1c, 0xcd, 0x3d, 0x9f, 0x2e, 0xb8,
0xcf, 0x66, 0xde, 0x9f, 0x38, 0x4d, 0x66, 0x92, 0x9c, 0x62, 0xef, 0x94, 0x21, 0x0b, 0xca, 0x1b,
0x67, 0xca, 0xab, 0x33, 0x6d, 0x60, 0x2f, 0xfe, 0x96, 0x81, 0x72, 0x7a, 0xba, 0x42, 0x15, 0x28,
0xda, 0x0e, 0xed, 0x74, 0xed, 0x6f, 0xaf, 0x06, 0xc6, 0x47, 0x72, 0xd9, 0x1f, 0xb6, 0x5a, 0x18,
0xb7, 0x71, 0xdb, 0xc8, 0x20, 0x04, 0x55, 0xd9, 0x18, 0x70, 0x9b, 0x0e, 0xec, 0x1e, 0x76, 0x87,
0xf2, 0x4d, 0x39, 0x84, 0x5a, 0x8c, 0x39, 0x2e, 0x25, 0xee, 0x70, 0x80, 0x8d, 0x2c, 0x32, 0xa0,
0x1c, 0x83, 0x98, 0x10, 0x97, 0x18, 0x39, 0xd9, 0x08, 0x63, 0xe4, 0xe1, 0xfb, 0x94, 0x3c, 0x5f,
0xf9, 0xc6, 0x5f, 0x73, 0xb0, 0xaf, 0xa6, 0x91, 0x10, 0x5d, 0x41, 0x29, 0x35, 0xd6, 0xa3, 0xd3,
0xd4, 0xb5, 0x78, 0x38, 0xee, 0xd7, 0xcd, 0xdd, 0xe3, 0xe2, 0x32, 0xfa, 0x2a, 0x83, 0x5e, 0x41,
0x39, 0x3d, 0xa4, 0xa2, 0xf4, 0xf0, 0xb1, 0x63, 0x7a, 0xfd, 0xa0, 0xae, 0xd7, 0x60, 0xe0, 0x48,
0x78, 0x73, 0x39, 0x6c, 0xc4, 0xe3, 0x1f, 0xaa, 0xa7, 0xf8, 0x5b, 0x33, 0x65, 0xfd, 0x64, 0xa7,
0x2c, 0xae, 0x93, 0xae, 0x3e, 0x62, 0x3c, 0x80, 0x3d, 0x38, 0xe2, 0xe6, 0xd4, 0x57, 0xff, 0xf8,
0x7d, 0xe2, 0x58, 0xdb, 0x18, 0x0e, 0x77, 0x54, 0x34, 0xfa, 0x45, 0xda, 0x83, 0xf7, 0xf6, 0x83,
0xfa, 0xf3, 0xff, 0x47, 0x5b, 0x5b, 0xd9, 0x51, 0xfa, 0x1b, 0x56, 0xde, 0xdf, 0x38, 0x36, 0xac,
0x7c, 0xa0, 0x83, 0xbc, 0xfc, 0xd5, 0xef, 0x2f, 0x27, 0x9e, 0x98, 0x2e, 0x6f, 0x2e, 0x46, 0xc1,
0xfc, 0x72, 0xe6, 0x4d, 0xa6, 0xc2, 0xf7, 0xfc, 0x89, 0xcf, 0xc5, 0x1f, 0x83, 0xf0, 0xee, 0x72,
0xe6, 0x8f, 0x2f, 0xd5, 0x40, 0x7b, 0xb9, 0x52, 0x77, 0xb3, 0xaf, 0xfe, 0x0e, 0xfe, 0xfa, 0x7f,
0x01, 0x00, 0x00, 0xff, 0xff, 0x6d, 0xa6, 0xd9, 0x94, 0x3e, 0x0e, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
lnrpc/routerrpc/router.proto
+22 -13
View File
@@ -323,9 +323,13 @@ message ResetMissionControlResponse{}
message QueryMissionControlRequest {}
/// QueryMissionControlResponse contains mission control state per node.
/// QueryMissionControlResponse contains mission control state.
message QueryMissionControlResponse {
/// Node-level mission control state.
repeated NodeHistory nodes = 1;
/// Node pair-level mission control state.
repeated PairHistory pairs = 2;
}
/// NodeHistory contains the mission control state for a particular node.
@@ -336,26 +340,31 @@ message NodeHistory {
/// Time stamp of last failure. Set to zero if no failure happened yet.
int64 last_fail_time = 2 [json_name = "last_fail_time"];
/// Estimation of success probability for channels not in the channel array.
float other_chan_success_prob = 3 [json_name = "other_chan_success_prob"];
/**
Estimation of success probability of forwarding towards peers of this node
for which no specific history is available.
**/
float other_success_prob = 3 [json_name = "other_success_prob"];
/// Historical information of particular channels.
repeated ChannelHistory channels = 4 [json_name = "channels"];
reserved 4;
}
/// NodeHistory contains the mission control state for a particular channel.
message ChannelHistory {
/// Short channel id
uint64 channel_id = 1 [json_name = "channel_id"];
/// PairHistory contains the mission control state for a particular node pair.
message PairHistory {
/// The source node pubkey of the pair.
bytes node_from = 1 [json_name="node_from"];
/// The destination node pubkey of the pair.
bytes node_to = 2 [json_name="node_to"];
/// Time stamp of last failure.
int64 last_fail_time = 2 [json_name = "last_fail_time"];
int64 last_fail_time = 3 [json_name = "last_fail_time"];
/// Minimum penalization amount.
int64 min_penalize_amt_sat = 3 [json_name = "min_penalize_amt_sat"];
int64 min_penalize_amt_sat = 4 [json_name = "min_penalize_amt_sat"];
/// Estimation of success probability for this channel.
float success_prob = 4 [json_name = "success_prob"];
/// Estimation of success probability for this pair.
float success_prob = 5 [json_name = "success_prob"];
}
service Router {
lnrpc/routerrpc/router_backend.go
+70 -38
View File
@@ -57,17 +57,17 @@ type RouterBackend struct {
// MissionControl defines the mission control dependencies of routerrpc.
type MissionControl interface {
// GetEdgeProbability is expected to return the success probability of a payment
// from fromNode along edge.
GetEdgeProbability(fromNode route.Vertex,
edge routing.EdgeLocator, amt lnwire.MilliSatoshi) float64
// GetProbability is expected to return the success probability of a
// payment from fromNode to toNode.
GetProbability(fromNode, toNode route.Vertex,
amt lnwire.MilliSatoshi) float64
// ResetHistory resets the history of MissionControl returning it to a state as
// if no payment attempts have been made.
// ResetHistory resets the history of MissionControl returning it to a
// state as if no payment attempts have been made.
ResetHistory() error
// GetHistorySnapshot takes a snapshot from the current mission control state
// and actual probability estimates.
// GetHistorySnapshot takes a snapshot from the current mission control
// state and actual probability estimates.
GetHistorySnapshot() *routing.MissionControlSnapshot
}
@@ -89,15 +89,7 @@ func (r *RouterBackend) QueryRoutes(ctx context.Context,
return route.Vertex{}, err
}
if len(pubKeyBytes) != 33 {
return route.Vertex{},
errors.New("invalid key length")
}
var v route.Vertex
copy(v[:], pubKeyBytes)
return v, nil
return route.NewVertexFromBytes(pubKeyBytes)
}
// Parse the hex-encoded source and target public keys into full public
@@ -134,36 +126,57 @@ func (r *RouterBackend) QueryRoutes(ctx context.Context,
ignoredNodes := make(map[route.Vertex]struct{})
for _, ignorePubKey := range in.IgnoredNodes {
if len(ignorePubKey) != 33 {
return nil, fmt.Errorf("invalid ignore node pubkey")
ignoreVertex, err := route.NewVertexFromBytes(ignorePubKey)
if err != nil {
return nil, err
}
var ignoreVertex route.Vertex
copy(ignoreVertex[:], ignorePubKey)
ignoredNodes[ignoreVertex] = struct{}{}
}
ignoredEdges := make(map[routing.EdgeLocator]struct{})
ignoredPairs := make(map[routing.DirectedNodePair]struct{})
// Convert deprecated ignoredEdges to pairs.
for _, ignoredEdge := range in.IgnoredEdges {
locator := routing.EdgeLocator{
ChannelID: ignoredEdge.ChannelId,
pair, err := r.rpcEdgeToPair(ignoredEdge)
if err != nil {
log.Warnf("Ignore channel %v skipped: %v",
ignoredEdge.ChannelId, err)
continue
}
if ignoredEdge.DirectionReverse {
locator.Direction = 1
ignoredPairs[pair] = struct{}{}
}
// Add ignored pairs to set.
for _, ignorePair := range in.IgnoredPairs {
from, err := route.NewVertexFromBytes(ignorePair.From)
if err != nil {
return nil, err
}
ignoredEdges[locator] = struct{}{}
to, err := route.NewVertexFromBytes(ignorePair.To)
if err != nil {
return nil, err
}
pair := routing.NewDirectedNodePair(from, to)
ignoredPairs[pair] = struct{}{}
}
restrictions := &routing.RestrictParams{
FeeLimit: feeLimit,
ProbabilitySource: func(node route.Vertex,
edge routing.EdgeLocator,
ProbabilitySource: func(fromNode, toNode route.Vertex,
amt lnwire.MilliSatoshi) float64 {
if _, ok := ignoredNodes[node]; ok {
if _, ok := ignoredNodes[fromNode]; ok {
return 0
}
if _, ok := ignoredEdges[edge]; ok {
pair := routing.DirectedNodePair{
From: fromNode,
To: toNode,
}
if _, ok := ignoredPairs[pair]; ok {
return 0
}
@@ -171,8 +184,8 @@ func (r *RouterBackend) QueryRoutes(ctx context.Context,
return 1
}
return r.MissionControl.GetEdgeProbability(
node, edge, amt,
return r.MissionControl.GetProbability(
fromNode, toNode, amt,
)
},
}
@@ -211,6 +224,26 @@ func (r *RouterBackend) QueryRoutes(ctx context.Context,
return routeResp, nil
}
// rpcEdgeToPair looks up the provided channel and returns the channel endpoints
// as a directed pair.
func (r *RouterBackend) rpcEdgeToPair(e *lnrpc.EdgeLocator) (
routing.DirectedNodePair, error) {
a, b, err := r.FetchChannelEndpoints(e.ChannelId)
if err != nil {
return routing.DirectedNodePair{}, err
}
var pair routing.DirectedNodePair
if e.DirectionReverse {
pair.From, pair.To = b, a
} else {
pair.From, pair.To = a, b
}
return pair, nil
}
// calculateFeeLimit returns the fee limit in millisatoshis. If a percentage
// based fee limit has been requested, we'll factor in the ratio provided with
// the amount of the payment.
@@ -484,12 +517,11 @@ func (r *RouterBackend) extractIntentFromSendRequest(
// from the other fields.
// Payment destination.
if len(rpcPayReq.Dest) != 33 {
return nil, errors.New("invalid key length")
target, err := route.NewVertexFromBytes(rpcPayReq.Dest)
if err != nil {
return nil, err
}
pubBytes := rpcPayReq.Dest
copy(payIntent.Target[:], pubBytes)
payIntent.Target = target
// Final payment CLTV delta.
if rpcPayReq.FinalCltvDelta != 0 {
lnrpc/routerrpc/router_backend_test.go
+30 -12
View File
@@ -23,6 +23,10 @@ const (
var (
sourceKey = route.Vertex{1, 2, 3}
node1 = route.Vertex{10}
node2 = route.Vertex{11}
)
// TestQueryRoutes asserts that query routes rpc parameters are properly parsed
@@ -50,11 +54,6 @@ func testQueryRoutes(t *testing.T, useMissionControl bool) {
t.Fatal(err)
}
ignoredEdge := routing.EdgeLocator{
ChannelID: 555,
Direction: 1,
}
request := &lnrpc.QueryRoutesRequest{
PubKey: destKey,
Amt: 100000,
@@ -69,6 +68,10 @@ func testQueryRoutes(t *testing.T, useMissionControl bool) {
ChannelId: 555,
DirectionReverse: true,
}},
IgnoredPairs: []*lnrpc.NodePair{{
From: node1[:],
To: node2[:],
}},
UseMissionControl: useMissionControl,
}
@@ -92,24 +95,28 @@ func testQueryRoutes(t *testing.T, useMissionControl bool) {
t.Fatal("unexpected fee limit")
}
if restrictions.ProbabilitySource(route.Vertex{},
ignoredEdge, 0,
if restrictions.ProbabilitySource(route.Vertex{2},
route.Vertex{1}, 0,
) != 0 {
t.Fatal("expecting 0% probability for ignored edge")
}
if restrictions.ProbabilitySource(ignoreNodeVertex,
routing.EdgeLocator{}, 0,
route.Vertex{6}, 0,
) != 0 {
t.Fatal("expecting 0% probability for ignored node")
}
if restrictions.ProbabilitySource(node1, node2, 0) != 0 {
t.Fatal("expecting 0% probability for ignored pair")
}
expectedProb := 1.0
if useMissionControl {
expectedProb = testMissionControlProb
}
if restrictions.ProbabilitySource(route.Vertex{},
routing.EdgeLocator{}, 0,
if restrictions.ProbabilitySource(route.Vertex{4},
route.Vertex{5}, 0,
) != expectedProb {
t.Fatal("expecting 100% probability")
}
@@ -128,6 +135,16 @@ func testQueryRoutes(t *testing.T, useMissionControl bool) {
return 1, nil
},
MissionControl: &mockMissionControl{},
FetchChannelEndpoints: func(chanID uint64) (route.Vertex,
route.Vertex, error) {
if chanID != 555 {
t.Fatal("expected endpoints to be fetched for "+
"channel 555, but got %v instead",
chanID)
}
return route.Vertex{1}, route.Vertex{2}, nil
},
}
resp, err := backend.QueryRoutes(context.Background(), request)
@@ -142,8 +159,9 @@ func testQueryRoutes(t *testing.T, useMissionControl bool) {
type mockMissionControl struct {
}
func (m *mockMissionControl) GetEdgeProbability(fromNode route.Vertex,
edge routing.EdgeLocator, amt lnwire.MilliSatoshi) float64 {
func (m *mockMissionControl) GetProbability(fromNode, toNode route.Vertex,
amt lnwire.MilliSatoshi) float64 {
return testMissionControlProb
}
lnrpc/routerrpc/router_server.go
+27 -24
View File
@@ -451,40 +451,43 @@ func (s *Server) QueryMissionControl(ctx context.Context,
snapshot := s.cfg.RouterBackend.MissionControl.GetHistorySnapshot()
rpcNodes := make([]*NodeHistory, len(snapshot.Nodes))
for i, n := range snapshot.Nodes {
rpcNodes := make([]*NodeHistory, 0, len(snapshot.Nodes))
for _, n := range snapshot.Nodes {
// Copy node struct to prevent loop variable binding bugs.
node := n
channels := make([]*ChannelHistory, len(node.Channels))
for j, channel := range node.Channels {
channels[j] = &ChannelHistory{
ChannelId: channel.ChannelID,
LastFailTime: channel.LastFail.Unix(),
MinPenalizeAmtSat: int64(
channel.MinPenalizeAmt.ToSatoshis(),
),
SuccessProb: float32(channel.SuccessProb),
}
}
var lastFail int64
if node.LastFail != nil {
lastFail = node.LastFail.Unix()
}
rpcNodes[i] = &NodeHistory{
rpcNode := NodeHistory{
Pubkey: node.Node[:],
LastFailTime: lastFail,
OtherChanSuccessProb: float32(
node.OtherChanSuccessProb,
LastFailTime: node.LastFail.Unix(),
OtherSuccessProb: float32(
node.OtherSuccessProb,
),
Channels: channels,
}
rpcNodes = append(rpcNodes, &rpcNode)
}
rpcPairs := make([]*PairHistory, 0, len(snapshot.Pairs))
for _, p := range snapshot.Pairs {
// Prevent binding to loop variable.
pair := p
rpcPair := PairHistory{
NodeFrom: pair.Pair.From[:],
NodeTo: pair.Pair.To[:],
LastFailTime: pair.LastFail.Unix(),
MinPenalizeAmtSat: int64(
pair.MinPenalizeAmt.ToSatoshis(),
),
SuccessProb: float32(pair.SuccessProb),
}
rpcPairs = append(rpcPairs, &rpcPair)
}
response := QueryMissionControlResponse{
Nodes: rpcNodes,
Pairs: rpcPairs,
}
return &response, nil
lnrpc/rpc.pb.go
+628 -564
View File
File diff suppressed because it is too large. Load diff
lnrpc/rpc.proto
+15 -2
View File
@@ -1645,9 +1645,9 @@ message QueryRoutesRequest {
repeated bytes ignored_nodes = 6;
/**
A list of edges to ignore during path finding.
Deprecated. A list of edges to ignore during path finding.
*/
repeated EdgeLocator ignored_edges = 7;
repeated EdgeLocator ignored_edges = 7 [deprecated = true];
/**
The source node where the request route should originated from. If empty,
@@ -1660,6 +1660,19 @@ message QueryRoutesRequest {
the optimal route.
*/
bool use_mission_control = 9;
/**
A list of directed node pairs that will be ignored during path finding.
*/
repeated NodePair ignored_pairs = 10;
}
message NodePair {
/// The sending node of the pair.
bytes from = 1;
/// The receiving node of the pair.
bytes to = 2;
}
message EdgeLocator {