decred.org/dcrwallet/v3@v3.1.0/rpc/walletrpc/api_grpc.pb.go

// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.2.0
// - protoc             v3.21.10
// source: api.proto

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

// VersionServiceClient is the client API for VersionService 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 VersionServiceClient interface {
	Version(ctx context.Context, in *VersionRequest, opts ...grpc.CallOption) (*VersionResponse, error)
}

type versionServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewVersionServiceClient(cc grpc.ClientConnInterface) VersionServiceClient {
	return &versionServiceClient{cc}
}

func (c *versionServiceClient) Version(ctx context.Context, in *VersionRequest, opts ...grpc.CallOption) (*VersionResponse, error) {
	out := new(VersionResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.VersionService/Version", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// VersionServiceServer is the server API for VersionService service.
// All implementations must embed UnimplementedVersionServiceServer
// for forward compatibility
type VersionServiceServer interface {
	Version(context.Context, *VersionRequest) (*VersionResponse, error)
	mustEmbedUnimplementedVersionServiceServer()
}

// UnimplementedVersionServiceServer must be embedded to have forward compatible implementations.
type UnimplementedVersionServiceServer struct {
}

func (UnimplementedVersionServiceServer) Version(context.Context, *VersionRequest) (*VersionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Version not implemented")
}
func (UnimplementedVersionServiceServer) mustEmbedUnimplementedVersionServiceServer() {}

// UnsafeVersionServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to VersionServiceServer will
// result in compilation errors.
type UnsafeVersionServiceServer interface {
	mustEmbedUnimplementedVersionServiceServer()
}

func RegisterVersionServiceServer(s grpc.ServiceRegistrar, srv VersionServiceServer) {
	s.RegisterService(&VersionService_ServiceDesc, srv)
}

func _VersionService_Version_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(VersionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VersionServiceServer).Version(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.VersionService/Version",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VersionServiceServer).Version(ctx, req.(*VersionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// VersionService_ServiceDesc is the grpc.ServiceDesc for VersionService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var VersionService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "walletrpc.VersionService",
	HandlerType: (*VersionServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Version",
			Handler:    _VersionService_Version_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "api.proto",
}

// WalletServiceClient is the client API for WalletService 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 WalletServiceClient interface {
	// Queries
	Ping(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (*PingResponse, error)
	Network(ctx context.Context, in *NetworkRequest, opts ...grpc.CallOption) (*NetworkResponse, error)
	CoinType(ctx context.Context, in *CoinTypeRequest, opts ...grpc.CallOption) (*CoinTypeResponse, error)
	AccountNumber(ctx context.Context, in *AccountNumberRequest, opts ...grpc.CallOption) (*AccountNumberResponse, error)
	Accounts(ctx context.Context, in *AccountsRequest, opts ...grpc.CallOption) (*AccountsResponse, error)
	Address(ctx context.Context, in *AddressRequest, opts ...grpc.CallOption) (*AddressResponse, error)
	Balance(ctx context.Context, in *BalanceRequest, opts ...grpc.CallOption) (*BalanceResponse, error)
	GetAccountExtendedPubKey(ctx context.Context, in *GetAccountExtendedPubKeyRequest, opts ...grpc.CallOption) (*GetAccountExtendedPubKeyResponse, error)
	GetAccountExtendedPrivKey(ctx context.Context, in *GetAccountExtendedPrivKeyRequest, opts ...grpc.CallOption) (*GetAccountExtendedPrivKeyResponse, error)
	GetTransaction(ctx context.Context, in *GetTransactionRequest, opts ...grpc.CallOption) (*GetTransactionResponse, error)
	GetTransactions(ctx context.Context, in *GetTransactionsRequest, opts ...grpc.CallOption) (WalletService_GetTransactionsClient, error)
	GetTicket(ctx context.Context, in *GetTicketRequest, opts ...grpc.CallOption) (*GetTicketsResponse, error)
	GetTickets(ctx context.Context, in *GetTicketsRequest, opts ...grpc.CallOption) (WalletService_GetTicketsClient, error)
	TicketPrice(ctx context.Context, in *TicketPriceRequest, opts ...grpc.CallOption) (*TicketPriceResponse, error)
	StakeInfo(ctx context.Context, in *StakeInfoRequest, opts ...grpc.CallOption) (*StakeInfoResponse, error)
	BlockInfo(ctx context.Context, in *BlockInfoRequest, opts ...grpc.CallOption) (*BlockInfoResponse, error)
	BestBlock(ctx context.Context, in *BestBlockRequest, opts ...grpc.CallOption) (*BestBlockResponse, error)
	Spender(ctx context.Context, in *SpenderRequest, opts ...grpc.CallOption) (*SpenderResponse, error)
	GetCFilters(ctx context.Context, in *GetCFiltersRequest, opts ...grpc.CallOption) (WalletService_GetCFiltersClient, error)
	GetPeerInfo(ctx context.Context, in *GetPeerInfoRequest, opts ...grpc.CallOption) (*GetPeerInfoResponse, error)
	DumpPrivateKey(ctx context.Context, in *DumpPrivateKeyRequest, opts ...grpc.CallOption) (*DumpPrivateKeyResponse, error)
	// Notifications
	TransactionNotifications(ctx context.Context, in *TransactionNotificationsRequest, opts ...grpc.CallOption) (WalletService_TransactionNotificationsClient, error)
	AccountNotifications(ctx context.Context, in *AccountNotificationsRequest, opts ...grpc.CallOption) (WalletService_AccountNotificationsClient, error)
	ConfirmationNotifications(ctx context.Context, opts ...grpc.CallOption) (WalletService_ConfirmationNotificationsClient, error)
	// Control
	ChangePassphrase(ctx context.Context, in *ChangePassphraseRequest, opts ...grpc.CallOption) (*ChangePassphraseResponse, error)
	RenameAccount(ctx context.Context, in *RenameAccountRequest, opts ...grpc.CallOption) (*RenameAccountResponse, error)
	Rescan(ctx context.Context, in *RescanRequest, opts ...grpc.CallOption) (WalletService_RescanClient, error)
	NextAccount(ctx context.Context, in *NextAccountRequest, opts ...grpc.CallOption) (*NextAccountResponse, error)
	NextAddress(ctx context.Context, in *NextAddressRequest, opts ...grpc.CallOption) (*NextAddressResponse, error)
	ImportPrivateKey(ctx context.Context, in *ImportPrivateKeyRequest, opts ...grpc.CallOption) (*ImportPrivateKeyResponse, error)
	ImportExtendedPublicKey(ctx context.Context, in *ImportExtendedPublicKeyRequest, opts ...grpc.CallOption) (*ImportExtendedPublicKeyResponse, error)
	ImportVotingAccountFromSeed(ctx context.Context, in *ImportVotingAccountFromSeedRequest, opts ...grpc.CallOption) (*ImportVotingAccountFromSeedResponse, error)
	ImportScript(ctx context.Context, in *ImportScriptRequest, opts ...grpc.CallOption) (*ImportScriptResponse, error)
	FundTransaction(ctx context.Context, in *FundTransactionRequest, opts ...grpc.CallOption) (*FundTransactionResponse, error)
	UnspentOutputs(ctx context.Context, in *UnspentOutputsRequest, opts ...grpc.CallOption) (WalletService_UnspentOutputsClient, error)
	ConstructTransaction(ctx context.Context, in *ConstructTransactionRequest, opts ...grpc.CallOption) (*ConstructTransactionResponse, error)
	SignTransaction(ctx context.Context, in *SignTransactionRequest, opts ...grpc.CallOption) (*SignTransactionResponse, error)
	SignTransactions(ctx context.Context, in *SignTransactionsRequest, opts ...grpc.CallOption) (*SignTransactionsResponse, error)
	CreateSignature(ctx context.Context, in *CreateSignatureRequest, opts ...grpc.CallOption) (*CreateSignatureResponse, error)
	PublishTransaction(ctx context.Context, in *PublishTransactionRequest, opts ...grpc.CallOption) (*PublishTransactionResponse, error)
	PublishUnminedTransactions(ctx context.Context, in *PublishUnminedTransactionsRequest, opts ...grpc.CallOption) (*PublishUnminedTransactionsResponse, error)
	PurchaseTickets(ctx context.Context, in *PurchaseTicketsRequest, opts ...grpc.CallOption) (*PurchaseTicketsResponse, error)
	RevokeTicket(ctx context.Context, in *RevokeTicketRequest, opts ...grpc.CallOption) (*RevokeTicketResponse, error)
	RevokeTickets(ctx context.Context, in *RevokeTicketsRequest, opts ...grpc.CallOption) (*RevokeTicketsResponse, error)
	LoadActiveDataFilters(ctx context.Context, in *LoadActiveDataFiltersRequest, opts ...grpc.CallOption) (*LoadActiveDataFiltersResponse, error)
	SignMessage(ctx context.Context, in *SignMessageRequest, opts ...grpc.CallOption) (*SignMessageResponse, error)
	SignMessages(ctx context.Context, in *SignMessagesRequest, opts ...grpc.CallOption) (*SignMessagesResponse, error)
	ValidateAddress(ctx context.Context, in *ValidateAddressRequest, opts ...grpc.CallOption) (*ValidateAddressResponse, error)
	CommittedTickets(ctx context.Context, in *CommittedTicketsRequest, opts ...grpc.CallOption) (*CommittedTicketsResponse, error)
	SweepAccount(ctx context.Context, in *SweepAccountRequest, opts ...grpc.CallOption) (*SweepAccountResponse, error)
	AbandonTransaction(ctx context.Context, in *AbandonTransactionRequest, opts ...grpc.CallOption) (*AbandonTransactionResponse, error)
	SignHashes(ctx context.Context, in *SignHashesRequest, opts ...grpc.CallOption) (*SignHashesResponse, error)
	GetCoinjoinOutputspByAcct(ctx context.Context, in *GetCoinjoinOutputspByAcctRequest, opts ...grpc.CallOption) (*GetCoinjoinOutputspByAcctResponse, error)
	SetAccountPassphrase(ctx context.Context, in *SetAccountPassphraseRequest, opts ...grpc.CallOption) (*SetAccountPassphraseResponse, error)
	UnlockAccount(ctx context.Context, in *UnlockAccountRequest, opts ...grpc.CallOption) (*UnlockAccountResponse, error)
	LockAccount(ctx context.Context, in *LockAccountRequest, opts ...grpc.CallOption) (*LockAccountResponse, error)
	UnlockWallet(ctx context.Context, in *UnlockWalletRequest, opts ...grpc.CallOption) (*UnlockWalletResponse, error)
	LockWallet(ctx context.Context, in *LockWalletRequest, opts ...grpc.CallOption) (*LockWalletResponse, error)
	AccountUnlocked(ctx context.Context, in *AccountUnlockedRequest, opts ...grpc.CallOption) (*AccountUnlockedResponse, error)
	SyncVSPFailedTickets(ctx context.Context, in *SyncVSPTicketsRequest, opts ...grpc.CallOption) (*SyncVSPTicketsResponse, error)
	GetVSPTicketsByFeeStatus(ctx context.Context, in *GetVSPTicketsByFeeStatusRequest, opts ...grpc.CallOption) (*GetVSPTicketsByFeeStatusResponse, error)
	ProcessManagedTickets(ctx context.Context, in *ProcessManagedTicketsRequest, opts ...grpc.CallOption) (*ProcessManagedTicketsResponse, error)
	ProcessUnmanagedTickets(ctx context.Context, in *ProcessUnmanagedTicketsRequest, opts ...grpc.CallOption) (*ProcessUnmanagedTicketsResponse, error)
	SetVspdVoteChoices(ctx context.Context, in *SetVspdVoteChoicesRequest, opts ...grpc.CallOption) (*SetVspdVoteChoicesResponse, error)
	GetTrackedVSPTickets(ctx context.Context, in *GetTrackedVSPTicketsRequest, opts ...grpc.CallOption) (*GetTrackedVSPTicketsResponse, error)
	DiscoverUsage(ctx context.Context, in *DiscoverUsageRequest, opts ...grpc.CallOption) (*DiscoverUsageResponse, error)
}

type walletServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewWalletServiceClient(cc grpc.ClientConnInterface) WalletServiceClient {
	return &walletServiceClient{cc}
}

func (c *walletServiceClient) Ping(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (*PingResponse, error) {
	out := new(PingResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/Ping", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) Network(ctx context.Context, in *NetworkRequest, opts ...grpc.CallOption) (*NetworkResponse, error) {
	out := new(NetworkResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/Network", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) CoinType(ctx context.Context, in *CoinTypeRequest, opts ...grpc.CallOption) (*CoinTypeResponse, error) {
	out := new(CoinTypeResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/CoinType", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) AccountNumber(ctx context.Context, in *AccountNumberRequest, opts ...grpc.CallOption) (*AccountNumberResponse, error) {
	out := new(AccountNumberResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/AccountNumber", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) Accounts(ctx context.Context, in *AccountsRequest, opts ...grpc.CallOption) (*AccountsResponse, error) {
	out := new(AccountsResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/Accounts", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) Address(ctx context.Context, in *AddressRequest, opts ...grpc.CallOption) (*AddressResponse, error) {
	out := new(AddressResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/Address", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) Balance(ctx context.Context, in *BalanceRequest, opts ...grpc.CallOption) (*BalanceResponse, error) {
	out := new(BalanceResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/Balance", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) GetAccountExtendedPubKey(ctx context.Context, in *GetAccountExtendedPubKeyRequest, opts ...grpc.CallOption) (*GetAccountExtendedPubKeyResponse, error) {
	out := new(GetAccountExtendedPubKeyResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/GetAccountExtendedPubKey", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) GetAccountExtendedPrivKey(ctx context.Context, in *GetAccountExtendedPrivKeyRequest, opts ...grpc.CallOption) (*GetAccountExtendedPrivKeyResponse, error) {
	out := new(GetAccountExtendedPrivKeyResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/GetAccountExtendedPrivKey", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) GetTransaction(ctx context.Context, in *GetTransactionRequest, opts ...grpc.CallOption) (*GetTransactionResponse, error) {
	out := new(GetTransactionResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/GetTransaction", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) GetTransactions(ctx context.Context, in *GetTransactionsRequest, opts ...grpc.CallOption) (WalletService_GetTransactionsClient, error) {
	stream, err := c.cc.NewStream(ctx, &WalletService_ServiceDesc.Streams[0], "/walletrpc.WalletService/GetTransactions", opts...)
	if err != nil {
		return nil, err
	}
	x := &walletServiceGetTransactionsClient{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 WalletService_GetTransactionsClient interface {
	Recv() (*GetTransactionsResponse, error)
	grpc.ClientStream
}

type walletServiceGetTransactionsClient struct {
	grpc.ClientStream
}

func (x *walletServiceGetTransactionsClient) Recv() (*GetTransactionsResponse, error) {
	m := new(GetTransactionsResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *walletServiceClient) GetTicket(ctx context.Context, in *GetTicketRequest, opts ...grpc.CallOption) (*GetTicketsResponse, error) {
	out := new(GetTicketsResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/GetTicket", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) GetTickets(ctx context.Context, in *GetTicketsRequest, opts ...grpc.CallOption) (WalletService_GetTicketsClient, error) {
	stream, err := c.cc.NewStream(ctx, &WalletService_ServiceDesc.Streams[1], "/walletrpc.WalletService/GetTickets", opts...)
	if err != nil {
		return nil, err
	}
	x := &walletServiceGetTicketsClient{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 WalletService_GetTicketsClient interface {
	Recv() (*GetTicketsResponse, error)
	grpc.ClientStream
}

type walletServiceGetTicketsClient struct {
	grpc.ClientStream
}

func (x *walletServiceGetTicketsClient) Recv() (*GetTicketsResponse, error) {
	m := new(GetTicketsResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *walletServiceClient) TicketPrice(ctx context.Context, in *TicketPriceRequest, opts ...grpc.CallOption) (*TicketPriceResponse, error) {
	out := new(TicketPriceResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/TicketPrice", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) StakeInfo(ctx context.Context, in *StakeInfoRequest, opts ...grpc.CallOption) (*StakeInfoResponse, error) {
	out := new(StakeInfoResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/StakeInfo", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) BlockInfo(ctx context.Context, in *BlockInfoRequest, opts ...grpc.CallOption) (*BlockInfoResponse, error) {
	out := new(BlockInfoResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/BlockInfo", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) BestBlock(ctx context.Context, in *BestBlockRequest, opts ...grpc.CallOption) (*BestBlockResponse, error) {
	out := new(BestBlockResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/BestBlock", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) Spender(ctx context.Context, in *SpenderRequest, opts ...grpc.CallOption) (*SpenderResponse, error) {
	out := new(SpenderResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/Spender", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) GetCFilters(ctx context.Context, in *GetCFiltersRequest, opts ...grpc.CallOption) (WalletService_GetCFiltersClient, error) {
	stream, err := c.cc.NewStream(ctx, &WalletService_ServiceDesc.Streams[2], "/walletrpc.WalletService/GetCFilters", opts...)
	if err != nil {
		return nil, err
	}
	x := &walletServiceGetCFiltersClient{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 WalletService_GetCFiltersClient interface {
	Recv() (*GetCFiltersResponse, error)
	grpc.ClientStream
}

type walletServiceGetCFiltersClient struct {
	grpc.ClientStream
}

func (x *walletServiceGetCFiltersClient) Recv() (*GetCFiltersResponse, error) {
	m := new(GetCFiltersResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *walletServiceClient) GetPeerInfo(ctx context.Context, in *GetPeerInfoRequest, opts ...grpc.CallOption) (*GetPeerInfoResponse, error) {
	out := new(GetPeerInfoResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/GetPeerInfo", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) DumpPrivateKey(ctx context.Context, in *DumpPrivateKeyRequest, opts ...grpc.CallOption) (*DumpPrivateKeyResponse, error) {
	out := new(DumpPrivateKeyResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/DumpPrivateKey", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) TransactionNotifications(ctx context.Context, in *TransactionNotificationsRequest, opts ...grpc.CallOption) (WalletService_TransactionNotificationsClient, error) {
	stream, err := c.cc.NewStream(ctx, &WalletService_ServiceDesc.Streams[3], "/walletrpc.WalletService/TransactionNotifications", opts...)
	if err != nil {
		return nil, err
	}
	x := &walletServiceTransactionNotificationsClient{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 WalletService_TransactionNotificationsClient interface {
	Recv() (*TransactionNotificationsResponse, error)
	grpc.ClientStream
}

type walletServiceTransactionNotificationsClient struct {
	grpc.ClientStream
}

func (x *walletServiceTransactionNotificationsClient) Recv() (*TransactionNotificationsResponse, error) {
	m := new(TransactionNotificationsResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *walletServiceClient) AccountNotifications(ctx context.Context, in *AccountNotificationsRequest, opts ...grpc.CallOption) (WalletService_AccountNotificationsClient, error) {
	stream, err := c.cc.NewStream(ctx, &WalletService_ServiceDesc.Streams[4], "/walletrpc.WalletService/AccountNotifications", opts...)
	if err != nil {
		return nil, err
	}
	x := &walletServiceAccountNotificationsClient{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 WalletService_AccountNotificationsClient interface {
	Recv() (*AccountNotificationsResponse, error)
	grpc.ClientStream
}

type walletServiceAccountNotificationsClient struct {
	grpc.ClientStream
}

func (x *walletServiceAccountNotificationsClient) Recv() (*AccountNotificationsResponse, error) {
	m := new(AccountNotificationsResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *walletServiceClient) ConfirmationNotifications(ctx context.Context, opts ...grpc.CallOption) (WalletService_ConfirmationNotificationsClient, error) {
	stream, err := c.cc.NewStream(ctx, &WalletService_ServiceDesc.Streams[5], "/walletrpc.WalletService/ConfirmationNotifications", opts...)
	if err != nil {
		return nil, err
	}
	x := &walletServiceConfirmationNotificationsClient{stream}
	return x, nil
}

type WalletService_ConfirmationNotificationsClient interface {
	Send(*ConfirmationNotificationsRequest) error
	Recv() (*ConfirmationNotificationsResponse, error)
	grpc.ClientStream
}

type walletServiceConfirmationNotificationsClient struct {
	grpc.ClientStream
}

func (x *walletServiceConfirmationNotificationsClient) Send(m *ConfirmationNotificationsRequest) error {
	return x.ClientStream.SendMsg(m)
}

func (x *walletServiceConfirmationNotificationsClient) Recv() (*ConfirmationNotificationsResponse, error) {
	m := new(ConfirmationNotificationsResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *walletServiceClient) ChangePassphrase(ctx context.Context, in *ChangePassphraseRequest, opts ...grpc.CallOption) (*ChangePassphraseResponse, error) {
	out := new(ChangePassphraseResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/ChangePassphrase", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) RenameAccount(ctx context.Context, in *RenameAccountRequest, opts ...grpc.CallOption) (*RenameAccountResponse, error) {
	out := new(RenameAccountResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/RenameAccount", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) Rescan(ctx context.Context, in *RescanRequest, opts ...grpc.CallOption) (WalletService_RescanClient, error) {
	stream, err := c.cc.NewStream(ctx, &WalletService_ServiceDesc.Streams[6], "/walletrpc.WalletService/Rescan", opts...)
	if err != nil {
		return nil, err
	}
	x := &walletServiceRescanClient{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 WalletService_RescanClient interface {
	Recv() (*RescanResponse, error)
	grpc.ClientStream
}

type walletServiceRescanClient struct {
	grpc.ClientStream
}

func (x *walletServiceRescanClient) Recv() (*RescanResponse, error) {
	m := new(RescanResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *walletServiceClient) NextAccount(ctx context.Context, in *NextAccountRequest, opts ...grpc.CallOption) (*NextAccountResponse, error) {
	out := new(NextAccountResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/NextAccount", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) NextAddress(ctx context.Context, in *NextAddressRequest, opts ...grpc.CallOption) (*NextAddressResponse, error) {
	out := new(NextAddressResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/NextAddress", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) ImportPrivateKey(ctx context.Context, in *ImportPrivateKeyRequest, opts ...grpc.CallOption) (*ImportPrivateKeyResponse, error) {
	out := new(ImportPrivateKeyResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/ImportPrivateKey", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) ImportExtendedPublicKey(ctx context.Context, in *ImportExtendedPublicKeyRequest, opts ...grpc.CallOption) (*ImportExtendedPublicKeyResponse, error) {
	out := new(ImportExtendedPublicKeyResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/ImportExtendedPublicKey", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) ImportVotingAccountFromSeed(ctx context.Context, in *ImportVotingAccountFromSeedRequest, opts ...grpc.CallOption) (*ImportVotingAccountFromSeedResponse, error) {
	out := new(ImportVotingAccountFromSeedResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/ImportVotingAccountFromSeed", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) ImportScript(ctx context.Context, in *ImportScriptRequest, opts ...grpc.CallOption) (*ImportScriptResponse, error) {
	out := new(ImportScriptResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/ImportScript", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) FundTransaction(ctx context.Context, in *FundTransactionRequest, opts ...grpc.CallOption) (*FundTransactionResponse, error) {
	out := new(FundTransactionResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/FundTransaction", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) UnspentOutputs(ctx context.Context, in *UnspentOutputsRequest, opts ...grpc.CallOption) (WalletService_UnspentOutputsClient, error) {
	stream, err := c.cc.NewStream(ctx, &WalletService_ServiceDesc.Streams[7], "/walletrpc.WalletService/UnspentOutputs", opts...)
	if err != nil {
		return nil, err
	}
	x := &walletServiceUnspentOutputsClient{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 WalletService_UnspentOutputsClient interface {
	Recv() (*UnspentOutputResponse, error)
	grpc.ClientStream
}

type walletServiceUnspentOutputsClient struct {
	grpc.ClientStream
}

func (x *walletServiceUnspentOutputsClient) Recv() (*UnspentOutputResponse, error) {
	m := new(UnspentOutputResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *walletServiceClient) ConstructTransaction(ctx context.Context, in *ConstructTransactionRequest, opts ...grpc.CallOption) (*ConstructTransactionResponse, error) {
	out := new(ConstructTransactionResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/ConstructTransaction", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) SignTransaction(ctx context.Context, in *SignTransactionRequest, opts ...grpc.CallOption) (*SignTransactionResponse, error) {
	out := new(SignTransactionResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/SignTransaction", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) SignTransactions(ctx context.Context, in *SignTransactionsRequest, opts ...grpc.CallOption) (*SignTransactionsResponse, error) {
	out := new(SignTransactionsResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/SignTransactions", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) CreateSignature(ctx context.Context, in *CreateSignatureRequest, opts ...grpc.CallOption) (*CreateSignatureResponse, error) {
	out := new(CreateSignatureResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/CreateSignature", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) PublishTransaction(ctx context.Context, in *PublishTransactionRequest, opts ...grpc.CallOption) (*PublishTransactionResponse, error) {
	out := new(PublishTransactionResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/PublishTransaction", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) PublishUnminedTransactions(ctx context.Context, in *PublishUnminedTransactionsRequest, opts ...grpc.CallOption) (*PublishUnminedTransactionsResponse, error) {
	out := new(PublishUnminedTransactionsResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/PublishUnminedTransactions", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) PurchaseTickets(ctx context.Context, in *PurchaseTicketsRequest, opts ...grpc.CallOption) (*PurchaseTicketsResponse, error) {
	out := new(PurchaseTicketsResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/PurchaseTickets", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) RevokeTicket(ctx context.Context, in *RevokeTicketRequest, opts ...grpc.CallOption) (*RevokeTicketResponse, error) {
	out := new(RevokeTicketResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/RevokeTicket", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) RevokeTickets(ctx context.Context, in *RevokeTicketsRequest, opts ...grpc.CallOption) (*RevokeTicketsResponse, error) {
	out := new(RevokeTicketsResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/RevokeTickets", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) LoadActiveDataFilters(ctx context.Context, in *LoadActiveDataFiltersRequest, opts ...grpc.CallOption) (*LoadActiveDataFiltersResponse, error) {
	out := new(LoadActiveDataFiltersResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/LoadActiveDataFilters", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) SignMessage(ctx context.Context, in *SignMessageRequest, opts ...grpc.CallOption) (*SignMessageResponse, error) {
	out := new(SignMessageResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/SignMessage", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) SignMessages(ctx context.Context, in *SignMessagesRequest, opts ...grpc.CallOption) (*SignMessagesResponse, error) {
	out := new(SignMessagesResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/SignMessages", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) ValidateAddress(ctx context.Context, in *ValidateAddressRequest, opts ...grpc.CallOption) (*ValidateAddressResponse, error) {
	out := new(ValidateAddressResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/ValidateAddress", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) CommittedTickets(ctx context.Context, in *CommittedTicketsRequest, opts ...grpc.CallOption) (*CommittedTicketsResponse, error) {
	out := new(CommittedTicketsResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/CommittedTickets", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) SweepAccount(ctx context.Context, in *SweepAccountRequest, opts ...grpc.CallOption) (*SweepAccountResponse, error) {
	out := new(SweepAccountResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/SweepAccount", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) AbandonTransaction(ctx context.Context, in *AbandonTransactionRequest, opts ...grpc.CallOption) (*AbandonTransactionResponse, error) {
	out := new(AbandonTransactionResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/AbandonTransaction", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) SignHashes(ctx context.Context, in *SignHashesRequest, opts ...grpc.CallOption) (*SignHashesResponse, error) {
	out := new(SignHashesResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/SignHashes", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) GetCoinjoinOutputspByAcct(ctx context.Context, in *GetCoinjoinOutputspByAcctRequest, opts ...grpc.CallOption) (*GetCoinjoinOutputspByAcctResponse, error) {
	out := new(GetCoinjoinOutputspByAcctResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/GetCoinjoinOutputspByAcct", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) SetAccountPassphrase(ctx context.Context, in *SetAccountPassphraseRequest, opts ...grpc.CallOption) (*SetAccountPassphraseResponse, error) {
	out := new(SetAccountPassphraseResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/SetAccountPassphrase", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) UnlockAccount(ctx context.Context, in *UnlockAccountRequest, opts ...grpc.CallOption) (*UnlockAccountResponse, error) {
	out := new(UnlockAccountResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/UnlockAccount", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) LockAccount(ctx context.Context, in *LockAccountRequest, opts ...grpc.CallOption) (*LockAccountResponse, error) {
	out := new(LockAccountResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/LockAccount", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) UnlockWallet(ctx context.Context, in *UnlockWalletRequest, opts ...grpc.CallOption) (*UnlockWalletResponse, error) {
	out := new(UnlockWalletResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/UnlockWallet", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) LockWallet(ctx context.Context, in *LockWalletRequest, opts ...grpc.CallOption) (*LockWalletResponse, error) {
	out := new(LockWalletResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/LockWallet", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) AccountUnlocked(ctx context.Context, in *AccountUnlockedRequest, opts ...grpc.CallOption) (*AccountUnlockedResponse, error) {
	out := new(AccountUnlockedResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/AccountUnlocked", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) SyncVSPFailedTickets(ctx context.Context, in *SyncVSPTicketsRequest, opts ...grpc.CallOption) (*SyncVSPTicketsResponse, error) {
	out := new(SyncVSPTicketsResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/SyncVSPFailedTickets", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) GetVSPTicketsByFeeStatus(ctx context.Context, in *GetVSPTicketsByFeeStatusRequest, opts ...grpc.CallOption) (*GetVSPTicketsByFeeStatusResponse, error) {
	out := new(GetVSPTicketsByFeeStatusResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/GetVSPTicketsByFeeStatus", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) ProcessManagedTickets(ctx context.Context, in *ProcessManagedTicketsRequest, opts ...grpc.CallOption) (*ProcessManagedTicketsResponse, error) {
	out := new(ProcessManagedTicketsResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/ProcessManagedTickets", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) ProcessUnmanagedTickets(ctx context.Context, in *ProcessUnmanagedTicketsRequest, opts ...grpc.CallOption) (*ProcessUnmanagedTicketsResponse, error) {
	out := new(ProcessUnmanagedTicketsResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/ProcessUnmanagedTickets", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) SetVspdVoteChoices(ctx context.Context, in *SetVspdVoteChoicesRequest, opts ...grpc.CallOption) (*SetVspdVoteChoicesResponse, error) {
	out := new(SetVspdVoteChoicesResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/SetVspdVoteChoices", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) GetTrackedVSPTickets(ctx context.Context, in *GetTrackedVSPTicketsRequest, opts ...grpc.CallOption) (*GetTrackedVSPTicketsResponse, error) {
	out := new(GetTrackedVSPTicketsResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/GetTrackedVSPTickets", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletServiceClient) DiscoverUsage(ctx context.Context, in *DiscoverUsageRequest, opts ...grpc.CallOption) (*DiscoverUsageResponse, error) {
	out := new(DiscoverUsageResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletService/DiscoverUsage", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// WalletServiceServer is the server API for WalletService service.
// All implementations must embed UnimplementedWalletServiceServer
// for forward compatibility
type WalletServiceServer interface {
	// Queries
	Ping(context.Context, *PingRequest) (*PingResponse, error)
	Network(context.Context, *NetworkRequest) (*NetworkResponse, error)
	CoinType(context.Context, *CoinTypeRequest) (*CoinTypeResponse, error)
	AccountNumber(context.Context, *AccountNumberRequest) (*AccountNumberResponse, error)
	Accounts(context.Context, *AccountsRequest) (*AccountsResponse, error)
	Address(context.Context, *AddressRequest) (*AddressResponse, error)
	Balance(context.Context, *BalanceRequest) (*BalanceResponse, error)
	GetAccountExtendedPubKey(context.Context, *GetAccountExtendedPubKeyRequest) (*GetAccountExtendedPubKeyResponse, error)
	GetAccountExtendedPrivKey(context.Context, *GetAccountExtendedPrivKeyRequest) (*GetAccountExtendedPrivKeyResponse, error)
	GetTransaction(context.Context, *GetTransactionRequest) (*GetTransactionResponse, error)
	GetTransactions(*GetTransactionsRequest, WalletService_GetTransactionsServer) error
	GetTicket(context.Context, *GetTicketRequest) (*GetTicketsResponse, error)
	GetTickets(*GetTicketsRequest, WalletService_GetTicketsServer) error
	TicketPrice(context.Context, *TicketPriceRequest) (*TicketPriceResponse, error)
	StakeInfo(context.Context, *StakeInfoRequest) (*StakeInfoResponse, error)
	BlockInfo(context.Context, *BlockInfoRequest) (*BlockInfoResponse, error)
	BestBlock(context.Context, *BestBlockRequest) (*BestBlockResponse, error)
	Spender(context.Context, *SpenderRequest) (*SpenderResponse, error)
	GetCFilters(*GetCFiltersRequest, WalletService_GetCFiltersServer) error
	GetPeerInfo(context.Context, *GetPeerInfoRequest) (*GetPeerInfoResponse, error)
	DumpPrivateKey(context.Context, *DumpPrivateKeyRequest) (*DumpPrivateKeyResponse, error)
	// Notifications
	TransactionNotifications(*TransactionNotificationsRequest, WalletService_TransactionNotificationsServer) error
	AccountNotifications(*AccountNotificationsRequest, WalletService_AccountNotificationsServer) error
	ConfirmationNotifications(WalletService_ConfirmationNotificationsServer) error
	// Control
	ChangePassphrase(context.Context, *ChangePassphraseRequest) (*ChangePassphraseResponse, error)
	RenameAccount(context.Context, *RenameAccountRequest) (*RenameAccountResponse, error)
	Rescan(*RescanRequest, WalletService_RescanServer) error
	NextAccount(context.Context, *NextAccountRequest) (*NextAccountResponse, error)
	NextAddress(context.Context, *NextAddressRequest) (*NextAddressResponse, error)
	ImportPrivateKey(context.Context, *ImportPrivateKeyRequest) (*ImportPrivateKeyResponse, error)
	ImportExtendedPublicKey(context.Context, *ImportExtendedPublicKeyRequest) (*ImportExtendedPublicKeyResponse, error)
	ImportVotingAccountFromSeed(context.Context, *ImportVotingAccountFromSeedRequest) (*ImportVotingAccountFromSeedResponse, error)
	ImportScript(context.Context, *ImportScriptRequest) (*ImportScriptResponse, error)
	FundTransaction(context.Context, *FundTransactionRequest) (*FundTransactionResponse, error)
	UnspentOutputs(*UnspentOutputsRequest, WalletService_UnspentOutputsServer) error
	ConstructTransaction(context.Context, *ConstructTransactionRequest) (*ConstructTransactionResponse, error)
	SignTransaction(context.Context, *SignTransactionRequest) (*SignTransactionResponse, error)
	SignTransactions(context.Context, *SignTransactionsRequest) (*SignTransactionsResponse, error)
	CreateSignature(context.Context, *CreateSignatureRequest) (*CreateSignatureResponse, error)
	PublishTransaction(context.Context, *PublishTransactionRequest) (*PublishTransactionResponse, error)
	PublishUnminedTransactions(context.Context, *PublishUnminedTransactionsRequest) (*PublishUnminedTransactionsResponse, error)
	PurchaseTickets(context.Context, *PurchaseTicketsRequest) (*PurchaseTicketsResponse, error)
	RevokeTicket(context.Context, *RevokeTicketRequest) (*RevokeTicketResponse, error)
	RevokeTickets(context.Context, *RevokeTicketsRequest) (*RevokeTicketsResponse, error)
	LoadActiveDataFilters(context.Context, *LoadActiveDataFiltersRequest) (*LoadActiveDataFiltersResponse, error)
	SignMessage(context.Context, *SignMessageRequest) (*SignMessageResponse, error)
	SignMessages(context.Context, *SignMessagesRequest) (*SignMessagesResponse, error)
	ValidateAddress(context.Context, *ValidateAddressRequest) (*ValidateAddressResponse, error)
	CommittedTickets(context.Context, *CommittedTicketsRequest) (*CommittedTicketsResponse, error)
	SweepAccount(context.Context, *SweepAccountRequest) (*SweepAccountResponse, error)
	AbandonTransaction(context.Context, *AbandonTransactionRequest) (*AbandonTransactionResponse, error)
	SignHashes(context.Context, *SignHashesRequest) (*SignHashesResponse, error)
	GetCoinjoinOutputspByAcct(context.Context, *GetCoinjoinOutputspByAcctRequest) (*GetCoinjoinOutputspByAcctResponse, error)
	SetAccountPassphrase(context.Context, *SetAccountPassphraseRequest) (*SetAccountPassphraseResponse, error)
	UnlockAccount(context.Context, *UnlockAccountRequest) (*UnlockAccountResponse, error)
	LockAccount(context.Context, *LockAccountRequest) (*LockAccountResponse, error)
	UnlockWallet(context.Context, *UnlockWalletRequest) (*UnlockWalletResponse, error)
	LockWallet(context.Context, *LockWalletRequest) (*LockWalletResponse, error)
	AccountUnlocked(context.Context, *AccountUnlockedRequest) (*AccountUnlockedResponse, error)
	SyncVSPFailedTickets(context.Context, *SyncVSPTicketsRequest) (*SyncVSPTicketsResponse, error)
	GetVSPTicketsByFeeStatus(context.Context, *GetVSPTicketsByFeeStatusRequest) (*GetVSPTicketsByFeeStatusResponse, error)
	ProcessManagedTickets(context.Context, *ProcessManagedTicketsRequest) (*ProcessManagedTicketsResponse, error)
	ProcessUnmanagedTickets(context.Context, *ProcessUnmanagedTicketsRequest) (*ProcessUnmanagedTicketsResponse, error)
	SetVspdVoteChoices(context.Context, *SetVspdVoteChoicesRequest) (*SetVspdVoteChoicesResponse, error)
	GetTrackedVSPTickets(context.Context, *GetTrackedVSPTicketsRequest) (*GetTrackedVSPTicketsResponse, error)
	DiscoverUsage(context.Context, *DiscoverUsageRequest) (*DiscoverUsageResponse, error)
	mustEmbedUnimplementedWalletServiceServer()
}

// UnimplementedWalletServiceServer must be embedded to have forward compatible implementations.
type UnimplementedWalletServiceServer struct {
}

func (UnimplementedWalletServiceServer) Ping(context.Context, *PingRequest) (*PingResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Ping not implemented")
}
func (UnimplementedWalletServiceServer) Network(context.Context, *NetworkRequest) (*NetworkResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Network not implemented")
}
func (UnimplementedWalletServiceServer) CoinType(context.Context, *CoinTypeRequest) (*CoinTypeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CoinType not implemented")
}
func (UnimplementedWalletServiceServer) AccountNumber(context.Context, *AccountNumberRequest) (*AccountNumberResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AccountNumber not implemented")
}
func (UnimplementedWalletServiceServer) Accounts(context.Context, *AccountsRequest) (*AccountsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Accounts not implemented")
}
func (UnimplementedWalletServiceServer) Address(context.Context, *AddressRequest) (*AddressResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Address not implemented")
}
func (UnimplementedWalletServiceServer) Balance(context.Context, *BalanceRequest) (*BalanceResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Balance not implemented")
}
func (UnimplementedWalletServiceServer) GetAccountExtendedPubKey(context.Context, *GetAccountExtendedPubKeyRequest) (*GetAccountExtendedPubKeyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetAccountExtendedPubKey not implemented")
}
func (UnimplementedWalletServiceServer) GetAccountExtendedPrivKey(context.Context, *GetAccountExtendedPrivKeyRequest) (*GetAccountExtendedPrivKeyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetAccountExtendedPrivKey not implemented")
}
func (UnimplementedWalletServiceServer) GetTransaction(context.Context, *GetTransactionRequest) (*GetTransactionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetTransaction not implemented")
}
func (UnimplementedWalletServiceServer) GetTransactions(*GetTransactionsRequest, WalletService_GetTransactionsServer) error {
	return status.Errorf(codes.Unimplemented, "method GetTransactions not implemented")
}
func (UnimplementedWalletServiceServer) GetTicket(context.Context, *GetTicketRequest) (*GetTicketsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetTicket not implemented")
}
func (UnimplementedWalletServiceServer) GetTickets(*GetTicketsRequest, WalletService_GetTicketsServer) error {
	return status.Errorf(codes.Unimplemented, "method GetTickets not implemented")
}
func (UnimplementedWalletServiceServer) TicketPrice(context.Context, *TicketPriceRequest) (*TicketPriceResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method TicketPrice not implemented")
}
func (UnimplementedWalletServiceServer) StakeInfo(context.Context, *StakeInfoRequest) (*StakeInfoResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StakeInfo not implemented")
}
func (UnimplementedWalletServiceServer) BlockInfo(context.Context, *BlockInfoRequest) (*BlockInfoResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BlockInfo not implemented")
}
func (UnimplementedWalletServiceServer) BestBlock(context.Context, *BestBlockRequest) (*BestBlockResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BestBlock not implemented")
}
func (UnimplementedWalletServiceServer) Spender(context.Context, *SpenderRequest) (*SpenderResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Spender not implemented")
}
func (UnimplementedWalletServiceServer) GetCFilters(*GetCFiltersRequest, WalletService_GetCFiltersServer) error {
	return status.Errorf(codes.Unimplemented, "method GetCFilters not implemented")
}
func (UnimplementedWalletServiceServer) GetPeerInfo(context.Context, *GetPeerInfoRequest) (*GetPeerInfoResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetPeerInfo not implemented")
}
func (UnimplementedWalletServiceServer) DumpPrivateKey(context.Context, *DumpPrivateKeyRequest) (*DumpPrivateKeyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DumpPrivateKey not implemented")
}
func (UnimplementedWalletServiceServer) TransactionNotifications(*TransactionNotificationsRequest, WalletService_TransactionNotificationsServer) error {
	return status.Errorf(codes.Unimplemented, "method TransactionNotifications not implemented")
}
func (UnimplementedWalletServiceServer) AccountNotifications(*AccountNotificationsRequest, WalletService_AccountNotificationsServer) error {
	return status.Errorf(codes.Unimplemented, "method AccountNotifications not implemented")
}
func (UnimplementedWalletServiceServer) ConfirmationNotifications(WalletService_ConfirmationNotificationsServer) error {
	return status.Errorf(codes.Unimplemented, "method ConfirmationNotifications not implemented")
}
func (UnimplementedWalletServiceServer) ChangePassphrase(context.Context, *ChangePassphraseRequest) (*ChangePassphraseResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ChangePassphrase not implemented")
}
func (UnimplementedWalletServiceServer) RenameAccount(context.Context, *RenameAccountRequest) (*RenameAccountResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RenameAccount not implemented")
}
func (UnimplementedWalletServiceServer) Rescan(*RescanRequest, WalletService_RescanServer) error {
	return status.Errorf(codes.Unimplemented, "method Rescan not implemented")
}
func (UnimplementedWalletServiceServer) NextAccount(context.Context, *NextAccountRequest) (*NextAccountResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method NextAccount not implemented")
}
func (UnimplementedWalletServiceServer) NextAddress(context.Context, *NextAddressRequest) (*NextAddressResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method NextAddress not implemented")
}
func (UnimplementedWalletServiceServer) ImportPrivateKey(context.Context, *ImportPrivateKeyRequest) (*ImportPrivateKeyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ImportPrivateKey not implemented")
}
func (UnimplementedWalletServiceServer) ImportExtendedPublicKey(context.Context, *ImportExtendedPublicKeyRequest) (*ImportExtendedPublicKeyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ImportExtendedPublicKey not implemented")
}
func (UnimplementedWalletServiceServer) ImportVotingAccountFromSeed(context.Context, *ImportVotingAccountFromSeedRequest) (*ImportVotingAccountFromSeedResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ImportVotingAccountFromSeed not implemented")
}
func (UnimplementedWalletServiceServer) ImportScript(context.Context, *ImportScriptRequest) (*ImportScriptResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ImportScript not implemented")
}
func (UnimplementedWalletServiceServer) FundTransaction(context.Context, *FundTransactionRequest) (*FundTransactionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method FundTransaction not implemented")
}
func (UnimplementedWalletServiceServer) UnspentOutputs(*UnspentOutputsRequest, WalletService_UnspentOutputsServer) error {
	return status.Errorf(codes.Unimplemented, "method UnspentOutputs not implemented")
}
func (UnimplementedWalletServiceServer) ConstructTransaction(context.Context, *ConstructTransactionRequest) (*ConstructTransactionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ConstructTransaction not implemented")
}
func (UnimplementedWalletServiceServer) SignTransaction(context.Context, *SignTransactionRequest) (*SignTransactionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SignTransaction not implemented")
}
func (UnimplementedWalletServiceServer) SignTransactions(context.Context, *SignTransactionsRequest) (*SignTransactionsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SignTransactions not implemented")
}
func (UnimplementedWalletServiceServer) CreateSignature(context.Context, *CreateSignatureRequest) (*CreateSignatureResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateSignature not implemented")
}
func (UnimplementedWalletServiceServer) PublishTransaction(context.Context, *PublishTransactionRequest) (*PublishTransactionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PublishTransaction not implemented")
}
func (UnimplementedWalletServiceServer) PublishUnminedTransactions(context.Context, *PublishUnminedTransactionsRequest) (*PublishUnminedTransactionsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PublishUnminedTransactions not implemented")
}
func (UnimplementedWalletServiceServer) PurchaseTickets(context.Context, *PurchaseTicketsRequest) (*PurchaseTicketsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PurchaseTickets not implemented")
}
func (UnimplementedWalletServiceServer) RevokeTicket(context.Context, *RevokeTicketRequest) (*RevokeTicketResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RevokeTicket not implemented")
}
func (UnimplementedWalletServiceServer) RevokeTickets(context.Context, *RevokeTicketsRequest) (*RevokeTicketsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RevokeTickets not implemented")
}
func (UnimplementedWalletServiceServer) LoadActiveDataFilters(context.Context, *LoadActiveDataFiltersRequest) (*LoadActiveDataFiltersResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method LoadActiveDataFilters not implemented")
}
func (UnimplementedWalletServiceServer) SignMessage(context.Context, *SignMessageRequest) (*SignMessageResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SignMessage not implemented")
}
func (UnimplementedWalletServiceServer) SignMessages(context.Context, *SignMessagesRequest) (*SignMessagesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SignMessages not implemented")
}
func (UnimplementedWalletServiceServer) ValidateAddress(context.Context, *ValidateAddressRequest) (*ValidateAddressResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ValidateAddress not implemented")
}
func (UnimplementedWalletServiceServer) CommittedTickets(context.Context, *CommittedTicketsRequest) (*CommittedTicketsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CommittedTickets not implemented")
}
func (UnimplementedWalletServiceServer) SweepAccount(context.Context, *SweepAccountRequest) (*SweepAccountResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SweepAccount not implemented")
}
func (UnimplementedWalletServiceServer) AbandonTransaction(context.Context, *AbandonTransactionRequest) (*AbandonTransactionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AbandonTransaction not implemented")
}
func (UnimplementedWalletServiceServer) SignHashes(context.Context, *SignHashesRequest) (*SignHashesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SignHashes not implemented")
}
func (UnimplementedWalletServiceServer) GetCoinjoinOutputspByAcct(context.Context, *GetCoinjoinOutputspByAcctRequest) (*GetCoinjoinOutputspByAcctResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetCoinjoinOutputspByAcct not implemented")
}
func (UnimplementedWalletServiceServer) SetAccountPassphrase(context.Context, *SetAccountPassphraseRequest) (*SetAccountPassphraseResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetAccountPassphrase not implemented")
}
func (UnimplementedWalletServiceServer) UnlockAccount(context.Context, *UnlockAccountRequest) (*UnlockAccountResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UnlockAccount not implemented")
}
func (UnimplementedWalletServiceServer) LockAccount(context.Context, *LockAccountRequest) (*LockAccountResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method LockAccount not implemented")
}
func (UnimplementedWalletServiceServer) UnlockWallet(context.Context, *UnlockWalletRequest) (*UnlockWalletResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UnlockWallet not implemented")
}
func (UnimplementedWalletServiceServer) LockWallet(context.Context, *LockWalletRequest) (*LockWalletResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method LockWallet not implemented")
}
func (UnimplementedWalletServiceServer) AccountUnlocked(context.Context, *AccountUnlockedRequest) (*AccountUnlockedResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AccountUnlocked not implemented")
}
func (UnimplementedWalletServiceServer) SyncVSPFailedTickets(context.Context, *SyncVSPTicketsRequest) (*SyncVSPTicketsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SyncVSPFailedTickets not implemented")
}
func (UnimplementedWalletServiceServer) GetVSPTicketsByFeeStatus(context.Context, *GetVSPTicketsByFeeStatusRequest) (*GetVSPTicketsByFeeStatusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetVSPTicketsByFeeStatus not implemented")
}
func (UnimplementedWalletServiceServer) ProcessManagedTickets(context.Context, *ProcessManagedTicketsRequest) (*ProcessManagedTicketsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ProcessManagedTickets not implemented")
}
func (UnimplementedWalletServiceServer) ProcessUnmanagedTickets(context.Context, *ProcessUnmanagedTicketsRequest) (*ProcessUnmanagedTicketsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ProcessUnmanagedTickets not implemented")
}
func (UnimplementedWalletServiceServer) SetVspdVoteChoices(context.Context, *SetVspdVoteChoicesRequest) (*SetVspdVoteChoicesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetVspdVoteChoices not implemented")
}
func (UnimplementedWalletServiceServer) GetTrackedVSPTickets(context.Context, *GetTrackedVSPTicketsRequest) (*GetTrackedVSPTicketsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetTrackedVSPTickets not implemented")
}
func (UnimplementedWalletServiceServer) DiscoverUsage(context.Context, *DiscoverUsageRequest) (*DiscoverUsageResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DiscoverUsage not implemented")
}
func (UnimplementedWalletServiceServer) mustEmbedUnimplementedWalletServiceServer() {}

// UnsafeWalletServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to WalletServiceServer will
// result in compilation errors.
type UnsafeWalletServiceServer interface {
	mustEmbedUnimplementedWalletServiceServer()
}

func RegisterWalletServiceServer(s grpc.ServiceRegistrar, srv WalletServiceServer) {
	s.RegisterService(&WalletService_ServiceDesc, srv)
}

func _WalletService_Ping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PingRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).Ping(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/Ping",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).Ping(ctx, req.(*PingRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_Network_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(NetworkRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).Network(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/Network",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).Network(ctx, req.(*NetworkRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_CoinType_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CoinTypeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).CoinType(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/CoinType",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).CoinType(ctx, req.(*CoinTypeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_AccountNumber_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AccountNumberRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).AccountNumber(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/AccountNumber",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).AccountNumber(ctx, req.(*AccountNumberRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_Accounts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AccountsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).Accounts(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/Accounts",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).Accounts(ctx, req.(*AccountsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_Address_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddressRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).Address(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/Address",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).Address(ctx, req.(*AddressRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_Balance_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BalanceRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).Balance(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/Balance",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).Balance(ctx, req.(*BalanceRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_GetAccountExtendedPubKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetAccountExtendedPubKeyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).GetAccountExtendedPubKey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/GetAccountExtendedPubKey",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).GetAccountExtendedPubKey(ctx, req.(*GetAccountExtendedPubKeyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_GetAccountExtendedPrivKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetAccountExtendedPrivKeyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).GetAccountExtendedPrivKey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/GetAccountExtendedPrivKey",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).GetAccountExtendedPrivKey(ctx, req.(*GetAccountExtendedPrivKeyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_GetTransaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetTransactionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).GetTransaction(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/GetTransaction",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).GetTransaction(ctx, req.(*GetTransactionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_GetTransactions_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(GetTransactionsRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(WalletServiceServer).GetTransactions(m, &walletServiceGetTransactionsServer{stream})
}

type WalletService_GetTransactionsServer interface {
	Send(*GetTransactionsResponse) error
	grpc.ServerStream
}

type walletServiceGetTransactionsServer struct {
	grpc.ServerStream
}

func (x *walletServiceGetTransactionsServer) Send(m *GetTransactionsResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _WalletService_GetTicket_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetTicketRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).GetTicket(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/GetTicket",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).GetTicket(ctx, req.(*GetTicketRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_GetTickets_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(GetTicketsRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(WalletServiceServer).GetTickets(m, &walletServiceGetTicketsServer{stream})
}

type WalletService_GetTicketsServer interface {
	Send(*GetTicketsResponse) error
	grpc.ServerStream
}

type walletServiceGetTicketsServer struct {
	grpc.ServerStream
}

func (x *walletServiceGetTicketsServer) Send(m *GetTicketsResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _WalletService_TicketPrice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TicketPriceRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).TicketPrice(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/TicketPrice",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).TicketPrice(ctx, req.(*TicketPriceRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_StakeInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StakeInfoRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).StakeInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/StakeInfo",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).StakeInfo(ctx, req.(*StakeInfoRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_BlockInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BlockInfoRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).BlockInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/BlockInfo",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).BlockInfo(ctx, req.(*BlockInfoRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_BestBlock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BestBlockRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).BestBlock(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/BestBlock",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).BestBlock(ctx, req.(*BestBlockRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_Spender_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SpenderRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).Spender(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/Spender",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).Spender(ctx, req.(*SpenderRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_GetCFilters_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(GetCFiltersRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(WalletServiceServer).GetCFilters(m, &walletServiceGetCFiltersServer{stream})
}

type WalletService_GetCFiltersServer interface {
	Send(*GetCFiltersResponse) error
	grpc.ServerStream
}

type walletServiceGetCFiltersServer struct {
	grpc.ServerStream
}

func (x *walletServiceGetCFiltersServer) Send(m *GetCFiltersResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _WalletService_GetPeerInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetPeerInfoRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).GetPeerInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/GetPeerInfo",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).GetPeerInfo(ctx, req.(*GetPeerInfoRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_DumpPrivateKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DumpPrivateKeyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).DumpPrivateKey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/DumpPrivateKey",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).DumpPrivateKey(ctx, req.(*DumpPrivateKeyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_TransactionNotifications_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(TransactionNotificationsRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(WalletServiceServer).TransactionNotifications(m, &walletServiceTransactionNotificationsServer{stream})
}

type WalletService_TransactionNotificationsServer interface {
	Send(*TransactionNotificationsResponse) error
	grpc.ServerStream
}

type walletServiceTransactionNotificationsServer struct {
	grpc.ServerStream
}

func (x *walletServiceTransactionNotificationsServer) Send(m *TransactionNotificationsResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _WalletService_AccountNotifications_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(AccountNotificationsRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(WalletServiceServer).AccountNotifications(m, &walletServiceAccountNotificationsServer{stream})
}

type WalletService_AccountNotificationsServer interface {
	Send(*AccountNotificationsResponse) error
	grpc.ServerStream
}

type walletServiceAccountNotificationsServer struct {
	grpc.ServerStream
}

func (x *walletServiceAccountNotificationsServer) Send(m *AccountNotificationsResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _WalletService_ConfirmationNotifications_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(WalletServiceServer).ConfirmationNotifications(&walletServiceConfirmationNotificationsServer{stream})
}

type WalletService_ConfirmationNotificationsServer interface {
	Send(*ConfirmationNotificationsResponse) error
	Recv() (*ConfirmationNotificationsRequest, error)
	grpc.ServerStream
}

type walletServiceConfirmationNotificationsServer struct {
	grpc.ServerStream
}

func (x *walletServiceConfirmationNotificationsServer) Send(m *ConfirmationNotificationsResponse) error {
	return x.ServerStream.SendMsg(m)
}

func (x *walletServiceConfirmationNotificationsServer) Recv() (*ConfirmationNotificationsRequest, error) {
	m := new(ConfirmationNotificationsRequest)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _WalletService_ChangePassphrase_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ChangePassphraseRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).ChangePassphrase(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/ChangePassphrase",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).ChangePassphrase(ctx, req.(*ChangePassphraseRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_RenameAccount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RenameAccountRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).RenameAccount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/RenameAccount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).RenameAccount(ctx, req.(*RenameAccountRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_Rescan_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(RescanRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(WalletServiceServer).Rescan(m, &walletServiceRescanServer{stream})
}

type WalletService_RescanServer interface {
	Send(*RescanResponse) error
	grpc.ServerStream
}

type walletServiceRescanServer struct {
	grpc.ServerStream
}

func (x *walletServiceRescanServer) Send(m *RescanResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _WalletService_NextAccount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(NextAccountRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).NextAccount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/NextAccount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).NextAccount(ctx, req.(*NextAccountRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_NextAddress_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(NextAddressRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).NextAddress(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/NextAddress",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).NextAddress(ctx, req.(*NextAddressRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_ImportPrivateKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ImportPrivateKeyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).ImportPrivateKey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/ImportPrivateKey",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).ImportPrivateKey(ctx, req.(*ImportPrivateKeyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_ImportExtendedPublicKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ImportExtendedPublicKeyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).ImportExtendedPublicKey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/ImportExtendedPublicKey",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).ImportExtendedPublicKey(ctx, req.(*ImportExtendedPublicKeyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_ImportVotingAccountFromSeed_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ImportVotingAccountFromSeedRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).ImportVotingAccountFromSeed(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/ImportVotingAccountFromSeed",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).ImportVotingAccountFromSeed(ctx, req.(*ImportVotingAccountFromSeedRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_ImportScript_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ImportScriptRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).ImportScript(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/ImportScript",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).ImportScript(ctx, req.(*ImportScriptRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_FundTransaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(FundTransactionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).FundTransaction(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/FundTransaction",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).FundTransaction(ctx, req.(*FundTransactionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_UnspentOutputs_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(UnspentOutputsRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(WalletServiceServer).UnspentOutputs(m, &walletServiceUnspentOutputsServer{stream})
}

type WalletService_UnspentOutputsServer interface {
	Send(*UnspentOutputResponse) error
	grpc.ServerStream
}

type walletServiceUnspentOutputsServer struct {
	grpc.ServerStream
}

func (x *walletServiceUnspentOutputsServer) Send(m *UnspentOutputResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _WalletService_ConstructTransaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ConstructTransactionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).ConstructTransaction(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/ConstructTransaction",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).ConstructTransaction(ctx, req.(*ConstructTransactionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_SignTransaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SignTransactionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).SignTransaction(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/SignTransaction",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).SignTransaction(ctx, req.(*SignTransactionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_SignTransactions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SignTransactionsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).SignTransactions(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/SignTransactions",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).SignTransactions(ctx, req.(*SignTransactionsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_CreateSignature_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateSignatureRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).CreateSignature(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/CreateSignature",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).CreateSignature(ctx, req.(*CreateSignatureRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_PublishTransaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PublishTransactionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).PublishTransaction(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/PublishTransaction",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).PublishTransaction(ctx, req.(*PublishTransactionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_PublishUnminedTransactions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PublishUnminedTransactionsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).PublishUnminedTransactions(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/PublishUnminedTransactions",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).PublishUnminedTransactions(ctx, req.(*PublishUnminedTransactionsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_PurchaseTickets_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PurchaseTicketsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).PurchaseTickets(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/PurchaseTickets",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).PurchaseTickets(ctx, req.(*PurchaseTicketsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_RevokeTicket_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RevokeTicketRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).RevokeTicket(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/RevokeTicket",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).RevokeTicket(ctx, req.(*RevokeTicketRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_RevokeTickets_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RevokeTicketsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).RevokeTickets(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/RevokeTickets",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).RevokeTickets(ctx, req.(*RevokeTicketsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_LoadActiveDataFilters_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LoadActiveDataFiltersRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).LoadActiveDataFilters(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/LoadActiveDataFilters",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).LoadActiveDataFilters(ctx, req.(*LoadActiveDataFiltersRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_SignMessage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SignMessageRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).SignMessage(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/SignMessage",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).SignMessage(ctx, req.(*SignMessageRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_SignMessages_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SignMessagesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).SignMessages(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/SignMessages",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).SignMessages(ctx, req.(*SignMessagesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_ValidateAddress_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ValidateAddressRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).ValidateAddress(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/ValidateAddress",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).ValidateAddress(ctx, req.(*ValidateAddressRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_CommittedTickets_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CommittedTicketsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).CommittedTickets(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/CommittedTickets",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).CommittedTickets(ctx, req.(*CommittedTicketsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_SweepAccount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SweepAccountRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).SweepAccount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/SweepAccount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).SweepAccount(ctx, req.(*SweepAccountRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_AbandonTransaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AbandonTransactionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).AbandonTransaction(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/AbandonTransaction",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).AbandonTransaction(ctx, req.(*AbandonTransactionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_SignHashes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SignHashesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).SignHashes(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/SignHashes",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).SignHashes(ctx, req.(*SignHashesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_GetCoinjoinOutputspByAcct_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetCoinjoinOutputspByAcctRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).GetCoinjoinOutputspByAcct(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/GetCoinjoinOutputspByAcct",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).GetCoinjoinOutputspByAcct(ctx, req.(*GetCoinjoinOutputspByAcctRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_SetAccountPassphrase_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetAccountPassphraseRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).SetAccountPassphrase(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/SetAccountPassphrase",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).SetAccountPassphrase(ctx, req.(*SetAccountPassphraseRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_UnlockAccount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UnlockAccountRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).UnlockAccount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/UnlockAccount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).UnlockAccount(ctx, req.(*UnlockAccountRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_LockAccount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LockAccountRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).LockAccount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/LockAccount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).LockAccount(ctx, req.(*LockAccountRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_UnlockWallet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UnlockWalletRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).UnlockWallet(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/UnlockWallet",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).UnlockWallet(ctx, req.(*UnlockWalletRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_LockWallet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LockWalletRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).LockWallet(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/LockWallet",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).LockWallet(ctx, req.(*LockWalletRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_AccountUnlocked_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AccountUnlockedRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).AccountUnlocked(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/AccountUnlocked",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).AccountUnlocked(ctx, req.(*AccountUnlockedRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_SyncVSPFailedTickets_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SyncVSPTicketsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).SyncVSPFailedTickets(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/SyncVSPFailedTickets",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).SyncVSPFailedTickets(ctx, req.(*SyncVSPTicketsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_GetVSPTicketsByFeeStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetVSPTicketsByFeeStatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).GetVSPTicketsByFeeStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/GetVSPTicketsByFeeStatus",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).GetVSPTicketsByFeeStatus(ctx, req.(*GetVSPTicketsByFeeStatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_ProcessManagedTickets_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ProcessManagedTicketsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).ProcessManagedTickets(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/ProcessManagedTickets",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).ProcessManagedTickets(ctx, req.(*ProcessManagedTicketsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_ProcessUnmanagedTickets_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ProcessUnmanagedTicketsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).ProcessUnmanagedTickets(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/ProcessUnmanagedTickets",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).ProcessUnmanagedTickets(ctx, req.(*ProcessUnmanagedTicketsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_SetVspdVoteChoices_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetVspdVoteChoicesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).SetVspdVoteChoices(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/SetVspdVoteChoices",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).SetVspdVoteChoices(ctx, req.(*SetVspdVoteChoicesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_GetTrackedVSPTickets_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetTrackedVSPTicketsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).GetTrackedVSPTickets(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/GetTrackedVSPTickets",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).GetTrackedVSPTickets(ctx, req.(*GetTrackedVSPTicketsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletService_DiscoverUsage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DiscoverUsageRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletServiceServer).DiscoverUsage(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletService/DiscoverUsage",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletServiceServer).DiscoverUsage(ctx, req.(*DiscoverUsageRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// WalletService_ServiceDesc is the grpc.ServiceDesc for WalletService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var WalletService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "walletrpc.WalletService",
	HandlerType: (*WalletServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Ping",
			Handler:    _WalletService_Ping_Handler,
		},
		{
			MethodName: "Network",
			Handler:    _WalletService_Network_Handler,
		},
		{
			MethodName: "CoinType",
			Handler:    _WalletService_CoinType_Handler,
		},
		{
			MethodName: "AccountNumber",
			Handler:    _WalletService_AccountNumber_Handler,
		},
		{
			MethodName: "Accounts",
			Handler:    _WalletService_Accounts_Handler,
		},
		{
			MethodName: "Address",
			Handler:    _WalletService_Address_Handler,
		},
		{
			MethodName: "Balance",
			Handler:    _WalletService_Balance_Handler,
		},
		{
			MethodName: "GetAccountExtendedPubKey",
			Handler:    _WalletService_GetAccountExtendedPubKey_Handler,
		},
		{
			MethodName: "GetAccountExtendedPrivKey",
			Handler:    _WalletService_GetAccountExtendedPrivKey_Handler,
		},
		{
			MethodName: "GetTransaction",
			Handler:    _WalletService_GetTransaction_Handler,
		},
		{
			MethodName: "GetTicket",
			Handler:    _WalletService_GetTicket_Handler,
		},
		{
			MethodName: "TicketPrice",
			Handler:    _WalletService_TicketPrice_Handler,
		},
		{
			MethodName: "StakeInfo",
			Handler:    _WalletService_StakeInfo_Handler,
		},
		{
			MethodName: "BlockInfo",
			Handler:    _WalletService_BlockInfo_Handler,
		},
		{
			MethodName: "BestBlock",
			Handler:    _WalletService_BestBlock_Handler,
		},
		{
			MethodName: "Spender",
			Handler:    _WalletService_Spender_Handler,
		},
		{
			MethodName: "GetPeerInfo",
			Handler:    _WalletService_GetPeerInfo_Handler,
		},
		{
			MethodName: "DumpPrivateKey",
			Handler:    _WalletService_DumpPrivateKey_Handler,
		},
		{
			MethodName: "ChangePassphrase",
			Handler:    _WalletService_ChangePassphrase_Handler,
		},
		{
			MethodName: "RenameAccount",
			Handler:    _WalletService_RenameAccount_Handler,
		},
		{
			MethodName: "NextAccount",
			Handler:    _WalletService_NextAccount_Handler,
		},
		{
			MethodName: "NextAddress",
			Handler:    _WalletService_NextAddress_Handler,
		},
		{
			MethodName: "ImportPrivateKey",
			Handler:    _WalletService_ImportPrivateKey_Handler,
		},
		{
			MethodName: "ImportExtendedPublicKey",
			Handler:    _WalletService_ImportExtendedPublicKey_Handler,
		},
		{
			MethodName: "ImportVotingAccountFromSeed",
			Handler:    _WalletService_ImportVotingAccountFromSeed_Handler,
		},
		{
			MethodName: "ImportScript",
			Handler:    _WalletService_ImportScript_Handler,
		},
		{
			MethodName: "FundTransaction",
			Handler:    _WalletService_FundTransaction_Handler,
		},
		{
			MethodName: "ConstructTransaction",
			Handler:    _WalletService_ConstructTransaction_Handler,
		},
		{
			MethodName: "SignTransaction",
			Handler:    _WalletService_SignTransaction_Handler,
		},
		{
			MethodName: "SignTransactions",
			Handler:    _WalletService_SignTransactions_Handler,
		},
		{
			MethodName: "CreateSignature",
			Handler:    _WalletService_CreateSignature_Handler,
		},
		{
			MethodName: "PublishTransaction",
			Handler:    _WalletService_PublishTransaction_Handler,
		},
		{
			MethodName: "PublishUnminedTransactions",
			Handler:    _WalletService_PublishUnminedTransactions_Handler,
		},
		{
			MethodName: "PurchaseTickets",
			Handler:    _WalletService_PurchaseTickets_Handler,
		},
		{
			MethodName: "RevokeTicket",
			Handler:    _WalletService_RevokeTicket_Handler,
		},
		{
			MethodName: "RevokeTickets",
			Handler:    _WalletService_RevokeTickets_Handler,
		},
		{
			MethodName: "LoadActiveDataFilters",
			Handler:    _WalletService_LoadActiveDataFilters_Handler,
		},
		{
			MethodName: "SignMessage",
			Handler:    _WalletService_SignMessage_Handler,
		},
		{
			MethodName: "SignMessages",
			Handler:    _WalletService_SignMessages_Handler,
		},
		{
			MethodName: "ValidateAddress",
			Handler:    _WalletService_ValidateAddress_Handler,
		},
		{
			MethodName: "CommittedTickets",
			Handler:    _WalletService_CommittedTickets_Handler,
		},
		{
			MethodName: "SweepAccount",
			Handler:    _WalletService_SweepAccount_Handler,
		},
		{
			MethodName: "AbandonTransaction",
			Handler:    _WalletService_AbandonTransaction_Handler,
		},
		{
			MethodName: "SignHashes",
			Handler:    _WalletService_SignHashes_Handler,
		},
		{
			MethodName: "GetCoinjoinOutputspByAcct",
			Handler:    _WalletService_GetCoinjoinOutputspByAcct_Handler,
		},
		{
			MethodName: "SetAccountPassphrase",
			Handler:    _WalletService_SetAccountPassphrase_Handler,
		},
		{
			MethodName: "UnlockAccount",
			Handler:    _WalletService_UnlockAccount_Handler,
		},
		{
			MethodName: "LockAccount",
			Handler:    _WalletService_LockAccount_Handler,
		},
		{
			MethodName: "UnlockWallet",
			Handler:    _WalletService_UnlockWallet_Handler,
		},
		{
			MethodName: "LockWallet",
			Handler:    _WalletService_LockWallet_Handler,
		},
		{
			MethodName: "AccountUnlocked",
			Handler:    _WalletService_AccountUnlocked_Handler,
		},
		{
			MethodName: "SyncVSPFailedTickets",
			Handler:    _WalletService_SyncVSPFailedTickets_Handler,
		},
		{
			MethodName: "GetVSPTicketsByFeeStatus",
			Handler:    _WalletService_GetVSPTicketsByFeeStatus_Handler,
		},
		{
			MethodName: "ProcessManagedTickets",
			Handler:    _WalletService_ProcessManagedTickets_Handler,
		},
		{
			MethodName: "ProcessUnmanagedTickets",
			Handler:    _WalletService_ProcessUnmanagedTickets_Handler,
		},
		{
			MethodName: "SetVspdVoteChoices",
			Handler:    _WalletService_SetVspdVoteChoices_Handler,
		},
		{
			MethodName: "GetTrackedVSPTickets",
			Handler:    _WalletService_GetTrackedVSPTickets_Handler,
		},
		{
			MethodName: "DiscoverUsage",
			Handler:    _WalletService_DiscoverUsage_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetTransactions",
			Handler:       _WalletService_GetTransactions_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetTickets",
			Handler:       _WalletService_GetTickets_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetCFilters",
			Handler:       _WalletService_GetCFilters_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "TransactionNotifications",
			Handler:       _WalletService_TransactionNotifications_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "AccountNotifications",
			Handler:       _WalletService_AccountNotifications_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ConfirmationNotifications",
			Handler:       _WalletService_ConfirmationNotifications_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "Rescan",
			Handler:       _WalletService_Rescan_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "UnspentOutputs",
			Handler:       _WalletService_UnspentOutputs_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "api.proto",
}

// WalletLoaderServiceClient is the client API for WalletLoaderService 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 WalletLoaderServiceClient interface {
	WalletExists(ctx context.Context, in *WalletExistsRequest, opts ...grpc.CallOption) (*WalletExistsResponse, error)
	CreateWallet(ctx context.Context, in *CreateWalletRequest, opts ...grpc.CallOption) (*CreateWalletResponse, error)
	CreateWatchingOnlyWallet(ctx context.Context, in *CreateWatchingOnlyWalletRequest, opts ...grpc.CallOption) (*CreateWatchingOnlyWalletResponse, error)
	OpenWallet(ctx context.Context, in *OpenWalletRequest, opts ...grpc.CallOption) (*OpenWalletResponse, error)
	CloseWallet(ctx context.Context, in *CloseWalletRequest, opts ...grpc.CallOption) (*CloseWalletResponse, error)
	SpvSync(ctx context.Context, in *SpvSyncRequest, opts ...grpc.CallOption) (WalletLoaderService_SpvSyncClient, error)
	RpcSync(ctx context.Context, in *RpcSyncRequest, opts ...grpc.CallOption) (WalletLoaderService_RpcSyncClient, error)
	RescanPoint(ctx context.Context, in *RescanPointRequest, opts ...grpc.CallOption) (*RescanPointResponse, error)
}

type walletLoaderServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewWalletLoaderServiceClient(cc grpc.ClientConnInterface) WalletLoaderServiceClient {
	return &walletLoaderServiceClient{cc}
}

func (c *walletLoaderServiceClient) WalletExists(ctx context.Context, in *WalletExistsRequest, opts ...grpc.CallOption) (*WalletExistsResponse, error) {
	out := new(WalletExistsResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletLoaderService/WalletExists", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletLoaderServiceClient) CreateWallet(ctx context.Context, in *CreateWalletRequest, opts ...grpc.CallOption) (*CreateWalletResponse, error) {
	out := new(CreateWalletResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletLoaderService/CreateWallet", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletLoaderServiceClient) CreateWatchingOnlyWallet(ctx context.Context, in *CreateWatchingOnlyWalletRequest, opts ...grpc.CallOption) (*CreateWatchingOnlyWalletResponse, error) {
	out := new(CreateWatchingOnlyWalletResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletLoaderService/CreateWatchingOnlyWallet", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletLoaderServiceClient) OpenWallet(ctx context.Context, in *OpenWalletRequest, opts ...grpc.CallOption) (*OpenWalletResponse, error) {
	out := new(OpenWalletResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletLoaderService/OpenWallet", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletLoaderServiceClient) CloseWallet(ctx context.Context, in *CloseWalletRequest, opts ...grpc.CallOption) (*CloseWalletResponse, error) {
	out := new(CloseWalletResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletLoaderService/CloseWallet", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *walletLoaderServiceClient) SpvSync(ctx context.Context, in *SpvSyncRequest, opts ...grpc.CallOption) (WalletLoaderService_SpvSyncClient, error) {
	stream, err := c.cc.NewStream(ctx, &WalletLoaderService_ServiceDesc.Streams[0], "/walletrpc.WalletLoaderService/SpvSync", opts...)
	if err != nil {
		return nil, err
	}
	x := &walletLoaderServiceSpvSyncClient{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 WalletLoaderService_SpvSyncClient interface {
	Recv() (*SpvSyncResponse, error)
	grpc.ClientStream
}

type walletLoaderServiceSpvSyncClient struct {
	grpc.ClientStream
}

func (x *walletLoaderServiceSpvSyncClient) Recv() (*SpvSyncResponse, error) {
	m := new(SpvSyncResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *walletLoaderServiceClient) RpcSync(ctx context.Context, in *RpcSyncRequest, opts ...grpc.CallOption) (WalletLoaderService_RpcSyncClient, error) {
	stream, err := c.cc.NewStream(ctx, &WalletLoaderService_ServiceDesc.Streams[1], "/walletrpc.WalletLoaderService/RpcSync", opts...)
	if err != nil {
		return nil, err
	}
	x := &walletLoaderServiceRpcSyncClient{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 WalletLoaderService_RpcSyncClient interface {
	Recv() (*RpcSyncResponse, error)
	grpc.ClientStream
}

type walletLoaderServiceRpcSyncClient struct {
	grpc.ClientStream
}

func (x *walletLoaderServiceRpcSyncClient) Recv() (*RpcSyncResponse, error) {
	m := new(RpcSyncResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *walletLoaderServiceClient) RescanPoint(ctx context.Context, in *RescanPointRequest, opts ...grpc.CallOption) (*RescanPointResponse, error) {
	out := new(RescanPointResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.WalletLoaderService/RescanPoint", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// WalletLoaderServiceServer is the server API for WalletLoaderService service.
// All implementations must embed UnimplementedWalletLoaderServiceServer
// for forward compatibility
type WalletLoaderServiceServer interface {
	WalletExists(context.Context, *WalletExistsRequest) (*WalletExistsResponse, error)
	CreateWallet(context.Context, *CreateWalletRequest) (*CreateWalletResponse, error)
	CreateWatchingOnlyWallet(context.Context, *CreateWatchingOnlyWalletRequest) (*CreateWatchingOnlyWalletResponse, error)
	OpenWallet(context.Context, *OpenWalletRequest) (*OpenWalletResponse, error)
	CloseWallet(context.Context, *CloseWalletRequest) (*CloseWalletResponse, error)
	SpvSync(*SpvSyncRequest, WalletLoaderService_SpvSyncServer) error
	RpcSync(*RpcSyncRequest, WalletLoaderService_RpcSyncServer) error
	RescanPoint(context.Context, *RescanPointRequest) (*RescanPointResponse, error)
	mustEmbedUnimplementedWalletLoaderServiceServer()
}

// UnimplementedWalletLoaderServiceServer must be embedded to have forward compatible implementations.
type UnimplementedWalletLoaderServiceServer struct {
}

func (UnimplementedWalletLoaderServiceServer) WalletExists(context.Context, *WalletExistsRequest) (*WalletExistsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method WalletExists not implemented")
}
func (UnimplementedWalletLoaderServiceServer) CreateWallet(context.Context, *CreateWalletRequest) (*CreateWalletResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateWallet not implemented")
}
func (UnimplementedWalletLoaderServiceServer) CreateWatchingOnlyWallet(context.Context, *CreateWatchingOnlyWalletRequest) (*CreateWatchingOnlyWalletResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateWatchingOnlyWallet not implemented")
}
func (UnimplementedWalletLoaderServiceServer) OpenWallet(context.Context, *OpenWalletRequest) (*OpenWalletResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method OpenWallet not implemented")
}
func (UnimplementedWalletLoaderServiceServer) CloseWallet(context.Context, *CloseWalletRequest) (*CloseWalletResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CloseWallet not implemented")
}
func (UnimplementedWalletLoaderServiceServer) SpvSync(*SpvSyncRequest, WalletLoaderService_SpvSyncServer) error {
	return status.Errorf(codes.Unimplemented, "method SpvSync not implemented")
}
func (UnimplementedWalletLoaderServiceServer) RpcSync(*RpcSyncRequest, WalletLoaderService_RpcSyncServer) error {
	return status.Errorf(codes.Unimplemented, "method RpcSync not implemented")
}
func (UnimplementedWalletLoaderServiceServer) RescanPoint(context.Context, *RescanPointRequest) (*RescanPointResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RescanPoint not implemented")
}
func (UnimplementedWalletLoaderServiceServer) mustEmbedUnimplementedWalletLoaderServiceServer() {}

// UnsafeWalletLoaderServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to WalletLoaderServiceServer will
// result in compilation errors.
type UnsafeWalletLoaderServiceServer interface {
	mustEmbedUnimplementedWalletLoaderServiceServer()
}

func RegisterWalletLoaderServiceServer(s grpc.ServiceRegistrar, srv WalletLoaderServiceServer) {
	s.RegisterService(&WalletLoaderService_ServiceDesc, srv)
}

func _WalletLoaderService_WalletExists_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(WalletExistsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletLoaderServiceServer).WalletExists(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletLoaderService/WalletExists",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletLoaderServiceServer).WalletExists(ctx, req.(*WalletExistsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletLoaderService_CreateWallet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateWalletRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletLoaderServiceServer).CreateWallet(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletLoaderService/CreateWallet",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletLoaderServiceServer).CreateWallet(ctx, req.(*CreateWalletRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletLoaderService_CreateWatchingOnlyWallet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateWatchingOnlyWalletRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletLoaderServiceServer).CreateWatchingOnlyWallet(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletLoaderService/CreateWatchingOnlyWallet",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletLoaderServiceServer).CreateWatchingOnlyWallet(ctx, req.(*CreateWatchingOnlyWalletRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletLoaderService_OpenWallet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(OpenWalletRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletLoaderServiceServer).OpenWallet(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletLoaderService/OpenWallet",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletLoaderServiceServer).OpenWallet(ctx, req.(*OpenWalletRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletLoaderService_CloseWallet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CloseWalletRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletLoaderServiceServer).CloseWallet(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletLoaderService/CloseWallet",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletLoaderServiceServer).CloseWallet(ctx, req.(*CloseWalletRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WalletLoaderService_SpvSync_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SpvSyncRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(WalletLoaderServiceServer).SpvSync(m, &walletLoaderServiceSpvSyncServer{stream})
}

type WalletLoaderService_SpvSyncServer interface {
	Send(*SpvSyncResponse) error
	grpc.ServerStream
}

type walletLoaderServiceSpvSyncServer struct {
	grpc.ServerStream
}

func (x *walletLoaderServiceSpvSyncServer) Send(m *SpvSyncResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _WalletLoaderService_RpcSync_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(RpcSyncRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(WalletLoaderServiceServer).RpcSync(m, &walletLoaderServiceRpcSyncServer{stream})
}

type WalletLoaderService_RpcSyncServer interface {
	Send(*RpcSyncResponse) error
	grpc.ServerStream
}

type walletLoaderServiceRpcSyncServer struct {
	grpc.ServerStream
}

func (x *walletLoaderServiceRpcSyncServer) Send(m *RpcSyncResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _WalletLoaderService_RescanPoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RescanPointRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WalletLoaderServiceServer).RescanPoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.WalletLoaderService/RescanPoint",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WalletLoaderServiceServer).RescanPoint(ctx, req.(*RescanPointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// WalletLoaderService_ServiceDesc is the grpc.ServiceDesc for WalletLoaderService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var WalletLoaderService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "walletrpc.WalletLoaderService",
	HandlerType: (*WalletLoaderServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "WalletExists",
			Handler:    _WalletLoaderService_WalletExists_Handler,
		},
		{
			MethodName: "CreateWallet",
			Handler:    _WalletLoaderService_CreateWallet_Handler,
		},
		{
			MethodName: "CreateWatchingOnlyWallet",
			Handler:    _WalletLoaderService_CreateWatchingOnlyWallet_Handler,
		},
		{
			MethodName: "OpenWallet",
			Handler:    _WalletLoaderService_OpenWallet_Handler,
		},
		{
			MethodName: "CloseWallet",
			Handler:    _WalletLoaderService_CloseWallet_Handler,
		},
		{
			MethodName: "RescanPoint",
			Handler:    _WalletLoaderService_RescanPoint_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "SpvSync",
			Handler:       _WalletLoaderService_SpvSync_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "RpcSync",
			Handler:       _WalletLoaderService_RpcSync_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "api.proto",
}

// AccountMixerServiceClient is the client API for AccountMixerService 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 AccountMixerServiceClient interface {
	RunAccountMixer(ctx context.Context, in *RunAccountMixerRequest, opts ...grpc.CallOption) (AccountMixerService_RunAccountMixerClient, error)
}

type accountMixerServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewAccountMixerServiceClient(cc grpc.ClientConnInterface) AccountMixerServiceClient {
	return &accountMixerServiceClient{cc}
}

func (c *accountMixerServiceClient) RunAccountMixer(ctx context.Context, in *RunAccountMixerRequest, opts ...grpc.CallOption) (AccountMixerService_RunAccountMixerClient, error) {
	stream, err := c.cc.NewStream(ctx, &AccountMixerService_ServiceDesc.Streams[0], "/walletrpc.AccountMixerService/RunAccountMixer", opts...)
	if err != nil {
		return nil, err
	}
	x := &accountMixerServiceRunAccountMixerClient{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 AccountMixerService_RunAccountMixerClient interface {
	Recv() (*RunAccountMixerResponse, error)
	grpc.ClientStream
}

type accountMixerServiceRunAccountMixerClient struct {
	grpc.ClientStream
}

func (x *accountMixerServiceRunAccountMixerClient) Recv() (*RunAccountMixerResponse, error) {
	m := new(RunAccountMixerResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// AccountMixerServiceServer is the server API for AccountMixerService service.
// All implementations must embed UnimplementedAccountMixerServiceServer
// for forward compatibility
type AccountMixerServiceServer interface {
	RunAccountMixer(*RunAccountMixerRequest, AccountMixerService_RunAccountMixerServer) error
	mustEmbedUnimplementedAccountMixerServiceServer()
}

// UnimplementedAccountMixerServiceServer must be embedded to have forward compatible implementations.
type UnimplementedAccountMixerServiceServer struct {
}

func (UnimplementedAccountMixerServiceServer) RunAccountMixer(*RunAccountMixerRequest, AccountMixerService_RunAccountMixerServer) error {
	return status.Errorf(codes.Unimplemented, "method RunAccountMixer not implemented")
}
func (UnimplementedAccountMixerServiceServer) mustEmbedUnimplementedAccountMixerServiceServer() {}

// UnsafeAccountMixerServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to AccountMixerServiceServer will
// result in compilation errors.
type UnsafeAccountMixerServiceServer interface {
	mustEmbedUnimplementedAccountMixerServiceServer()
}

func RegisterAccountMixerServiceServer(s grpc.ServiceRegistrar, srv AccountMixerServiceServer) {
	s.RegisterService(&AccountMixerService_ServiceDesc, srv)
}

func _AccountMixerService_RunAccountMixer_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(RunAccountMixerRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(AccountMixerServiceServer).RunAccountMixer(m, &accountMixerServiceRunAccountMixerServer{stream})
}

type AccountMixerService_RunAccountMixerServer interface {
	Send(*RunAccountMixerResponse) error
	grpc.ServerStream
}

type accountMixerServiceRunAccountMixerServer struct {
	grpc.ServerStream
}

func (x *accountMixerServiceRunAccountMixerServer) Send(m *RunAccountMixerResponse) error {
	return x.ServerStream.SendMsg(m)
}

// AccountMixerService_ServiceDesc is the grpc.ServiceDesc for AccountMixerService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var AccountMixerService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "walletrpc.AccountMixerService",
	HandlerType: (*AccountMixerServiceServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "RunAccountMixer",
			Handler:       _AccountMixerService_RunAccountMixer_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "api.proto",
}

// TicketBuyerV2ServiceClient is the client API for TicketBuyerV2Service 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 TicketBuyerV2ServiceClient interface {
	RunTicketBuyer(ctx context.Context, in *RunTicketBuyerRequest, opts ...grpc.CallOption) (TicketBuyerV2Service_RunTicketBuyerClient, error)
}

type ticketBuyerV2ServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewTicketBuyerV2ServiceClient(cc grpc.ClientConnInterface) TicketBuyerV2ServiceClient {
	return &ticketBuyerV2ServiceClient{cc}
}

func (c *ticketBuyerV2ServiceClient) RunTicketBuyer(ctx context.Context, in *RunTicketBuyerRequest, opts ...grpc.CallOption) (TicketBuyerV2Service_RunTicketBuyerClient, error) {
	stream, err := c.cc.NewStream(ctx, &TicketBuyerV2Service_ServiceDesc.Streams[0], "/walletrpc.TicketBuyerV2Service/RunTicketBuyer", opts...)
	if err != nil {
		return nil, err
	}
	x := &ticketBuyerV2ServiceRunTicketBuyerClient{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 TicketBuyerV2Service_RunTicketBuyerClient interface {
	Recv() (*RunTicketBuyerResponse, error)
	grpc.ClientStream
}

type ticketBuyerV2ServiceRunTicketBuyerClient struct {
	grpc.ClientStream
}

func (x *ticketBuyerV2ServiceRunTicketBuyerClient) Recv() (*RunTicketBuyerResponse, error) {
	m := new(RunTicketBuyerResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// TicketBuyerV2ServiceServer is the server API for TicketBuyerV2Service service.
// All implementations must embed UnimplementedTicketBuyerV2ServiceServer
// for forward compatibility
type TicketBuyerV2ServiceServer interface {
	RunTicketBuyer(*RunTicketBuyerRequest, TicketBuyerV2Service_RunTicketBuyerServer) error
	mustEmbedUnimplementedTicketBuyerV2ServiceServer()
}

// UnimplementedTicketBuyerV2ServiceServer must be embedded to have forward compatible implementations.
type UnimplementedTicketBuyerV2ServiceServer struct {
}

func (UnimplementedTicketBuyerV2ServiceServer) RunTicketBuyer(*RunTicketBuyerRequest, TicketBuyerV2Service_RunTicketBuyerServer) error {
	return status.Errorf(codes.Unimplemented, "method RunTicketBuyer not implemented")
}
func (UnimplementedTicketBuyerV2ServiceServer) mustEmbedUnimplementedTicketBuyerV2ServiceServer() {}

// UnsafeTicketBuyerV2ServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to TicketBuyerV2ServiceServer will
// result in compilation errors.
type UnsafeTicketBuyerV2ServiceServer interface {
	mustEmbedUnimplementedTicketBuyerV2ServiceServer()
}

func RegisterTicketBuyerV2ServiceServer(s grpc.ServiceRegistrar, srv TicketBuyerV2ServiceServer) {
	s.RegisterService(&TicketBuyerV2Service_ServiceDesc, srv)
}

func _TicketBuyerV2Service_RunTicketBuyer_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(RunTicketBuyerRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(TicketBuyerV2ServiceServer).RunTicketBuyer(m, &ticketBuyerV2ServiceRunTicketBuyerServer{stream})
}

type TicketBuyerV2Service_RunTicketBuyerServer interface {
	Send(*RunTicketBuyerResponse) error
	grpc.ServerStream
}

type ticketBuyerV2ServiceRunTicketBuyerServer struct {
	grpc.ServerStream
}

func (x *ticketBuyerV2ServiceRunTicketBuyerServer) Send(m *RunTicketBuyerResponse) error {
	return x.ServerStream.SendMsg(m)
}

// TicketBuyerV2Service_ServiceDesc is the grpc.ServiceDesc for TicketBuyerV2Service service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var TicketBuyerV2Service_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "walletrpc.TicketBuyerV2Service",
	HandlerType: (*TicketBuyerV2ServiceServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "RunTicketBuyer",
			Handler:       _TicketBuyerV2Service_RunTicketBuyer_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "api.proto",
}

// TicketBuyerServiceClient is the client API for TicketBuyerService 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 TicketBuyerServiceClient interface {
	StartAutoBuyer(ctx context.Context, in *StartAutoBuyerRequest, opts ...grpc.CallOption) (*StartAutoBuyerResponse, error)
	StopAutoBuyer(ctx context.Context, in *StopAutoBuyerRequest, opts ...grpc.CallOption) (*StopAutoBuyerResponse, error)
	TicketBuyerConfig(ctx context.Context, in *TicketBuyerConfigRequest, opts ...grpc.CallOption) (*TicketBuyerConfigResponse, error)
	SetAccount(ctx context.Context, in *SetAccountRequest, opts ...grpc.CallOption) (*SetAccountResponse, error)
	SetBalanceToMaintain(ctx context.Context, in *SetBalanceToMaintainRequest, opts ...grpc.CallOption) (*SetBalanceToMaintainResponse, error)
	SetMaxFee(ctx context.Context, in *SetMaxFeeRequest, opts ...grpc.CallOption) (*SetMaxFeeResponse, error)
	SetMaxPriceRelative(ctx context.Context, in *SetMaxPriceRelativeRequest, opts ...grpc.CallOption) (*SetMaxPriceRelativeResponse, error)
	SetMaxPriceAbsolute(ctx context.Context, in *SetMaxPriceAbsoluteRequest, opts ...grpc.CallOption) (*SetMaxPriceAbsoluteResponse, error)
	SetVotingAddress(ctx context.Context, in *SetVotingAddressRequest, opts ...grpc.CallOption) (*SetVotingAddressResponse, error)
	SetPoolAddress(ctx context.Context, in *SetPoolAddressRequest, opts ...grpc.CallOption) (*SetPoolAddressResponse, error)
	SetPoolFees(ctx context.Context, in *SetPoolFeesRequest, opts ...grpc.CallOption) (*SetPoolFeesResponse, error)
	SetMaxPerBlock(ctx context.Context, in *SetMaxPerBlockRequest, opts ...grpc.CallOption) (*SetMaxPerBlockResponse, error)
}

type ticketBuyerServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewTicketBuyerServiceClient(cc grpc.ClientConnInterface) TicketBuyerServiceClient {
	return &ticketBuyerServiceClient{cc}
}

func (c *ticketBuyerServiceClient) StartAutoBuyer(ctx context.Context, in *StartAutoBuyerRequest, opts ...grpc.CallOption) (*StartAutoBuyerResponse, error) {
	out := new(StartAutoBuyerResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.TicketBuyerService/StartAutoBuyer", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ticketBuyerServiceClient) StopAutoBuyer(ctx context.Context, in *StopAutoBuyerRequest, opts ...grpc.CallOption) (*StopAutoBuyerResponse, error) {
	out := new(StopAutoBuyerResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.TicketBuyerService/StopAutoBuyer", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ticketBuyerServiceClient) TicketBuyerConfig(ctx context.Context, in *TicketBuyerConfigRequest, opts ...grpc.CallOption) (*TicketBuyerConfigResponse, error) {
	out := new(TicketBuyerConfigResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.TicketBuyerService/TicketBuyerConfig", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ticketBuyerServiceClient) SetAccount(ctx context.Context, in *SetAccountRequest, opts ...grpc.CallOption) (*SetAccountResponse, error) {
	out := new(SetAccountResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.TicketBuyerService/SetAccount", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ticketBuyerServiceClient) SetBalanceToMaintain(ctx context.Context, in *SetBalanceToMaintainRequest, opts ...grpc.CallOption) (*SetBalanceToMaintainResponse, error) {
	out := new(SetBalanceToMaintainResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.TicketBuyerService/SetBalanceToMaintain", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ticketBuyerServiceClient) SetMaxFee(ctx context.Context, in *SetMaxFeeRequest, opts ...grpc.CallOption) (*SetMaxFeeResponse, error) {
	out := new(SetMaxFeeResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.TicketBuyerService/SetMaxFee", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ticketBuyerServiceClient) SetMaxPriceRelative(ctx context.Context, in *SetMaxPriceRelativeRequest, opts ...grpc.CallOption) (*SetMaxPriceRelativeResponse, error) {
	out := new(SetMaxPriceRelativeResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.TicketBuyerService/SetMaxPriceRelative", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ticketBuyerServiceClient) SetMaxPriceAbsolute(ctx context.Context, in *SetMaxPriceAbsoluteRequest, opts ...grpc.CallOption) (*SetMaxPriceAbsoluteResponse, error) {
	out := new(SetMaxPriceAbsoluteResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.TicketBuyerService/SetMaxPriceAbsolute", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ticketBuyerServiceClient) SetVotingAddress(ctx context.Context, in *SetVotingAddressRequest, opts ...grpc.CallOption) (*SetVotingAddressResponse, error) {
	out := new(SetVotingAddressResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.TicketBuyerService/SetVotingAddress", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ticketBuyerServiceClient) SetPoolAddress(ctx context.Context, in *SetPoolAddressRequest, opts ...grpc.CallOption) (*SetPoolAddressResponse, error) {
	out := new(SetPoolAddressResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.TicketBuyerService/SetPoolAddress", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ticketBuyerServiceClient) SetPoolFees(ctx context.Context, in *SetPoolFeesRequest, opts ...grpc.CallOption) (*SetPoolFeesResponse, error) {
	out := new(SetPoolFeesResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.TicketBuyerService/SetPoolFees", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *ticketBuyerServiceClient) SetMaxPerBlock(ctx context.Context, in *SetMaxPerBlockRequest, opts ...grpc.CallOption) (*SetMaxPerBlockResponse, error) {
	out := new(SetMaxPerBlockResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.TicketBuyerService/SetMaxPerBlock", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// TicketBuyerServiceServer is the server API for TicketBuyerService service.
// All implementations must embed UnimplementedTicketBuyerServiceServer
// for forward compatibility
type TicketBuyerServiceServer interface {
	StartAutoBuyer(context.Context, *StartAutoBuyerRequest) (*StartAutoBuyerResponse, error)
	StopAutoBuyer(context.Context, *StopAutoBuyerRequest) (*StopAutoBuyerResponse, error)
	TicketBuyerConfig(context.Context, *TicketBuyerConfigRequest) (*TicketBuyerConfigResponse, error)
	SetAccount(context.Context, *SetAccountRequest) (*SetAccountResponse, error)
	SetBalanceToMaintain(context.Context, *SetBalanceToMaintainRequest) (*SetBalanceToMaintainResponse, error)
	SetMaxFee(context.Context, *SetMaxFeeRequest) (*SetMaxFeeResponse, error)
	SetMaxPriceRelative(context.Context, *SetMaxPriceRelativeRequest) (*SetMaxPriceRelativeResponse, error)
	SetMaxPriceAbsolute(context.Context, *SetMaxPriceAbsoluteRequest) (*SetMaxPriceAbsoluteResponse, error)
	SetVotingAddress(context.Context, *SetVotingAddressRequest) (*SetVotingAddressResponse, error)
	SetPoolAddress(context.Context, *SetPoolAddressRequest) (*SetPoolAddressResponse, error)
	SetPoolFees(context.Context, *SetPoolFeesRequest) (*SetPoolFeesResponse, error)
	SetMaxPerBlock(context.Context, *SetMaxPerBlockRequest) (*SetMaxPerBlockResponse, error)
	mustEmbedUnimplementedTicketBuyerServiceServer()
}

// UnimplementedTicketBuyerServiceServer must be embedded to have forward compatible implementations.
type UnimplementedTicketBuyerServiceServer struct {
}

func (UnimplementedTicketBuyerServiceServer) StartAutoBuyer(context.Context, *StartAutoBuyerRequest) (*StartAutoBuyerResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StartAutoBuyer not implemented")
}
func (UnimplementedTicketBuyerServiceServer) StopAutoBuyer(context.Context, *StopAutoBuyerRequest) (*StopAutoBuyerResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StopAutoBuyer not implemented")
}
func (UnimplementedTicketBuyerServiceServer) TicketBuyerConfig(context.Context, *TicketBuyerConfigRequest) (*TicketBuyerConfigResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method TicketBuyerConfig not implemented")
}
func (UnimplementedTicketBuyerServiceServer) SetAccount(context.Context, *SetAccountRequest) (*SetAccountResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetAccount not implemented")
}
func (UnimplementedTicketBuyerServiceServer) SetBalanceToMaintain(context.Context, *SetBalanceToMaintainRequest) (*SetBalanceToMaintainResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetBalanceToMaintain not implemented")
}
func (UnimplementedTicketBuyerServiceServer) SetMaxFee(context.Context, *SetMaxFeeRequest) (*SetMaxFeeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetMaxFee not implemented")
}
func (UnimplementedTicketBuyerServiceServer) SetMaxPriceRelative(context.Context, *SetMaxPriceRelativeRequest) (*SetMaxPriceRelativeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetMaxPriceRelative not implemented")
}
func (UnimplementedTicketBuyerServiceServer) SetMaxPriceAbsolute(context.Context, *SetMaxPriceAbsoluteRequest) (*SetMaxPriceAbsoluteResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetMaxPriceAbsolute not implemented")
}
func (UnimplementedTicketBuyerServiceServer) SetVotingAddress(context.Context, *SetVotingAddressRequest) (*SetVotingAddressResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetVotingAddress not implemented")
}
func (UnimplementedTicketBuyerServiceServer) SetPoolAddress(context.Context, *SetPoolAddressRequest) (*SetPoolAddressResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetPoolAddress not implemented")
}
func (UnimplementedTicketBuyerServiceServer) SetPoolFees(context.Context, *SetPoolFeesRequest) (*SetPoolFeesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetPoolFees not implemented")
}
func (UnimplementedTicketBuyerServiceServer) SetMaxPerBlock(context.Context, *SetMaxPerBlockRequest) (*SetMaxPerBlockResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetMaxPerBlock not implemented")
}
func (UnimplementedTicketBuyerServiceServer) mustEmbedUnimplementedTicketBuyerServiceServer() {}

// UnsafeTicketBuyerServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to TicketBuyerServiceServer will
// result in compilation errors.
type UnsafeTicketBuyerServiceServer interface {
	mustEmbedUnimplementedTicketBuyerServiceServer()
}

func RegisterTicketBuyerServiceServer(s grpc.ServiceRegistrar, srv TicketBuyerServiceServer) {
	s.RegisterService(&TicketBuyerService_ServiceDesc, srv)
}

func _TicketBuyerService_StartAutoBuyer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StartAutoBuyerRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TicketBuyerServiceServer).StartAutoBuyer(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.TicketBuyerService/StartAutoBuyer",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TicketBuyerServiceServer).StartAutoBuyer(ctx, req.(*StartAutoBuyerRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TicketBuyerService_StopAutoBuyer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StopAutoBuyerRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TicketBuyerServiceServer).StopAutoBuyer(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.TicketBuyerService/StopAutoBuyer",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TicketBuyerServiceServer).StopAutoBuyer(ctx, req.(*StopAutoBuyerRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TicketBuyerService_TicketBuyerConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TicketBuyerConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TicketBuyerServiceServer).TicketBuyerConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.TicketBuyerService/TicketBuyerConfig",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TicketBuyerServiceServer).TicketBuyerConfig(ctx, req.(*TicketBuyerConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TicketBuyerService_SetAccount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetAccountRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TicketBuyerServiceServer).SetAccount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.TicketBuyerService/SetAccount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TicketBuyerServiceServer).SetAccount(ctx, req.(*SetAccountRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TicketBuyerService_SetBalanceToMaintain_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetBalanceToMaintainRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TicketBuyerServiceServer).SetBalanceToMaintain(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.TicketBuyerService/SetBalanceToMaintain",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TicketBuyerServiceServer).SetBalanceToMaintain(ctx, req.(*SetBalanceToMaintainRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TicketBuyerService_SetMaxFee_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetMaxFeeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TicketBuyerServiceServer).SetMaxFee(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.TicketBuyerService/SetMaxFee",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TicketBuyerServiceServer).SetMaxFee(ctx, req.(*SetMaxFeeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TicketBuyerService_SetMaxPriceRelative_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetMaxPriceRelativeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TicketBuyerServiceServer).SetMaxPriceRelative(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.TicketBuyerService/SetMaxPriceRelative",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TicketBuyerServiceServer).SetMaxPriceRelative(ctx, req.(*SetMaxPriceRelativeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TicketBuyerService_SetMaxPriceAbsolute_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetMaxPriceAbsoluteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TicketBuyerServiceServer).SetMaxPriceAbsolute(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.TicketBuyerService/SetMaxPriceAbsolute",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TicketBuyerServiceServer).SetMaxPriceAbsolute(ctx, req.(*SetMaxPriceAbsoluteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TicketBuyerService_SetVotingAddress_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetVotingAddressRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TicketBuyerServiceServer).SetVotingAddress(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.TicketBuyerService/SetVotingAddress",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TicketBuyerServiceServer).SetVotingAddress(ctx, req.(*SetVotingAddressRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TicketBuyerService_SetPoolAddress_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetPoolAddressRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TicketBuyerServiceServer).SetPoolAddress(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.TicketBuyerService/SetPoolAddress",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TicketBuyerServiceServer).SetPoolAddress(ctx, req.(*SetPoolAddressRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TicketBuyerService_SetPoolFees_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetPoolFeesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TicketBuyerServiceServer).SetPoolFees(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.TicketBuyerService/SetPoolFees",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TicketBuyerServiceServer).SetPoolFees(ctx, req.(*SetPoolFeesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TicketBuyerService_SetMaxPerBlock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetMaxPerBlockRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TicketBuyerServiceServer).SetMaxPerBlock(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.TicketBuyerService/SetMaxPerBlock",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TicketBuyerServiceServer).SetMaxPerBlock(ctx, req.(*SetMaxPerBlockRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// TicketBuyerService_ServiceDesc is the grpc.ServiceDesc for TicketBuyerService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var TicketBuyerService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "walletrpc.TicketBuyerService",
	HandlerType: (*TicketBuyerServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "StartAutoBuyer",
			Handler:    _TicketBuyerService_StartAutoBuyer_Handler,
		},
		{
			MethodName: "StopAutoBuyer",
			Handler:    _TicketBuyerService_StopAutoBuyer_Handler,
		},
		{
			MethodName: "TicketBuyerConfig",
			Handler:    _TicketBuyerService_TicketBuyerConfig_Handler,
		},
		{
			MethodName: "SetAccount",
			Handler:    _TicketBuyerService_SetAccount_Handler,
		},
		{
			MethodName: "SetBalanceToMaintain",
			Handler:    _TicketBuyerService_SetBalanceToMaintain_Handler,
		},
		{
			MethodName: "SetMaxFee",
			Handler:    _TicketBuyerService_SetMaxFee_Handler,
		},
		{
			MethodName: "SetMaxPriceRelative",
			Handler:    _TicketBuyerService_SetMaxPriceRelative_Handler,
		},
		{
			MethodName: "SetMaxPriceAbsolute",
			Handler:    _TicketBuyerService_SetMaxPriceAbsolute_Handler,
		},
		{
			MethodName: "SetVotingAddress",
			Handler:    _TicketBuyerService_SetVotingAddress_Handler,
		},
		{
			MethodName: "SetPoolAddress",
			Handler:    _TicketBuyerService_SetPoolAddress_Handler,
		},
		{
			MethodName: "SetPoolFees",
			Handler:    _TicketBuyerService_SetPoolFees_Handler,
		},
		{
			MethodName: "SetMaxPerBlock",
			Handler:    _TicketBuyerService_SetMaxPerBlock_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "api.proto",
}

// SeedServiceClient is the client API for SeedService 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 SeedServiceClient interface {
	GenerateRandomSeed(ctx context.Context, in *GenerateRandomSeedRequest, opts ...grpc.CallOption) (*GenerateRandomSeedResponse, error)
	DecodeSeed(ctx context.Context, in *DecodeSeedRequest, opts ...grpc.CallOption) (*DecodeSeedResponse, error)
}

type seedServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewSeedServiceClient(cc grpc.ClientConnInterface) SeedServiceClient {
	return &seedServiceClient{cc}
}

func (c *seedServiceClient) GenerateRandomSeed(ctx context.Context, in *GenerateRandomSeedRequest, opts ...grpc.CallOption) (*GenerateRandomSeedResponse, error) {
	out := new(GenerateRandomSeedResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.SeedService/GenerateRandomSeed", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *seedServiceClient) DecodeSeed(ctx context.Context, in *DecodeSeedRequest, opts ...grpc.CallOption) (*DecodeSeedResponse, error) {
	out := new(DecodeSeedResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.SeedService/DecodeSeed", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// SeedServiceServer is the server API for SeedService service.
// All implementations must embed UnimplementedSeedServiceServer
// for forward compatibility
type SeedServiceServer interface {
	GenerateRandomSeed(context.Context, *GenerateRandomSeedRequest) (*GenerateRandomSeedResponse, error)
	DecodeSeed(context.Context, *DecodeSeedRequest) (*DecodeSeedResponse, error)
	mustEmbedUnimplementedSeedServiceServer()
}

// UnimplementedSeedServiceServer must be embedded to have forward compatible implementations.
type UnimplementedSeedServiceServer struct {
}

func (UnimplementedSeedServiceServer) GenerateRandomSeed(context.Context, *GenerateRandomSeedRequest) (*GenerateRandomSeedResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GenerateRandomSeed not implemented")
}
func (UnimplementedSeedServiceServer) DecodeSeed(context.Context, *DecodeSeedRequest) (*DecodeSeedResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DecodeSeed not implemented")
}
func (UnimplementedSeedServiceServer) mustEmbedUnimplementedSeedServiceServer() {}

// UnsafeSeedServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to SeedServiceServer will
// result in compilation errors.
type UnsafeSeedServiceServer interface {
	mustEmbedUnimplementedSeedServiceServer()
}

func RegisterSeedServiceServer(s grpc.ServiceRegistrar, srv SeedServiceServer) {
	s.RegisterService(&SeedService_ServiceDesc, srv)
}

func _SeedService_GenerateRandomSeed_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GenerateRandomSeedRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SeedServiceServer).GenerateRandomSeed(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.SeedService/GenerateRandomSeed",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SeedServiceServer).GenerateRandomSeed(ctx, req.(*GenerateRandomSeedRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SeedService_DecodeSeed_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DecodeSeedRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SeedServiceServer).DecodeSeed(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.SeedService/DecodeSeed",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SeedServiceServer).DecodeSeed(ctx, req.(*DecodeSeedRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// SeedService_ServiceDesc is the grpc.ServiceDesc for SeedService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var SeedService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "walletrpc.SeedService",
	HandlerType: (*SeedServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GenerateRandomSeed",
			Handler:    _SeedService_GenerateRandomSeed_Handler,
		},
		{
			MethodName: "DecodeSeed",
			Handler:    _SeedService_DecodeSeed_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "api.proto",
}

// AgendaServiceClient is the client API for AgendaService 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 AgendaServiceClient interface {
	Agendas(ctx context.Context, in *AgendasRequest, opts ...grpc.CallOption) (*AgendasResponse, error)
}

type agendaServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewAgendaServiceClient(cc grpc.ClientConnInterface) AgendaServiceClient {
	return &agendaServiceClient{cc}
}

func (c *agendaServiceClient) Agendas(ctx context.Context, in *AgendasRequest, opts ...grpc.CallOption) (*AgendasResponse, error) {
	out := new(AgendasResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.AgendaService/Agendas", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// AgendaServiceServer is the server API for AgendaService service.
// All implementations must embed UnimplementedAgendaServiceServer
// for forward compatibility
type AgendaServiceServer interface {
	Agendas(context.Context, *AgendasRequest) (*AgendasResponse, error)
	mustEmbedUnimplementedAgendaServiceServer()
}

// UnimplementedAgendaServiceServer must be embedded to have forward compatible implementations.
type UnimplementedAgendaServiceServer struct {
}

func (UnimplementedAgendaServiceServer) Agendas(context.Context, *AgendasRequest) (*AgendasResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Agendas not implemented")
}
func (UnimplementedAgendaServiceServer) mustEmbedUnimplementedAgendaServiceServer() {}

// UnsafeAgendaServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to AgendaServiceServer will
// result in compilation errors.
type UnsafeAgendaServiceServer interface {
	mustEmbedUnimplementedAgendaServiceServer()
}

func RegisterAgendaServiceServer(s grpc.ServiceRegistrar, srv AgendaServiceServer) {
	s.RegisterService(&AgendaService_ServiceDesc, srv)
}

func _AgendaService_Agendas_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AgendasRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AgendaServiceServer).Agendas(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.AgendaService/Agendas",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AgendaServiceServer).Agendas(ctx, req.(*AgendasRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// AgendaService_ServiceDesc is the grpc.ServiceDesc for AgendaService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var AgendaService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "walletrpc.AgendaService",
	HandlerType: (*AgendaServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Agendas",
			Handler:    _AgendaService_Agendas_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "api.proto",
}

// VotingServiceClient is the client API for VotingService 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 VotingServiceClient interface {
	VoteChoices(ctx context.Context, in *VoteChoicesRequest, opts ...grpc.CallOption) (*VoteChoicesResponse, error)
	SetVoteChoices(ctx context.Context, in *SetVoteChoicesRequest, opts ...grpc.CallOption) (*SetVoteChoicesResponse, error)
	TSpendPolicies(ctx context.Context, in *TSpendPoliciesRequest, opts ...grpc.CallOption) (*TSpendPoliciesResponse, error)
	SetTSpendPolicy(ctx context.Context, in *SetTSpendPolicyRequest, opts ...grpc.CallOption) (*SetTSpendPolicyResponse, error)
	TreasuryPolicies(ctx context.Context, in *TreasuryPoliciesRequest, opts ...grpc.CallOption) (*TreasuryPoliciesResponse, error)
	SetTreasuryPolicy(ctx context.Context, in *SetTreasuryPolicyRequest, opts ...grpc.CallOption) (*SetTreasuryPolicyResponse, error)
}

type votingServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewVotingServiceClient(cc grpc.ClientConnInterface) VotingServiceClient {
	return &votingServiceClient{cc}
}

func (c *votingServiceClient) VoteChoices(ctx context.Context, in *VoteChoicesRequest, opts ...grpc.CallOption) (*VoteChoicesResponse, error) {
	out := new(VoteChoicesResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.VotingService/VoteChoices", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *votingServiceClient) SetVoteChoices(ctx context.Context, in *SetVoteChoicesRequest, opts ...grpc.CallOption) (*SetVoteChoicesResponse, error) {
	out := new(SetVoteChoicesResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.VotingService/SetVoteChoices", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *votingServiceClient) TSpendPolicies(ctx context.Context, in *TSpendPoliciesRequest, opts ...grpc.CallOption) (*TSpendPoliciesResponse, error) {
	out := new(TSpendPoliciesResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.VotingService/TSpendPolicies", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *votingServiceClient) SetTSpendPolicy(ctx context.Context, in *SetTSpendPolicyRequest, opts ...grpc.CallOption) (*SetTSpendPolicyResponse, error) {
	out := new(SetTSpendPolicyResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.VotingService/SetTSpendPolicy", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *votingServiceClient) TreasuryPolicies(ctx context.Context, in *TreasuryPoliciesRequest, opts ...grpc.CallOption) (*TreasuryPoliciesResponse, error) {
	out := new(TreasuryPoliciesResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.VotingService/TreasuryPolicies", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *votingServiceClient) SetTreasuryPolicy(ctx context.Context, in *SetTreasuryPolicyRequest, opts ...grpc.CallOption) (*SetTreasuryPolicyResponse, error) {
	out := new(SetTreasuryPolicyResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.VotingService/SetTreasuryPolicy", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// VotingServiceServer is the server API for VotingService service.
// All implementations must embed UnimplementedVotingServiceServer
// for forward compatibility
type VotingServiceServer interface {
	VoteChoices(context.Context, *VoteChoicesRequest) (*VoteChoicesResponse, error)
	SetVoteChoices(context.Context, *SetVoteChoicesRequest) (*SetVoteChoicesResponse, error)
	TSpendPolicies(context.Context, *TSpendPoliciesRequest) (*TSpendPoliciesResponse, error)
	SetTSpendPolicy(context.Context, *SetTSpendPolicyRequest) (*SetTSpendPolicyResponse, error)
	TreasuryPolicies(context.Context, *TreasuryPoliciesRequest) (*TreasuryPoliciesResponse, error)
	SetTreasuryPolicy(context.Context, *SetTreasuryPolicyRequest) (*SetTreasuryPolicyResponse, error)
	mustEmbedUnimplementedVotingServiceServer()
}

// UnimplementedVotingServiceServer must be embedded to have forward compatible implementations.
type UnimplementedVotingServiceServer struct {
}

func (UnimplementedVotingServiceServer) VoteChoices(context.Context, *VoteChoicesRequest) (*VoteChoicesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method VoteChoices not implemented")
}
func (UnimplementedVotingServiceServer) SetVoteChoices(context.Context, *SetVoteChoicesRequest) (*SetVoteChoicesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetVoteChoices not implemented")
}
func (UnimplementedVotingServiceServer) TSpendPolicies(context.Context, *TSpendPoliciesRequest) (*TSpendPoliciesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method TSpendPolicies not implemented")
}
func (UnimplementedVotingServiceServer) SetTSpendPolicy(context.Context, *SetTSpendPolicyRequest) (*SetTSpendPolicyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetTSpendPolicy not implemented")
}
func (UnimplementedVotingServiceServer) TreasuryPolicies(context.Context, *TreasuryPoliciesRequest) (*TreasuryPoliciesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method TreasuryPolicies not implemented")
}
func (UnimplementedVotingServiceServer) SetTreasuryPolicy(context.Context, *SetTreasuryPolicyRequest) (*SetTreasuryPolicyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetTreasuryPolicy not implemented")
}
func (UnimplementedVotingServiceServer) mustEmbedUnimplementedVotingServiceServer() {}

// UnsafeVotingServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to VotingServiceServer will
// result in compilation errors.
type UnsafeVotingServiceServer interface {
	mustEmbedUnimplementedVotingServiceServer()
}

func RegisterVotingServiceServer(s grpc.ServiceRegistrar, srv VotingServiceServer) {
	s.RegisterService(&VotingService_ServiceDesc, srv)
}

func _VotingService_VoteChoices_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(VoteChoicesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VotingServiceServer).VoteChoices(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.VotingService/VoteChoices",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VotingServiceServer).VoteChoices(ctx, req.(*VoteChoicesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VotingService_SetVoteChoices_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetVoteChoicesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VotingServiceServer).SetVoteChoices(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.VotingService/SetVoteChoices",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VotingServiceServer).SetVoteChoices(ctx, req.(*SetVoteChoicesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VotingService_TSpendPolicies_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TSpendPoliciesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VotingServiceServer).TSpendPolicies(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.VotingService/TSpendPolicies",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VotingServiceServer).TSpendPolicies(ctx, req.(*TSpendPoliciesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VotingService_SetTSpendPolicy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetTSpendPolicyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VotingServiceServer).SetTSpendPolicy(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.VotingService/SetTSpendPolicy",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VotingServiceServer).SetTSpendPolicy(ctx, req.(*SetTSpendPolicyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VotingService_TreasuryPolicies_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TreasuryPoliciesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VotingServiceServer).TreasuryPolicies(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.VotingService/TreasuryPolicies",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VotingServiceServer).TreasuryPolicies(ctx, req.(*TreasuryPoliciesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VotingService_SetTreasuryPolicy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetTreasuryPolicyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VotingServiceServer).SetTreasuryPolicy(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.VotingService/SetTreasuryPolicy",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VotingServiceServer).SetTreasuryPolicy(ctx, req.(*SetTreasuryPolicyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// VotingService_ServiceDesc is the grpc.ServiceDesc for VotingService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var VotingService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "walletrpc.VotingService",
	HandlerType: (*VotingServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "VoteChoices",
			Handler:    _VotingService_VoteChoices_Handler,
		},
		{
			MethodName: "SetVoteChoices",
			Handler:    _VotingService_SetVoteChoices_Handler,
		},
		{
			MethodName: "TSpendPolicies",
			Handler:    _VotingService_TSpendPolicies_Handler,
		},
		{
			MethodName: "SetTSpendPolicy",
			Handler:    _VotingService_SetTSpendPolicy_Handler,
		},
		{
			MethodName: "TreasuryPolicies",
			Handler:    _VotingService_TreasuryPolicies_Handler,
		},
		{
			MethodName: "SetTreasuryPolicy",
			Handler:    _VotingService_SetTreasuryPolicy_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "api.proto",
}

// MessageVerificationServiceClient is the client API for MessageVerificationService 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 MessageVerificationServiceClient interface {
	VerifyMessage(ctx context.Context, in *VerifyMessageRequest, opts ...grpc.CallOption) (*VerifyMessageResponse, error)
}

type messageVerificationServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewMessageVerificationServiceClient(cc grpc.ClientConnInterface) MessageVerificationServiceClient {
	return &messageVerificationServiceClient{cc}
}

func (c *messageVerificationServiceClient) VerifyMessage(ctx context.Context, in *VerifyMessageRequest, opts ...grpc.CallOption) (*VerifyMessageResponse, error) {
	out := new(VerifyMessageResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.MessageVerificationService/VerifyMessage", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// MessageVerificationServiceServer is the server API for MessageVerificationService service.
// All implementations must embed UnimplementedMessageVerificationServiceServer
// for forward compatibility
type MessageVerificationServiceServer interface {
	VerifyMessage(context.Context, *VerifyMessageRequest) (*VerifyMessageResponse, error)
	mustEmbedUnimplementedMessageVerificationServiceServer()
}

// UnimplementedMessageVerificationServiceServer must be embedded to have forward compatible implementations.
type UnimplementedMessageVerificationServiceServer struct {
}

func (UnimplementedMessageVerificationServiceServer) VerifyMessage(context.Context, *VerifyMessageRequest) (*VerifyMessageResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method VerifyMessage not implemented")
}
func (UnimplementedMessageVerificationServiceServer) mustEmbedUnimplementedMessageVerificationServiceServer() {
}

// UnsafeMessageVerificationServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to MessageVerificationServiceServer will
// result in compilation errors.
type UnsafeMessageVerificationServiceServer interface {
	mustEmbedUnimplementedMessageVerificationServiceServer()
}

func RegisterMessageVerificationServiceServer(s grpc.ServiceRegistrar, srv MessageVerificationServiceServer) {
	s.RegisterService(&MessageVerificationService_ServiceDesc, srv)
}

func _MessageVerificationService_VerifyMessage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(VerifyMessageRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MessageVerificationServiceServer).VerifyMessage(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.MessageVerificationService/VerifyMessage",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MessageVerificationServiceServer).VerifyMessage(ctx, req.(*VerifyMessageRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// MessageVerificationService_ServiceDesc is the grpc.ServiceDesc for MessageVerificationService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var MessageVerificationService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "walletrpc.MessageVerificationService",
	HandlerType: (*MessageVerificationServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "VerifyMessage",
			Handler:    _MessageVerificationService_VerifyMessage_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "api.proto",
}

// NetworkServiceClient is the client API for NetworkService 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 NetworkServiceClient interface {
	GetRawBlock(ctx context.Context, in *GetRawBlockRequest, opts ...grpc.CallOption) (*GetRawBlockResponse, error)
}

type networkServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewNetworkServiceClient(cc grpc.ClientConnInterface) NetworkServiceClient {
	return &networkServiceClient{cc}
}

func (c *networkServiceClient) GetRawBlock(ctx context.Context, in *GetRawBlockRequest, opts ...grpc.CallOption) (*GetRawBlockResponse, error) {
	out := new(GetRawBlockResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.NetworkService/GetRawBlock", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// NetworkServiceServer is the server API for NetworkService service.
// All implementations must embed UnimplementedNetworkServiceServer
// for forward compatibility
type NetworkServiceServer interface {
	GetRawBlock(context.Context, *GetRawBlockRequest) (*GetRawBlockResponse, error)
	mustEmbedUnimplementedNetworkServiceServer()
}

// UnimplementedNetworkServiceServer must be embedded to have forward compatible implementations.
type UnimplementedNetworkServiceServer struct {
}

func (UnimplementedNetworkServiceServer) GetRawBlock(context.Context, *GetRawBlockRequest) (*GetRawBlockResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetRawBlock not implemented")
}
func (UnimplementedNetworkServiceServer) mustEmbedUnimplementedNetworkServiceServer() {}

// UnsafeNetworkServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to NetworkServiceServer will
// result in compilation errors.
type UnsafeNetworkServiceServer interface {
	mustEmbedUnimplementedNetworkServiceServer()
}

func RegisterNetworkServiceServer(s grpc.ServiceRegistrar, srv NetworkServiceServer) {
	s.RegisterService(&NetworkService_ServiceDesc, srv)
}

func _NetworkService_GetRawBlock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetRawBlockRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NetworkServiceServer).GetRawBlock(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.NetworkService/GetRawBlock",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NetworkServiceServer).GetRawBlock(ctx, req.(*GetRawBlockRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// NetworkService_ServiceDesc is the grpc.ServiceDesc for NetworkService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var NetworkService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "walletrpc.NetworkService",
	HandlerType: (*NetworkServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetRawBlock",
			Handler:    _NetworkService_GetRawBlock_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "api.proto",
}

// DecodeMessageServiceClient is the client API for DecodeMessageService 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 DecodeMessageServiceClient interface {
	DecodeRawTransaction(ctx context.Context, in *DecodeRawTransactionRequest, opts ...grpc.CallOption) (*DecodeRawTransactionResponse, error)
}

type decodeMessageServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewDecodeMessageServiceClient(cc grpc.ClientConnInterface) DecodeMessageServiceClient {
	return &decodeMessageServiceClient{cc}
}

func (c *decodeMessageServiceClient) DecodeRawTransaction(ctx context.Context, in *DecodeRawTransactionRequest, opts ...grpc.CallOption) (*DecodeRawTransactionResponse, error) {
	out := new(DecodeRawTransactionResponse)
	err := c.cc.Invoke(ctx, "/walletrpc.DecodeMessageService/DecodeRawTransaction", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// DecodeMessageServiceServer is the server API for DecodeMessageService service.
// All implementations must embed UnimplementedDecodeMessageServiceServer
// for forward compatibility
type DecodeMessageServiceServer interface {
	DecodeRawTransaction(context.Context, *DecodeRawTransactionRequest) (*DecodeRawTransactionResponse, error)
	mustEmbedUnimplementedDecodeMessageServiceServer()
}

// UnimplementedDecodeMessageServiceServer must be embedded to have forward compatible implementations.
type UnimplementedDecodeMessageServiceServer struct {
}

func (UnimplementedDecodeMessageServiceServer) DecodeRawTransaction(context.Context, *DecodeRawTransactionRequest) (*DecodeRawTransactionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DecodeRawTransaction not implemented")
}
func (UnimplementedDecodeMessageServiceServer) mustEmbedUnimplementedDecodeMessageServiceServer() {}

// UnsafeDecodeMessageServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to DecodeMessageServiceServer will
// result in compilation errors.
type UnsafeDecodeMessageServiceServer interface {
	mustEmbedUnimplementedDecodeMessageServiceServer()
}

func RegisterDecodeMessageServiceServer(s grpc.ServiceRegistrar, srv DecodeMessageServiceServer) {
	s.RegisterService(&DecodeMessageService_ServiceDesc, srv)
}

func _DecodeMessageService_DecodeRawTransaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DecodeRawTransactionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DecodeMessageServiceServer).DecodeRawTransaction(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/walletrpc.DecodeMessageService/DecodeRawTransaction",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DecodeMessageServiceServer).DecodeRawTransaction(ctx, req.(*DecodeRawTransactionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// DecodeMessageService_ServiceDesc is the grpc.ServiceDesc for DecodeMessageService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var DecodeMessageService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "walletrpc.DecodeMessageService",
	HandlerType: (*DecodeMessageServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "DecodeRawTransaction",
			Handler:    _DecodeMessageService_DecodeRawTransaction_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "api.proto",
}