From 8aee8c65f2a447ffd33e583e0e87173707c0669d Mon Sep 17 00:00:00 2001 From: "Jonathan \"Duke\" Leto" Date: Fri, 17 Jun 2022 06:37:54 -0700 Subject: [PATCH] add service grpc protocol buffer --- walletrpc/service_grpc.pb.go | 564 +++++++++++++++++++++++++++++++++++ 1 file changed, 564 insertions(+) create mode 100644 walletrpc/service_grpc.pb.go diff --git a/walletrpc/service_grpc.pb.go b/walletrpc/service_grpc.pb.go new file mode 100644 index 0000000..97a349b --- /dev/null +++ b/walletrpc/service_grpc.pb.go @@ -0,0 +1,564 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. + +package walletrpc + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.32.0 or later. +const _ = grpc.SupportPackageIsVersion7 + +// CompactTxStreamerClient is the client API for CompactTxStreamer service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type CompactTxStreamerClient interface { + // Compact Blocks + GetLatestBlock(ctx context.Context, in *ChainSpec, opts ...grpc.CallOption) (*BlockID, error) + GetBlock(ctx context.Context, in *BlockID, opts ...grpc.CallOption) (*CompactBlock, error) + GetBlockRange(ctx context.Context, in *BlockRange, opts ...grpc.CallOption) (CompactTxStreamer_GetBlockRangeClient, error) + // Transactions + GetTransaction(ctx context.Context, in *TxFilter, opts ...grpc.CallOption) (*RawTransaction, error) + SendTransaction(ctx context.Context, in *RawTransaction, opts ...grpc.CallOption) (*SendResponse, error) + // t-Address support + GetAddressTxids(ctx context.Context, in *TransparentAddressBlockFilter, opts ...grpc.CallOption) (CompactTxStreamer_GetAddressTxidsClient, error) + // Misc + GetLightdInfo(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*LightdInfo, error) + GetCoinsupply(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Coinsupply, error) + // Return the compact transactions currently in the mempool; the results + // can be a few seconds out of date. If the Exclude list is empty, return + // all transactions; otherwise return all *except* those in the Exclude list + // (if any); this allows the client to avoid receiving transactions that it + // already has (from an earlier call to this rpc). The transaction IDs in the + // Exclude list can be shortened to any number of bytes to make the request + // more bandwidth-efficient; if two or more transactions in the mempool + // match a shortened txid, they are all sent (none is excluded). Transactions + // in the exclude list that don't exist in the mempool are ignored. + GetMempoolTx(ctx context.Context, in *Exclude, opts ...grpc.CallOption) (CompactTxStreamer_GetMempoolTxClient, error) + // Return a stream of current Mempool transactions. This will keep the output stream open while + // there are mempool transactions. It will close the returned stream when a new block is mined. + GetMempoolStream(ctx context.Context, in *Empty, opts ...grpc.CallOption) (CompactTxStreamer_GetMempoolStreamClient, error) +} + +type compactTxStreamerClient struct { + cc grpc.ClientConnInterface +} + +func NewCompactTxStreamerClient(cc grpc.ClientConnInterface) CompactTxStreamerClient { + return &compactTxStreamerClient{cc} +} + +func (c *compactTxStreamerClient) GetLatestBlock(ctx context.Context, in *ChainSpec, opts ...grpc.CallOption) (*BlockID, error) { + out := new(BlockID) + err := c.cc.Invoke(ctx, "/hush.wallet.sdk.rpc.CompactTxStreamer/GetLatestBlock", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *compactTxStreamerClient) GetBlock(ctx context.Context, in *BlockID, opts ...grpc.CallOption) (*CompactBlock, error) { + out := new(CompactBlock) + err := c.cc.Invoke(ctx, "/hush.wallet.sdk.rpc.CompactTxStreamer/GetBlock", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *compactTxStreamerClient) GetBlockRange(ctx context.Context, in *BlockRange, opts ...grpc.CallOption) (CompactTxStreamer_GetBlockRangeClient, error) { + stream, err := c.cc.NewStream(ctx, &CompactTxStreamer_ServiceDesc.Streams[0], "/hush.wallet.sdk.rpc.CompactTxStreamer/GetBlockRange", opts...) + if err != nil { + return nil, err + } + x := &compactTxStreamerGetBlockRangeClient{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 CompactTxStreamer_GetBlockRangeClient interface { + Recv() (*CompactBlock, error) + grpc.ClientStream +} + +type compactTxStreamerGetBlockRangeClient struct { + grpc.ClientStream +} + +func (x *compactTxStreamerGetBlockRangeClient) Recv() (*CompactBlock, error) { + m := new(CompactBlock) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func (c *compactTxStreamerClient) GetTransaction(ctx context.Context, in *TxFilter, opts ...grpc.CallOption) (*RawTransaction, error) { + out := new(RawTransaction) + err := c.cc.Invoke(ctx, "/hush.wallet.sdk.rpc.CompactTxStreamer/GetTransaction", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *compactTxStreamerClient) SendTransaction(ctx context.Context, in *RawTransaction, opts ...grpc.CallOption) (*SendResponse, error) { + out := new(SendResponse) + err := c.cc.Invoke(ctx, "/hush.wallet.sdk.rpc.CompactTxStreamer/SendTransaction", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *compactTxStreamerClient) GetAddressTxids(ctx context.Context, in *TransparentAddressBlockFilter, opts ...grpc.CallOption) (CompactTxStreamer_GetAddressTxidsClient, error) { + stream, err := c.cc.NewStream(ctx, &CompactTxStreamer_ServiceDesc.Streams[1], "/hush.wallet.sdk.rpc.CompactTxStreamer/GetAddressTxids", opts...) + if err != nil { + return nil, err + } + x := &compactTxStreamerGetAddressTxidsClient{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 CompactTxStreamer_GetAddressTxidsClient interface { + Recv() (*RawTransaction, error) + grpc.ClientStream +} + +type compactTxStreamerGetAddressTxidsClient struct { + grpc.ClientStream +} + +func (x *compactTxStreamerGetAddressTxidsClient) Recv() (*RawTransaction, error) { + m := new(RawTransaction) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func (c *compactTxStreamerClient) GetLightdInfo(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*LightdInfo, error) { + out := new(LightdInfo) + err := c.cc.Invoke(ctx, "/hush.wallet.sdk.rpc.CompactTxStreamer/GetLightdInfo", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *compactTxStreamerClient) GetCoinsupply(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Coinsupply, error) { + out := new(Coinsupply) + err := c.cc.Invoke(ctx, "/hush.wallet.sdk.rpc.CompactTxStreamer/GetCoinsupply", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *compactTxStreamerClient) GetMempoolTx(ctx context.Context, in *Exclude, opts ...grpc.CallOption) (CompactTxStreamer_GetMempoolTxClient, error) { + stream, err := c.cc.NewStream(ctx, &CompactTxStreamer_ServiceDesc.Streams[2], "/hush.wallet.sdk.rpc.CompactTxStreamer/GetMempoolTx", opts...) + if err != nil { + return nil, err + } + x := &compactTxStreamerGetMempoolTxClient{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 CompactTxStreamer_GetMempoolTxClient interface { + Recv() (*CompactTx, error) + grpc.ClientStream +} + +type compactTxStreamerGetMempoolTxClient struct { + grpc.ClientStream +} + +func (x *compactTxStreamerGetMempoolTxClient) Recv() (*CompactTx, error) { + m := new(CompactTx) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func (c *compactTxStreamerClient) GetMempoolStream(ctx context.Context, in *Empty, opts ...grpc.CallOption) (CompactTxStreamer_GetMempoolStreamClient, error) { + stream, err := c.cc.NewStream(ctx, &CompactTxStreamer_ServiceDesc.Streams[3], "/hush.wallet.sdk.rpc.CompactTxStreamer/GetMempoolStream", opts...) + if err != nil { + return nil, err + } + x := &compactTxStreamerGetMempoolStreamClient{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 CompactTxStreamer_GetMempoolStreamClient interface { + Recv() (*RawTransaction, error) + grpc.ClientStream +} + +type compactTxStreamerGetMempoolStreamClient struct { + grpc.ClientStream +} + +func (x *compactTxStreamerGetMempoolStreamClient) Recv() (*RawTransaction, error) { + m := new(RawTransaction) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +// CompactTxStreamerServer is the server API for CompactTxStreamer service. +// All implementations must embed UnimplementedCompactTxStreamerServer +// for forward compatibility +type CompactTxStreamerServer interface { + // Compact Blocks + GetLatestBlock(context.Context, *ChainSpec) (*BlockID, error) + GetBlock(context.Context, *BlockID) (*CompactBlock, error) + GetBlockRange(*BlockRange, CompactTxStreamer_GetBlockRangeServer) error + // Transactions + GetTransaction(context.Context, *TxFilter) (*RawTransaction, error) + SendTransaction(context.Context, *RawTransaction) (*SendResponse, error) + // t-Address support + GetAddressTxids(*TransparentAddressBlockFilter, CompactTxStreamer_GetAddressTxidsServer) error + // Misc + GetLightdInfo(context.Context, *Empty) (*LightdInfo, error) + GetCoinsupply(context.Context, *Empty) (*Coinsupply, error) + // Return the compact transactions currently in the mempool; the results + // can be a few seconds out of date. If the Exclude list is empty, return + // all transactions; otherwise return all *except* those in the Exclude list + // (if any); this allows the client to avoid receiving transactions that it + // already has (from an earlier call to this rpc). The transaction IDs in the + // Exclude list can be shortened to any number of bytes to make the request + // more bandwidth-efficient; if two or more transactions in the mempool + // match a shortened txid, they are all sent (none is excluded). Transactions + // in the exclude list that don't exist in the mempool are ignored. + GetMempoolTx(*Exclude, CompactTxStreamer_GetMempoolTxServer) error + // Return a stream of current Mempool transactions. This will keep the output stream open while + // there are mempool transactions. It will close the returned stream when a new block is mined. + GetMempoolStream(*Empty, CompactTxStreamer_GetMempoolStreamServer) error + mustEmbedUnimplementedCompactTxStreamerServer() +} + +// UnimplementedCompactTxStreamerServer must be embedded to have forward compatible implementations. +type UnimplementedCompactTxStreamerServer struct { +} + +func (UnimplementedCompactTxStreamerServer) GetLatestBlock(context.Context, *ChainSpec) (*BlockID, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetLatestBlock not implemented") +} +func (UnimplementedCompactTxStreamerServer) GetBlock(context.Context, *BlockID) (*CompactBlock, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetBlock not implemented") +} +func (UnimplementedCompactTxStreamerServer) GetBlockRange(*BlockRange, CompactTxStreamer_GetBlockRangeServer) error { + return status.Errorf(codes.Unimplemented, "method GetBlockRange not implemented") +} +func (UnimplementedCompactTxStreamerServer) GetTransaction(context.Context, *TxFilter) (*RawTransaction, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetTransaction not implemented") +} +func (UnimplementedCompactTxStreamerServer) SendTransaction(context.Context, *RawTransaction) (*SendResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method SendTransaction not implemented") +} +func (UnimplementedCompactTxStreamerServer) GetAddressTxids(*TransparentAddressBlockFilter, CompactTxStreamer_GetAddressTxidsServer) error { + return status.Errorf(codes.Unimplemented, "method GetAddressTxids not implemented") +} +func (UnimplementedCompactTxStreamerServer) GetLightdInfo(context.Context, *Empty) (*LightdInfo, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetLightdInfo not implemented") +} +func (UnimplementedCompactTxStreamerServer) GetCoinsupply(context.Context, *Empty) (*Coinsupply, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetCoinsupply not implemented") +} +func (UnimplementedCompactTxStreamerServer) GetMempoolTx(*Exclude, CompactTxStreamer_GetMempoolTxServer) error { + return status.Errorf(codes.Unimplemented, "method GetMempoolTx not implemented") +} +func (UnimplementedCompactTxStreamerServer) GetMempoolStream(*Empty, CompactTxStreamer_GetMempoolStreamServer) error { + return status.Errorf(codes.Unimplemented, "method GetMempoolStream not implemented") +} +func (UnimplementedCompactTxStreamerServer) mustEmbedUnimplementedCompactTxStreamerServer() {} + +// UnsafeCompactTxStreamerServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to CompactTxStreamerServer will +// result in compilation errors. +type UnsafeCompactTxStreamerServer interface { + mustEmbedUnimplementedCompactTxStreamerServer() +} + +func RegisterCompactTxStreamerServer(s grpc.ServiceRegistrar, srv CompactTxStreamerServer) { + s.RegisterService(&CompactTxStreamer_ServiceDesc, srv) +} + +func _CompactTxStreamer_GetLatestBlock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ChainSpec) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CompactTxStreamerServer).GetLatestBlock(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/hush.wallet.sdk.rpc.CompactTxStreamer/GetLatestBlock", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CompactTxStreamerServer).GetLatestBlock(ctx, req.(*ChainSpec)) + } + return interceptor(ctx, in, info, handler) +} + +func _CompactTxStreamer_GetBlock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(BlockID) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CompactTxStreamerServer).GetBlock(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/hush.wallet.sdk.rpc.CompactTxStreamer/GetBlock", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CompactTxStreamerServer).GetBlock(ctx, req.(*BlockID)) + } + return interceptor(ctx, in, info, handler) +} + +func _CompactTxStreamer_GetBlockRange_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(BlockRange) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(CompactTxStreamerServer).GetBlockRange(m, &compactTxStreamerGetBlockRangeServer{stream}) +} + +type CompactTxStreamer_GetBlockRangeServer interface { + Send(*CompactBlock) error + grpc.ServerStream +} + +type compactTxStreamerGetBlockRangeServer struct { + grpc.ServerStream +} + +func (x *compactTxStreamerGetBlockRangeServer) Send(m *CompactBlock) error { + return x.ServerStream.SendMsg(m) +} + +func _CompactTxStreamer_GetTransaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(TxFilter) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CompactTxStreamerServer).GetTransaction(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/hush.wallet.sdk.rpc.CompactTxStreamer/GetTransaction", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CompactTxStreamerServer).GetTransaction(ctx, req.(*TxFilter)) + } + return interceptor(ctx, in, info, handler) +} + +func _CompactTxStreamer_SendTransaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RawTransaction) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CompactTxStreamerServer).SendTransaction(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/hush.wallet.sdk.rpc.CompactTxStreamer/SendTransaction", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CompactTxStreamerServer).SendTransaction(ctx, req.(*RawTransaction)) + } + return interceptor(ctx, in, info, handler) +} + +func _CompactTxStreamer_GetAddressTxids_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(TransparentAddressBlockFilter) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(CompactTxStreamerServer).GetAddressTxids(m, &compactTxStreamerGetAddressTxidsServer{stream}) +} + +type CompactTxStreamer_GetAddressTxidsServer interface { + Send(*RawTransaction) error + grpc.ServerStream +} + +type compactTxStreamerGetAddressTxidsServer struct { + grpc.ServerStream +} + +func (x *compactTxStreamerGetAddressTxidsServer) Send(m *RawTransaction) error { + return x.ServerStream.SendMsg(m) +} + +func _CompactTxStreamer_GetLightdInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(Empty) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CompactTxStreamerServer).GetLightdInfo(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/hush.wallet.sdk.rpc.CompactTxStreamer/GetLightdInfo", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CompactTxStreamerServer).GetLightdInfo(ctx, req.(*Empty)) + } + return interceptor(ctx, in, info, handler) +} + +func _CompactTxStreamer_GetCoinsupply_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(Empty) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CompactTxStreamerServer).GetCoinsupply(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/hush.wallet.sdk.rpc.CompactTxStreamer/GetCoinsupply", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CompactTxStreamerServer).GetCoinsupply(ctx, req.(*Empty)) + } + return interceptor(ctx, in, info, handler) +} + +func _CompactTxStreamer_GetMempoolTx_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(Exclude) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(CompactTxStreamerServer).GetMempoolTx(m, &compactTxStreamerGetMempoolTxServer{stream}) +} + +type CompactTxStreamer_GetMempoolTxServer interface { + Send(*CompactTx) error + grpc.ServerStream +} + +type compactTxStreamerGetMempoolTxServer struct { + grpc.ServerStream +} + +func (x *compactTxStreamerGetMempoolTxServer) Send(m *CompactTx) error { + return x.ServerStream.SendMsg(m) +} + +func _CompactTxStreamer_GetMempoolStream_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(Empty) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(CompactTxStreamerServer).GetMempoolStream(m, &compactTxStreamerGetMempoolStreamServer{stream}) +} + +type CompactTxStreamer_GetMempoolStreamServer interface { + Send(*RawTransaction) error + grpc.ServerStream +} + +type compactTxStreamerGetMempoolStreamServer struct { + grpc.ServerStream +} + +func (x *compactTxStreamerGetMempoolStreamServer) Send(m *RawTransaction) error { + return x.ServerStream.SendMsg(m) +} + +// CompactTxStreamer_ServiceDesc is the grpc.ServiceDesc for CompactTxStreamer service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var CompactTxStreamer_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "hush.wallet.sdk.rpc.CompactTxStreamer", + HandlerType: (*CompactTxStreamerServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "GetLatestBlock", + Handler: _CompactTxStreamer_GetLatestBlock_Handler, + }, + { + MethodName: "GetBlock", + Handler: _CompactTxStreamer_GetBlock_Handler, + }, + { + MethodName: "GetTransaction", + Handler: _CompactTxStreamer_GetTransaction_Handler, + }, + { + MethodName: "SendTransaction", + Handler: _CompactTxStreamer_SendTransaction_Handler, + }, + { + MethodName: "GetLightdInfo", + Handler: _CompactTxStreamer_GetLightdInfo_Handler, + }, + { + MethodName: "GetCoinsupply", + Handler: _CompactTxStreamer_GetCoinsupply_Handler, + }, + }, + Streams: []grpc.StreamDesc{ + { + StreamName: "GetBlockRange", + Handler: _CompactTxStreamer_GetBlockRange_Handler, + ServerStreams: true, + }, + { + StreamName: "GetAddressTxids", + Handler: _CompactTxStreamer_GetAddressTxids_Handler, + ServerStreams: true, + }, + { + StreamName: "GetMempoolTx", + Handler: _CompactTxStreamer_GetMempoolTx_Handler, + ServerStreams: true, + }, + { + StreamName: "GetMempoolStream", + Handler: _CompactTxStreamer_GetMempoolStream_Handler, + ServerStreams: true, + }, + }, + Metadata: "service.proto", +}