From e299dc696c31cf5e37ef551e0ef87ca0c983fe49 Mon Sep 17 00:00:00 2001 From: Olaoluwa Osuntokun Date: Wed, 6 Mar 2019 18:24:29 -0800 Subject: [PATCH] looprpc: rename service actions from uncharge to loop out In this commit, we rename all the service actions from uncharge, to loop out instead. We do this in order to be line with the new naming scheme for the service. --- looprpc/client.pb.go | 285 +++++++++++++++++++++--------------------- looprpc/client.proto | 134 ++++++++++---------- looprpc/server.pb.go | 288 +++++++++++++++++++++---------------------- looprpc/server.proto | 24 ++-- 4 files changed, 367 insertions(+), 364 deletions(-) diff --git a/looprpc/client.pb.go b/looprpc/client.pb.go index c8b1347..c14c261 100644 --- a/looprpc/client.pb.go +++ b/looprpc/client.pb.go @@ -26,22 +26,22 @@ const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package type SwapType int32 const ( - // UNCHARGE indicates an uncharge swap (off-chain to on-chain) - SwapType_UNCHARGE SwapType = 0 + // LOOP_OUT indicates an loop out swap (off-chain to on-chain) + SwapType_LOOP_OUT SwapType = 0 ) var SwapType_name = map[int32]string{ - 0: "UNCHARGE", + 0: "LOOP_OUT", } var SwapType_value = map[string]int32{ - "UNCHARGE": 0, + "LOOP_OUT": 0, } func (x SwapType) String() string { return proto.EnumName(SwapType_name, int32(x)) } func (SwapType) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_client_55d0482164e13e67, []int{0} + return fileDescriptor_client_e8e8b003a83cbb2b, []int{0} } type SwapState int32 @@ -86,13 +86,12 @@ func (x SwapState) String() string { return proto.EnumName(SwapState_name, int32(x)) } func (SwapState) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_client_55d0482164e13e67, []int{1} + return fileDescriptor_client_e8e8b003a83cbb2b, []int{1} } -type UnchargeRequest struct { +type LoopOutRequest struct { // * - // Requested swap amount in sat. This does not include the swap and miner - // fee. + // Requested swap amount in sat. This does not include the swap and miner fee. Amt int64 `protobuf:"varint,1,opt,name=amt,proto3" json:"amt,omitempty"` // * // Base58 encoded destination address for the swap. @@ -122,101 +121,101 @@ type UnchargeRequest struct { // value, we cancel the swap. If the fee estimate is lower, we publish the // sweep tx. // - // If the sweep tx isn't confirmed, we are forced to ratchet up fees until - // it is swept. Possibly even exceeding max_miner_fee if we get close to the - // htlc timeout. Because the initial publication revealed the preimage, we - // have no other choice. The server may already have pulled the off-chain - // htlc. Only when the fee becomes higher than the swap amount, we can only - // wait for fees to come down and hope - if we are past the timeout - that - // the server isn't publishing the revocation. + // If the sweep tx is not confirmed, we are forced to ratchet up fees until it + // is swept. Possibly even exceeding max_miner_fee if we get close to the htlc + // timeout. Because the initial publication revealed the preimage, we have no + // other choice. The server may already have pulled the off-chain htlc. Only + // when the fee becomes higher than the swap amount, we can only wait for fees + // to come down and hope - if we are past the timeout - that the server is not + // publishing the revocation. // // max_miner_fee is typically taken from the response of the GetQuote call. MaxMinerFee int64 `protobuf:"varint,7,opt,name=max_miner_fee,json=maxMinerFee,proto3" json:"max_miner_fee,omitempty"` // * - // The channel to uncharge. If zero, the channel to uncharge is selected based - // on the lowest routing fee for the swap payment to the server. - UnchargeChannel uint64 `protobuf:"varint,8,opt,name=uncharge_channel,json=unchargeChannel,proto3" json:"uncharge_channel,omitempty"` + // The channel to loop out, the channel to loop out is selected based on the + // lowest routing fee for the swap payment to the server. + LoopOutChannel uint64 `protobuf:"varint,8,opt,name=loop_out_channel,json=loopOutChannel,proto3" json:"loop_out_channel,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } -func (m *UnchargeRequest) Reset() { *m = UnchargeRequest{} } -func (m *UnchargeRequest) String() string { return proto.CompactTextString(m) } -func (*UnchargeRequest) ProtoMessage() {} -func (*UnchargeRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_client_55d0482164e13e67, []int{0} +func (m *LoopOutRequest) Reset() { *m = LoopOutRequest{} } +func (m *LoopOutRequest) String() string { return proto.CompactTextString(m) } +func (*LoopOutRequest) ProtoMessage() {} +func (*LoopOutRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_client_e8e8b003a83cbb2b, []int{0} } -func (m *UnchargeRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_UnchargeRequest.Unmarshal(m, b) +func (m *LoopOutRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_LoopOutRequest.Unmarshal(m, b) } -func (m *UnchargeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_UnchargeRequest.Marshal(b, m, deterministic) +func (m *LoopOutRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_LoopOutRequest.Marshal(b, m, deterministic) } -func (dst *UnchargeRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_UnchargeRequest.Merge(dst, src) +func (dst *LoopOutRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_LoopOutRequest.Merge(dst, src) } -func (m *UnchargeRequest) XXX_Size() int { - return xxx_messageInfo_UnchargeRequest.Size(m) +func (m *LoopOutRequest) XXX_Size() int { + return xxx_messageInfo_LoopOutRequest.Size(m) } -func (m *UnchargeRequest) XXX_DiscardUnknown() { - xxx_messageInfo_UnchargeRequest.DiscardUnknown(m) +func (m *LoopOutRequest) XXX_DiscardUnknown() { + xxx_messageInfo_LoopOutRequest.DiscardUnknown(m) } -var xxx_messageInfo_UnchargeRequest proto.InternalMessageInfo +var xxx_messageInfo_LoopOutRequest proto.InternalMessageInfo -func (m *UnchargeRequest) GetAmt() int64 { +func (m *LoopOutRequest) GetAmt() int64 { if m != nil { return m.Amt } return 0 } -func (m *UnchargeRequest) GetDest() string { +func (m *LoopOutRequest) GetDest() string { if m != nil { return m.Dest } return "" } -func (m *UnchargeRequest) GetMaxSwapRoutingFee() int64 { +func (m *LoopOutRequest) GetMaxSwapRoutingFee() int64 { if m != nil { return m.MaxSwapRoutingFee } return 0 } -func (m *UnchargeRequest) GetMaxPrepayRoutingFee() int64 { +func (m *LoopOutRequest) GetMaxPrepayRoutingFee() int64 { if m != nil { return m.MaxPrepayRoutingFee } return 0 } -func (m *UnchargeRequest) GetMaxSwapFee() int64 { +func (m *LoopOutRequest) GetMaxSwapFee() int64 { if m != nil { return m.MaxSwapFee } return 0 } -func (m *UnchargeRequest) GetMaxPrepayAmt() int64 { +func (m *LoopOutRequest) GetMaxPrepayAmt() int64 { if m != nil { return m.MaxPrepayAmt } return 0 } -func (m *UnchargeRequest) GetMaxMinerFee() int64 { +func (m *LoopOutRequest) GetMaxMinerFee() int64 { if m != nil { return m.MaxMinerFee } return 0 } -func (m *UnchargeRequest) GetUnchargeChannel() uint64 { +func (m *LoopOutRequest) GetLoopOutChannel() uint64 { if m != nil { - return m.UnchargeChannel + return m.LoopOutChannel } return 0 } @@ -235,7 +234,7 @@ func (m *SwapResponse) Reset() { *m = SwapResponse{} } func (m *SwapResponse) String() string { return proto.CompactTextString(m) } func (*SwapResponse) ProtoMessage() {} func (*SwapResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_client_55d0482164e13e67, []int{1} + return fileDescriptor_client_e8e8b003a83cbb2b, []int{1} } func (m *SwapResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_SwapResponse.Unmarshal(m, b) @@ -272,7 +271,7 @@ func (m *MonitorRequest) Reset() { *m = MonitorRequest{} } func (m *MonitorRequest) String() string { return proto.CompactTextString(m) } func (*MonitorRequest) ProtoMessage() {} func (*MonitorRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_client_55d0482164e13e67, []int{2} + return fileDescriptor_client_e8e8b003a83cbb2b, []int{2} } func (m *MonitorRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_MonitorRequest.Unmarshal(m, b) @@ -325,7 +324,7 @@ func (m *SwapStatus) Reset() { *m = SwapStatus{} } func (m *SwapStatus) String() string { return proto.CompactTextString(m) } func (*SwapStatus) ProtoMessage() {} func (*SwapStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_client_55d0482164e13e67, []int{3} + return fileDescriptor_client_e8e8b003a83cbb2b, []int{3} } func (m *SwapStatus) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_SwapStatus.Unmarshal(m, b) @@ -363,7 +362,7 @@ func (m *SwapStatus) GetType() SwapType { if m != nil { return m.Type } - return SwapType_UNCHARGE + return SwapType_LOOP_OUT } func (m *SwapStatus) GetState() SwapState { @@ -404,7 +403,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_client_55d0482164e13e67, []int{4} + return fileDescriptor_client_e8e8b003a83cbb2b, []int{4} } func (m *TermsRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_TermsRequest.Unmarshal(m, b) @@ -459,7 +458,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_client_55d0482164e13e67, []int{5} + return fileDescriptor_client_e8e8b003a83cbb2b, []int{5} } func (m *TermsResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_TermsResponse.Unmarshal(m, b) @@ -548,7 +547,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_client_55d0482164e13e67, []int{6} + return fileDescriptor_client_e8e8b003a83cbb2b, []int{6} } func (m *QuoteRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_QuoteRequest.Unmarshal(m, b) @@ -596,7 +595,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_client_55d0482164e13e67, []int{7} + return fileDescriptor_client_e8e8b003a83cbb2b, []int{7} } func (m *QuoteResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_QuoteResponse.Unmarshal(m, b) @@ -638,7 +637,7 @@ func (m *QuoteResponse) GetMinerFee() int64 { } func init() { - proto.RegisterType((*UnchargeRequest)(nil), "looprpc.UnchargeRequest") + proto.RegisterType((*LoopOutRequest)(nil), "looprpc.LoopOutRequest") proto.RegisterType((*SwapResponse)(nil), "looprpc.SwapResponse") proto.RegisterType((*MonitorRequest)(nil), "looprpc.MonitorRequest") proto.RegisterType((*SwapStatus)(nil), "looprpc.SwapStatus") @@ -663,20 +662,20 @@ const _ = grpc.SupportPackageIsVersion4 // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. type SwapClientClient interface { // * - // Uncharge initiates an uncharge swap with the given parameters. The call + // LoopOut initiates an loop out swap with the given parameters. The call // returns after the swap has been set up with the swap server. From that - // point onwards, progress can be tracked via the SwapStatus stream - // that is returned from Monitor(). - Uncharge(ctx context.Context, in *UnchargeRequest, opts ...grpc.CallOption) (*SwapResponse, error) + // point onwards, progress can be tracked via the SwapStatus stream that is + // returned from Monitor(). + LoopOut(ctx context.Context, in *LoopOutRequest, opts ...grpc.CallOption) (*SwapResponse, error) // * // Monitor will return a stream of swap updates for currently active swaps. Monitor(ctx context.Context, in *MonitorRequest, opts ...grpc.CallOption) (SwapClient_MonitorClient, error) // * - // GetTerms returns the terms that the server enforces for swaps. - GetUnchargeTerms(ctx context.Context, in *TermsRequest, opts ...grpc.CallOption) (*TermsResponse, error) + // GetLoopOutTerms returns the terms that the server enforces for swaps. + GetLoopOutTerms(ctx context.Context, in *TermsRequest, opts ...grpc.CallOption) (*TermsResponse, error) // * - // GetQuote returns a quote for a swap with the provided parameters. - GetUnchargeQuote(ctx context.Context, in *QuoteRequest, opts ...grpc.CallOption) (*QuoteResponse, error) + // GetLoopOutQuote returns a quote for a swap with the provided parameters. + GetLoopOutQuote(ctx context.Context, in *QuoteRequest, opts ...grpc.CallOption) (*QuoteResponse, error) } type swapClientClient struct { @@ -687,9 +686,9 @@ func NewSwapClientClient(cc *grpc.ClientConn) SwapClientClient { return &swapClientClient{cc} } -func (c *swapClientClient) Uncharge(ctx context.Context, in *UnchargeRequest, opts ...grpc.CallOption) (*SwapResponse, error) { +func (c *swapClientClient) LoopOut(ctx context.Context, in *LoopOutRequest, opts ...grpc.CallOption) (*SwapResponse, error) { out := new(SwapResponse) - err := c.cc.Invoke(ctx, "/looprpc.SwapClient/Uncharge", in, out, opts...) + err := c.cc.Invoke(ctx, "/looprpc.SwapClient/LoopOut", in, out, opts...) if err != nil { return nil, err } @@ -728,18 +727,18 @@ func (x *swapClientMonitorClient) Recv() (*SwapStatus, error) { return m, nil } -func (c *swapClientClient) GetUnchargeTerms(ctx context.Context, in *TermsRequest, opts ...grpc.CallOption) (*TermsResponse, error) { +func (c *swapClientClient) GetLoopOutTerms(ctx context.Context, in *TermsRequest, opts ...grpc.CallOption) (*TermsResponse, error) { out := new(TermsResponse) - err := c.cc.Invoke(ctx, "/looprpc.SwapClient/GetUnchargeTerms", in, out, opts...) + err := c.cc.Invoke(ctx, "/looprpc.SwapClient/GetLoopOutTerms", in, out, opts...) if err != nil { return nil, err } return out, nil } -func (c *swapClientClient) GetUnchargeQuote(ctx context.Context, in *QuoteRequest, opts ...grpc.CallOption) (*QuoteResponse, error) { +func (c *swapClientClient) GetLoopOutQuote(ctx context.Context, in *QuoteRequest, opts ...grpc.CallOption) (*QuoteResponse, error) { out := new(QuoteResponse) - err := c.cc.Invoke(ctx, "/looprpc.SwapClient/GetUnchargeQuote", in, out, opts...) + err := c.cc.Invoke(ctx, "/looprpc.SwapClient/GetLoopOutQuote", in, out, opts...) if err != nil { return nil, err } @@ -749,40 +748,40 @@ func (c *swapClientClient) GetUnchargeQuote(ctx context.Context, in *QuoteReques // SwapClientServer is the server API for SwapClient service. type SwapClientServer interface { // * - // Uncharge initiates an uncharge swap with the given parameters. The call + // LoopOut initiates an loop out swap with the given parameters. The call // returns after the swap has been set up with the swap server. From that - // point onwards, progress can be tracked via the SwapStatus stream - // that is returned from Monitor(). - Uncharge(context.Context, *UnchargeRequest) (*SwapResponse, error) + // point onwards, progress can be tracked via the SwapStatus stream that is + // returned from Monitor(). + LoopOut(context.Context, *LoopOutRequest) (*SwapResponse, error) // * // Monitor will return a stream of swap updates for currently active swaps. Monitor(*MonitorRequest, SwapClient_MonitorServer) error // * - // GetTerms returns the terms that the server enforces for swaps. - GetUnchargeTerms(context.Context, *TermsRequest) (*TermsResponse, error) + // GetLoopOutTerms returns the terms that the server enforces for swaps. + GetLoopOutTerms(context.Context, *TermsRequest) (*TermsResponse, error) // * - // GetQuote returns a quote for a swap with the provided parameters. - GetUnchargeQuote(context.Context, *QuoteRequest) (*QuoteResponse, error) + // GetLoopOutQuote returns a quote for a swap with the provided parameters. + GetLoopOutQuote(context.Context, *QuoteRequest) (*QuoteResponse, error) } func RegisterSwapClientServer(s *grpc.Server, srv SwapClientServer) { s.RegisterService(&_SwapClient_serviceDesc, srv) } -func _SwapClient_Uncharge_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(UnchargeRequest) +func _SwapClient_LoopOut_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(LoopOutRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { - return srv.(SwapClientServer).Uncharge(ctx, in) + return srv.(SwapClientServer).LoopOut(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/looprpc.SwapClient/Uncharge", + FullMethod: "/looprpc.SwapClient/LoopOut", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(SwapClientServer).Uncharge(ctx, req.(*UnchargeRequest)) + return srv.(SwapClientServer).LoopOut(ctx, req.(*LoopOutRequest)) } return interceptor(ctx, in, info, handler) } @@ -808,38 +807,38 @@ func (x *swapClientMonitorServer) Send(m *SwapStatus) error { return x.ServerStream.SendMsg(m) } -func _SwapClient_GetUnchargeTerms_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { +func _SwapClient_GetLoopOutTerms_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(TermsRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { - return srv.(SwapClientServer).GetUnchargeTerms(ctx, in) + return srv.(SwapClientServer).GetLoopOutTerms(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/looprpc.SwapClient/GetUnchargeTerms", + FullMethod: "/looprpc.SwapClient/GetLoopOutTerms", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(SwapClientServer).GetUnchargeTerms(ctx, req.(*TermsRequest)) + return srv.(SwapClientServer).GetLoopOutTerms(ctx, req.(*TermsRequest)) } return interceptor(ctx, in, info, handler) } -func _SwapClient_GetUnchargeQuote_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { +func _SwapClient_GetLoopOutQuote_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(QuoteRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { - return srv.(SwapClientServer).GetUnchargeQuote(ctx, in) + return srv.(SwapClientServer).GetLoopOutQuote(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/looprpc.SwapClient/GetUnchargeQuote", + FullMethod: "/looprpc.SwapClient/GetLoopOutQuote", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(SwapClientServer).GetUnchargeQuote(ctx, req.(*QuoteRequest)) + return srv.(SwapClientServer).GetLoopOutQuote(ctx, req.(*QuoteRequest)) } return interceptor(ctx, in, info, handler) } @@ -849,16 +848,16 @@ var _SwapClient_serviceDesc = grpc.ServiceDesc{ HandlerType: (*SwapClientServer)(nil), Methods: []grpc.MethodDesc{ { - MethodName: "Uncharge", - Handler: _SwapClient_Uncharge_Handler, + MethodName: "LoopOut", + Handler: _SwapClient_LoopOut_Handler, }, { - MethodName: "GetUnchargeTerms", - Handler: _SwapClient_GetUnchargeTerms_Handler, + MethodName: "GetLoopOutTerms", + Handler: _SwapClient_GetLoopOutTerms_Handler, }, { - MethodName: "GetUnchargeQuote", - Handler: _SwapClient_GetUnchargeQuote_Handler, + MethodName: "GetLoopOutQuote", + Handler: _SwapClient_GetLoopOutQuote_Handler, }, }, Streams: []grpc.StreamDesc{ @@ -871,55 +870,55 @@ var _SwapClient_serviceDesc = grpc.ServiceDesc{ Metadata: "client.proto", } -func init() { proto.RegisterFile("client.proto", fileDescriptor_client_55d0482164e13e67) } +func init() { proto.RegisterFile("client.proto", fileDescriptor_client_e8e8b003a83cbb2b) } -var fileDescriptor_client_55d0482164e13e67 = []byte{ +var fileDescriptor_client_e8e8b003a83cbb2b = []byte{ // 749 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x54, 0x4d, 0x6f, 0xeb, 0x44, - 0x14, 0x7d, 0x71, 0x3e, 0x7d, 0xe3, 0x38, 0xce, 0x3c, 0xde, 0x23, 0xaf, 0xa8, 0x28, 0x58, 0x7c, - 0x84, 0x2e, 0x0a, 0x6a, 0x57, 0x88, 0x95, 0x49, 0xdc, 0x12, 0x44, 0xab, 0x32, 0x49, 0xd8, 0x5a, - 0xd3, 0x64, 0xda, 0x5a, 0xf2, 0xd8, 0xc6, 0x1e, 0xb7, 0xc9, 0x5f, 0xe0, 0xb7, 0xb0, 0xe4, 0xaf, - 0xb1, 0x47, 0xf3, 0x61, 0x37, 0x0e, 0xbc, 0x9d, 0x75, 0xe6, 0xdc, 0x73, 0x3d, 0xe7, 0x9e, 0x3b, - 0x60, 0x6d, 0xa2, 0x90, 0xc6, 0xfc, 0x3c, 0xcd, 0x12, 0x9e, 0xa0, 0x6e, 0x94, 0x24, 0x69, 0x96, - 0x6e, 0xdc, 0xbf, 0x0d, 0x18, 0xae, 0xe3, 0xcd, 0x13, 0xc9, 0x1e, 0x29, 0xa6, 0x7f, 0x14, 0x34, - 0xe7, 0xc8, 0x81, 0x26, 0x61, 0x7c, 0xdc, 0x98, 0x34, 0xa6, 0x4d, 0x2c, 0x3e, 0x11, 0x82, 0xd6, - 0x96, 0xe6, 0x7c, 0x6c, 0x4c, 0x1a, 0x53, 0x13, 0xcb, 0x6f, 0xf4, 0x1d, 0x7c, 0xc2, 0xc8, 0x2e, - 0xc8, 0x5f, 0x48, 0x1a, 0x64, 0x49, 0xc1, 0xc3, 0xf8, 0x31, 0x78, 0xa0, 0x74, 0xdc, 0x94, 0x65, - 0x23, 0x46, 0x76, 0xcb, 0x17, 0x92, 0x62, 0x75, 0x72, 0x45, 0x29, 0xba, 0x84, 0xf7, 0xa2, 0x20, - 0xcd, 0x68, 0x4a, 0xf6, 0xb5, 0x92, 0x96, 0x2c, 0x79, 0xcb, 0xc8, 0xee, 0x4e, 0x1e, 0x1e, 0x14, - 0x4d, 0xc0, 0xaa, 0xba, 0x08, 0x6a, 0x5b, 0x52, 0x41, 0xab, 0x0b, 0xc6, 0x97, 0x60, 0x1f, 0xc8, - 0x8a, 0x1f, 0xef, 0x48, 0x8e, 0x55, 0xc9, 0x79, 0x8c, 0x23, 0x17, 0x06, 0x82, 0xc5, 0xc2, 0x98, - 0x66, 0x52, 0xa8, 0x2b, 0x49, 0x7d, 0x46, 0x76, 0x37, 0x02, 0x13, 0x4a, 0xdf, 0x82, 0x53, 0x68, - 0x2b, 0x82, 0xcd, 0x13, 0x89, 0x63, 0x1a, 0x8d, 0x7b, 0x93, 0xc6, 0xb4, 0x85, 0x87, 0x25, 0x3e, - 0x53, 0xb0, 0xfb, 0x39, 0x58, 0xf2, 0x76, 0x34, 0x4f, 0x93, 0x38, 0xa7, 0xc8, 0x06, 0x23, 0xdc, - 0x4a, 0xc7, 0x4c, 0x6c, 0x84, 0x5b, 0xd7, 0x01, 0xfb, 0x26, 0x89, 0x43, 0x9e, 0x64, 0xda, 0x54, - 0xf7, 0x9f, 0x06, 0x80, 0x28, 0x59, 0x72, 0xc2, 0x8b, 0xfc, 0x7f, 0x3c, 0x56, 0x12, 0x46, 0x29, - 0x81, 0xbe, 0x82, 0x16, 0xdf, 0xa7, 0xca, 0x4f, 0xfb, 0x62, 0x74, 0xae, 0x27, 0x76, 0x2e, 0x44, - 0x56, 0xfb, 0x94, 0x62, 0x79, 0x8c, 0xa6, 0xd0, 0xce, 0x39, 0xe1, 0xca, 0x44, 0xfb, 0x02, 0xd5, - 0x78, 0xa2, 0x19, 0xc5, 0x8a, 0x80, 0xbe, 0x81, 0x61, 0x18, 0x87, 0x3c, 0x24, 0x3c, 0x4c, 0xe2, - 0x80, 0x87, 0xac, 0x74, 0xd3, 0x7e, 0x85, 0x57, 0x21, 0x13, 0x92, 0x4e, 0x44, 0x72, 0x1e, 0x14, - 0xe9, 0x96, 0x70, 0xaa, 0x98, 0xca, 0x53, 0x5b, 0xe0, 0x6b, 0x09, 0x4b, 0xe6, 0x17, 0x60, 0x3d, - 0xf1, 0x68, 0x13, 0x90, 0xed, 0x36, 0xa3, 0x79, 0x2e, 0x4d, 0x35, 0x71, 0x5f, 0x60, 0x9e, 0x82, - 0x5c, 0x1b, 0xac, 0x15, 0xcd, 0x58, 0x5e, 0xfa, 0xf0, 0x97, 0x01, 0x03, 0x0d, 0x68, 0xef, 0xce, - 0x60, 0x24, 0xc7, 0x9b, 0x92, 0x3d, 0xa3, 0x31, 0x0f, 0x64, 0xd2, 0x94, 0x95, 0x43, 0x71, 0x70, - 0xa7, 0xf0, 0xb9, 0x08, 0x9d, 0x0b, 0x83, 0x32, 0x0a, 0xc1, 0x3d, 0xc9, 0xa9, 0xf4, 0xab, 0x89, - 0xfb, 0xb9, 0x0a, 0xc3, 0x4f, 0x24, 0xa7, 0x35, 0x4e, 0x26, 0x9c, 0x69, 0xd6, 0x38, 0x58, 0x78, - 0x71, 0x0a, 0x70, 0x10, 0x18, 0x95, 0x3f, 0x33, 0xad, 0xd2, 0xf2, 0x35, 0x0c, 0x59, 0x18, 0xab, - 0xd4, 0x11, 0x96, 0x14, 0x31, 0xd7, 0x56, 0x0d, 0x58, 0x18, 0x0b, 0x63, 0x3d, 0x09, 0x4a, 0x5e, - 0x99, 0x4e, 0xcd, 0xeb, 0x68, 0x9e, 0x0a, 0xa8, 0xe6, 0x9d, 0x02, 0x6c, 0x22, 0xfe, 0x1c, 0x6c, - 0x69, 0xc4, 0x89, 0x74, 0xa9, 0x8d, 0x4d, 0x81, 0xcc, 0x05, 0x80, 0x3e, 0x40, 0x4f, 0xc8, 0x08, - 0x40, 0x06, 0xae, 0x8d, 0xbb, 0x8c, 0xec, 0x66, 0x11, 0x7f, 0x76, 0x27, 0x60, 0xfd, 0x56, 0x24, - 0xfc, 0xe3, 0xbb, 0xe9, 0x3e, 0xc0, 0x40, 0x33, 0xb4, 0x9f, 0x1f, 0xa0, 0x57, 0xad, 0x8b, 0xe2, - 0x75, 0xf5, 0xd5, 0x8f, 0xae, 0x6d, 0x1c, 0x5f, 0xfb, 0x33, 0x30, 0x5f, 0x17, 0x44, 0xb9, 0xd6, - 0x63, 0x7a, 0x3b, 0xce, 0xc6, 0xd0, 0x2b, 0xa3, 0x87, 0x2c, 0xe8, 0xad, 0x6f, 0x67, 0x3f, 0x7b, - 0xf8, 0xda, 0x77, 0xde, 0x9c, 0xfd, 0x02, 0x66, 0x15, 0x36, 0x34, 0x00, 0x73, 0x71, 0xbb, 0x58, - 0x2d, 0xbc, 0x95, 0x3f, 0x77, 0xde, 0xa0, 0x77, 0x30, 0xba, 0xc3, 0xfe, 0xe2, 0xc6, 0xbb, 0xf6, - 0x03, 0xec, 0xff, 0xee, 0x7b, 0xbf, 0xfa, 0x73, 0xa7, 0x81, 0xfa, 0xd0, 0x5d, 0xae, 0x67, 0x33, - 0x7f, 0xb9, 0x74, 0x9a, 0x08, 0xa0, 0x73, 0xe5, 0x2d, 0xc4, 0x41, 0xeb, 0xe2, 0x4f, 0x43, 0xad, - 0xc9, 0x4c, 0xbe, 0x56, 0xe8, 0x47, 0xe8, 0x95, 0xaf, 0x13, 0x1a, 0x57, 0xd1, 0x3e, 0x7a, 0xb0, - 0x4e, 0xde, 0xd5, 0x42, 0x5f, 0x19, 0xf1, 0x03, 0x74, 0xf5, 0x12, 0xa2, 0x4f, 0x2b, 0x46, 0x7d, - 0x2d, 0x4f, 0xde, 0xfe, 0x67, 0x5f, 0x8a, 0xfc, 0xfb, 0x06, 0xf2, 0xc0, 0xb9, 0xa6, 0xbc, 0xec, - 0x23, 0xf3, 0x8a, 0x5e, 0xbb, 0x1c, 0x06, 0xfa, 0xe4, 0xfd, 0x31, 0xac, 0xbb, 0xd7, 0x25, 0xe4, - 0x88, 0x0e, 0x24, 0x0e, 0x87, 0x7a, 0x20, 0x51, 0x9b, 0xe4, 0x7d, 0x47, 0x3e, 0xd6, 0x97, 0xff, - 0x06, 0x00, 0x00, 0xff, 0xff, 0xd4, 0x03, 0x9d, 0x1d, 0xbc, 0x05, 0x00, 0x00, + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x94, 0xcf, 0x72, 0xda, 0x3a, + 0x14, 0xc6, 0x83, 0xf9, 0xeb, 0x83, 0x31, 0xa0, 0xdc, 0xe4, 0x92, 0xdc, 0xc9, 0x1d, 0xae, 0xe7, + 0xb6, 0x65, 0xb2, 0x48, 0x3b, 0xc9, 0x2a, 0xbb, 0x52, 0x20, 0x19, 0x3a, 0x49, 0xa1, 0x86, 0x74, + 0xeb, 0x51, 0x40, 0x69, 0x3c, 0x63, 0xd9, 0xae, 0x25, 0x27, 0xf0, 0x02, 0x7d, 0x9a, 0xae, 0xfa, + 0x6e, 0xdd, 0x77, 0xf4, 0x07, 0x62, 0xa7, 0xed, 0xce, 0xf3, 0xe9, 0x3b, 0x47, 0xd6, 0x4f, 0xdf, + 0x11, 0x58, 0x8b, 0xc0, 0x27, 0x21, 0x3f, 0x89, 0x93, 0x88, 0x47, 0xa8, 0x1a, 0x44, 0x51, 0x9c, + 0xc4, 0x0b, 0xe7, 0xbb, 0x01, 0xf6, 0x55, 0x14, 0xc5, 0x93, 0x94, 0xbb, 0xe4, 0x4b, 0x4a, 0x18, + 0x47, 0x2d, 0x28, 0x62, 0xca, 0x3b, 0x85, 0x6e, 0xa1, 0x57, 0x74, 0xc5, 0x27, 0x42, 0x50, 0x5a, + 0x12, 0xc6, 0x3b, 0x46, 0xb7, 0xd0, 0x33, 0x5d, 0xf9, 0x8d, 0x5e, 0xc3, 0x5f, 0x14, 0xaf, 0x3c, + 0xf6, 0x88, 0x63, 0x2f, 0x89, 0x52, 0xee, 0x87, 0x9f, 0xbd, 0x3b, 0x42, 0x3a, 0x45, 0x59, 0xd6, + 0xa6, 0x78, 0x35, 0x7b, 0xc4, 0xb1, 0xab, 0x56, 0x2e, 0x08, 0x41, 0x67, 0xb0, 0x2f, 0x0a, 0xe2, + 0x84, 0xc4, 0x78, 0x9d, 0x2b, 0x29, 0xc9, 0x92, 0x5d, 0x8a, 0x57, 0x53, 0xb9, 0x98, 0x29, 0xea, + 0x82, 0xb5, 0xdd, 0x45, 0x58, 0xcb, 0xd2, 0x0a, 0xba, 0xbb, 0x70, 0xfc, 0x0f, 0x76, 0xa6, 0xad, + 0xf8, 0xf1, 0x8a, 0xf4, 0x58, 0xdb, 0x76, 0x7d, 0xca, 0x91, 0x03, 0x0d, 0xe1, 0xa2, 0x7e, 0x48, + 0x12, 0xd9, 0xa8, 0x2a, 0x4d, 0x75, 0x8a, 0x57, 0xd7, 0x42, 0x13, 0x9d, 0x7a, 0xd0, 0x12, 0x54, + 0xbc, 0x28, 0xe5, 0xde, 0xe2, 0x1e, 0x87, 0x21, 0x09, 0x3a, 0xb5, 0x6e, 0xa1, 0x57, 0x72, 0xed, + 0x40, 0x11, 0x1a, 0x28, 0xd5, 0xf9, 0x17, 0x2c, 0x79, 0x38, 0xc2, 0xe2, 0x28, 0x64, 0x04, 0xd9, + 0x60, 0xf8, 0x4b, 0x09, 0xcc, 0x74, 0x0d, 0x7f, 0xe9, 0xb4, 0xc0, 0xbe, 0x8e, 0x42, 0x9f, 0x47, + 0x89, 0x66, 0xea, 0xfc, 0x28, 0x00, 0x88, 0x92, 0x19, 0xc7, 0x3c, 0x65, 0xbf, 0x41, 0xac, 0x5a, + 0x18, 0x9b, 0x16, 0xe8, 0x05, 0x94, 0xf8, 0x3a, 0x56, 0x38, 0xed, 0xd3, 0xf6, 0x89, 0xbe, 0xaf, + 0x13, 0xd1, 0x64, 0xbe, 0x8e, 0x89, 0x2b, 0x97, 0x51, 0x0f, 0xca, 0x8c, 0x63, 0xae, 0x18, 0xda, + 0xa7, 0x28, 0xe7, 0x13, 0x9b, 0x11, 0x57, 0x19, 0xd0, 0x2b, 0x68, 0xfa, 0xa1, 0xcf, 0x7d, 0xcc, + 0xfd, 0x28, 0xf4, 0xb8, 0x4f, 0x37, 0x30, 0xed, 0x27, 0x79, 0xee, 0x53, 0x85, 0x01, 0x33, 0xee, + 0xa5, 0xf1, 0x12, 0x73, 0xa2, 0x9c, 0x0a, 0xa9, 0x2d, 0xf4, 0x1b, 0x29, 0x4b, 0xe7, 0x7f, 0x60, + 0xdd, 0xf3, 0x60, 0xe1, 0xe1, 0xe5, 0x32, 0x21, 0x8c, 0x49, 0xa6, 0xa6, 0x5b, 0x17, 0x5a, 0x5f, + 0x49, 0x8e, 0x0d, 0xd6, 0x9c, 0x24, 0x94, 0x6d, 0x38, 0x7c, 0x33, 0xa0, 0xa1, 0x05, 0xcd, 0xee, + 0x18, 0xda, 0xf2, 0x76, 0x63, 0xbc, 0xa6, 0x24, 0xe4, 0x9e, 0x0c, 0x9a, 0x42, 0xd9, 0x14, 0x0b, + 0x53, 0xa5, 0x0f, 0x45, 0xe6, 0x1c, 0x68, 0x6c, 0x92, 0xe0, 0xdd, 0x62, 0x46, 0x24, 0xaf, 0xa2, + 0x5b, 0x67, 0x2a, 0x0b, 0xef, 0x30, 0x23, 0x39, 0x4f, 0x22, 0xc8, 0x14, 0x73, 0x1e, 0x57, 0xb0, + 0x38, 0x02, 0xc8, 0xe4, 0x45, 0xc5, 0xcf, 0x8c, 0xb7, 0x61, 0x79, 0x09, 0x4d, 0xea, 0x87, 0x2a, + 0x74, 0x98, 0x46, 0x69, 0xc8, 0x35, 0xaa, 0x06, 0xf5, 0x43, 0x01, 0xb6, 0x2f, 0x45, 0xe9, 0xdb, + 0x84, 0x53, 0xfb, 0x2a, 0xda, 0xa7, 0xf2, 0xa9, 0x7d, 0x47, 0x00, 0x8b, 0x80, 0x3f, 0x78, 0x4b, + 0x12, 0x70, 0x2c, 0x29, 0x95, 0x5d, 0x53, 0x28, 0x43, 0x21, 0xa0, 0x03, 0xa8, 0x89, 0x36, 0x42, + 0x90, 0x79, 0x2b, 0xbb, 0x55, 0x8a, 0x57, 0x83, 0x80, 0x3f, 0x38, 0x5d, 0xb0, 0x3e, 0xa6, 0x11, + 0x27, 0x7f, 0x1c, 0x4d, 0xe7, 0x0e, 0x1a, 0xda, 0xa1, 0x79, 0x1e, 0x40, 0x6d, 0x3b, 0x2d, 0xca, + 0x57, 0xd5, 0x47, 0x7f, 0x76, 0x6c, 0xe3, 0xf9, 0xb1, 0xff, 0x01, 0xf3, 0x69, 0x3e, 0x14, 0xb5, + 0x1a, 0xd5, 0xc3, 0x71, 0xdc, 0x81, 0xda, 0x26, 0x7a, 0xc8, 0x82, 0xda, 0xd5, 0x64, 0x32, 0xf5, + 0x26, 0x37, 0xf3, 0xd6, 0xce, 0xf1, 0x7b, 0x30, 0xb7, 0x61, 0x43, 0x0d, 0x30, 0xc7, 0x1f, 0xc6, + 0xf3, 0x71, 0x7f, 0x3e, 0x1a, 0xb6, 0x76, 0xd0, 0x1e, 0xb4, 0xa7, 0xee, 0x68, 0x7c, 0xdd, 0xbf, + 0x1c, 0x79, 0xee, 0xe8, 0xd3, 0xa8, 0x7f, 0x35, 0x1a, 0xb6, 0x0a, 0xa8, 0x0e, 0xd5, 0xd9, 0xcd, + 0x60, 0x30, 0x9a, 0xcd, 0x5a, 0x45, 0x04, 0x50, 0xb9, 0xe8, 0x8f, 0xc5, 0x42, 0xe9, 0xf4, 0xab, + 0xa1, 0xc6, 0x64, 0x20, 0xdf, 0x2a, 0x74, 0x0e, 0x55, 0xfd, 0x36, 0xa1, 0xbf, 0xb7, 0xc9, 0xce, + 0xbf, 0x56, 0x87, 0x7b, 0xb9, 0xc8, 0x6f, 0x31, 0x9c, 0x43, 0x55, 0x8f, 0x60, 0xa6, 0x34, 0x3f, + 0x94, 0x87, 0xbb, 0xbf, 0x4c, 0x4b, 0xca, 0xde, 0x14, 0xd0, 0x5b, 0x68, 0x5e, 0x12, 0xae, 0xb7, + 0x91, 0x61, 0x45, 0x4f, 0x9b, 0x64, 0xd3, 0x7c, 0xb8, 0xff, 0x5c, 0xd6, 0x9b, 0xe7, 0x3a, 0xc8, + 0xeb, 0xc9, 0x74, 0xc8, 0x5e, 0x68, 0xa6, 0x43, 0xee, 0x16, 0x6f, 0x2b, 0xf2, 0x99, 0x3e, 0xfb, + 0x19, 0x00, 0x00, 0xff, 0xff, 0xc5, 0x15, 0xc0, 0x11, 0xb6, 0x05, 0x00, 0x00, } diff --git a/looprpc/client.proto b/looprpc/client.proto index eba5530..d876232 100644 --- a/looprpc/client.proto +++ b/looprpc/client.proto @@ -2,10 +2,38 @@ syntax = "proto3"; package looprpc; -message UnchargeRequest { +/** +SwapClient is a service that handles the client side process of onchain/offchain +swaps. The service is designed for a single client. +*/ +service SwapClient { /** - Requested swap amount in sat. This does not include the swap and miner - fee. + LoopOut initiates an loop out swap with the given parameters. The call + returns after the swap has been set up with the swap server. From that + point onwards, progress can be tracked via the SwapStatus stream that is + returned from Monitor(). + */ + rpc LoopOut(LoopOutRequest) returns (SwapResponse); + + /** + Monitor will return a stream of swap updates for currently active swaps. + */ + rpc Monitor(MonitorRequest) returns(stream SwapStatus); + + /** + GetLoopOutTerms returns the terms that the server enforces for swaps. + */ + rpc GetLoopOutTerms(TermsRequest) returns(TermsResponse); + + /** + GetLoopOutQuote returns a quote for a swap with the provided parameters. + */ + rpc GetLoopOutQuote(QuoteRequest) returns(QuoteResponse); +} + +message LoopOutRequest { + /** + Requested swap amount in sat. This does not include the swap and miner fee. */ int64 amt = 1; @@ -19,51 +47,51 @@ message UnchargeRequest { This limit is applied during path finding. Typically this value is taken from the response of the GetQuote call. */ - int64 max_swap_routing_fee = 3; + int64 max_swap_routing_fee = 3; /** - Maximum off-chain fee in msat that may be paid for payment to the server. - This limit is applied during path finding. Typically this value is taken - from the response of the GetQuote call. + Maximum off-chain fee in msat that may be paid for payment to the server. + This limit is applied during path finding. Typically this value is taken + from the response of the GetQuote call. */ - int64 max_prepay_routing_fee = 4; + int64 max_prepay_routing_fee = 4; /** - Maximum we are willing to pay the server for the swap. This value is not - disclosed in the swap initiation call, but if the server asks for a - higher fee, we abort the swap. Typically this value is taken from the - response of the GetQuote call. It includes the prepay amount. + Maximum we are willing to pay the server for the swap. This value is not + disclosed in the swap initiation call, but if the server asks for a + higher fee, we abort the swap. Typically this value is taken from the + response of the GetQuote call. It includes the prepay amount. */ - int64 max_swap_fee = 5; + int64 max_swap_fee = 5; /** - Maximum amount of the swap fee that may be charged as a prepayment. + Maximum amount of the swap fee that may be charged as a prepayment. */ - int64 max_prepay_amt = 6; + int64 max_prepay_amt = 6; /** - Maximum in on-chain fees that we are willing to spent. If we want to - sweep the on-chain htlc and the fee estimate turns out higher than this - value, we cancel the swap. If the fee estimate is lower, we publish the - sweep tx. - - If the sweep tx isn't confirmed, we are forced to ratchet up fees until - it is swept. Possibly even exceeding max_miner_fee if we get close to the - htlc timeout. Because the initial publication revealed the preimage, we - have no other choice. The server may already have pulled the off-chain - htlc. Only when the fee becomes higher than the swap amount, we can only - wait for fees to come down and hope - if we are past the timeout - that - the server isn't publishing the revocation. - - max_miner_fee is typically taken from the response of the GetQuote call. + Maximum in on-chain fees that we are willing to spent. If we want to + sweep the on-chain htlc and the fee estimate turns out higher than this + value, we cancel the swap. If the fee estimate is lower, we publish the + sweep tx. + + If the sweep tx is not confirmed, we are forced to ratchet up fees until it + is swept. Possibly even exceeding max_miner_fee if we get close to the htlc + timeout. Because the initial publication revealed the preimage, we have no + other choice. The server may already have pulled the off-chain htlc. Only + when the fee becomes higher than the swap amount, we can only wait for fees + to come down and hope - if we are past the timeout - that the server is not + publishing the revocation. + + max_miner_fee is typically taken from the response of the GetQuote call. */ int64 max_miner_fee = 7; /** - The channel to uncharge. If zero, the channel to uncharge is selected based - on the lowest routing fee for the swap payment to the server. + The channel to loop out, the channel to loop out is selected based on the + lowest routing fee for the swap payment to the server. */ - uint64 uncharge_channel = 8; + uint64 loop_out_channel = 8; } @@ -78,7 +106,6 @@ message SwapResponse { message MonitorRequest{ } - message SwapStatus { /** Requested swap amount in sat. This does not include the swap and miner @@ -119,10 +146,8 @@ message SwapStatus { } enum SwapType { - // UNCHARGE indicates an uncharge swap (off-chain to on-chain) - UNCHARGE = 0; - - + // LOOP_OUT indicates an loop out swap (off-chain to on-chain) + LOOP_OUT = 0; } enum SwapState { @@ -218,42 +243,11 @@ message QuoteResponse { The part of the swap fee that is requested as a prepayment. */ - int64 prepay_amt = 2; + int64 prepay_amt = 2; /** An estimate of the on-chain fee that needs to be paid to sweep the htlc. */ - int64 miner_fee = 3; + int64 miner_fee = 3; } - -/** -SwapClient is a service that handles the client side process of onchain/offchain -swaps. The service is designed for a single client. -*/ -service SwapClient { - /** - Uncharge initiates an uncharge swap with the given parameters. The call - returns after the swap has been set up with the swap server. From that - point onwards, progress can be tracked via the SwapStatus stream - that is returned from Monitor(). - */ - rpc Uncharge(UnchargeRequest) returns (SwapResponse); - - - /** - Monitor will return a stream of swap updates for currently active swaps. - */ - rpc Monitor(MonitorRequest) returns(stream SwapStatus); - - /** - GetTerms returns the terms that the server enforces for swaps. - */ - rpc GetUnchargeTerms(TermsRequest) returns(TermsResponse); - - /** - GetQuote returns a quote for a swap with the provided parameters. - */ - rpc GetUnchargeQuote(QuoteRequest) returns(QuoteResponse); -} - diff --git a/looprpc/server.pb.go b/looprpc/server.pb.go index 17d59a2..fcb9eb5 100644 --- a/looprpc/server.pb.go +++ b/looprpc/server.pb.go @@ -24,7 +24,7 @@ var _ = math.Inf // proto package needs to be updated. const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package -type ServerUnchargeSwapRequest struct { +type ServerLoopOutRequest struct { ReceiverKey []byte `protobuf:"bytes,1,opt,name=receiver_key,json=receiverKey,proto3" json:"receiver_key,omitempty"` SwapHash []byte `protobuf:"bytes,2,opt,name=swap_hash,json=swapHash,proto3" json:"swap_hash,omitempty"` Amt uint64 `protobuf:"varint,3,opt,name=amt,proto3" json:"amt,omitempty"` @@ -33,52 +33,52 @@ type ServerUnchargeSwapRequest struct { XXX_sizecache int32 `json:"-"` } -func (m *ServerUnchargeSwapRequest) Reset() { *m = ServerUnchargeSwapRequest{} } -func (m *ServerUnchargeSwapRequest) String() string { return proto.CompactTextString(m) } -func (*ServerUnchargeSwapRequest) ProtoMessage() {} -func (*ServerUnchargeSwapRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_server_9aa9f93bbf0053c2, []int{0} +func (m *ServerLoopOutRequest) Reset() { *m = ServerLoopOutRequest{} } +func (m *ServerLoopOutRequest) String() string { return proto.CompactTextString(m) } +func (*ServerLoopOutRequest) ProtoMessage() {} +func (*ServerLoopOutRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_server_76a33eec530f39a2, []int{0} } -func (m *ServerUnchargeSwapRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_ServerUnchargeSwapRequest.Unmarshal(m, b) +func (m *ServerLoopOutRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ServerLoopOutRequest.Unmarshal(m, b) } -func (m *ServerUnchargeSwapRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_ServerUnchargeSwapRequest.Marshal(b, m, deterministic) +func (m *ServerLoopOutRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ServerLoopOutRequest.Marshal(b, m, deterministic) } -func (dst *ServerUnchargeSwapRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_ServerUnchargeSwapRequest.Merge(dst, src) +func (dst *ServerLoopOutRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ServerLoopOutRequest.Merge(dst, src) } -func (m *ServerUnchargeSwapRequest) XXX_Size() int { - return xxx_messageInfo_ServerUnchargeSwapRequest.Size(m) +func (m *ServerLoopOutRequest) XXX_Size() int { + return xxx_messageInfo_ServerLoopOutRequest.Size(m) } -func (m *ServerUnchargeSwapRequest) XXX_DiscardUnknown() { - xxx_messageInfo_ServerUnchargeSwapRequest.DiscardUnknown(m) +func (m *ServerLoopOutRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ServerLoopOutRequest.DiscardUnknown(m) } -var xxx_messageInfo_ServerUnchargeSwapRequest proto.InternalMessageInfo +var xxx_messageInfo_ServerLoopOutRequest proto.InternalMessageInfo -func (m *ServerUnchargeSwapRequest) GetReceiverKey() []byte { +func (m *ServerLoopOutRequest) GetReceiverKey() []byte { if m != nil { return m.ReceiverKey } return nil } -func (m *ServerUnchargeSwapRequest) GetSwapHash() []byte { +func (m *ServerLoopOutRequest) GetSwapHash() []byte { if m != nil { return m.SwapHash } return nil } -func (m *ServerUnchargeSwapRequest) GetAmt() uint64 { +func (m *ServerLoopOutRequest) GetAmt() uint64 { if m != nil { return m.Amt } return 0 } -type ServerUnchargeSwapResponse struct { +type ServerLoopOutResponse struct { SwapInvoice string `protobuf:"bytes,1,opt,name=swap_invoice,json=swapInvoice,proto3" json:"swap_invoice,omitempty"` PrepayInvoice string `protobuf:"bytes,2,opt,name=prepay_invoice,json=prepayInvoice,proto3" json:"prepay_invoice,omitempty"` SenderKey []byte `protobuf:"bytes,3,opt,name=sender_key,json=senderKey,proto3" json:"sender_key,omitempty"` @@ -88,89 +88,89 @@ type ServerUnchargeSwapResponse struct { XXX_sizecache int32 `json:"-"` } -func (m *ServerUnchargeSwapResponse) Reset() { *m = ServerUnchargeSwapResponse{} } -func (m *ServerUnchargeSwapResponse) String() string { return proto.CompactTextString(m) } -func (*ServerUnchargeSwapResponse) ProtoMessage() {} -func (*ServerUnchargeSwapResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_server_9aa9f93bbf0053c2, []int{1} +func (m *ServerLoopOutResponse) Reset() { *m = ServerLoopOutResponse{} } +func (m *ServerLoopOutResponse) String() string { return proto.CompactTextString(m) } +func (*ServerLoopOutResponse) ProtoMessage() {} +func (*ServerLoopOutResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_server_76a33eec530f39a2, []int{1} } -func (m *ServerUnchargeSwapResponse) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_ServerUnchargeSwapResponse.Unmarshal(m, b) +func (m *ServerLoopOutResponse) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ServerLoopOutResponse.Unmarshal(m, b) } -func (m *ServerUnchargeSwapResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_ServerUnchargeSwapResponse.Marshal(b, m, deterministic) +func (m *ServerLoopOutResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ServerLoopOutResponse.Marshal(b, m, deterministic) } -func (dst *ServerUnchargeSwapResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_ServerUnchargeSwapResponse.Merge(dst, src) +func (dst *ServerLoopOutResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ServerLoopOutResponse.Merge(dst, src) } -func (m *ServerUnchargeSwapResponse) XXX_Size() int { - return xxx_messageInfo_ServerUnchargeSwapResponse.Size(m) +func (m *ServerLoopOutResponse) XXX_Size() int { + return xxx_messageInfo_ServerLoopOutResponse.Size(m) } -func (m *ServerUnchargeSwapResponse) XXX_DiscardUnknown() { - xxx_messageInfo_ServerUnchargeSwapResponse.DiscardUnknown(m) +func (m *ServerLoopOutResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ServerLoopOutResponse.DiscardUnknown(m) } -var xxx_messageInfo_ServerUnchargeSwapResponse proto.InternalMessageInfo +var xxx_messageInfo_ServerLoopOutResponse proto.InternalMessageInfo -func (m *ServerUnchargeSwapResponse) GetSwapInvoice() string { +func (m *ServerLoopOutResponse) GetSwapInvoice() string { if m != nil { return m.SwapInvoice } return "" } -func (m *ServerUnchargeSwapResponse) GetPrepayInvoice() string { +func (m *ServerLoopOutResponse) GetPrepayInvoice() string { if m != nil { return m.PrepayInvoice } return "" } -func (m *ServerUnchargeSwapResponse) GetSenderKey() []byte { +func (m *ServerLoopOutResponse) GetSenderKey() []byte { if m != nil { return m.SenderKey } return nil } -func (m *ServerUnchargeSwapResponse) GetExpiry() int32 { +func (m *ServerLoopOutResponse) GetExpiry() int32 { if m != nil { return m.Expiry } return 0 } -type ServerUnchargeQuoteRequest struct { +type ServerLoopOutQuoteRequest struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } -func (m *ServerUnchargeQuoteRequest) Reset() { *m = ServerUnchargeQuoteRequest{} } -func (m *ServerUnchargeQuoteRequest) String() string { return proto.CompactTextString(m) } -func (*ServerUnchargeQuoteRequest) ProtoMessage() {} -func (*ServerUnchargeQuoteRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_server_9aa9f93bbf0053c2, []int{2} +func (m *ServerLoopOutQuoteRequest) Reset() { *m = ServerLoopOutQuoteRequest{} } +func (m *ServerLoopOutQuoteRequest) String() string { return proto.CompactTextString(m) } +func (*ServerLoopOutQuoteRequest) ProtoMessage() {} +func (*ServerLoopOutQuoteRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_server_76a33eec530f39a2, []int{2} } -func (m *ServerUnchargeQuoteRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_ServerUnchargeQuoteRequest.Unmarshal(m, b) +func (m *ServerLoopOutQuoteRequest) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ServerLoopOutQuoteRequest.Unmarshal(m, b) } -func (m *ServerUnchargeQuoteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_ServerUnchargeQuoteRequest.Marshal(b, m, deterministic) +func (m *ServerLoopOutQuoteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ServerLoopOutQuoteRequest.Marshal(b, m, deterministic) } -func (dst *ServerUnchargeQuoteRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_ServerUnchargeQuoteRequest.Merge(dst, src) +func (dst *ServerLoopOutQuoteRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ServerLoopOutQuoteRequest.Merge(dst, src) } -func (m *ServerUnchargeQuoteRequest) XXX_Size() int { - return xxx_messageInfo_ServerUnchargeQuoteRequest.Size(m) +func (m *ServerLoopOutQuoteRequest) XXX_Size() int { + return xxx_messageInfo_ServerLoopOutQuoteRequest.Size(m) } -func (m *ServerUnchargeQuoteRequest) XXX_DiscardUnknown() { - xxx_messageInfo_ServerUnchargeQuoteRequest.DiscardUnknown(m) +func (m *ServerLoopOutQuoteRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ServerLoopOutQuoteRequest.DiscardUnknown(m) } -var xxx_messageInfo_ServerUnchargeQuoteRequest proto.InternalMessageInfo +var xxx_messageInfo_ServerLoopOutQuoteRequest proto.InternalMessageInfo -type ServerUnchargeQuoteResponse struct { +type ServerLoopOutQuote struct { SwapPaymentDest string `protobuf:"bytes,1,opt,name=swap_payment_dest,json=swapPaymentDest,proto3" json:"swap_payment_dest,omitempty"` SwapFeeBase int64 `protobuf:"varint,2,opt,name=swap_fee_base,json=swapFeeBase,proto3" json:"swap_fee_base,omitempty"` SwapFeeRate int64 `protobuf:"varint,3,opt,name=swap_fee_rate,json=swapFeeRate,proto3" json:"swap_fee_rate,omitempty"` @@ -183,73 +183,73 @@ type ServerUnchargeQuoteResponse struct { XXX_sizecache int32 `json:"-"` } -func (m *ServerUnchargeQuoteResponse) Reset() { *m = ServerUnchargeQuoteResponse{} } -func (m *ServerUnchargeQuoteResponse) String() string { return proto.CompactTextString(m) } -func (*ServerUnchargeQuoteResponse) ProtoMessage() {} -func (*ServerUnchargeQuoteResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_server_9aa9f93bbf0053c2, []int{3} +func (m *ServerLoopOutQuote) Reset() { *m = ServerLoopOutQuote{} } +func (m *ServerLoopOutQuote) String() string { return proto.CompactTextString(m) } +func (*ServerLoopOutQuote) ProtoMessage() {} +func (*ServerLoopOutQuote) Descriptor() ([]byte, []int) { + return fileDescriptor_server_76a33eec530f39a2, []int{3} } -func (m *ServerUnchargeQuoteResponse) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_ServerUnchargeQuoteResponse.Unmarshal(m, b) +func (m *ServerLoopOutQuote) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ServerLoopOutQuote.Unmarshal(m, b) } -func (m *ServerUnchargeQuoteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_ServerUnchargeQuoteResponse.Marshal(b, m, deterministic) +func (m *ServerLoopOutQuote) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ServerLoopOutQuote.Marshal(b, m, deterministic) } -func (dst *ServerUnchargeQuoteResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_ServerUnchargeQuoteResponse.Merge(dst, src) +func (dst *ServerLoopOutQuote) XXX_Merge(src proto.Message) { + xxx_messageInfo_ServerLoopOutQuote.Merge(dst, src) } -func (m *ServerUnchargeQuoteResponse) XXX_Size() int { - return xxx_messageInfo_ServerUnchargeQuoteResponse.Size(m) +func (m *ServerLoopOutQuote) XXX_Size() int { + return xxx_messageInfo_ServerLoopOutQuote.Size(m) } -func (m *ServerUnchargeQuoteResponse) XXX_DiscardUnknown() { - xxx_messageInfo_ServerUnchargeQuoteResponse.DiscardUnknown(m) +func (m *ServerLoopOutQuote) XXX_DiscardUnknown() { + xxx_messageInfo_ServerLoopOutQuote.DiscardUnknown(m) } -var xxx_messageInfo_ServerUnchargeQuoteResponse proto.InternalMessageInfo +var xxx_messageInfo_ServerLoopOutQuote proto.InternalMessageInfo -func (m *ServerUnchargeQuoteResponse) GetSwapPaymentDest() string { +func (m *ServerLoopOutQuote) GetSwapPaymentDest() string { if m != nil { return m.SwapPaymentDest } return "" } -func (m *ServerUnchargeQuoteResponse) GetSwapFeeBase() int64 { +func (m *ServerLoopOutQuote) GetSwapFeeBase() int64 { if m != nil { return m.SwapFeeBase } return 0 } -func (m *ServerUnchargeQuoteResponse) GetSwapFeeRate() int64 { +func (m *ServerLoopOutQuote) GetSwapFeeRate() int64 { if m != nil { return m.SwapFeeRate } return 0 } -func (m *ServerUnchargeQuoteResponse) GetPrepayAmt() uint64 { +func (m *ServerLoopOutQuote) GetPrepayAmt() uint64 { if m != nil { return m.PrepayAmt } return 0 } -func (m *ServerUnchargeQuoteResponse) GetMinSwapAmount() uint64 { +func (m *ServerLoopOutQuote) GetMinSwapAmount() uint64 { if m != nil { return m.MinSwapAmount } return 0 } -func (m *ServerUnchargeQuoteResponse) GetMaxSwapAmount() uint64 { +func (m *ServerLoopOutQuote) GetMaxSwapAmount() uint64 { if m != nil { return m.MaxSwapAmount } return 0 } -func (m *ServerUnchargeQuoteResponse) GetCltvDelta() int32 { +func (m *ServerLoopOutQuote) GetCltvDelta() int32 { if m != nil { return m.CltvDelta } @@ -257,10 +257,10 @@ func (m *ServerUnchargeQuoteResponse) GetCltvDelta() int32 { } func init() { - proto.RegisterType((*ServerUnchargeSwapRequest)(nil), "looprpc.ServerUnchargeSwapRequest") - proto.RegisterType((*ServerUnchargeSwapResponse)(nil), "looprpc.ServerUnchargeSwapResponse") - proto.RegisterType((*ServerUnchargeQuoteRequest)(nil), "looprpc.ServerUnchargeQuoteRequest") - proto.RegisterType((*ServerUnchargeQuoteResponse)(nil), "looprpc.ServerUnchargeQuoteResponse") + proto.RegisterType((*ServerLoopOutRequest)(nil), "looprpc.ServerLoopOutRequest") + proto.RegisterType((*ServerLoopOutResponse)(nil), "looprpc.ServerLoopOutResponse") + proto.RegisterType((*ServerLoopOutQuoteRequest)(nil), "looprpc.ServerLoopOutQuoteRequest") + proto.RegisterType((*ServerLoopOutQuote)(nil), "looprpc.ServerLoopOutQuote") } // Reference imports to suppress errors if they are not otherwise used. @@ -275,8 +275,8 @@ const _ = grpc.SupportPackageIsVersion4 // // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. type SwapServerClient interface { - NewUnchargeSwap(ctx context.Context, in *ServerUnchargeSwapRequest, opts ...grpc.CallOption) (*ServerUnchargeSwapResponse, error) - UnchargeQuote(ctx context.Context, in *ServerUnchargeQuoteRequest, opts ...grpc.CallOption) (*ServerUnchargeQuoteResponse, error) + NewLoopOutSwap(ctx context.Context, in *ServerLoopOutRequest, opts ...grpc.CallOption) (*ServerLoopOutResponse, error) + LoopOutQuote(ctx context.Context, in *ServerLoopOutQuoteRequest, opts ...grpc.CallOption) (*ServerLoopOutQuote, error) } type swapServerClient struct { @@ -287,18 +287,18 @@ func NewSwapServerClient(cc *grpc.ClientConn) SwapServerClient { return &swapServerClient{cc} } -func (c *swapServerClient) NewUnchargeSwap(ctx context.Context, in *ServerUnchargeSwapRequest, opts ...grpc.CallOption) (*ServerUnchargeSwapResponse, error) { - out := new(ServerUnchargeSwapResponse) - err := c.cc.Invoke(ctx, "/looprpc.SwapServer/NewUnchargeSwap", in, out, opts...) +func (c *swapServerClient) NewLoopOutSwap(ctx context.Context, in *ServerLoopOutRequest, opts ...grpc.CallOption) (*ServerLoopOutResponse, error) { + out := new(ServerLoopOutResponse) + err := c.cc.Invoke(ctx, "/looprpc.SwapServer/NewLoopOutSwap", in, out, opts...) if err != nil { return nil, err } return out, nil } -func (c *swapServerClient) UnchargeQuote(ctx context.Context, in *ServerUnchargeQuoteRequest, opts ...grpc.CallOption) (*ServerUnchargeQuoteResponse, error) { - out := new(ServerUnchargeQuoteResponse) - err := c.cc.Invoke(ctx, "/looprpc.SwapServer/UnchargeQuote", in, out, opts...) +func (c *swapServerClient) LoopOutQuote(ctx context.Context, in *ServerLoopOutQuoteRequest, opts ...grpc.CallOption) (*ServerLoopOutQuote, error) { + out := new(ServerLoopOutQuote) + err := c.cc.Invoke(ctx, "/looprpc.SwapServer/LoopOutQuote", in, out, opts...) if err != nil { return nil, err } @@ -307,46 +307,46 @@ func (c *swapServerClient) UnchargeQuote(ctx context.Context, in *ServerUncharge // SwapServerServer is the server API for SwapServer service. type SwapServerServer interface { - NewUnchargeSwap(context.Context, *ServerUnchargeSwapRequest) (*ServerUnchargeSwapResponse, error) - UnchargeQuote(context.Context, *ServerUnchargeQuoteRequest) (*ServerUnchargeQuoteResponse, error) + NewLoopOutSwap(context.Context, *ServerLoopOutRequest) (*ServerLoopOutResponse, error) + LoopOutQuote(context.Context, *ServerLoopOutQuoteRequest) (*ServerLoopOutQuote, error) } func RegisterSwapServerServer(s *grpc.Server, srv SwapServerServer) { s.RegisterService(&_SwapServer_serviceDesc, srv) } -func _SwapServer_NewUnchargeSwap_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(ServerUnchargeSwapRequest) +func _SwapServer_NewLoopOutSwap_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ServerLoopOutRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { - return srv.(SwapServerServer).NewUnchargeSwap(ctx, in) + return srv.(SwapServerServer).NewLoopOutSwap(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/looprpc.SwapServer/NewUnchargeSwap", + FullMethod: "/looprpc.SwapServer/NewLoopOutSwap", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(SwapServerServer).NewUnchargeSwap(ctx, req.(*ServerUnchargeSwapRequest)) + return srv.(SwapServerServer).NewLoopOutSwap(ctx, req.(*ServerLoopOutRequest)) } return interceptor(ctx, in, info, handler) } -func _SwapServer_UnchargeQuote_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(ServerUnchargeQuoteRequest) +func _SwapServer_LoopOutQuote_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ServerLoopOutQuoteRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { - return srv.(SwapServerServer).UnchargeQuote(ctx, in) + return srv.(SwapServerServer).LoopOutQuote(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/looprpc.SwapServer/UnchargeQuote", + FullMethod: "/looprpc.SwapServer/LoopOutQuote", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(SwapServerServer).UnchargeQuote(ctx, req.(*ServerUnchargeQuoteRequest)) + return srv.(SwapServerServer).LoopOutQuote(ctx, req.(*ServerLoopOutQuoteRequest)) } return interceptor(ctx, in, info, handler) } @@ -356,50 +356,50 @@ var _SwapServer_serviceDesc = grpc.ServiceDesc{ HandlerType: (*SwapServerServer)(nil), Methods: []grpc.MethodDesc{ { - MethodName: "NewUnchargeSwap", - Handler: _SwapServer_NewUnchargeSwap_Handler, + MethodName: "NewLoopOutSwap", + Handler: _SwapServer_NewLoopOutSwap_Handler, }, { - MethodName: "UnchargeQuote", - Handler: _SwapServer_UnchargeQuote_Handler, + MethodName: "LoopOutQuote", + Handler: _SwapServer_LoopOutQuote_Handler, }, }, Streams: []grpc.StreamDesc{}, Metadata: "server.proto", } -func init() { proto.RegisterFile("server.proto", fileDescriptor_server_9aa9f93bbf0053c2) } - -var fileDescriptor_server_9aa9f93bbf0053c2 = []byte{ - // 471 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x93, 0xdd, 0x6e, 0xd3, 0x40, - 0x10, 0x85, 0xe5, 0x26, 0x4d, 0xc9, 0x34, 0x21, 0xe0, 0x0b, 0x64, 0xd2, 0x56, 0x0a, 0x86, 0x42, - 0xc4, 0x45, 0x22, 0xc1, 0x13, 0xb4, 0xaa, 0x10, 0x08, 0x09, 0x81, 0x2b, 0x6e, 0x72, 0x63, 0x4d, - 0x9c, 0xc1, 0x5e, 0x61, 0xef, 0x2e, 0xbb, 0x9b, 0xbf, 0x87, 0x41, 0xbc, 0x0c, 0x0f, 0x86, 0xf6, - 0xa7, 0x90, 0xa0, 0xb6, 0x77, 0xc9, 0xd9, 0x6f, 0x67, 0xce, 0x9c, 0x59, 0x43, 0x4f, 0x93, 0x5a, - 0x91, 0x9a, 0x48, 0x25, 0x8c, 0x88, 0x8f, 0x6a, 0x21, 0xa4, 0x92, 0xc5, 0xf0, 0xb4, 0x14, 0xa2, - 0xac, 0x69, 0x8a, 0x92, 0x4d, 0x91, 0x73, 0x61, 0xd0, 0x30, 0xc1, 0xb5, 0xc7, 0xd2, 0x06, 0x9e, - 0x5e, 0xbb, 0x6b, 0x5f, 0x79, 0x51, 0xa1, 0x2a, 0xe9, 0x7a, 0x8d, 0x32, 0xa3, 0x1f, 0x4b, 0xd2, - 0x26, 0x7e, 0x06, 0x3d, 0x45, 0x05, 0xb1, 0x15, 0xa9, 0xfc, 0x3b, 0x6d, 0x93, 0x68, 0x14, 0x8d, - 0x7b, 0xd9, 0xf1, 0x8d, 0xf6, 0x91, 0xb6, 0xf1, 0x09, 0x74, 0xf5, 0x1a, 0x65, 0x5e, 0xa1, 0xae, - 0x92, 0x03, 0x77, 0xfe, 0xc0, 0x0a, 0xef, 0x51, 0x57, 0xf1, 0x23, 0x68, 0x61, 0x63, 0x92, 0xd6, - 0x28, 0x1a, 0xb7, 0x33, 0xfb, 0x33, 0xfd, 0x19, 0xc1, 0xf0, 0xb6, 0x7e, 0x5a, 0x0a, 0xae, 0xc9, - 0x36, 0x74, 0xd5, 0x18, 0x5f, 0x09, 0x56, 0x90, 0x6b, 0xd8, 0xcd, 0x8e, 0xad, 0xf6, 0xc1, 0x4b, - 0xf1, 0x39, 0x3c, 0x94, 0x8a, 0x24, 0x6e, 0xff, 0x42, 0x07, 0x0e, 0xea, 0x7b, 0xf5, 0x06, 0x3b, - 0x03, 0xd0, 0xc4, 0x17, 0xc1, 0x78, 0xcb, 0x19, 0xeb, 0x7a, 0xc5, 0xda, 0x7e, 0x02, 0x1d, 0xda, - 0x48, 0xa6, 0xb6, 0x49, 0x7b, 0x14, 0x8d, 0x0f, 0xb3, 0xf0, 0x2f, 0x3d, 0xfd, 0xdf, 0xde, 0x97, - 0xa5, 0x30, 0x14, 0xf2, 0x48, 0x7f, 0x1d, 0xc0, 0xc9, 0xad, 0xc7, 0xc1, 0xfe, 0x6b, 0x78, 0xec, - 0xec, 0x4b, 0xdc, 0x36, 0xc4, 0x4d, 0xbe, 0x20, 0x6d, 0xc2, 0x0c, 0x03, 0x7b, 0xf0, 0xd9, 0xeb, - 0x57, 0x36, 0xdb, 0x14, 0xfa, 0x8e, 0xfd, 0x46, 0x94, 0xcf, 0x51, 0xfb, 0x31, 0x5a, 0x7e, 0xd6, - 0x77, 0x44, 0x97, 0xa8, 0x69, 0x8f, 0x51, 0x68, 0xc8, 0xcd, 0xf1, 0x8f, 0xc9, 0xd0, 0xb8, 0x41, - 0x43, 0x1e, 0x36, 0xea, 0xb6, 0x8b, 0xba, 0xeb, 0x95, 0x8b, 0xc6, 0xc4, 0x2f, 0x61, 0xd0, 0x30, - 0x9e, 0xbb, 0x32, 0xd8, 0x88, 0x25, 0x37, 0xc9, 0xa1, 0x63, 0xfa, 0x0d, 0xe3, 0x36, 0xfb, 0x0b, - 0x27, 0x3a, 0x0e, 0x37, 0x7b, 0x5c, 0x27, 0x70, 0xb8, 0xd9, 0xe1, 0xce, 0x00, 0x8a, 0xda, 0xac, - 0xf2, 0x05, 0xd5, 0x06, 0x93, 0x23, 0x17, 0x5e, 0xd7, 0x2a, 0x57, 0x56, 0x78, 0xf3, 0x3b, 0x02, - 0xb0, 0xb4, 0x4f, 0x29, 0x9e, 0xc1, 0xe0, 0x13, 0xad, 0x77, 0x57, 0x1d, 0xa7, 0x93, 0xf0, 0x30, - 0x27, 0x77, 0xbe, 0xbb, 0xe1, 0xf3, 0x7b, 0x99, 0x10, 0xf6, 0x0c, 0xfa, 0x7b, 0x5b, 0x88, 0xef, - 0xba, 0xb5, 0xbb, 0xc2, 0xe1, 0x8b, 0xfb, 0x21, 0x5f, 0xfb, 0xf2, 0xd5, 0xec, 0xbc, 0x64, 0xa6, - 0x5a, 0xce, 0x27, 0x85, 0x68, 0xa6, 0x35, 0x2b, 0x2b, 0xc3, 0x19, 0x2f, 0x6b, 0x9c, 0xeb, 0xa9, - 0xbd, 0x3f, 0x0d, 0x45, 0xe6, 0x1d, 0xf7, 0x15, 0xbd, 0xfd, 0x13, 0x00, 0x00, 0xff, 0xff, 0x55, - 0xfc, 0x38, 0x76, 0x7c, 0x03, 0x00, 0x00, +func init() { proto.RegisterFile("server.proto", fileDescriptor_server_76a33eec530f39a2) } + +var fileDescriptor_server_76a33eec530f39a2 = []byte{ + // 467 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x93, 0xd1, 0x6e, 0xd3, 0x30, + 0x14, 0x86, 0x95, 0xb6, 0xeb, 0xe8, 0x59, 0xbb, 0x81, 0x05, 0x28, 0xb4, 0x14, 0x95, 0x48, 0x83, + 0x8a, 0x8b, 0x56, 0x82, 0x27, 0xd8, 0x34, 0x21, 0x10, 0x88, 0x42, 0x76, 0xc7, 0x4d, 0x74, 0xda, + 0x1e, 0x12, 0x8b, 0xc4, 0x36, 0xb1, 0xd3, 0x36, 0x2f, 0x82, 0x78, 0x0a, 0x9e, 0x11, 0xd9, 0xf1, + 0x60, 0x85, 0xb1, 0xbb, 0xe4, 0x3f, 0xdf, 0xf1, 0xf9, 0xfd, 0xe7, 0x04, 0xfa, 0x9a, 0xca, 0x0d, + 0x95, 0x33, 0x55, 0x4a, 0x23, 0xd9, 0x61, 0x2e, 0xa5, 0x2a, 0xd5, 0x6a, 0xf8, 0x38, 0x95, 0x32, + 0xcd, 0x69, 0x8e, 0x8a, 0xcf, 0x51, 0x08, 0x69, 0xd0, 0x70, 0x29, 0x74, 0x83, 0x45, 0x19, 0xdc, + 0xbf, 0x74, 0x6d, 0xef, 0xa5, 0x54, 0x8b, 0xca, 0xc4, 0xf4, 0xad, 0x22, 0x6d, 0xd8, 0x53, 0xe8, + 0x97, 0xb4, 0x22, 0xbe, 0xa1, 0x32, 0xf9, 0x4a, 0x75, 0x18, 0x4c, 0x82, 0x69, 0x3f, 0x3e, 0xba, + 0xd2, 0xde, 0x51, 0xcd, 0x46, 0xd0, 0xd3, 0x5b, 0x54, 0x49, 0x86, 0x3a, 0x0b, 0x5b, 0xae, 0x7e, + 0xc7, 0x0a, 0x6f, 0x50, 0x67, 0xec, 0x2e, 0xb4, 0xb1, 0x30, 0x61, 0x7b, 0x12, 0x4c, 0x3b, 0xb1, + 0x7d, 0x8c, 0x7e, 0x04, 0xf0, 0xe0, 0xaf, 0x51, 0x5a, 0x49, 0xa1, 0xc9, 0xce, 0x72, 0x07, 0x71, + 0xb1, 0x91, 0x7c, 0x45, 0x6e, 0x56, 0x2f, 0x3e, 0xb2, 0xda, 0xdb, 0x46, 0x62, 0xa7, 0x70, 0xac, + 0x4a, 0x52, 0x58, 0xff, 0x86, 0x5a, 0x0e, 0x1a, 0x34, 0xea, 0x15, 0x36, 0x06, 0xd0, 0x24, 0xd6, + 0xde, 0x73, 0xdb, 0x79, 0xea, 0x35, 0x8a, 0x75, 0xfc, 0x10, 0xba, 0xb4, 0x53, 0xbc, 0xac, 0xc3, + 0xce, 0x24, 0x98, 0x1e, 0xc4, 0xfe, 0x2d, 0x1a, 0xc1, 0xa3, 0x3d, 0x67, 0x9f, 0x2a, 0x69, 0xc8, + 0x27, 0x11, 0x7d, 0x6f, 0x01, 0xfb, 0xb7, 0xca, 0x5e, 0xc0, 0x3d, 0x67, 0x5a, 0x61, 0x5d, 0x90, + 0x30, 0xc9, 0x9a, 0xb4, 0xf1, 0xce, 0x4f, 0x6c, 0xe1, 0x63, 0xa3, 0x5f, 0xd8, 0x30, 0x23, 0x18, + 0x38, 0xf6, 0x0b, 0x51, 0xb2, 0x44, 0xdd, 0x98, 0x6f, 0x37, 0x37, 0x7c, 0x4d, 0x74, 0x8e, 0x9a, + 0xf6, 0x98, 0x12, 0x0d, 0x39, 0xf7, 0x7f, 0x98, 0x18, 0x8d, 0xbb, 0x9e, 0x4f, 0xc1, 0x66, 0xdb, + 0x71, 0xd9, 0xf6, 0x1a, 0xe5, 0xac, 0x30, 0xec, 0x19, 0x9c, 0x14, 0x5c, 0x24, 0xee, 0x18, 0x2c, + 0x64, 0x25, 0x4c, 0x78, 0xe0, 0x98, 0x41, 0xc1, 0xc5, 0xe5, 0x16, 0xd5, 0x99, 0x13, 0x1d, 0x87, + 0xbb, 0x3d, 0xae, 0xeb, 0x39, 0xdc, 0x5d, 0xe3, 0xc6, 0x00, 0xab, 0xdc, 0x6c, 0x92, 0x35, 0xe5, + 0x06, 0xc3, 0x43, 0x17, 0x59, 0xcf, 0x2a, 0x17, 0x56, 0x78, 0xf9, 0x33, 0x00, 0xb0, 0x74, 0x13, + 0x0e, 0x5b, 0xc0, 0xf1, 0x07, 0xda, 0xfa, 0x8c, 0xac, 0xce, 0xc6, 0x33, 0xbf, 0x83, 0xb3, 0x9b, + 0x56, 0x6c, 0xf8, 0xe4, 0x7f, 0x65, 0xbf, 0x16, 0x0b, 0xe8, 0xef, 0x25, 0x1e, 0xdd, 0xcc, 0x5f, + 0xff, 0x58, 0xc3, 0xd1, 0x2d, 0xcc, 0xf9, 0xf3, 0xcf, 0xa7, 0x29, 0x37, 0x59, 0xb5, 0x9c, 0xad, + 0x64, 0x31, 0xcf, 0x79, 0x9a, 0x19, 0xc1, 0x45, 0x9a, 0xe3, 0x52, 0xcf, 0x6d, 0xdb, 0xdc, 0xf7, + 0x2e, 0xbb, 0xee, 0xdf, 0x78, 0xf5, 0x2b, 0x00, 0x00, 0xff, 0xff, 0x94, 0x23, 0x1c, 0x6e, 0x52, + 0x03, 0x00, 0x00, } diff --git a/looprpc/server.proto b/looprpc/server.proto index 54c41f9..d486516 100644 --- a/looprpc/server.proto +++ b/looprpc/server.proto @@ -7,34 +7,44 @@ package looprpc; option go_package = "github.com/lightninglabs/loop/looprpc"; service SwapServer { - rpc NewUnchargeSwap(ServerUnchargeSwapRequest) returns (ServerUnchargeSwapResponse); + rpc NewLoopOutSwap(ServerLoopOutRequest) returns (ServerLoopOutResponse); - rpc UnchargeQuote(ServerUnchargeQuoteRequest) returns (ServerUnchargeQuoteResponse); + rpc LoopOutQuote(ServerLoopOutQuoteRequest) returns (ServerLoopOutQuote); } -message ServerUnchargeSwapRequest { +message ServerLoopOutRequest { bytes receiver_key = 1; + bytes swap_hash = 2; + uint64 amt = 3; - } -message ServerUnchargeSwapResponse { +message ServerLoopOutResponse { string swap_invoice= 1; + string prepay_invoice = 2; + bytes sender_key = 3; + int32 expiry = 4; } -message ServerUnchargeQuoteRequest { +message ServerLoopOutQuoteRequest { } -message ServerUnchargeQuoteResponse { +message ServerLoopOutQuote { string swap_payment_dest = 1; + int64 swap_fee_base = 2; + int64 swap_fee_rate = 3; + uint64 prepay_amt = 4; + uint64 min_swap_amount = 5; + uint64 max_swap_amount = 6; + int32 cltv_delta = 7; }