github.com/fibonacci-chain/fbc@v0.0.0-20231124064014-c7636198c1e9/libs/cosmos-sdk/x/bank/internal/keeperadapter/bankgrpc_adapter.go (about)

     1  package keeperadapter
     2  
     3  import (
     4  	"context"
     5  
     6  	"google.golang.org/grpc/codes"
     7  	"google.golang.org/grpc/status"
     8  
     9  	sdk "github.com/fibonacci-chain/fbc/libs/cosmos-sdk/types"
    10  	"github.com/fibonacci-chain/fbc/libs/cosmos-sdk/types/query"
    11  	"github.com/fibonacci-chain/fbc/libs/cosmos-sdk/x/bank/internal/types"
    12  	"github.com/fibonacci-chain/fbc/libs/cosmos-sdk/x/bank/internal/typesadapter"
    13  )
    14  
    15  type BankQueryServer struct {
    16  	bankKeeper   ViewBankKeeper
    17  	supplyKeeper SupplyKeeper
    18  }
    19  
    20  func NewBankQueryServer(bankKeeper ViewBankKeeper, supplyKeeper SupplyKeeper) *BankQueryServer {
    21  	return &BankQueryServer{bankKeeper: bankKeeper, supplyKeeper: supplyKeeper}
    22  }
    23  
    24  var _ typesadapter.QueryServer = &BankQueryServer{}
    25  
    26  // Balance implements the Query/Balance gRPC method
    27  func (k BankQueryServer) Balance(ctx context.Context, req *typesadapter.QueryBalanceRequest) (*typesadapter.QueryBalanceResponse, error) {
    28  	if req == nil {
    29  		return nil, status.Error(codes.InvalidArgument, "empty request")
    30  	}
    31  
    32  	if req.Address == "" {
    33  		return nil, status.Error(codes.InvalidArgument, "address cannot be empty")
    34  	}
    35  
    36  	if req.Denom == "" {
    37  		return nil, status.Error(codes.InvalidArgument, "invalid denom")
    38  	}
    39  
    40  	sdkCtx := sdk.UnwrapSDKContext(ctx)
    41  	address, err := sdk.AccAddressFromBech32(req.Address)
    42  	if err != nil {
    43  		return nil, status.Errorf(codes.InvalidArgument, "invalid address: %s", err.Error())
    44  	}
    45  
    46  	balance := k.bankKeeper.GetBalance(sdkCtx, address, req.Denom)
    47  	dapter := sdk.CoinToCoinAdapter(balance)
    48  	return &typesadapter.QueryBalanceResponse{Balance: &dapter}, nil
    49  }
    50  
    51  // AllBalances implements the Query/AllBalances gRPC method
    52  func (k BankQueryServer) AllBalances(ctx context.Context, req *typesadapter.QueryAllBalancesRequest) (*typesadapter.QueryAllBalancesResponse, error) {
    53  	if req == nil {
    54  		return nil, status.Error(codes.InvalidArgument, "empty request")
    55  	}
    56  
    57  	if req.Address == "" {
    58  		return nil, status.Error(codes.InvalidArgument, "address cannot be empty")
    59  	}
    60  
    61  	addr, err := sdk.AccAddressFromBech32(req.Address)
    62  	if err != nil {
    63  		return nil, status.Errorf(codes.InvalidArgument, "invalid address: %s", err.Error())
    64  	}
    65  
    66  	sdkCtx := sdk.UnwrapSDKContext(ctx)
    67  
    68  	balances := k.bankKeeper.GetAllBalances(sdkCtx, addr)
    69  	adapters := sdk.CoinsToCoinAdapters(balances)
    70  
    71  	pageRes := &query.PageResponse{NextKey: nil, Total: uint64(len(balances))}
    72  
    73  	return &typesadapter.QueryAllBalancesResponse{Balances: adapters, Pagination: pageRes}, nil
    74  }
    75  
    76  // TotalSupply implements the Query/TotalSupply gRPC method
    77  func (k BankQueryServer) TotalSupply(ctx context.Context, req *typesadapter.QueryTotalSupplyRequest) (*typesadapter.QueryTotalSupplyResponse, error) {
    78  	sdkCtx := sdk.UnwrapSDKContext(ctx)
    79  	supply := k.supplyKeeper.GetSupply(sdkCtx)
    80  	total := supply.GetTotal()
    81  	adapters := sdk.CoinsToCoinAdapters(total)
    82  	pageRes := &query.PageResponse{NextKey: nil, Total: uint64(len(adapters))}
    83  	return &typesadapter.QueryTotalSupplyResponse{Supply: adapters, Pagination: pageRes}, nil
    84  }
    85  
    86  // SupplyOf implements the Query/SupplyOf gRPC method
    87  func (k BankQueryServer) SupplyOf(c context.Context, req *typesadapter.QuerySupplyOfRequest) (*typesadapter.QuerySupplyOfResponse, error) {
    88  	if req == nil {
    89  		return nil, status.Error(codes.InvalidArgument, "empty request")
    90  	}
    91  
    92  	if req.Denom == "" {
    93  		return nil, status.Error(codes.InvalidArgument, "invalid denom")
    94  	}
    95  
    96  	sdkCtx := sdk.UnwrapSDKContext(c)
    97  	supply := k.supplyKeeper.GetSupply(sdkCtx)
    98  	total := supply.GetTotal()
    99  	coin := sdk.Coin{
   100  		req.Denom,
   101  		total.AmountOf(req.Denom),
   102  	}
   103  	adapter := sdk.CoinToCoinAdapter(coin)
   104  	return &typesadapter.QuerySupplyOfResponse{Amount: adapter}, nil
   105  }
   106  
   107  // Params implements the gRPC service handler for querying x/bank parameters.
   108  func (k BankQueryServer) Params(ctx context.Context, req *typesadapter.QueryParamsRequest) (*typesadapter.QueryParamsResponse, error) {
   109  	if req == nil {
   110  		return nil, status.Errorf(codes.InvalidArgument, "empty request")
   111  	}
   112  
   113  	//TODO params is part adapter
   114  	sdkCtx := sdk.UnwrapSDKContext(ctx)
   115  	sendEnable := k.bankKeeper.GetSendEnabled(sdkCtx)
   116  	adapter := typesadapter.Params{
   117  		SendEnabled:        nil, // maybe need init
   118  		DefaultSendEnabled: sendEnable,
   119  	}
   120  	return &typesadapter.QueryParamsResponse{Params: adapter}, nil
   121  }
   122  
   123  // DenomsMetadata implements Query/DenomsMetadata gRPC method.
   124  func (k BankQueryServer) DenomsMetadata(c context.Context, req *typesadapter.QueryDenomsMetadataRequest) (*typesadapter.QueryDenomsMetadataResponse, error) {
   125  	return nil, types.ErrUnSupportQueryType("Query/DenomsMetadata")
   126  }
   127  
   128  // DenomMetadata implements Query/DenomMetadata gRPC method.
   129  func (k BankQueryServer) DenomMetadata(c context.Context, req *typesadapter.QueryDenomMetadataRequest) (*typesadapter.QueryDenomMetadataResponse, error) {
   130  	return nil, types.ErrUnSupportQueryType("Query/DenomMetadata")
   131  }