From 3e25bc3174b2394aebbdbc97b2cf54f7a352de85 Mon Sep 17 00:00:00 2001 From: Oliver Gugger Date: Fri, 31 Jan 2020 13:57:22 +0100 Subject: [PATCH] loopd+looprpc: add REST compatible status calls --- loopd/swapclient_server.go | 44 +++++ looprpc/client.pb.go | 383 +++++++++++++++++++++++++++--------- looprpc/client.pb.gw.go | 125 ++++++++++++ looprpc/client.proto | 46 ++++- looprpc/client.swagger.json | 73 +++++++ 5 files changed, 575 insertions(+), 96 deletions(-) diff --git a/loopd/swapclient_server.go b/loopd/swapclient_server.go index 8966c7e..658ccb7 100644 --- a/loopd/swapclient_server.go +++ b/loopd/swapclient_server.go @@ -241,6 +241,50 @@ func (s *swapClientServer) Monitor(in *looprpc.MonitorRequest, } } +// ListSwaps returns a list of all currently known swaps and their current +// status. +func (s *swapClientServer) ListSwaps(_ context.Context, + _ *looprpc.ListSwapsRequest) (*looprpc.ListSwapsResponse, error) { + + var ( + rpcSwaps = make([]*looprpc.SwapStatus, len(s.swaps)) + idx = 0 + err error + ) + + // We can just use the server's in-memory cache as that contains the + // most up-to-date state including temporary failures which aren't + // persisted to disk. The swaps field is a map, that's why we need an + // additional index. + for _, swp := range s.swaps { + swp := swp + rpcSwaps[idx], err = s.marshallSwap(&swp) + if err != nil { + return nil, err + } + idx++ + } + return &looprpc.ListSwapsResponse{Swaps: rpcSwaps}, nil +} + +// SwapInfo returns all known details about a single swap. +func (s *swapClientServer) SwapInfo(_ context.Context, + req *looprpc.SwapInfoRequest) (*looprpc.SwapStatus, error) { + + swapHash, err := lntypes.MakeHash(req.Id) + if err != nil { + return nil, fmt.Errorf("error parsing swap hash: %v", err) + } + + // Just return the server's in-memory cache here too as we also want to + // return temporary failures to the client. + swp, ok := s.swaps[swapHash] + if !ok { + return nil, fmt.Errorf("swap with hash %s not found", req.Id) + } + return s.marshallSwap(&swp) +} + // LoopOutTerms returns the terms that the server enforces for loop out swaps. func (s *swapClientServer) LoopOutTerms(ctx context.Context, req *looprpc.TermsRequest) (*looprpc.TermsResponse, error) { diff --git a/looprpc/client.pb.go b/looprpc/client.pb.go index 6898c86..db75ac3 100644 --- a/looprpc/client.pb.go +++ b/looprpc/client.pb.go @@ -572,6 +572,120 @@ func (m *SwapStatus) GetCostOffchain() int64 { return 0 } +type ListSwapsRequest struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ListSwapsRequest) Reset() { *m = ListSwapsRequest{} } +func (m *ListSwapsRequest) String() string { return proto.CompactTextString(m) } +func (*ListSwapsRequest) ProtoMessage() {} +func (*ListSwapsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_014de31d7ac8c57c, []int{5} +} + +func (m *ListSwapsRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ListSwapsRequest.Unmarshal(m, b) +} +func (m *ListSwapsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ListSwapsRequest.Marshal(b, m, deterministic) +} +func (m *ListSwapsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ListSwapsRequest.Merge(m, src) +} +func (m *ListSwapsRequest) XXX_Size() int { + return xxx_messageInfo_ListSwapsRequest.Size(m) +} +func (m *ListSwapsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ListSwapsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ListSwapsRequest proto.InternalMessageInfo + +type ListSwapsResponse struct { + //* + //The list of all currently known swaps and their status. + Swaps []*SwapStatus `protobuf:"bytes,1,rep,name=swaps,proto3" json:"swaps,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ListSwapsResponse) Reset() { *m = ListSwapsResponse{} } +func (m *ListSwapsResponse) String() string { return proto.CompactTextString(m) } +func (*ListSwapsResponse) ProtoMessage() {} +func (*ListSwapsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_014de31d7ac8c57c, []int{6} +} + +func (m *ListSwapsResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ListSwapsResponse.Unmarshal(m, b) +} +func (m *ListSwapsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ListSwapsResponse.Marshal(b, m, deterministic) +} +func (m *ListSwapsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ListSwapsResponse.Merge(m, src) +} +func (m *ListSwapsResponse) XXX_Size() int { + return xxx_messageInfo_ListSwapsResponse.Size(m) +} +func (m *ListSwapsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ListSwapsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ListSwapsResponse proto.InternalMessageInfo + +func (m *ListSwapsResponse) GetSwaps() []*SwapStatus { + if m != nil { + return m.Swaps + } + return nil +} + +type SwapInfoRequest struct { + //* + //The swap identifier which currently is the hash that locks the HTLCs. When + //using REST, this field must be encoded as base64. + Id []byte `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SwapInfoRequest) Reset() { *m = SwapInfoRequest{} } +func (m *SwapInfoRequest) String() string { return proto.CompactTextString(m) } +func (*SwapInfoRequest) ProtoMessage() {} +func (*SwapInfoRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_014de31d7ac8c57c, []int{7} +} + +func (m *SwapInfoRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_SwapInfoRequest.Unmarshal(m, b) +} +func (m *SwapInfoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_SwapInfoRequest.Marshal(b, m, deterministic) +} +func (m *SwapInfoRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_SwapInfoRequest.Merge(m, src) +} +func (m *SwapInfoRequest) XXX_Size() int { + return xxx_messageInfo_SwapInfoRequest.Size(m) +} +func (m *SwapInfoRequest) XXX_DiscardUnknown() { + xxx_messageInfo_SwapInfoRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_SwapInfoRequest proto.InternalMessageInfo + +func (m *SwapInfoRequest) GetId() []byte { + if m != nil { + return m.Id + } + return nil +} + type TermsRequest struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` @@ -582,7 +696,7 @@ func (m *TermsRequest) Reset() { *m = TermsRequest{} } func (m *TermsRequest) String() string { return proto.CompactTextString(m) } func (*TermsRequest) ProtoMessage() {} func (*TermsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_014de31d7ac8c57c, []int{5} + return fileDescriptor_014de31d7ac8c57c, []int{8} } func (m *TermsRequest) XXX_Unmarshal(b []byte) error { @@ -619,7 +733,7 @@ func (m *TermsResponse) Reset() { *m = TermsResponse{} } func (m *TermsResponse) String() string { return proto.CompactTextString(m) } func (*TermsResponse) ProtoMessage() {} func (*TermsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_014de31d7ac8c57c, []int{6} + return fileDescriptor_014de31d7ac8c57c, []int{9} } func (m *TermsResponse) XXX_Unmarshal(b []byte) error { @@ -684,7 +798,7 @@ func (m *QuoteRequest) Reset() { *m = QuoteRequest{} } func (m *QuoteRequest) String() string { return proto.CompactTextString(m) } func (*QuoteRequest) ProtoMessage() {} func (*QuoteRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_014de31d7ac8c57c, []int{7} + return fileDescriptor_014de31d7ac8c57c, []int{10} } func (m *QuoteRequest) XXX_Unmarshal(b []byte) error { @@ -759,7 +873,7 @@ func (m *QuoteResponse) Reset() { *m = QuoteResponse{} } func (m *QuoteResponse) String() string { return proto.CompactTextString(m) } func (*QuoteResponse) ProtoMessage() {} func (*QuoteResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_014de31d7ac8c57c, []int{8} + return fileDescriptor_014de31d7ac8c57c, []int{11} } func (m *QuoteResponse) XXX_Unmarshal(b []byte) error { @@ -825,7 +939,7 @@ func (m *TokensRequest) Reset() { *m = TokensRequest{} } func (m *TokensRequest) String() string { return proto.CompactTextString(m) } func (*TokensRequest) ProtoMessage() {} func (*TokensRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_014de31d7ac8c57c, []int{9} + return fileDescriptor_014de31d7ac8c57c, []int{12} } func (m *TokensRequest) XXX_Unmarshal(b []byte) error { @@ -859,7 +973,7 @@ func (m *TokensResponse) Reset() { *m = TokensResponse{} } func (m *TokensResponse) String() string { return proto.CompactTextString(m) } func (*TokensResponse) ProtoMessage() {} func (*TokensResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_014de31d7ac8c57c, []int{10} + return fileDescriptor_014de31d7ac8c57c, []int{13} } func (m *TokensResponse) XXX_Unmarshal(b []byte) error { @@ -924,7 +1038,7 @@ func (m *LsatToken) Reset() { *m = LsatToken{} } func (m *LsatToken) String() string { return proto.CompactTextString(m) } func (*LsatToken) ProtoMessage() {} func (*LsatToken) Descriptor() ([]byte, []int) { - return fileDescriptor_014de31d7ac8c57c, []int{11} + return fileDescriptor_014de31d7ac8c57c, []int{14} } func (m *LsatToken) XXX_Unmarshal(b []byte) error { @@ -1009,6 +1123,9 @@ func init() { proto.RegisterType((*SwapResponse)(nil), "looprpc.SwapResponse") proto.RegisterType((*MonitorRequest)(nil), "looprpc.MonitorRequest") proto.RegisterType((*SwapStatus)(nil), "looprpc.SwapStatus") + proto.RegisterType((*ListSwapsRequest)(nil), "looprpc.ListSwapsRequest") + proto.RegisterType((*ListSwapsResponse)(nil), "looprpc.ListSwapsResponse") + proto.RegisterType((*SwapInfoRequest)(nil), "looprpc.SwapInfoRequest") proto.RegisterType((*TermsRequest)(nil), "looprpc.TermsRequest") proto.RegisterType((*TermsResponse)(nil), "looprpc.TermsResponse") proto.RegisterType((*QuoteRequest)(nil), "looprpc.QuoteRequest") @@ -1021,90 +1138,96 @@ func init() { func init() { proto.RegisterFile("client.proto", fileDescriptor_014de31d7ac8c57c) } var fileDescriptor_014de31d7ac8c57c = []byte{ - // 1322 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x56, 0xcd, 0x72, 0x1a, 0xc7, - 0x16, 0xf6, 0xc0, 0x20, 0xe0, 0x30, 0x0c, 0xa3, 0x96, 0x2d, 0x21, 0xee, 0x75, 0x19, 0xcf, 0xbd, - 0x76, 0x88, 0x16, 0x26, 0xb6, 0x57, 0x71, 0x65, 0x43, 0x10, 0xb6, 0x50, 0x49, 0x82, 0x0c, 0xc8, - 0x55, 0xce, 0x66, 0xd2, 0x86, 0x96, 0x34, 0x15, 0xa6, 0x67, 0x3c, 0xdd, 0xd8, 0x52, 0xa5, 0xbc, - 0xc9, 0x2b, 0x64, 0x97, 0x65, 0xde, 0x20, 0x55, 0xd9, 0x65, 0x95, 0x67, 0xc8, 0x3e, 0xab, 0x3c, - 0x48, 0xaa, 0x7f, 0x66, 0x34, 0x88, 0xd8, 0x0b, 0xef, 0xe0, 0xeb, 0xaf, 0xbf, 0x3e, 0xe7, 0xf4, - 0x77, 0x4e, 0x0f, 0x58, 0xb3, 0x45, 0x40, 0x28, 0x7f, 0x14, 0x27, 0x11, 0x8f, 0x50, 0x79, 0x11, - 0x45, 0x71, 0x12, 0xcf, 0x5a, 0xff, 0x3d, 0x8f, 0xa2, 0xf3, 0x05, 0xe9, 0xe2, 0x38, 0xe8, 0x62, - 0x4a, 0x23, 0x8e, 0x79, 0x10, 0x51, 0xa6, 0x68, 0xee, 0xcf, 0x45, 0xb0, 0x8f, 0xa2, 0x28, 0x1e, - 0x2d, 0xb9, 0x47, 0xde, 0x2c, 0x09, 0xe3, 0xc8, 0x81, 0x22, 0x0e, 0x79, 0xd3, 0x68, 0x1b, 0x9d, - 0xa2, 0x27, 0x7e, 0x22, 0x04, 0xe6, 0x9c, 0x30, 0xde, 0x2c, 0xb4, 0x8d, 0x4e, 0xd5, 0x93, 0xbf, - 0x51, 0x17, 0x6e, 0x87, 0xf8, 0xd2, 0x67, 0xef, 0x70, 0xec, 0x27, 0xd1, 0x92, 0x07, 0xf4, 0xdc, - 0x3f, 0x23, 0xa4, 0x59, 0x94, 0xdb, 0x36, 0x43, 0x7c, 0x39, 0x79, 0x87, 0x63, 0x4f, 0xad, 0x3c, - 0x27, 0x04, 0x3d, 0x85, 0x6d, 0xb1, 0x21, 0x4e, 0x48, 0x8c, 0xaf, 0x56, 0xb6, 0x98, 0x72, 0xcb, - 0x56, 0x88, 0x2f, 0xc7, 0x72, 0x31, 0xb7, 0xa9, 0x0d, 0x56, 0x76, 0x8a, 0xa0, 0x96, 0x24, 0x15, - 0xb4, 0xba, 0x60, 0xfc, 0x1f, 0xec, 0x9c, 0xac, 0x08, 0x7c, 0x43, 0x72, 0xac, 0x4c, 0xae, 0x17, - 0x72, 0xe4, 0x42, 0x5d, 0xb0, 0xc2, 0x80, 0x92, 0x44, 0x0a, 0x95, 0x25, 0xa9, 0x16, 0xe2, 0xcb, - 0x63, 0x81, 0x09, 0xa5, 0x0e, 0x38, 0xa2, 0x66, 0x7e, 0xb4, 0xe4, 0xfe, 0xec, 0x02, 0x53, 0x4a, - 0x16, 0xcd, 0x4a, 0xdb, 0xe8, 0x98, 0x9e, 0xbd, 0x50, 0x15, 0xea, 0x2b, 0x14, 0xed, 0xc1, 0x26, - 0x7b, 0x47, 0x48, 0xec, 0xcf, 0x22, 0x7a, 0xe6, 0x73, 0x9c, 0x9c, 0x13, 0xde, 0xac, 0xb6, 0x8d, - 0x4e, 0xc9, 0x6b, 0xc8, 0x85, 0x7e, 0x44, 0xcf, 0xa6, 0x12, 0x46, 0xcf, 0x60, 0x57, 0x46, 0x1f, - 0x2f, 0x5f, 0x2f, 0x82, 0x99, 0xac, 0xbd, 0x3f, 0x27, 0x78, 0xbe, 0x08, 0x28, 0x69, 0x82, 0x94, - 0xdf, 0x11, 0x84, 0xf1, 0xf5, 0xfa, 0xbe, 0x5e, 0x76, 0x7f, 0x33, 0xa0, 0x2e, 0x2e, 0x67, 0x48, - 0x3f, 0x7c, 0x37, 0x37, 0x2b, 0x54, 0x58, 0xab, 0xd0, 0x5a, 0xee, 0xc5, 0xf5, 0xdc, 0x1f, 0x42, - 0x43, 0xe6, 0x1e, 0xd0, 0x2c, 0x75, 0x53, 0xc6, 0x56, 0x5f, 0xc8, 0xf3, 0xd3, 0xcc, 0xff, 0x07, - 0x75, 0x72, 0xc9, 0x49, 0x42, 0xf1, 0xc2, 0xbf, 0xe0, 0x8b, 0x99, 0xbc, 0x90, 0x8a, 0x67, 0xa5, - 0xe0, 0x01, 0x5f, 0xcc, 0xdc, 0x1e, 0x58, 0xf2, 0xee, 0x09, 0x8b, 0x23, 0xca, 0x08, 0xb2, 0xa1, - 0x10, 0xcc, 0x65, 0xcc, 0x55, 0xaf, 0x10, 0xcc, 0xd1, 0x7d, 0xb0, 0xc4, 0x5e, 0x1f, 0xcf, 0xe7, - 0x09, 0x61, 0x4c, 0xdb, 0xaa, 0x26, 0xb0, 0x9e, 0x82, 0x5c, 0x07, 0xec, 0xe3, 0x88, 0x06, 0x3c, - 0x4a, 0x74, 0xe6, 0xee, 0x5f, 0x05, 0x00, 0xa1, 0x3a, 0xe1, 0x98, 0x2f, 0xd9, 0xbf, 0x14, 0x42, - 0x9d, 0x52, 0xc8, 0x4e, 0x79, 0x00, 0x26, 0xbf, 0x8a, 0x55, 0xb6, 0xf6, 0x93, 0xcd, 0x47, 0xba, - 0x1f, 0x1e, 0x09, 0x91, 0xe9, 0x55, 0x4c, 0x3c, 0xb9, 0x8c, 0x3a, 0x50, 0x62, 0x1c, 0x73, 0xe5, - 0x42, 0xfb, 0x09, 0x5a, 0xe1, 0x89, 0xc3, 0x88, 0xa7, 0x08, 0xe8, 0x33, 0x68, 0x04, 0x34, 0xe0, - 0x81, 0xba, 0x43, 0x1e, 0x84, 0xa9, 0x1d, 0xed, 0x6b, 0x78, 0x1a, 0x84, 0xca, 0x48, 0x98, 0x71, - 0x7f, 0x19, 0xcf, 0x31, 0x27, 0x8a, 0xa9, 0x4c, 0x69, 0x0b, 0xfc, 0x54, 0xc2, 0x92, 0x79, 0xb3, - 0x12, 0xe5, 0xb5, 0x4a, 0xa0, 0x7b, 0x50, 0x9b, 0x45, 0x8c, 0xfb, 0x8c, 0x24, 0x6f, 0x49, 0x22, - 0x0d, 0x59, 0xf4, 0x40, 0x40, 0x13, 0x89, 0x08, 0x0d, 0x49, 0x88, 0xe8, 0xec, 0x02, 0x07, 0x54, - 0xfa, 0xb0, 0xe8, 0xc9, 0x4d, 0x23, 0x05, 0x89, 0x5b, 0x53, 0x94, 0xb3, 0x33, 0xc5, 0x01, 0xd5, - 0x22, 0x92, 0xa3, 0x31, 0xd7, 0x06, 0x6b, 0x4a, 0x92, 0x90, 0xa5, 0x05, 0x7f, 0x0f, 0x75, 0xfd, - 0x5f, 0x5f, 0xe3, 0x43, 0x68, 0x84, 0x01, 0x55, 0x4e, 0xc3, 0x61, 0xb4, 0xa4, 0x5c, 0xe7, 0x5f, - 0x0f, 0x03, 0x2a, 0xaa, 0xd5, 0x93, 0xa0, 0xe4, 0xa5, 0x8e, 0xd4, 0xbc, 0x0d, 0xcd, 0x53, 0xa6, - 0x54, 0xbc, 0x43, 0xb3, 0x62, 0x38, 0x85, 0x43, 0xb3, 0x52, 0x70, 0x8a, 0x87, 0x66, 0xa5, 0xe8, - 0x98, 0x87, 0x66, 0xc5, 0x74, 0x4a, 0x87, 0x66, 0xa5, 0xec, 0x54, 0xdc, 0x5f, 0x0c, 0xb0, 0xbe, - 0x59, 0x46, 0x9c, 0x7c, 0xd8, 0xfa, 0xb2, 0x34, 0xd7, 0x0d, 0x58, 0x90, 0x0d, 0x08, 0xb3, 0xeb, - 0xde, 0x5b, 0x73, 0x6b, 0x71, 0xdd, 0xad, 0x1f, 0x6f, 0x50, 0xf3, 0xe3, 0x0d, 0xfa, 0xab, 0x01, - 0x75, 0x1d, 0xa4, 0x2e, 0xd2, 0x2e, 0x54, 0xb2, 0x56, 0x54, 0xa1, 0x96, 0x99, 0xee, 0xc3, 0xbb, - 0x00, 0xb9, 0x29, 0xa5, 0xfa, 0xb4, 0x1a, 0x67, 0x23, 0xea, 0x3f, 0x50, 0xbd, 0xd9, 0xa2, 0x95, - 0x30, 0xed, 0x4f, 0x39, 0x71, 0x44, 0x90, 0xf8, 0x2a, 0x24, 0x94, 0xfb, 0x72, 0x1c, 0x8b, 0xe0, - 0x2c, 0x31, 0x71, 0x70, 0x3c, 0x56, 0xf8, 0xbe, 0x28, 0xd4, 0x5d, 0x80, 0xd9, 0x82, 0xbf, 0xf5, - 0xe7, 0x64, 0xc1, 0xb1, 0xbc, 0xa2, 0x92, 0x57, 0x15, 0xc8, 0xbe, 0x00, 0xdc, 0x06, 0xd4, 0xa7, - 0xd1, 0xf7, 0x84, 0x66, 0x17, 0xfd, 0x15, 0xd8, 0x29, 0xa0, 0x93, 0xd8, 0x83, 0x0d, 0x2e, 0x91, - 0xa6, 0xd1, 0x2e, 0x76, 0x6a, 0xb9, 0xa6, 0x38, 0x62, 0x98, 0x4b, 0xb2, 0xa7, 0x19, 0xee, 0xef, - 0x05, 0xa8, 0x66, 0xa8, 0xa8, 0xf8, 0x6b, 0xcc, 0x88, 0x1f, 0xe2, 0x19, 0x4e, 0xa2, 0x88, 0xca, - 0x1a, 0x58, 0x9e, 0x25, 0xc0, 0x63, 0x8d, 0x09, 0xc7, 0xa6, 0x79, 0x5c, 0x60, 0x76, 0x21, 0x4b, - 0x61, 0x79, 0x35, 0x8d, 0x1d, 0x60, 0x76, 0x81, 0x3e, 0x07, 0x27, 0xa5, 0xc4, 0x09, 0x09, 0x42, - 0x7c, 0xae, 0x6a, 0x62, 0x79, 0x0d, 0x8d, 0x8f, 0x35, 0x2c, 0xba, 0x4d, 0xb9, 0xcc, 0x8f, 0x71, - 0x30, 0xf7, 0x43, 0x86, 0xb9, 0x7e, 0x51, 0x6c, 0x85, 0x8f, 0x71, 0x30, 0x3f, 0x66, 0x98, 0xa3, - 0xc7, 0x70, 0x27, 0xf7, 0xec, 0xe4, 0xe8, 0xca, 0xc6, 0x28, 0xc9, 0xde, 0x9d, 0x6c, 0xcb, 0x7d, - 0xb0, 0x44, 0xfb, 0xfa, 0xb3, 0x84, 0x60, 0x4e, 0xe6, 0xda, 0xc8, 0x35, 0x81, 0xf5, 0x15, 0x84, - 0x9a, 0x50, 0x26, 0x97, 0x71, 0x90, 0x90, 0xb9, 0x6c, 0xdf, 0x8a, 0x97, 0xfe, 0x15, 0x9b, 0x19, - 0x8f, 0x12, 0x7c, 0x4e, 0x7c, 0x8a, 0x43, 0x22, 0x7b, 0xb7, 0xea, 0xd5, 0x34, 0x76, 0x82, 0x43, - 0xb2, 0xf7, 0x00, 0x2a, 0xe9, 0x3c, 0x42, 0x16, 0x54, 0x8e, 0x46, 0xa3, 0xb1, 0x3f, 0x3a, 0x9d, - 0x3a, 0xb7, 0x50, 0x0d, 0xca, 0xf2, 0xdf, 0xf0, 0xc4, 0x31, 0xf6, 0x18, 0x54, 0xb3, 0x71, 0x84, - 0xea, 0x50, 0x1d, 0x9e, 0x0c, 0xa7, 0xc3, 0xde, 0x74, 0xb0, 0xef, 0xdc, 0x42, 0x77, 0x60, 0x73, - 0xec, 0x0d, 0x86, 0xc7, 0xbd, 0x17, 0x03, 0xdf, 0x1b, 0xbc, 0x1c, 0xf4, 0x8e, 0x06, 0xfb, 0x8e, - 0x81, 0x10, 0xd8, 0x07, 0xd3, 0xa3, 0xbe, 0x3f, 0x3e, 0xfd, 0xfa, 0x68, 0x38, 0x39, 0x18, 0xec, - 0x3b, 0x05, 0xa1, 0x39, 0x39, 0xed, 0xf7, 0x07, 0x93, 0x89, 0x53, 0x44, 0x00, 0x1b, 0xcf, 0x7b, - 0x43, 0x41, 0x36, 0xd1, 0x16, 0x34, 0x86, 0x27, 0x2f, 0x47, 0xc3, 0xfe, 0xc0, 0x9f, 0x0c, 0xa6, - 0x53, 0x01, 0x96, 0x9e, 0xfc, 0x51, 0x52, 0x13, 0xb7, 0x2f, 0x3f, 0x2b, 0x90, 0x07, 0x65, 0xfd, - 0xa1, 0x80, 0x76, 0xae, 0xfd, 0xb0, 0xf2, 0xe9, 0xd0, 0xba, 0xb3, 0x32, 0x3d, 0x53, 0x3f, 0xb9, - 0x3b, 0x3f, 0xfe, 0xf9, 0xf7, 0x4f, 0x85, 0x4d, 0xd7, 0xea, 0xbe, 0x7d, 0xdc, 0x15, 0x8c, 0x6e, - 0xb4, 0xe4, 0xcf, 0x8c, 0x3d, 0x34, 0x82, 0x0d, 0xf5, 0xbe, 0xa1, 0xed, 0x15, 0xc9, 0xec, 0xc1, - 0xfb, 0x90, 0xe2, 0xb6, 0x54, 0x74, 0xdc, 0x5a, 0xa6, 0x18, 0x50, 0x21, 0xf8, 0x25, 0x94, 0xf5, - 0xbb, 0x91, 0x0b, 0x72, 0xf5, 0x25, 0x69, 0x6d, 0xad, 0x8d, 0xf8, 0x25, 0xfb, 0xc2, 0x40, 0xaf, - 0xc0, 0xd2, 0xd9, 0xc8, 0xb1, 0x87, 0xae, 0x4f, 0xce, 0x8f, 0xc5, 0xd6, 0xf6, 0x4d, 0x58, 0x47, - 0xd4, 0x92, 0x11, 0xdd, 0x46, 0x28, 0x9f, 0x63, 0x97, 0x4b, 0x29, 0x3f, 0x93, 0x96, 0xc3, 0x22, - 0x27, 0x9d, 0x9f, 0x70, 0x39, 0xe9, 0x95, 0x99, 0xe2, 0xb6, 0xa5, 0x74, 0x0b, 0x35, 0x57, 0xa4, - 0xdf, 0x08, 0x4e, 0xf7, 0x07, 0x1c, 0xf2, 0xf7, 0xe8, 0x5b, 0xb0, 0x5f, 0x10, 0xae, 0x2a, 0xf7, - 0x49, 0xd1, 0xef, 0xca, 0x23, 0xb6, 0xd0, 0x66, 0xae, 0x9e, 0x3a, 0xf8, 0xef, 0x72, 0xda, 0x9f, - 0x14, 0xfe, 0x3d, 0xa9, 0xbd, 0x8b, 0x76, 0xf2, 0xda, 0xf9, 0xe8, 0x5f, 0x41, 0x5d, 0x9c, 0x90, - 0x0e, 0x11, 0x96, 0x33, 0xc3, 0xca, 0xa4, 0x6a, 0xed, 0xac, 0xe1, 0xab, 0x06, 0x43, 0x0d, 0x79, - 0x04, 0xc3, 0xbc, 0xab, 0xa6, 0xd3, 0xeb, 0x0d, 0xf9, 0x95, 0xfb, 0xf4, 0x9f, 0x00, 0x00, 0x00, - 0xff, 0xff, 0x55, 0xbe, 0xbc, 0x0e, 0x1c, 0x0b, 0x00, 0x00, + // 1421 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x57, 0xcd, 0x6e, 0xdb, 0xc6, + 0x16, 0x8e, 0x24, 0xda, 0x92, 0x8e, 0x28, 0x8a, 0x1e, 0x27, 0xb6, 0xac, 0x7b, 0x83, 0x38, 0xbc, + 0x37, 0xa9, 0xe3, 0x45, 0xd4, 0x38, 0xbb, 0xa0, 0x28, 0xa0, 0xca, 0x4a, 0x2c, 0xc3, 0x7f, 0xa5, + 0xe4, 0x00, 0xc9, 0x86, 0x9d, 0x48, 0x63, 0x9b, 0xa8, 0xf8, 0x13, 0xce, 0x28, 0xb1, 0x11, 0x64, + 0xd3, 0x07, 0xe8, 0xa6, 0xbb, 0x2e, 0xfb, 0x06, 0x05, 0xba, 0xeb, 0x63, 0x74, 0xdf, 0x55, 0x1f, + 0xa4, 0x98, 0x33, 0x43, 0x8a, 0xb2, 0x9c, 0x2c, 0xb2, 0xb3, 0xbe, 0xf9, 0xe6, 0x9b, 0x33, 0xe7, + 0xe7, 0x1b, 0x1a, 0xcc, 0xd1, 0xc4, 0x67, 0xa1, 0x78, 0x1c, 0x27, 0x91, 0x88, 0x48, 0x79, 0x12, + 0x45, 0x71, 0x12, 0x8f, 0x5a, 0xff, 0x3d, 0x8f, 0xa2, 0xf3, 0x09, 0x6b, 0xd3, 0xd8, 0x6f, 0xd3, + 0x30, 0x8c, 0x04, 0x15, 0x7e, 0x14, 0x72, 0x45, 0x73, 0x7e, 0x2d, 0x81, 0x75, 0x10, 0x45, 0xf1, + 0xf1, 0x54, 0xb8, 0xec, 0xed, 0x94, 0x71, 0x41, 0x6c, 0x28, 0xd1, 0x40, 0x34, 0x0b, 0x9b, 0x85, + 0xad, 0x92, 0x2b, 0xff, 0x24, 0x04, 0x8c, 0x31, 0xe3, 0xa2, 0x59, 0xdc, 0x2c, 0x6c, 0x55, 0x5d, + 0xfc, 0x9b, 0xb4, 0xe1, 0x76, 0x40, 0x2f, 0x3d, 0xfe, 0x9e, 0xc6, 0x5e, 0x12, 0x4d, 0x85, 0x1f, + 0x9e, 0x7b, 0x67, 0x8c, 0x35, 0x4b, 0xb8, 0x6d, 0x25, 0xa0, 0x97, 0x83, 0xf7, 0x34, 0x76, 0xd5, + 0xca, 0x73, 0xc6, 0xc8, 0x53, 0x58, 0x93, 0x1b, 0xe2, 0x84, 0xc5, 0xf4, 0x6a, 0x6e, 0x8b, 0x81, + 0x5b, 0x56, 0x03, 0x7a, 0x79, 0x82, 0x8b, 0xb9, 0x4d, 0x9b, 0x60, 0x66, 0xa7, 0x48, 0xea, 0x12, + 0x52, 0x41, 0xab, 0x4b, 0xc6, 0xff, 0xc1, 0xca, 0xc9, 0xca, 0xc0, 0x97, 0x91, 0x63, 0x66, 0x72, + 0x9d, 0x40, 0x10, 0x07, 0xea, 0x92, 0x15, 0xf8, 0x21, 0x4b, 0x50, 0xa8, 0x8c, 0xa4, 0x5a, 0x40, + 0x2f, 0x0f, 0x25, 0x26, 0x95, 0xb6, 0xc0, 0x96, 0x39, 0xf3, 0xa2, 0xa9, 0xf0, 0x46, 0x17, 0x34, + 0x0c, 0xd9, 0xa4, 0x59, 0xd9, 0x2c, 0x6c, 0x19, 0xae, 0x35, 0x51, 0x19, 0xea, 0x2a, 0x94, 0x6c, + 0xc3, 0x0a, 0x7f, 0xcf, 0x58, 0xec, 0x8d, 0xa2, 0xf0, 0xcc, 0x13, 0x34, 0x39, 0x67, 0xa2, 0x59, + 0xdd, 0x2c, 0x6c, 0x2d, 0xb9, 0x0d, 0x5c, 0xe8, 0x46, 0xe1, 0xd9, 0x10, 0x61, 0xf2, 0x0c, 0x36, + 0x30, 0xfa, 0x78, 0xfa, 0x66, 0xe2, 0x8f, 0x30, 0xf7, 0xde, 0x98, 0xd1, 0xf1, 0xc4, 0x0f, 0x59, + 0x13, 0x50, 0x7e, 0x5d, 0x12, 0x4e, 0x66, 0xeb, 0xbb, 0x7a, 0xd9, 0xf9, 0xa3, 0x00, 0x75, 0x59, + 0x9c, 0x7e, 0xf8, 0xe9, 0xda, 0x5c, 0xcf, 0x50, 0x71, 0x21, 0x43, 0x0b, 0x77, 0x2f, 0x2d, 0xde, + 0xfd, 0x21, 0x34, 0xf0, 0xee, 0x7e, 0x98, 0x5d, 0xdd, 0xc0, 0xd8, 0xea, 0x13, 0x3c, 0x3f, 0xbd, + 0xf9, 0xff, 0xa0, 0xce, 0x2e, 0x05, 0x4b, 0x42, 0x3a, 0xf1, 0x2e, 0xc4, 0x64, 0x84, 0x05, 0xa9, + 0xb8, 0x66, 0x0a, 0xee, 0x89, 0xc9, 0xc8, 0xe9, 0x80, 0x89, 0xb5, 0x67, 0x3c, 0x8e, 0x42, 0xce, + 0x88, 0x05, 0x45, 0x7f, 0x8c, 0x31, 0x57, 0xdd, 0xa2, 0x3f, 0x26, 0xf7, 0xc1, 0x94, 0x7b, 0x3d, + 0x3a, 0x1e, 0x27, 0x8c, 0x73, 0xdd, 0x56, 0x35, 0x89, 0x75, 0x14, 0xe4, 0xd8, 0x60, 0x1d, 0x46, + 0xa1, 0x2f, 0xa2, 0x44, 0xdf, 0xdc, 0xf9, 0xbb, 0x08, 0x20, 0x55, 0x07, 0x82, 0x8a, 0x29, 0xbf, + 0x21, 0x11, 0xea, 0x94, 0x62, 0x76, 0xca, 0x03, 0x30, 0xc4, 0x55, 0xac, 0x6e, 0x6b, 0xed, 0xac, + 0x3c, 0xd6, 0xf3, 0xf0, 0x58, 0x8a, 0x0c, 0xaf, 0x62, 0xe6, 0xe2, 0x32, 0xd9, 0x82, 0x25, 0x2e, + 0xa8, 0x50, 0x5d, 0x68, 0xed, 0x90, 0x39, 0x9e, 0x3c, 0x8c, 0xb9, 0x8a, 0x40, 0xbe, 0x82, 0x86, + 0x1f, 0xfa, 0xc2, 0x57, 0x35, 0x14, 0x7e, 0x90, 0xb6, 0xa3, 0x35, 0x83, 0x87, 0x7e, 0xa0, 0x1a, + 0x89, 0x72, 0xe1, 0x4d, 0xe3, 0x31, 0x15, 0x4c, 0x31, 0x55, 0x53, 0x5a, 0x12, 0x3f, 0x45, 0x18, + 0x99, 0xd7, 0x33, 0x51, 0x5e, 0xc8, 0x04, 0xb9, 0x07, 0xb5, 0x51, 0xc4, 0x85, 0xc7, 0x59, 0xf2, + 0x8e, 0x25, 0xd8, 0x90, 0x25, 0x17, 0x24, 0x34, 0x40, 0x44, 0x6a, 0x20, 0x21, 0x0a, 0x47, 0x17, + 0xd4, 0x0f, 0xb1, 0x0f, 0x4b, 0x2e, 0x6e, 0x3a, 0x56, 0x90, 0xac, 0x9a, 0xa2, 0x9c, 0x9d, 0x29, + 0x0e, 0xa8, 0x11, 0x41, 0x8e, 0xc6, 0x1c, 0x02, 0xf6, 0x81, 0xcf, 0x85, 0xbc, 0x36, 0x4f, 0x93, + 0xfe, 0x2d, 0xac, 0xe4, 0x30, 0x5d, 0xce, 0x47, 0xb0, 0x24, 0xbb, 0x8d, 0x37, 0x0b, 0x9b, 0xa5, + 0xad, 0xda, 0xce, 0xea, 0x42, 0xc6, 0xa6, 0xdc, 0x55, 0x0c, 0xe7, 0x3e, 0x34, 0x24, 0xd8, 0x0f, + 0xcf, 0xa2, 0xb4, 0x83, 0x67, 0xcd, 0x60, 0xca, 0x32, 0x39, 0x16, 0x98, 0x43, 0x96, 0x04, 0xd9, + 0x91, 0x1f, 0xa1, 0xae, 0x7f, 0xeb, 0xe3, 0x1e, 0x42, 0x23, 0xf0, 0x43, 0xd5, 0xe0, 0x34, 0x88, + 0xa6, 0xa1, 0xd0, 0x69, 0xaf, 0x07, 0x7e, 0x28, 0xd5, 0x3b, 0x08, 0x22, 0x2f, 0x1d, 0x04, 0xcd, + 0x5b, 0xd6, 0x3c, 0x35, 0x0b, 0x8a, 0xb7, 0x6f, 0x54, 0x0a, 0x76, 0x71, 0xdf, 0xa8, 0x14, 0xed, + 0xd2, 0xbe, 0x51, 0x29, 0xd9, 0xc6, 0xbe, 0x51, 0x31, 0xec, 0xa5, 0x7d, 0xa3, 0x52, 0xb6, 0x2b, + 0xce, 0x6f, 0x05, 0x30, 0xbf, 0x9f, 0x46, 0x82, 0x7d, 0x7a, 0xe2, 0xb0, 0x22, 0xb3, 0xb9, 0x2f, + 0xe2, 0xdc, 0xc3, 0x68, 0x36, 0xf2, 0x0b, 0x43, 0x52, 0x5a, 0x1c, 0x92, 0xcf, 0xfb, 0x82, 0xf1, + 0x79, 0x5f, 0xf8, 0xbd, 0x00, 0x75, 0x1d, 0xa4, 0x4e, 0xd2, 0x06, 0x54, 0x32, 0x07, 0x50, 0xa1, + 0x96, 0xb9, 0x1e, 0xff, 0xbb, 0x00, 0x39, 0x73, 0x54, 0xf6, 0x50, 0x8d, 0x33, 0x67, 0xfc, 0x0f, + 0x54, 0xaf, 0x3b, 0x43, 0x25, 0x48, 0x6d, 0x01, 0x8d, 0x4e, 0x06, 0x49, 0xaf, 0x02, 0x16, 0x0a, + 0x0f, 0x5f, 0x01, 0x03, 0x6b, 0xd7, 0xc0, 0xe0, 0x14, 0xbe, 0x2b, 0x13, 0x75, 0x17, 0x60, 0x34, + 0x11, 0xef, 0xbc, 0x31, 0x9b, 0x08, 0x8a, 0x25, 0x5a, 0x72, 0xab, 0x12, 0xd9, 0x95, 0x80, 0xd3, + 0x80, 0xfa, 0x30, 0xfa, 0x91, 0x85, 0x59, 0xa1, 0xbf, 0x01, 0x2b, 0x05, 0xf4, 0x25, 0xb6, 0x61, + 0x59, 0x20, 0xa2, 0x3b, 0x6b, 0x36, 0x8b, 0x07, 0x9c, 0x0a, 0x24, 0xbb, 0x9a, 0xe1, 0xfc, 0x59, + 0x84, 0x6a, 0x86, 0xca, 0x8c, 0xbf, 0xa1, 0x9c, 0x79, 0x01, 0x1d, 0xd1, 0x24, 0x8a, 0x42, 0xdd, + 0x5f, 0xa6, 0x04, 0x0f, 0x35, 0x26, 0x07, 0x25, 0xbd, 0xc7, 0x05, 0xe5, 0x17, 0x98, 0x0a, 0xd3, + 0xad, 0x69, 0x6c, 0x8f, 0xf2, 0x0b, 0xf2, 0x08, 0xec, 0x94, 0x12, 0x27, 0xcc, 0x0f, 0xe8, 0xb9, + 0xca, 0x89, 0xe9, 0x36, 0x34, 0x7e, 0xa2, 0x61, 0x39, 0xe4, 0xaa, 0xcb, 0xbc, 0x98, 0xfa, 0x63, + 0x2f, 0xe0, 0x54, 0xe8, 0x87, 0xcc, 0x52, 0xf8, 0x09, 0xf5, 0xc7, 0x87, 0x9c, 0x0a, 0xf2, 0x04, + 0xee, 0xe4, 0x5e, 0xbb, 0x1c, 0x5d, 0xb5, 0x31, 0x49, 0xb2, 0xe7, 0x2e, 0xdb, 0x72, 0x1f, 0x4c, + 0xe9, 0x1a, 0xde, 0x28, 0x61, 0x54, 0xb0, 0xb1, 0x6e, 0xe4, 0x9a, 0xc4, 0xba, 0x0a, 0x22, 0x4d, + 0x28, 0xb3, 0xcb, 0xd8, 0x4f, 0xd8, 0x18, 0x5d, 0xa3, 0xe2, 0xa6, 0x3f, 0xe5, 0x66, 0x2e, 0xa2, + 0x84, 0x9e, 0x33, 0x2f, 0xa4, 0x01, 0x43, 0xcb, 0xa8, 0xba, 0x35, 0x8d, 0x1d, 0xd1, 0x80, 0x6d, + 0x3f, 0x80, 0x4a, 0x6a, 0x83, 0xc4, 0x84, 0xca, 0xc1, 0xf1, 0xf1, 0x89, 0x77, 0x7c, 0x3a, 0xb4, + 0x6f, 0x91, 0x1a, 0x94, 0xf1, 0x57, 0xff, 0xc8, 0x2e, 0x6c, 0x73, 0xa8, 0x66, 0x2e, 0x48, 0xea, + 0x50, 0xed, 0x1f, 0xf5, 0x87, 0xfd, 0xce, 0xb0, 0xb7, 0x6b, 0xdf, 0x22, 0x77, 0x60, 0xe5, 0xc4, + 0xed, 0xf5, 0x0f, 0x3b, 0x2f, 0x7a, 0x9e, 0xdb, 0x7b, 0xd9, 0xeb, 0x1c, 0xf4, 0x76, 0xed, 0x02, + 0x21, 0x60, 0xed, 0x0d, 0x0f, 0xba, 0xde, 0xc9, 0xe9, 0x77, 0x07, 0xfd, 0xc1, 0x5e, 0x6f, 0xd7, + 0x2e, 0x4a, 0xcd, 0xc1, 0x69, 0xb7, 0xdb, 0x1b, 0x0c, 0xec, 0x12, 0x01, 0x58, 0x7e, 0xde, 0xe9, + 0x4b, 0xb2, 0x41, 0x56, 0xa1, 0xd1, 0x3f, 0x7a, 0x79, 0xdc, 0xef, 0xf6, 0xbc, 0x41, 0x6f, 0x38, + 0x94, 0xe0, 0xd2, 0xce, 0xcf, 0x65, 0x65, 0xf4, 0x5d, 0xfc, 0x9a, 0x21, 0x2e, 0x94, 0xf5, 0xf7, + 0x09, 0x59, 0x9f, 0xf5, 0xc3, 0xdc, 0x17, 0x4b, 0xeb, 0xce, 0x9c, 0x05, 0xa5, 0xfd, 0xe4, 0xac, + 0xff, 0xf4, 0xd7, 0x3f, 0xbf, 0x14, 0x57, 0x1c, 0xb3, 0xfd, 0xee, 0x49, 0x5b, 0x32, 0xda, 0xd1, + 0x54, 0x3c, 0x2b, 0x6c, 0x93, 0x63, 0x58, 0x56, 0xcf, 0x2a, 0x59, 0x9b, 0x93, 0xcc, 0xde, 0xd9, + 0x4f, 0x29, 0xae, 0xa1, 0xa2, 0xed, 0xd4, 0x32, 0x45, 0x3f, 0x94, 0x82, 0x03, 0x28, 0xeb, 0xe7, + 0x2a, 0x17, 0xe4, 0xfc, 0x03, 0xd6, 0xba, 0xc9, 0x27, 0x9d, 0x26, 0x0a, 0x12, 0x62, 0x67, 0x82, + 0x81, 0xda, 0xf5, 0x75, 0x81, 0xbc, 0x86, 0x6a, 0x66, 0xbe, 0x64, 0x63, 0x16, 0xe8, 0x35, 0x93, + 0x6e, 0xb5, 0x6e, 0x5a, 0x9a, 0x0f, 0x98, 0x58, 0x99, 0x3e, 0x1a, 0x33, 0x39, 0x55, 0x0d, 0x20, + 0x8d, 0x99, 0x34, 0xe7, 0x02, 0xcb, 0x79, 0xf5, 0xcd, 0x21, 0xb7, 0x50, 0xf2, 0x36, 0x21, 0x73, + 0x92, 0xed, 0x0f, 0xfe, 0xf8, 0x23, 0x79, 0x05, 0xa6, 0x2e, 0x0d, 0x7a, 0x38, 0x99, 0xa5, 0x31, + 0xef, 0xf1, 0xad, 0xb5, 0xeb, 0xb0, 0x8e, 0x76, 0x51, 0x3a, 0x9a, 0x8a, 0xb6, 0x40, 0x29, 0x2f, + 0x93, 0x46, 0xe7, 0xcb, 0x49, 0xe7, 0xed, 0x3a, 0x27, 0x3d, 0x67, 0x90, 0xce, 0x26, 0x4a, 0xb7, + 0x48, 0x73, 0x4e, 0xfa, 0xad, 0xe4, 0xb4, 0x3f, 0xd0, 0x40, 0x7c, 0x24, 0xaf, 0xc1, 0x7a, 0xc1, + 0x84, 0x6a, 0x83, 0x2f, 0x8a, 0x7e, 0x03, 0x8f, 0x58, 0x25, 0x2b, 0xb9, 0xe6, 0xd0, 0xc1, 0xff, + 0x90, 0xd3, 0xfe, 0xa2, 0xf0, 0xef, 0xa1, 0xf6, 0x06, 0x59, 0xcf, 0x6b, 0xe7, 0xa3, 0x7f, 0x05, + 0x75, 0x79, 0x42, 0xea, 0x88, 0x3c, 0xd7, 0xd9, 0x73, 0xb6, 0xdb, 0x5a, 0x5f, 0xc0, 0xe7, 0xa7, + 0x85, 0x34, 0xf0, 0x08, 0x4e, 0x45, 0x5b, 0x59, 0xed, 0x9b, 0x65, 0xfc, 0x4f, 0xe1, 0xe9, 0xbf, + 0x01, 0x00, 0x00, 0xff, 0xff, 0x63, 0x64, 0x76, 0xf5, 0x60, 0x0c, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -1133,8 +1256,14 @@ type SwapClientClient interface { LoopIn(ctx context.Context, in *LoopInRequest, opts ...grpc.CallOption) (*SwapResponse, error) //* loop: `monitor` //Monitor will return a stream of swap updates for currently active swaps. - //TODO: add MonitorSync version for REST clients. Monitor(ctx context.Context, in *MonitorRequest, opts ...grpc.CallOption) (SwapClient_MonitorClient, error) + //* + //ListSwaps returns a list of all currently known swaps and their current + //status. + ListSwaps(ctx context.Context, in *ListSwapsRequest, opts ...grpc.CallOption) (*ListSwapsResponse, error) + //* + //SwapInfo returns all known details about a single swap. + SwapInfo(ctx context.Context, in *SwapInfoRequest, opts ...grpc.CallOption) (*SwapStatus, error) //* loop: `terms` //LoopOutTerms returns the terms that the server enforces for a loop out swap. LoopOutTerms(ctx context.Context, in *TermsRequest, opts ...grpc.CallOption) (*TermsResponse, error) @@ -1211,6 +1340,24 @@ func (x *swapClientMonitorClient) Recv() (*SwapStatus, error) { return m, nil } +func (c *swapClientClient) ListSwaps(ctx context.Context, in *ListSwapsRequest, opts ...grpc.CallOption) (*ListSwapsResponse, error) { + out := new(ListSwapsResponse) + err := c.cc.Invoke(ctx, "/looprpc.SwapClient/ListSwaps", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *swapClientClient) SwapInfo(ctx context.Context, in *SwapInfoRequest, opts ...grpc.CallOption) (*SwapStatus, error) { + out := new(SwapStatus) + err := c.cc.Invoke(ctx, "/looprpc.SwapClient/SwapInfo", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *swapClientClient) LoopOutTerms(ctx context.Context, in *TermsRequest, opts ...grpc.CallOption) (*TermsResponse, error) { out := new(TermsResponse) err := c.cc.Invoke(ctx, "/looprpc.SwapClient/LoopOutTerms", in, out, opts...) @@ -1272,8 +1419,14 @@ type SwapClientServer interface { LoopIn(context.Context, *LoopInRequest) (*SwapResponse, error) //* loop: `monitor` //Monitor will return a stream of swap updates for currently active swaps. - //TODO: add MonitorSync version for REST clients. Monitor(*MonitorRequest, SwapClient_MonitorServer) error + //* + //ListSwaps returns a list of all currently known swaps and their current + //status. + ListSwaps(context.Context, *ListSwapsRequest) (*ListSwapsResponse, error) + //* + //SwapInfo returns all known details about a single swap. + SwapInfo(context.Context, *SwapInfoRequest) (*SwapStatus, error) //* loop: `terms` //LoopOutTerms returns the terms that the server enforces for a loop out swap. LoopOutTerms(context.Context, *TermsRequest) (*TermsResponse, error) @@ -1353,6 +1506,42 @@ func (x *swapClientMonitorServer) Send(m *SwapStatus) error { return x.ServerStream.SendMsg(m) } +func _SwapClient_ListSwaps_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ListSwapsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SwapClientServer).ListSwaps(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/looprpc.SwapClient/ListSwaps", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SwapClientServer).ListSwaps(ctx, req.(*ListSwapsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _SwapClient_SwapInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SwapInfoRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SwapClientServer).SwapInfo(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/looprpc.SwapClient/SwapInfo", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SwapClientServer).SwapInfo(ctx, req.(*SwapInfoRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _SwapClient_LoopOutTerms_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(TermsRequest) if err := dec(in); err != nil { @@ -1455,6 +1644,14 @@ var _SwapClient_serviceDesc = grpc.ServiceDesc{ MethodName: "LoopIn", Handler: _SwapClient_LoopIn_Handler, }, + { + MethodName: "ListSwaps", + Handler: _SwapClient_ListSwaps_Handler, + }, + { + MethodName: "SwapInfo", + Handler: _SwapClient_SwapInfo_Handler, + }, { MethodName: "LoopOutTerms", Handler: _SwapClient_LoopOutTerms_Handler, diff --git a/looprpc/client.pb.gw.go b/looprpc/client.pb.gw.go index 575b768..05bd907 100644 --- a/looprpc/client.pb.gw.go +++ b/looprpc/client.pb.gw.go @@ -62,6 +62,59 @@ func request_SwapClient_LoopIn_0(ctx context.Context, marshaler runtime.Marshale } +func request_SwapClient_Monitor_0(ctx context.Context, marshaler runtime.Marshaler, client SwapClientClient, req *http.Request, pathParams map[string]string) (SwapClient_MonitorClient, runtime.ServerMetadata, error) { + var protoReq MonitorRequest + var metadata runtime.ServerMetadata + + stream, err := client.Monitor(ctx, &protoReq) + if err != nil { + return nil, metadata, err + } + header, err := stream.Header() + if err != nil { + return nil, metadata, err + } + metadata.HeaderMD = header + return stream, metadata, nil + +} + +func request_SwapClient_ListSwaps_0(ctx context.Context, marshaler runtime.Marshaler, client SwapClientClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq ListSwapsRequest + var metadata runtime.ServerMetadata + + msg, err := client.ListSwaps(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func request_SwapClient_SwapInfo_0(ctx context.Context, marshaler runtime.Marshaler, client SwapClientClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq SwapInfoRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["id"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id") + } + + protoReq.Id, err = runtime.Bytes(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err) + } + + msg, err := client.SwapInfo(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + func request_SwapClient_LoopOutTerms_0(ctx context.Context, marshaler runtime.Marshaler, client SwapClientClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq TermsRequest var metadata runtime.ServerMetadata @@ -237,6 +290,66 @@ func RegisterSwapClientHandlerClient(ctx context.Context, mux *runtime.ServeMux, }) + mux.Handle("GET", pattern_SwapClient_Monitor_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_SwapClient_Monitor_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_SwapClient_Monitor_0(ctx, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_SwapClient_ListSwaps_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_SwapClient_ListSwaps_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_SwapClient_ListSwaps_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_SwapClient_SwapInfo_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_SwapClient_SwapInfo_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_SwapClient_SwapInfo_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + mux.Handle("GET", pattern_SwapClient_LoopOutTerms_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() @@ -345,6 +458,12 @@ var ( pattern_SwapClient_LoopIn_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "loop", "in"}, "")) + pattern_SwapClient_Monitor_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "loop", "monitor"}, "")) + + pattern_SwapClient_ListSwaps_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "loop", "swaps"}, "")) + + pattern_SwapClient_SwapInfo_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"v1", "loop", "swap", "id"}, "")) + pattern_SwapClient_LoopOutTerms_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "loop", "out", "terms"}, "")) pattern_SwapClient_LoopOutQuote_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"v1", "loop", "out", "quote", "amt"}, "")) @@ -361,6 +480,12 @@ var ( forward_SwapClient_LoopIn_0 = runtime.ForwardResponseMessage + forward_SwapClient_Monitor_0 = runtime.ForwardResponseStream + + forward_SwapClient_ListSwaps_0 = runtime.ForwardResponseMessage + + forward_SwapClient_SwapInfo_0 = runtime.ForwardResponseMessage + forward_SwapClient_LoopOutTerms_0 = runtime.ForwardResponseMessage forward_SwapClient_LoopOutQuote_0 = runtime.ForwardResponseMessage diff --git a/looprpc/client.proto b/looprpc/client.proto index e9b7a68..23d2d91 100644 --- a/looprpc/client.proto +++ b/looprpc/client.proto @@ -37,9 +37,31 @@ service SwapClient { /** loop: `monitor` Monitor will return a stream of swap updates for currently active swaps. - TODO: add MonitorSync version for REST clients. */ - rpc Monitor (MonitorRequest) returns (stream SwapStatus); + rpc Monitor (MonitorRequest) returns (stream SwapStatus) { + option (google.api.http) = { + get: "/v1/loop/monitor" + }; + } + + /** + ListSwaps returns a list of all currently known swaps and their current + status. + */ + rpc ListSwaps (ListSwapsRequest) returns (ListSwapsResponse) { + option (google.api.http) = { + get: "/v1/loop/swaps" + }; + } + + /** + SwapInfo returns all known details about a single swap. + */ + rpc SwapInfo (SwapInfoRequest) returns (SwapStatus) { + option (google.api.http) = { + get: "/v1/loop/swap/{id}" + }; + } /** loop: `terms` LoopOutTerms returns the terms that the server enforces for a loop out swap. @@ -319,6 +341,24 @@ enum SwapState { INVOICE_SETTLED = 5; } +message ListSwapsRequest { +} + +message ListSwapsResponse { + /** + The list of all currently known swaps and their status. + */ + repeated SwapStatus swaps = 1; +} + +message SwapInfoRequest { + /** + The swap identifier which currently is the hash that locks the HTLCs. When + using REST, this field must be encoded as base64. + */ + bytes id = 1; +} + message TermsRequest { } @@ -442,7 +482,7 @@ message LsatToken { Indicates whether the token is expired or still valid. */ bool expired = 7; - + /** Identifying attribute of this token in the store. Currently represents the file name of the token where it's stored on the file system. diff --git a/looprpc/client.swagger.json b/looprpc/client.swagger.json index 0acdb39..ab6cdc1 100644 --- a/looprpc/client.swagger.json +++ b/looprpc/client.swagger.json @@ -110,6 +110,23 @@ ] } }, + "/v1/loop/monitor": { + "get": { + "summary": "* loop: `monitor`\nMonitor will return a stream of swap updates for currently active swaps.", + "operationId": "Monitor", + "responses": { + "200": { + "description": "A successful response.(streaming responses)", + "schema": { + "$ref": "#/x-stream-definitions/looprpcSwapStatus" + } + } + }, + "tags": [ + "SwapClient" + ] + } + }, "/v1/loop/out": { "post": { "summary": "* loop: `out`\nLoopOut initiates an loop out swap with the given parameters. The call\nreturns after the swap has been set up with the swap server. From that\npoint onwards, progress can be tracked via the SwapStatus stream that is\nreturned from Monitor().", @@ -205,6 +222,50 @@ ] } }, + "/v1/loop/swap/{id}": { + "get": { + "summary": "*\nSwapInfo returns all known details about a single swap.", + "operationId": "SwapInfo", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/looprpcSwapStatus" + } + } + }, + "parameters": [ + { + "name": "id", + "description": "*\nThe swap identifier which currently is the hash that locks the HTLCs. When\nusing REST, this field must be encoded as base64.", + "in": "path", + "required": true, + "type": "string", + "format": "byte" + } + ], + "tags": [ + "SwapClient" + ] + } + }, + "/v1/loop/swaps": { + "get": { + "summary": "*\nListSwaps returns a list of all currently known swaps and their current\nstatus.", + "operationId": "ListSwaps", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/looprpcListSwapsResponse" + } + } + }, + "tags": [ + "SwapClient" + ] + } + }, "/v1/lsat/tokens": { "get": { "summary": "*\nGetLsatTokens returns all LSAT tokens the daemon ever paid for.", @@ -224,6 +285,18 @@ } }, "definitions": { + "looprpcListSwapsResponse": { + "type": "object", + "properties": { + "swaps": { + "type": "array", + "items": { + "$ref": "#/definitions/looprpcSwapStatus" + }, + "description": "*\nThe list of all currently known swaps and their status." + } + } + }, "looprpcLoopInRequest": { "type": "object", "properties": {