From dd9acfdd4d6f29810312b2a6f79ecdbd2cd2a477 Mon Sep 17 00:00:00 2001 From: Olaoluwa Osuntokun Date: Thu, 7 Jul 2016 15:24:52 -0700 Subject: [PATCH] lnrpc: add pendingchannels RPC call, regenerate protos --- lnrpc/rpc.pb.go | 725 ++++++++++++++++++++++++++++++++++++++---------- lnrpc/rpc.proto | 25 ++ 2 files changed, 606 insertions(+), 144 deletions(-) diff --git a/lnrpc/rpc.pb.go b/lnrpc/rpc.pb.go index 31b51c9e..2a5545cc 100644 --- a/lnrpc/rpc.pb.go +++ b/lnrpc/rpc.pb.go @@ -26,10 +26,15 @@ It has these top-level messages: ListPeersResponse GetInfoRequest GetInfoResponse - OpenChannelRequest - OpenChannelResponse + ConfirmationUpdate + ChannelOpenUpdate + ChannelCloseUpdate CloseChannelRequest - CloseChannelResponse + CloseStatusUpdate + OpenChannelRequest + OpenStatusUpdate + PendingChannelRequest + PendingChannelResponse WalletBalanceRequest WalletBalanceResponse */ @@ -53,6 +58,30 @@ var _ = math.Inf // is compatible with the proto package it is being compiled against. const _ = proto.ProtoPackageIsVersion1 +type ChannelStatus int32 + +const ( + ChannelStatus_ALL ChannelStatus = 0 + ChannelStatus_OPENING ChannelStatus = 1 + ChannelStatus_CLOSING ChannelStatus = 2 +) + +var ChannelStatus_name = map[int32]string{ + 0: "ALL", + 1: "OPENING", + 2: "CLOSING", +} +var ChannelStatus_value = map[string]int32{ + "ALL": 0, + "OPENING": 1, + "CLOSING": 2, +} + +func (x ChannelStatus) String() string { + return proto.EnumName(ChannelStatus_name, int32(x)) +} +func (ChannelStatus) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0} } + type NewAddressRequest_AddressType int32 const ( @@ -292,6 +321,182 @@ func (m *GetInfoResponse) String() string { return proto.CompactTextS func (*GetInfoResponse) ProtoMessage() {} func (*GetInfoResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{16} } +type ConfirmationUpdate struct { + BlockSha []byte `protobuf:"bytes,1,opt,name=block_sha,proto3" json:"block_sha,omitempty"` + BlockHeight int32 `protobuf:"varint,2,opt,name=block_height" json:"block_height,omitempty"` + NumConfsLeft uint32 `protobuf:"varint,3,opt,name=num_confs_left" json:"num_confs_left,omitempty"` +} + +func (m *ConfirmationUpdate) Reset() { *m = ConfirmationUpdate{} } +func (m *ConfirmationUpdate) String() string { return proto.CompactTextString(m) } +func (*ConfirmationUpdate) ProtoMessage() {} +func (*ConfirmationUpdate) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{17} } + +type ChannelOpenUpdate struct { + ChannelPoint *ChannelPoint `protobuf:"bytes,1,opt,name=channel_point" json:"channel_point,omitempty"` +} + +func (m *ChannelOpenUpdate) Reset() { *m = ChannelOpenUpdate{} } +func (m *ChannelOpenUpdate) String() string { return proto.CompactTextString(m) } +func (*ChannelOpenUpdate) ProtoMessage() {} +func (*ChannelOpenUpdate) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{18} } + +func (m *ChannelOpenUpdate) GetChannelPoint() *ChannelPoint { + if m != nil { + return m.ChannelPoint + } + return nil +} + +type ChannelCloseUpdate struct { + ClosingTxid []byte `protobuf:"bytes,1,opt,name=closing_txid,proto3" json:"closing_txid,omitempty"` + Success bool `protobuf:"varint,2,opt,name=success" json:"success,omitempty"` +} + +func (m *ChannelCloseUpdate) Reset() { *m = ChannelCloseUpdate{} } +func (m *ChannelCloseUpdate) String() string { return proto.CompactTextString(m) } +func (*ChannelCloseUpdate) ProtoMessage() {} +func (*ChannelCloseUpdate) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{19} } + +type CloseChannelRequest struct { + ChannelPoint *ChannelPoint `protobuf:"bytes,1,opt,name=channel_point" json:"channel_point,omitempty"` + TimeLimit int64 `protobuf:"varint,2,opt,name=time_limit" json:"time_limit,omitempty"` + AllowForceClose bool `protobuf:"varint,3,opt,name=allow_force_close" json:"allow_force_close,omitempty"` +} + +func (m *CloseChannelRequest) Reset() { *m = CloseChannelRequest{} } +func (m *CloseChannelRequest) String() string { return proto.CompactTextString(m) } +func (*CloseChannelRequest) ProtoMessage() {} +func (*CloseChannelRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{20} } + +func (m *CloseChannelRequest) GetChannelPoint() *ChannelPoint { + if m != nil { + return m.ChannelPoint + } + return nil +} + +type CloseStatusUpdate struct { + // Types that are valid to be assigned to Update: + // *CloseStatusUpdate_Confirmation + // *CloseStatusUpdate_ChanClose + Update isCloseStatusUpdate_Update `protobuf_oneof:"update"` +} + +func (m *CloseStatusUpdate) Reset() { *m = CloseStatusUpdate{} } +func (m *CloseStatusUpdate) String() string { return proto.CompactTextString(m) } +func (*CloseStatusUpdate) ProtoMessage() {} +func (*CloseStatusUpdate) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{21} } + +type isCloseStatusUpdate_Update interface { + isCloseStatusUpdate_Update() +} + +type CloseStatusUpdate_Confirmation struct { + Confirmation *ConfirmationUpdate `protobuf:"bytes,1,opt,name=confirmation,oneof"` +} +type CloseStatusUpdate_ChanClose struct { + ChanClose *ChannelCloseUpdate `protobuf:"bytes,2,opt,name=chan_close,oneof"` +} + +func (*CloseStatusUpdate_Confirmation) isCloseStatusUpdate_Update() {} +func (*CloseStatusUpdate_ChanClose) isCloseStatusUpdate_Update() {} + +func (m *CloseStatusUpdate) GetUpdate() isCloseStatusUpdate_Update { + if m != nil { + return m.Update + } + return nil +} + +func (m *CloseStatusUpdate) GetConfirmation() *ConfirmationUpdate { + if x, ok := m.GetUpdate().(*CloseStatusUpdate_Confirmation); ok { + return x.Confirmation + } + return nil +} + +func (m *CloseStatusUpdate) GetChanClose() *ChannelCloseUpdate { + if x, ok := m.GetUpdate().(*CloseStatusUpdate_ChanClose); ok { + return x.ChanClose + } + return nil +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*CloseStatusUpdate) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { + return _CloseStatusUpdate_OneofMarshaler, _CloseStatusUpdate_OneofUnmarshaler, _CloseStatusUpdate_OneofSizer, []interface{}{ + (*CloseStatusUpdate_Confirmation)(nil), + (*CloseStatusUpdate_ChanClose)(nil), + } +} + +func _CloseStatusUpdate_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*CloseStatusUpdate) + // update + switch x := m.Update.(type) { + case *CloseStatusUpdate_Confirmation: + b.EncodeVarint(1<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.Confirmation); err != nil { + return err + } + case *CloseStatusUpdate_ChanClose: + b.EncodeVarint(2<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.ChanClose); err != nil { + return err + } + case nil: + default: + return fmt.Errorf("CloseStatusUpdate.Update has unexpected type %T", x) + } + return nil +} + +func _CloseStatusUpdate_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*CloseStatusUpdate) + switch tag { + case 1: // update.confirmation + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(ConfirmationUpdate) + err := b.DecodeMessage(msg) + m.Update = &CloseStatusUpdate_Confirmation{msg} + return true, err + case 2: // update.chan_close + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(ChannelCloseUpdate) + err := b.DecodeMessage(msg) + m.Update = &CloseStatusUpdate_ChanClose{msg} + return true, err + default: + return false, nil + } +} + +func _CloseStatusUpdate_OneofSizer(msg proto.Message) (n int) { + m := msg.(*CloseStatusUpdate) + // update + switch x := m.Update.(type) { + case *CloseStatusUpdate_Confirmation: + s := proto.Size(x.Confirmation) + n += proto.SizeVarint(1<<3 | proto.WireBytes) + n += proto.SizeVarint(uint64(s)) + n += s + case *CloseStatusUpdate_ChanClose: + s := proto.Size(x.ChanClose) + n += proto.SizeVarint(2<<3 | proto.WireBytes) + n += proto.SizeVarint(uint64(s)) + n += s + case nil: + default: + panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) + } + return n +} + type OpenChannelRequest struct { TargetPeerId int32 `protobuf:"varint,1,opt,name=target_peer_id" json:"target_peer_id,omitempty"` TargetNode *LightningAddress `protobuf:"bytes,2,opt,name=target_node" json:"target_node,omitempty"` @@ -304,7 +509,7 @@ type OpenChannelRequest struct { func (m *OpenChannelRequest) Reset() { *m = OpenChannelRequest{} } func (m *OpenChannelRequest) String() string { return proto.CompactTextString(m) } func (*OpenChannelRequest) ProtoMessage() {} -func (*OpenChannelRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{17} } +func (*OpenChannelRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{22} } func (m *OpenChannelRequest) GetTargetNode() *LightningAddress { if m != nil { @@ -313,48 +518,169 @@ func (m *OpenChannelRequest) GetTargetNode() *LightningAddress { return nil } -type OpenChannelResponse struct { - ChannelPoint *ChannelPoint `protobuf:"bytes,1,opt,name=channel_point" json:"channel_point,omitempty"` +type OpenStatusUpdate struct { + // Types that are valid to be assigned to Update: + // *OpenStatusUpdate_Confirmation + // *OpenStatusUpdate_ChanOpen + Update isOpenStatusUpdate_Update `protobuf_oneof:"update"` } -func (m *OpenChannelResponse) Reset() { *m = OpenChannelResponse{} } -func (m *OpenChannelResponse) String() string { return proto.CompactTextString(m) } -func (*OpenChannelResponse) ProtoMessage() {} -func (*OpenChannelResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{18} } +func (m *OpenStatusUpdate) Reset() { *m = OpenStatusUpdate{} } +func (m *OpenStatusUpdate) String() string { return proto.CompactTextString(m) } +func (*OpenStatusUpdate) ProtoMessage() {} +func (*OpenStatusUpdate) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{23} } -func (m *OpenChannelResponse) GetChannelPoint() *ChannelPoint { +type isOpenStatusUpdate_Update interface { + isOpenStatusUpdate_Update() +} + +type OpenStatusUpdate_Confirmation struct { + Confirmation *ConfirmationUpdate `protobuf:"bytes,1,opt,name=confirmation,oneof"` +} +type OpenStatusUpdate_ChanOpen struct { + ChanOpen *ChannelOpenUpdate `protobuf:"bytes,2,opt,name=chan_open,oneof"` +} + +func (*OpenStatusUpdate_Confirmation) isOpenStatusUpdate_Update() {} +func (*OpenStatusUpdate_ChanOpen) isOpenStatusUpdate_Update() {} + +func (m *OpenStatusUpdate) GetUpdate() isOpenStatusUpdate_Update { if m != nil { - return m.ChannelPoint + return m.Update } return nil } -type CloseChannelRequest struct { - ChannelPoint *ChannelPoint `protobuf:"bytes,1,opt,name=channel_point" json:"channel_point,omitempty"` - TimeLimit int64 `protobuf:"varint,2,opt,name=time_limit" json:"time_limit,omitempty"` - AllowForceClose bool `protobuf:"varint,3,opt,name=allow_force_close" json:"allow_force_close,omitempty"` -} - -func (m *CloseChannelRequest) Reset() { *m = CloseChannelRequest{} } -func (m *CloseChannelRequest) String() string { return proto.CompactTextString(m) } -func (*CloseChannelRequest) ProtoMessage() {} -func (*CloseChannelRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{19} } - -func (m *CloseChannelRequest) GetChannelPoint() *ChannelPoint { - if m != nil { - return m.ChannelPoint +func (m *OpenStatusUpdate) GetConfirmation() *ConfirmationUpdate { + if x, ok := m.GetUpdate().(*OpenStatusUpdate_Confirmation); ok { + return x.Confirmation } return nil } -type CloseChannelResponse struct { - Success bool `protobuf:"varint,1,opt,name=success" json:"success,omitempty"` +func (m *OpenStatusUpdate) GetChanOpen() *ChannelOpenUpdate { + if x, ok := m.GetUpdate().(*OpenStatusUpdate_ChanOpen); ok { + return x.ChanOpen + } + return nil } -func (m *CloseChannelResponse) Reset() { *m = CloseChannelResponse{} } -func (m *CloseChannelResponse) String() string { return proto.CompactTextString(m) } -func (*CloseChannelResponse) ProtoMessage() {} -func (*CloseChannelResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{20} } +// XXX_OneofFuncs is for the internal use of the proto package. +func (*OpenStatusUpdate) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { + return _OpenStatusUpdate_OneofMarshaler, _OpenStatusUpdate_OneofUnmarshaler, _OpenStatusUpdate_OneofSizer, []interface{}{ + (*OpenStatusUpdate_Confirmation)(nil), + (*OpenStatusUpdate_ChanOpen)(nil), + } +} + +func _OpenStatusUpdate_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*OpenStatusUpdate) + // update + switch x := m.Update.(type) { + case *OpenStatusUpdate_Confirmation: + b.EncodeVarint(1<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.Confirmation); err != nil { + return err + } + case *OpenStatusUpdate_ChanOpen: + b.EncodeVarint(2<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.ChanOpen); err != nil { + return err + } + case nil: + default: + return fmt.Errorf("OpenStatusUpdate.Update has unexpected type %T", x) + } + return nil +} + +func _OpenStatusUpdate_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*OpenStatusUpdate) + switch tag { + case 1: // update.confirmation + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(ConfirmationUpdate) + err := b.DecodeMessage(msg) + m.Update = &OpenStatusUpdate_Confirmation{msg} + return true, err + case 2: // update.chan_open + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(ChannelOpenUpdate) + err := b.DecodeMessage(msg) + m.Update = &OpenStatusUpdate_ChanOpen{msg} + return true, err + default: + return false, nil + } +} + +func _OpenStatusUpdate_OneofSizer(msg proto.Message) (n int) { + m := msg.(*OpenStatusUpdate) + // update + switch x := m.Update.(type) { + case *OpenStatusUpdate_Confirmation: + s := proto.Size(x.Confirmation) + n += proto.SizeVarint(1<<3 | proto.WireBytes) + n += proto.SizeVarint(uint64(s)) + n += s + case *OpenStatusUpdate_ChanOpen: + s := proto.Size(x.ChanOpen) + n += proto.SizeVarint(2<<3 | proto.WireBytes) + n += proto.SizeVarint(uint64(s)) + n += s + case nil: + default: + panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) + } + return n +} + +type PendingChannelRequest struct { + Status ChannelStatus `protobuf:"varint,1,opt,name=status,enum=lnrpc.ChannelStatus" json:"status,omitempty"` +} + +func (m *PendingChannelRequest) Reset() { *m = PendingChannelRequest{} } +func (m *PendingChannelRequest) String() string { return proto.CompactTextString(m) } +func (*PendingChannelRequest) ProtoMessage() {} +func (*PendingChannelRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{24} } + +type PendingChannelResponse struct { + PendingChannels []*PendingChannelResponse_PendingChannel `protobuf:"bytes,1,rep,name=pending_channels" json:"pending_channels,omitempty"` +} + +func (m *PendingChannelResponse) Reset() { *m = PendingChannelResponse{} } +func (m *PendingChannelResponse) String() string { return proto.CompactTextString(m) } +func (*PendingChannelResponse) ProtoMessage() {} +func (*PendingChannelResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{25} } + +func (m *PendingChannelResponse) GetPendingChannels() []*PendingChannelResponse_PendingChannel { + if m != nil { + return m.PendingChannels + } + return nil +} + +type PendingChannelResponse_PendingChannel struct { + PeerId int32 `protobuf:"varint,1,opt,name=peer_id" json:"peer_id,omitempty"` + LightningId string `protobuf:"bytes,2,opt,name=lightning_id" json:"lightning_id,omitempty"` + ChannelPoint string `protobuf:"bytes,3,opt,name=channel_point" json:"channel_point,omitempty"` + Capacity int64 `protobuf:"varint,4,opt,name=capacity" json:"capacity,omitempty"` + LocalBalance int64 `protobuf:"varint,5,opt,name=local_balance" json:"local_balance,omitempty"` + RemoteBalance int64 `protobuf:"varint,6,opt,name=remote_balance" json:"remote_balance,omitempty"` + ClosingTxid string `protobuf:"bytes,7,opt,name=closing_txid" json:"closing_txid,omitempty"` + Status ChannelStatus `protobuf:"varint,8,opt,name=status,enum=lnrpc.ChannelStatus" json:"status,omitempty"` +} + +func (m *PendingChannelResponse_PendingChannel) Reset() { *m = PendingChannelResponse_PendingChannel{} } +func (m *PendingChannelResponse_PendingChannel) String() string { return proto.CompactTextString(m) } +func (*PendingChannelResponse_PendingChannel) ProtoMessage() {} +func (*PendingChannelResponse_PendingChannel) Descriptor() ([]byte, []int) { + return fileDescriptor0, []int{25, 0} +} type WalletBalanceRequest struct { WitnessOnly bool `protobuf:"varint,1,opt,name=witness_only" json:"witness_only,omitempty"` @@ -363,7 +689,7 @@ type WalletBalanceRequest struct { func (m *WalletBalanceRequest) Reset() { *m = WalletBalanceRequest{} } func (m *WalletBalanceRequest) String() string { return proto.CompactTextString(m) } func (*WalletBalanceRequest) ProtoMessage() {} -func (*WalletBalanceRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{21} } +func (*WalletBalanceRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{26} } type WalletBalanceResponse struct { Balance float64 `protobuf:"fixed64,1,opt,name=balance" json:"balance,omitempty"` @@ -372,7 +698,7 @@ type WalletBalanceResponse struct { func (m *WalletBalanceResponse) Reset() { *m = WalletBalanceResponse{} } func (m *WalletBalanceResponse) String() string { return proto.CompactTextString(m) } func (*WalletBalanceResponse) ProtoMessage() {} -func (*WalletBalanceResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{22} } +func (*WalletBalanceResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{27} } func init() { proto.RegisterType((*ChannelPoint)(nil), "lnrpc.ChannelPoint") @@ -392,12 +718,19 @@ func init() { proto.RegisterType((*ListPeersResponse)(nil), "lnrpc.ListPeersResponse") proto.RegisterType((*GetInfoRequest)(nil), "lnrpc.GetInfoRequest") proto.RegisterType((*GetInfoResponse)(nil), "lnrpc.GetInfoResponse") - proto.RegisterType((*OpenChannelRequest)(nil), "lnrpc.OpenChannelRequest") - proto.RegisterType((*OpenChannelResponse)(nil), "lnrpc.OpenChannelResponse") + proto.RegisterType((*ConfirmationUpdate)(nil), "lnrpc.ConfirmationUpdate") + proto.RegisterType((*ChannelOpenUpdate)(nil), "lnrpc.ChannelOpenUpdate") + proto.RegisterType((*ChannelCloseUpdate)(nil), "lnrpc.ChannelCloseUpdate") proto.RegisterType((*CloseChannelRequest)(nil), "lnrpc.CloseChannelRequest") - proto.RegisterType((*CloseChannelResponse)(nil), "lnrpc.CloseChannelResponse") + proto.RegisterType((*CloseStatusUpdate)(nil), "lnrpc.CloseStatusUpdate") + proto.RegisterType((*OpenChannelRequest)(nil), "lnrpc.OpenChannelRequest") + proto.RegisterType((*OpenStatusUpdate)(nil), "lnrpc.OpenStatusUpdate") + proto.RegisterType((*PendingChannelRequest)(nil), "lnrpc.PendingChannelRequest") + proto.RegisterType((*PendingChannelResponse)(nil), "lnrpc.PendingChannelResponse") + proto.RegisterType((*PendingChannelResponse_PendingChannel)(nil), "lnrpc.PendingChannelResponse.PendingChannel") proto.RegisterType((*WalletBalanceRequest)(nil), "lnrpc.WalletBalanceRequest") proto.RegisterType((*WalletBalanceResponse)(nil), "lnrpc.WalletBalanceResponse") + proto.RegisterEnum("lnrpc.ChannelStatus", ChannelStatus_name, ChannelStatus_value) proto.RegisterEnum("lnrpc.NewAddressRequest_AddressType", NewAddressRequest_AddressType_name, NewAddressRequest_AddressType_value) } @@ -419,8 +752,9 @@ type LightningClient interface { ConnectPeer(ctx context.Context, in *ConnectPeerRequest, opts ...grpc.CallOption) (*ConnectPeerResponse, error) ListPeers(ctx context.Context, in *ListPeersRequest, opts ...grpc.CallOption) (*ListPeersResponse, error) GetInfo(ctx context.Context, in *GetInfoRequest, opts ...grpc.CallOption) (*GetInfoResponse, error) - OpenChannel(ctx context.Context, in *OpenChannelRequest, opts ...grpc.CallOption) (*OpenChannelResponse, error) - CloseChannel(ctx context.Context, in *CloseChannelRequest, opts ...grpc.CallOption) (*CloseChannelResponse, error) + OpenChannel(ctx context.Context, in *OpenChannelRequest, opts ...grpc.CallOption) (Lightning_OpenChannelClient, error) + CloseChannel(ctx context.Context, in *CloseChannelRequest, opts ...grpc.CallOption) (Lightning_CloseChannelClient, error) + PendingChannels(ctx context.Context, in *PendingChannelRequest, opts ...grpc.CallOption) (*PendingChannelResponse, error) } type lightningClient struct { @@ -494,18 +828,73 @@ func (c *lightningClient) GetInfo(ctx context.Context, in *GetInfoRequest, opts return out, nil } -func (c *lightningClient) OpenChannel(ctx context.Context, in *OpenChannelRequest, opts ...grpc.CallOption) (*OpenChannelResponse, error) { - out := new(OpenChannelResponse) - err := grpc.Invoke(ctx, "/lnrpc.Lightning/OpenChannel", in, out, c.cc, opts...) +func (c *lightningClient) OpenChannel(ctx context.Context, in *OpenChannelRequest, opts ...grpc.CallOption) (Lightning_OpenChannelClient, error) { + stream, err := grpc.NewClientStream(ctx, &_Lightning_serviceDesc.Streams[0], c.cc, "/lnrpc.Lightning/OpenChannel", opts...) if err != nil { return nil, err } - return out, nil + x := &lightningOpenChannelClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil } -func (c *lightningClient) CloseChannel(ctx context.Context, in *CloseChannelRequest, opts ...grpc.CallOption) (*CloseChannelResponse, error) { - out := new(CloseChannelResponse) - err := grpc.Invoke(ctx, "/lnrpc.Lightning/CloseChannel", in, out, c.cc, opts...) +type Lightning_OpenChannelClient interface { + Recv() (*ChannelOpenUpdate, error) + grpc.ClientStream +} + +type lightningOpenChannelClient struct { + grpc.ClientStream +} + +func (x *lightningOpenChannelClient) Recv() (*ChannelOpenUpdate, error) { + m := new(ChannelOpenUpdate) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func (c *lightningClient) CloseChannel(ctx context.Context, in *CloseChannelRequest, opts ...grpc.CallOption) (Lightning_CloseChannelClient, error) { + stream, err := grpc.NewClientStream(ctx, &_Lightning_serviceDesc.Streams[1], c.cc, "/lnrpc.Lightning/CloseChannel", opts...) + if err != nil { + return nil, err + } + x := &lightningCloseChannelClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type Lightning_CloseChannelClient interface { + Recv() (*ChannelCloseUpdate, error) + grpc.ClientStream +} + +type lightningCloseChannelClient struct { + grpc.ClientStream +} + +func (x *lightningCloseChannelClient) Recv() (*ChannelCloseUpdate, error) { + m := new(ChannelCloseUpdate) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func (c *lightningClient) PendingChannels(ctx context.Context, in *PendingChannelRequest, opts ...grpc.CallOption) (*PendingChannelResponse, error) { + out := new(PendingChannelResponse) + err := grpc.Invoke(ctx, "/lnrpc.Lightning/PendingChannels", in, out, c.cc, opts...) if err != nil { return nil, err } @@ -522,8 +911,9 @@ type LightningServer interface { ConnectPeer(context.Context, *ConnectPeerRequest) (*ConnectPeerResponse, error) ListPeers(context.Context, *ListPeersRequest) (*ListPeersResponse, error) GetInfo(context.Context, *GetInfoRequest) (*GetInfoResponse, error) - OpenChannel(context.Context, *OpenChannelRequest) (*OpenChannelResponse, error) - CloseChannel(context.Context, *CloseChannelRequest) (*CloseChannelResponse, error) + OpenChannel(*OpenChannelRequest, Lightning_OpenChannelServer) error + CloseChannel(*CloseChannelRequest, Lightning_CloseChannelServer) error + PendingChannels(context.Context, *PendingChannelRequest) (*PendingChannelResponse, error) } func RegisterLightningServer(s *grpc.Server, srv LightningServer) { @@ -656,38 +1046,62 @@ func _Lightning_GetInfo_Handler(srv interface{}, ctx context.Context, dec func(i return interceptor(ctx, in, info, handler) } -func _Lightning_OpenChannel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(OpenChannelRequest) - if err := dec(in); err != nil { - return nil, err +func _Lightning_OpenChannel_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(OpenChannelRequest) + if err := stream.RecvMsg(m); err != nil { + return err } - if interceptor == nil { - return srv.(LightningServer).OpenChannel(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/lnrpc.Lightning/OpenChannel", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(LightningServer).OpenChannel(ctx, req.(*OpenChannelRequest)) - } - return interceptor(ctx, in, info, handler) + return srv.(LightningServer).OpenChannel(m, &lightningOpenChannelServer{stream}) } -func _Lightning_CloseChannel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(CloseChannelRequest) +type Lightning_OpenChannelServer interface { + Send(*ChannelOpenUpdate) error + grpc.ServerStream +} + +type lightningOpenChannelServer struct { + grpc.ServerStream +} + +func (x *lightningOpenChannelServer) Send(m *ChannelOpenUpdate) error { + return x.ServerStream.SendMsg(m) +} + +func _Lightning_CloseChannel_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(CloseChannelRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(LightningServer).CloseChannel(m, &lightningCloseChannelServer{stream}) +} + +type Lightning_CloseChannelServer interface { + Send(*ChannelCloseUpdate) error + grpc.ServerStream +} + +type lightningCloseChannelServer struct { + grpc.ServerStream +} + +func (x *lightningCloseChannelServer) Send(m *ChannelCloseUpdate) error { + return x.ServerStream.SendMsg(m) +} + +func _Lightning_PendingChannels_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(PendingChannelRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { - return srv.(LightningServer).CloseChannel(ctx, in) + return srv.(LightningServer).PendingChannels(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/lnrpc.Lightning/CloseChannel", + FullMethod: "/lnrpc.Lightning/PendingChannels", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(LightningServer).CloseChannel(ctx, req.(*CloseChannelRequest)) + return srv.(LightningServer).PendingChannels(ctx, req.(*PendingChannelRequest)) } return interceptor(ctx, in, info, handler) } @@ -725,85 +1139,108 @@ var _Lightning_serviceDesc = grpc.ServiceDesc{ Handler: _Lightning_GetInfo_Handler, }, { - MethodName: "OpenChannel", - Handler: _Lightning_OpenChannel_Handler, - }, - { - MethodName: "CloseChannel", - Handler: _Lightning_CloseChannel_Handler, + MethodName: "PendingChannels", + Handler: _Lightning_PendingChannels_Handler, + }, + }, + Streams: []grpc.StreamDesc{ + { + StreamName: "OpenChannel", + Handler: _Lightning_OpenChannel_Handler, + ServerStreams: true, + }, + { + StreamName: "CloseChannel", + Handler: _Lightning_CloseChannel_Handler, + ServerStreams: true, }, }, - Streams: []grpc.StreamDesc{}, } var fileDescriptor0 = []byte{ - // 1076 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x94, 0x56, 0xcd, 0x6e, 0xdb, 0x46, - 0x10, 0xae, 0x2c, 0xc9, 0x96, 0x46, 0x96, 0x2d, 0xad, 0xfc, 0xa3, 0xc8, 0x29, 0x90, 0x2e, 0x9a, - 0xd4, 0x28, 0x02, 0xb7, 0x70, 0x7a, 0x08, 0x12, 0x20, 0x80, 0x62, 0x1b, 0x71, 0x9a, 0x34, 0x31, - 0x6a, 0x17, 0x41, 0x4f, 0x04, 0x45, 0xae, 0x2d, 0x22, 0xd4, 0x2e, 0xab, 0x5d, 0xda, 0x51, 0x1f, - 0xa0, 0xd7, 0x5e, 0xfb, 0x3e, 0xbd, 0xf7, 0x31, 0xfa, 0x1c, 0x9d, 0x5d, 0xee, 0x92, 0xd4, 0x4f, - 0x0e, 0x3d, 0x72, 0xe6, 0xdb, 0xd9, 0xf9, 0x66, 0xbe, 0x99, 0x25, 0x34, 0xa7, 0x49, 0x70, 0x94, - 0x4c, 0x85, 0x12, 0xa4, 0x1e, 0x73, 0xfc, 0xa0, 0xcf, 0x60, 0xf3, 0x64, 0xec, 0x73, 0xce, 0xe2, - 0x0b, 0x11, 0x71, 0x45, 0x76, 0x60, 0xf3, 0x3a, 0xe5, 0x61, 0xc4, 0x6f, 0x3c, 0xf5, 0x29, 0x0a, - 0xfb, 0x95, 0x07, 0x95, 0xc3, 0x4d, 0x6d, 0x15, 0xa9, 0x4a, 0x52, 0xe5, 0x45, 0x3c, 0x64, 0x9f, - 0xfa, 0x6b, 0x68, 0x6d, 0xd3, 0x1f, 0xa0, 0xf3, 0x36, 0xba, 0x19, 0x2b, 0x8e, 0xe8, 0x61, 0x18, - 0x4e, 0x99, 0x94, 0x84, 0x00, 0x24, 0xe9, 0xe8, 0x0d, 0x9b, 0x9d, 0xfb, 0x72, 0x6c, 0x4e, 0x37, - 0xc9, 0x26, 0xd4, 0xc6, 0x42, 0x2a, 0x73, 0xaa, 0x49, 0xff, 0xa8, 0xc0, 0xf6, 0x25, 0xe3, 0xe1, - 0x4f, 0x3e, 0x9f, 0xfd, 0xcc, 0x7e, 0x4b, 0x99, 0x54, 0xe4, 0x05, 0x6c, 0xea, 0x00, 0x57, 0x62, - 0x38, 0x11, 0x29, 0x57, 0x78, 0xae, 0x7a, 0xd8, 0x3a, 0x3e, 0x3c, 0x32, 0x39, 0x1e, 0x2d, 0xa0, - 0x8f, 0xca, 0xd0, 0x33, 0xae, 0xa6, 0xb3, 0xc1, 0x13, 0xe8, 0x2e, 0x19, 0x49, 0x0b, 0xaa, 0x1f, - 0xd9, 0xcc, 0xe6, 0xd0, 0x86, 0xfa, 0xad, 0x1f, 0xa7, 0xcc, 0x24, 0x51, 0x7d, 0xb6, 0xf6, 0xb4, - 0x42, 0x1f, 0x40, 0xa7, 0x88, 0x2c, 0x13, 0xc1, 0x25, 0xd3, 0xa9, 0xe6, 0xb4, 0x9b, 0xf4, 0xfb, - 0x0c, 0x71, 0x82, 0x95, 0x91, 0x2e, 0x55, 0x44, 0xf8, 0x78, 0x95, 0x0d, 0xbb, 0x05, 0xeb, 0x7e, - 0x96, 0xb2, 0x89, 0x4b, 0xbf, 0x82, 0x6e, 0xe9, 0xc4, 0xca, 0xa0, 0x7f, 0x55, 0xa0, 0xfb, 0x8e, - 0xdd, 0xd9, 0x82, 0xb9, 0xb0, 0xc7, 0x88, 0x99, 0x25, 0xcc, 0x60, 0xb6, 0x8e, 0xbf, 0xb6, 0xcc, - 0x97, 0x70, 0x47, 0xf6, 0xf3, 0x0a, 0xb1, 0xf4, 0x3d, 0xb4, 0x4a, 0x9f, 0x64, 0x1f, 0x7a, 0x1f, - 0x5e, 0x5f, 0xbd, 0x3b, 0xbb, 0xbc, 0xf4, 0x2e, 0x7e, 0x79, 0xf9, 0xe6, 0xec, 0x57, 0xef, 0x7c, - 0x78, 0x79, 0xde, 0xf9, 0x82, 0xec, 0x01, 0x41, 0xeb, 0xd5, 0xd9, 0xe9, 0x9c, 0xbd, 0x42, 0xb6, - 0xa1, 0x55, 0x36, 0xac, 0xd1, 0x87, 0x08, 0x2c, 0xdd, 0x68, 0xd3, 0xdf, 0x86, 0x0d, 0x3f, 0x33, - 0x59, 0x06, 0xcf, 0x81, 0x9c, 0x08, 0x94, 0x4c, 0xa0, 0x2e, 0x18, 0x9b, 0x3a, 0x06, 0x0f, 0x4b, - 0x85, 0x69, 0x1d, 0xef, 0x5b, 0x06, 0x8b, 0x02, 0xa1, 0x8f, 0xa0, 0x37, 0x77, 0xb8, 0xb8, 0x24, - 0xc1, 0x6f, 0xcf, 0x96, 0xa9, 0x4e, 0x4f, 0xa1, 0x76, 0x7e, 0xf5, 0xf6, 0x04, 0xf5, 0xb4, 0x66, - 0x6d, 0xd5, 0xc5, 0x6a, 0x93, 0x2e, 0x34, 0xc7, 0x28, 0x33, 0x2f, 0x16, 0xc1, 0xc7, 0x7e, 0xd5, - 0x28, 0x15, 0xfb, 0xac, 0x84, 0x97, 0xca, 0x7e, 0x0d, 0x3f, 0x1b, 0xf4, 0x9f, 0x0a, 0xb4, 0x87, - 0x81, 0x8a, 0x6e, 0x99, 0x55, 0xb9, 0x3e, 0x33, 0x65, 0x13, 0xa1, 0x98, 0xbb, 0xaa, 0x49, 0x76, - 0xa1, 0x1d, 0x64, 0x5e, 0x2f, 0xd1, 0x43, 0x90, 0x09, 0x95, 0x74, 0xa0, 0x11, 0xf8, 0x89, 0x1f, - 0x44, 0x6a, 0x66, 0x82, 0x57, 0x35, 0x10, 0xaf, 0xf2, 0x63, 0x6f, 0xe4, 0xc7, 0x3e, 0x0f, 0x98, - 0xb9, 0xa4, 0x8a, 0xf5, 0xdd, 0xb2, 0x21, 0x9d, 0xbd, 0x6e, 0xec, 0xf7, 0xa0, 0x9b, 0x22, 0x37, - 0xa5, 0x62, 0x16, 0x7a, 0x23, 0x96, 0xb9, 0xd6, 0x8d, 0x8b, 0x42, 0x3b, 0x61, 0xd9, 0x98, 0x8d, - 0x55, 0x1c, 0xc8, 0xfe, 0x86, 0x51, 0x7c, 0xcb, 0x56, 0xcd, 0x30, 0xef, 0x41, 0x8b, 0xa7, 0x13, - 0x2f, 0x4d, 0x42, 0x5f, 0x31, 0xd9, 0x6f, 0xe0, 0xc1, 0x1a, 0xfd, 0xbb, 0x02, 0x35, 0x5d, 0x38, - 0x3d, 0x92, 0xb1, 0xab, 0x6d, 0x41, 0xa5, 0x54, 0x46, 0x4d, 0xa2, 0x5e, 0x6e, 0x5e, 0xd5, 0x20, - 0xb0, 0xa0, 0xa3, 0x19, 0xc6, 0xf3, 0x24, 0x43, 0xa6, 0x9a, 0x40, 0xad, 0xb0, 0x4d, 0x59, 0x70, - 0x6b, 0x92, 0xaf, 0x69, 0xf6, 0xd2, 0x57, 0x19, 0x2a, 0xcb, 0xd9, 0x5a, 0x0c, 0x66, 0xc3, 0x58, - 0x30, 0x78, 0xc4, 0x47, 0xd8, 0x90, 0xd0, 0x64, 0xd7, 0x20, 0x8f, 0xb0, 0x64, 0x59, 0x25, 0x65, - 0xbf, 0x69, 0x18, 0xed, 0x58, 0x46, 0x73, 0x4d, 0xa0, 0x44, 0x6f, 0x0e, 0x69, 0x14, 0xe0, 0x94, - 0x4d, 0xbf, 0x83, 0x6e, 0xc9, 0x66, 0x65, 0x31, 0x80, 0xba, 0xe6, 0x23, 0xed, 0x46, 0x70, 0xf5, - 0xd1, 0x20, 0xda, 0x81, 0xad, 0x57, 0x4c, 0xbd, 0xe6, 0xd7, 0xc2, 0x85, 0xf8, 0x13, 0x57, 0x4b, - 0x6e, 0xb2, 0x11, 0x56, 0xd7, 0xa9, 0x0f, 0x9d, 0x28, 0x44, 0x6a, 0xd8, 0x5b, 0xcf, 0xd5, 0x27, - 0xeb, 0xfa, 0x7d, 0xd8, 0xd1, 0x55, 0x77, 0xdd, 0xc9, 0xe9, 0xe8, 0xea, 0xb5, 0xc9, 0x01, 0xf4, - 0xb4, 0xd7, 0x37, 0x6c, 0x0a, 0x67, 0xcd, 0x38, 0x51, 0x5a, 0xd9, 0x51, 0x9d, 0x70, 0xdd, 0xac, - 0x48, 0x6c, 0x17, 0x79, 0x8f, 0xb1, 0x2c, 0x71, 0x37, 0x2b, 0xa8, 0x18, 0xe5, 0x4f, 0x6f, 0x98, - 0xf2, 0xe6, 0x44, 0x4f, 0x1e, 0x43, 0xcb, 0xda, 0xb9, 0x08, 0xb3, 0x5d, 0xf5, 0xf9, 0x51, 0xd2, - 0xa9, 0x66, 0x72, 0x74, 0x1b, 0xdb, 0x0e, 0x47, 0x26, 0xd6, 0x2f, 0x61, 0xd7, 0xaa, 0x72, 0xc1, - 0x9d, 0x89, 0x76, 0x1f, 0xb6, 0x03, 0x31, 0x99, 0x44, 0x52, 0x46, 0x82, 0x7b, 0x32, 0xfa, 0xdd, - 0xa9, 0xd6, 0xb2, 0x08, 0x04, 0xbf, 0x96, 0xa6, 0xf3, 0x6d, 0x3a, 0x84, 0xde, 0x1c, 0x09, 0x5b, - 0xda, 0x6f, 0x17, 0xe7, 0x26, 0x1b, 0xfd, 0x9e, 0xcd, 0xb7, 0xfc, 0xae, 0xd0, 0x04, 0xc7, 0x3e, - 0x16, 0x92, 0x2d, 0x14, 0xe2, 0x7f, 0x84, 0xd0, 0x2a, 0x55, 0xd1, 0x84, 0x79, 0x71, 0x34, 0x89, - 0xdc, 0x06, 0xc0, 0x11, 0xf3, 0xe3, 0x58, 0xdc, 0x79, 0xd7, 0x62, 0x1a, 0x60, 0x43, 0xf4, 0x15, - 0x86, 0x7f, 0x83, 0x7e, 0x03, 0x3b, 0xf3, 0x37, 0x16, 0x9b, 0x46, 0xa6, 0x41, 0xe0, 0xd6, 0x59, - 0x83, 0x3e, 0x86, 0x9d, 0x0f, 0x18, 0x84, 0xa9, 0x97, 0xd9, 0xf4, 0xba, 0xdc, 0x50, 0x39, 0x77, - 0x91, 0xe2, 0x08, 0xf4, 0x04, 0x8f, 0x67, 0x16, 0x7d, 0x08, 0xbb, 0x0b, 0xe8, 0x22, 0xae, 0x1b, - 0x7f, 0x8d, 0xac, 0x1c, 0xff, 0x5b, 0x83, 0x66, 0xde, 0x33, 0xf2, 0x23, 0xb4, 0xe7, 0xce, 0x91, - 0x03, 0xcb, 0x71, 0xd5, 0xdd, 0x83, 0xfb, 0xab, 0x9d, 0xf6, 0xaa, 0xe7, 0xd0, 0x70, 0x2f, 0x17, - 0xd9, 0x5b, 0xfd, 0x48, 0x0e, 0xf6, 0x97, 0xec, 0xf6, 0xf0, 0x0b, 0x68, 0xe6, 0x4f, 0x14, 0x29, - 0xa3, 0xca, 0xcf, 0xdc, 0xa0, 0xbf, 0xec, 0xb0, 0xe7, 0x87, 0x00, 0xc5, 0x23, 0x41, 0xfa, 0x9f, - 0x7b, 0xa9, 0x06, 0xf7, 0x56, 0x78, 0x6c, 0x88, 0x53, 0x68, 0x95, 0xde, 0x00, 0xe2, 0x90, 0xcb, - 0x8f, 0xca, 0x60, 0xb0, 0xca, 0x55, 0x10, 0xc9, 0x17, 0x06, 0x29, 0x86, 0x64, 0x7e, 0xad, 0xe4, - 0x44, 0x96, 0x77, 0xcb, 0x53, 0xd8, 0xb0, 0xcb, 0x82, 0xec, 0x5a, 0xd0, 0xfc, 0x3e, 0x19, 0xec, - 0x2d, 0x9a, 0x8b, 0xfc, 0x4b, 0xf3, 0x90, 0xe7, 0xbf, 0x3c, 0xe8, 0x79, 0xfe, 0xab, 0xc6, 0xe7, - 0x15, 0xfe, 0x7a, 0x95, 0x04, 0x4a, 0x72, 0xae, 0xcb, 0x73, 0x32, 0x38, 0x58, 0xe9, 0xcb, 0x02, - 0x8d, 0xd6, 0xcd, 0x1f, 0xdd, 0x93, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0xa5, 0x75, 0xea, 0x81, - 0xde, 0x09, 0x00, 0x00, + // 1341 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xa4, 0x57, 0x4b, 0x6f, 0x13, 0x57, + 0x14, 0xc6, 0xaf, 0xd8, 0x3e, 0x8e, 0x13, 0xfb, 0xe6, 0x65, 0x06, 0x90, 0xe8, 0x08, 0x50, 0x84, + 0x68, 0xa0, 0xa1, 0x0b, 0x04, 0x2a, 0x55, 0x30, 0x29, 0xa6, 0xa4, 0x49, 0x54, 0x07, 0xa1, 0xae, + 0x46, 0xe3, 0xf1, 0x0d, 0x1e, 0x31, 0x9e, 0x99, 0xfa, 0xde, 0x01, 0xdc, 0x45, 0xa5, 0x6e, 0xba, + 0xed, 0xb6, 0xbf, 0xa2, 0xcb, 0xfe, 0x81, 0x2e, 0x2b, 0xf5, 0x37, 0xf5, 0xdc, 0xc7, 0x78, 0x5e, + 0x36, 0x52, 0xd5, 0xe5, 0x9c, 0x7b, 0x9e, 0xdf, 0x3d, 0xe7, 0x3b, 0x77, 0xa0, 0x39, 0x0b, 0x9d, + 0x83, 0x70, 0x16, 0xf0, 0x80, 0xd4, 0x3c, 0x1f, 0x3f, 0xcc, 0xc7, 0xb0, 0xde, 0x9f, 0xd8, 0xbe, + 0x4f, 0xbd, 0xf3, 0xc0, 0xf5, 0x39, 0xd9, 0x86, 0xf5, 0xcb, 0xc8, 0x1f, 0xbb, 0xfe, 0x5b, 0x8b, + 0x7f, 0x74, 0xc7, 0xbd, 0xd2, 0xcd, 0xd2, 0xfe, 0xba, 0x90, 0x06, 0x11, 0x0f, 0x23, 0x6e, 0xb9, + 0xfe, 0x98, 0x7e, 0xec, 0x95, 0x51, 0xda, 0x36, 0xbf, 0x84, 0xce, 0x89, 0xfb, 0x76, 0xc2, 0x7d, + 0xd4, 0x3e, 0x1a, 0x8f, 0x67, 0x94, 0x31, 0x42, 0x00, 0xc2, 0x68, 0xf4, 0x8a, 0xce, 0x07, 0x36, + 0x9b, 0x48, 0xeb, 0x26, 0x59, 0x87, 0xea, 0x24, 0x60, 0x5c, 0x5a, 0x35, 0xcd, 0x5f, 0x4b, 0xb0, + 0x39, 0xa4, 0xfe, 0xf8, 0x3b, 0xdb, 0x9f, 0x7f, 0x4f, 0x7f, 0x8c, 0x28, 0xe3, 0xe4, 0x29, 0xac, + 0x0b, 0x07, 0x17, 0xc1, 0xd1, 0x34, 0x88, 0x7c, 0x8e, 0x76, 0x95, 0xfd, 0xd6, 0xe1, 0xfe, 0x81, + 0xcc, 0xf1, 0x20, 0xa7, 0x7d, 0x90, 0x56, 0x3d, 0xf6, 0xf9, 0x6c, 0x6e, 0x3c, 0x84, 0x6e, 0x41, + 0x48, 0x5a, 0x50, 0x79, 0x47, 0xe7, 0x3a, 0x87, 0x36, 0xd4, 0xde, 0xdb, 0x5e, 0x44, 0x65, 0x12, + 0x95, 0xc7, 0xe5, 0x47, 0x25, 0xf3, 0x26, 0x74, 0x12, 0xcf, 0x2c, 0x0c, 0x7c, 0x46, 0x45, 0xaa, + 0x8b, 0xb2, 0x9b, 0xe6, 0x03, 0xa5, 0xd1, 0x47, 0x64, 0x58, 0x9c, 0x2a, 0x6a, 0xd8, 0x18, 0x4a, + 0xbb, 0xdd, 0x80, 0x35, 0x5b, 0xa5, 0x2c, 0xfd, 0x9a, 0x9f, 0x41, 0x37, 0x65, 0xb1, 0xd4, 0xe9, + 0xef, 0x25, 0xe8, 0x9e, 0xd2, 0x0f, 0x1a, 0xb0, 0xd8, 0xed, 0x21, 0xea, 0xcc, 0x43, 0x2a, 0x75, + 0x36, 0x0e, 0x6f, 0xe9, 0xca, 0x0b, 0x7a, 0x07, 0xfa, 0xf3, 0x02, 0x75, 0xcd, 0x33, 0x68, 0xa5, + 0x3e, 0xc9, 0x1e, 0x6c, 0xbd, 0x79, 0x79, 0x71, 0x7a, 0x3c, 0x1c, 0x5a, 0xe7, 0xaf, 0x9f, 0xbd, + 0x3a, 0xfe, 0xc1, 0x1a, 0x1c, 0x0d, 0x07, 0x9d, 0x2b, 0x64, 0x17, 0x08, 0x4a, 0x2f, 0x8e, 0x9f, + 0x67, 0xe4, 0x25, 0xb2, 0x09, 0xad, 0xb4, 0xa0, 0x6c, 0xde, 0x46, 0xc5, 0x54, 0x44, 0x9d, 0xfe, + 0x26, 0xd4, 0x6d, 0x25, 0xd2, 0x15, 0x3c, 0x01, 0xd2, 0x0f, 0xb0, 0x65, 0x1c, 0x7e, 0x4e, 0xe9, + 0x2c, 0xae, 0xe0, 0x76, 0x0a, 0x98, 0xd6, 0xe1, 0x9e, 0xae, 0x20, 0xdf, 0x20, 0xe6, 0x1d, 0xd8, + 0xca, 0x18, 0x27, 0x41, 0x42, 0xfc, 0xb6, 0x34, 0x4c, 0x35, 0xf3, 0x39, 0x54, 0x07, 0x17, 0x27, + 0x7d, 0xec, 0xa7, 0xb2, 0x96, 0x55, 0xf2, 0x68, 0x93, 0x2e, 0x34, 0x27, 0xd8, 0x66, 0x96, 0x17, + 0x38, 0xef, 0x7a, 0x15, 0xd9, 0xa9, 0x78, 0xcf, 0x3c, 0xb0, 0x22, 0xd6, 0xab, 0xe2, 0x67, 0xc3, + 0xfc, 0xa7, 0x04, 0xed, 0x23, 0x87, 0xbb, 0xef, 0xa9, 0xee, 0x72, 0x61, 0x33, 0xa3, 0xd3, 0x80, + 0xd3, 0x38, 0x54, 0x93, 0xec, 0x40, 0xdb, 0x51, 0xa7, 0x56, 0x28, 0x86, 0x40, 0x35, 0x2a, 0xe9, + 0x40, 0xc3, 0xb1, 0x43, 0xdb, 0x71, 0xf9, 0x5c, 0x3a, 0xaf, 0x08, 0x45, 0x0c, 0x65, 0x7b, 0xd6, + 0xc8, 0xf6, 0x6c, 0xdf, 0xa1, 0x32, 0x48, 0x05, 0xf1, 0xdd, 0xd0, 0x2e, 0x63, 0x79, 0x4d, 0xca, + 0xaf, 0x42, 0x37, 0xc2, 0xda, 0x38, 0xf7, 0xe8, 0xd8, 0x1a, 0x51, 0x75, 0xb4, 0x26, 0x8f, 0x4c, + 0x68, 0x87, 0x54, 0x8d, 0xd9, 0x84, 0x7b, 0x0e, 0xeb, 0xd5, 0x65, 0xc7, 0xb7, 0x34, 0x6a, 0xb2, + 0xf2, 0x2d, 0x68, 0xf9, 0xd1, 0xd4, 0x8a, 0xc2, 0xb1, 0xcd, 0x29, 0xeb, 0x35, 0xd0, 0xb0, 0x6a, + 0xfe, 0x55, 0x82, 0xaa, 0x00, 0x4e, 0x8c, 0xa4, 0x17, 0x63, 0x9b, 0x94, 0x92, 0x82, 0x51, 0x14, + 0x51, 0x4b, 0x5f, 0x5e, 0x45, 0x6a, 0x20, 0xa0, 0xa3, 0x39, 0xfa, 0xb3, 0x18, 0xc5, 0x4a, 0x45, + 0x01, 0xd5, 0x44, 0x36, 0xa3, 0xce, 0x7b, 0x99, 0x7c, 0x55, 0x54, 0xcf, 0x6c, 0xae, 0xb4, 0x54, + 0xce, 0x5a, 0x22, 0x75, 0xea, 0x52, 0x82, 0xce, 0x5d, 0x7f, 0x84, 0x17, 0x32, 0x96, 0xd9, 0x35, + 0xc8, 0x1d, 0x84, 0x4c, 0x21, 0xc9, 0x7a, 0x4d, 0x59, 0xd1, 0xb6, 0xae, 0x28, 0x73, 0x09, 0x26, + 0x11, 0xcc, 0xc1, 0x64, 0x07, 0xc4, 0x9d, 0x6d, 0xde, 0x87, 0x6e, 0x4a, 0xa6, 0xdb, 0xc2, 0x80, + 0x9a, 0xa8, 0x87, 0x69, 0x46, 0x88, 0xf1, 0x11, 0x4a, 0x66, 0x07, 0x36, 0x5e, 0x50, 0xfe, 0xd2, + 0xbf, 0x0c, 0x62, 0x17, 0xbf, 0x21, 0xb5, 0x2c, 0x44, 0xda, 0xc3, 0x72, 0x9c, 0x7a, 0xd0, 0x71, + 0xc7, 0x58, 0x1a, 0xde, 0xad, 0x15, 0xe3, 0xa3, 0x6e, 0xfd, 0x3a, 0x6c, 0x0b, 0xd4, 0xe3, 0xdb, + 0x59, 0x94, 0x23, 0xd0, 0x6b, 0x93, 0x6b, 0xb0, 0x25, 0x4e, 0x6d, 0x59, 0x4d, 0x72, 0x58, 0x95, + 0x87, 0xd8, 0x5a, 0xca, 0x54, 0x24, 0x5c, 0x93, 0x14, 0xf9, 0x5a, 0x8e, 0xca, 0xa5, 0x3b, 0x9b, + 0xda, 0xdc, 0x0d, 0xfc, 0xd7, 0xf2, 0x2e, 0x85, 0xe2, 0x48, 0xf4, 0xac, 0xc5, 0x26, 0x76, 0xc2, + 0xb0, 0x4a, 0x34, 0xa1, 0x22, 0x5b, 0x7d, 0x7b, 0xd8, 0x59, 0xc2, 0xa3, 0x83, 0x2e, 0x98, 0xe5, + 0xd1, 0x4b, 0xae, 0xd2, 0x30, 0xbf, 0x86, 0xae, 0x86, 0xf2, 0x0c, 0x13, 0xd5, 0x5e, 0xef, 0xe6, + 0xdb, 0x58, 0x4d, 0xe2, 0x96, 0xc6, 0x2c, 0x4d, 0xf3, 0x72, 0x84, 0xd5, 0x77, 0xdf, 0x0b, 0x18, + 0xd5, 0x1e, 0x30, 0x09, 0x07, 0x3f, 0x73, 0xe4, 0x8f, 0xb7, 0xcc, 0x22, 0xc7, 0x89, 0x21, 0x6a, + 0x98, 0x21, 0x8e, 0xb0, 0xb0, 0xd2, 0x1e, 0x62, 0x02, 0xf8, 0x0f, 0xf1, 0x45, 0xc7, 0x71, 0x77, + 0x4a, 0x2d, 0xcf, 0x9d, 0xba, 0xf1, 0x34, 0xe3, 0xb8, 0xd8, 0x9e, 0x17, 0x7c, 0xb0, 0x2e, 0x83, + 0x99, 0x83, 0xe0, 0x8a, 0x10, 0xb2, 0xde, 0x86, 0xf9, 0x0b, 0x72, 0xa6, 0x0c, 0x39, 0xe4, 0x36, + 0x8f, 0x98, 0x4e, 0xf7, 0x0b, 0x4c, 0x37, 0x05, 0xae, 0x8e, 0x77, 0x35, 0x8e, 0x57, 0xc0, 0x7d, + 0x70, 0x85, 0xdc, 0x07, 0x10, 0x39, 0x6a, 0xe7, 0xe5, 0xac, 0x41, 0x01, 0x90, 0xc1, 0x95, 0x67, + 0x0d, 0x58, 0x53, 0x03, 0x28, 0x26, 0x8f, 0x08, 0xb4, 0x73, 0x55, 0xe3, 0x15, 0x71, 0x7b, 0xf6, + 0x96, 0x72, 0x2b, 0xc3, 0x5f, 0xe4, 0x1e, 0xb4, 0xb4, 0xdc, 0x0f, 0xc6, 0x71, 0xa8, 0x55, 0xac, + 0x28, 0xba, 0x4e, 0x31, 0x4b, 0xbc, 0x7c, 0x35, 0xcf, 0x29, 0xde, 0xb9, 0x01, 0x3b, 0x9a, 0x60, + 0x72, 0xc7, 0x8a, 0x7f, 0xf6, 0x60, 0xd3, 0x09, 0xa6, 0x53, 0x97, 0x31, 0x2c, 0xd5, 0x62, 0xee, + 0x4f, 0x31, 0x01, 0xe9, 0x86, 0x94, 0xed, 0x23, 0x87, 0xb8, 0x6d, 0xfe, 0x0c, 0x1d, 0x51, 0xc4, + 0xff, 0xc5, 0xf1, 0x73, 0x68, 0x4a, 0x1c, 0x03, 0xf4, 0xa5, 0x6b, 0xeb, 0x65, 0x61, 0x4c, 0x1a, + 0x33, 0x83, 0xe2, 0x57, 0xb0, 0x73, 0xae, 0x46, 0x2b, 0x87, 0xe3, 0x2d, 0x58, 0x63, 0x32, 0x29, + 0xbd, 0x02, 0xb7, 0xb3, 0xee, 0x54, 0xc2, 0xe6, 0x1f, 0x65, 0xd8, 0xcd, 0xdb, 0xeb, 0x41, 0xff, + 0x06, 0x3a, 0x85, 0xa1, 0x55, 0xac, 0x71, 0x6f, 0xc1, 0x1a, 0xcb, 0x0c, 0x73, 0x62, 0xe3, 0xef, + 0x12, 0x6c, 0x64, 0x45, 0x85, 0xe5, 0x54, 0x20, 0x95, 0xf2, 0xf2, 0x3d, 0x52, 0x29, 0xec, 0x91, + 0xea, 0xf2, 0x3d, 0x52, 0x5b, 0xb1, 0x47, 0x14, 0xf1, 0xe6, 0xc7, 0xb2, 0x2e, 0xdd, 0x26, 0x80, + 0x35, 0x3e, 0x01, 0xd8, 0x3d, 0xd8, 0x7e, 0x83, 0x53, 0x45, 0xf9, 0x33, 0xe5, 0x32, 0x86, 0x1b, + 0x7d, 0x7e, 0x70, 0xb9, 0x8f, 0xbd, 0x67, 0x05, 0xbe, 0xa7, 0x5e, 0x49, 0x0d, 0x73, 0x1f, 0x76, + 0x72, 0xda, 0xc9, 0x7a, 0x8e, 0x73, 0x12, 0x9a, 0xa5, 0xbb, 0x87, 0xd0, 0xce, 0x04, 0x22, 0x75, + 0xa8, 0x1c, 0x9d, 0x9c, 0xe0, 0x6b, 0xa3, 0x05, 0xf5, 0xb3, 0xf3, 0xe3, 0xd3, 0x97, 0xa7, 0x2f, + 0xf0, 0x89, 0x81, 0x1f, 0xfd, 0x93, 0xb3, 0xa1, 0xf8, 0x28, 0x1f, 0xfe, 0x59, 0x83, 0xe6, 0xa2, + 0xf3, 0xc9, 0xb7, 0xd0, 0xce, 0xc4, 0x22, 0xd7, 0x74, 0x01, 0xcb, 0xf2, 0x35, 0xae, 0x2f, 0x3f, + 0xd4, 0xe9, 0x3d, 0x81, 0x46, 0xfc, 0x94, 0x23, 0xbb, 0xcb, 0x5f, 0x8d, 0xc6, 0x5e, 0x41, 0xae, + 0x8d, 0x9f, 0x42, 0x73, 0xf1, 0x66, 0x23, 0x69, 0xad, 0xf4, 0xbb, 0xcf, 0xe8, 0x15, 0x0f, 0xb4, + 0xfd, 0x11, 0x40, 0xf2, 0x6a, 0x22, 0xbd, 0x55, 0x4f, 0x37, 0xe3, 0xea, 0x92, 0x13, 0xed, 0xe2, + 0x39, 0xb4, 0x52, 0x8f, 0x22, 0x92, 0x1a, 0xbd, 0xdc, 0x2b, 0xcb, 0x30, 0x96, 0x1d, 0x25, 0x85, + 0x2c, 0x36, 0x28, 0x49, 0xa8, 0x26, 0xbb, 0x67, 0x17, 0x85, 0x14, 0x97, 0xed, 0x23, 0xa8, 0xeb, + 0xed, 0x49, 0x76, 0xb4, 0x52, 0x76, 0xc1, 0x1a, 0xbb, 0x79, 0x71, 0x92, 0x7f, 0x8a, 0x1a, 0x17, + 0xf9, 0x17, 0xe9, 0xd2, 0x58, 0xc9, 0x12, 0x0f, 0x4a, 0xe4, 0x05, 0xfe, 0x8b, 0xa4, 0xf6, 0x0a, + 0x59, 0xd4, 0x5a, 0x5c, 0x36, 0xc6, 0x6a, 0xd2, 0x46, 0x47, 0xa7, 0xb0, 0x99, 0x9d, 0x60, 0x24, + 0xd8, 0x15, 0x1c, 0xa0, 0xbc, 0xdd, 0xf8, 0x24, 0x43, 0x8c, 0xd6, 0xe4, 0x2f, 0xd3, 0xc3, 0x7f, + 0x03, 0x00, 0x00, 0xff, 0xff, 0xc9, 0x77, 0x85, 0x99, 0x3f, 0x0d, 0x00, 0x00, } diff --git a/lnrpc/rpc.proto b/lnrpc/rpc.proto index 9eba9d62..046265fa 100644 --- a/lnrpc/rpc.proto +++ b/lnrpc/rpc.proto @@ -14,6 +14,7 @@ service Lightning { rpc OpenChannel(OpenChannelRequest) returns (stream ChannelOpenUpdate); rpc CloseChannel(CloseChannelRequest) returns (stream ChannelCloseUpdate); + rpc PendingChannels(PendingChannelRequest) returns (PendingChannelResponse); } message ChannelPoint { @@ -167,7 +168,31 @@ message OpenStatusUpdate { } } +enum ChannelStatus { + ALL = 0; + OPENING = 1; + CLOSING = 2; } +message PendingChannelRequest { + ChannelStatus status = 1; +} +message PendingChannelResponse { + message PendingChannel { + int32 peer_id = 1; + + string lightning_id = 2; + string channel_point = 3; + + int64 capacity = 4; + int64 local_balance = 5; + int64 remote_balance = 6; + + string closing_txid = 7; + + ChannelStatus status = 8; + } + + repeated PendingChannel pending_channels = 1; } message WalletBalanceRequest {