github.com/fibonacci-chain/fbc@v0.0.0-20231124064014-c7636198c1e9/x/erc20/keeper/querier.go (about)

     1  package keeper
     2  
     3  import (
     4  	"encoding/json"
     5  	"fmt"
     6  
     7  	ethcmm "github.com/ethereum/go-ethereum/common"
     8  	"github.com/fibonacci-chain/fbc/libs/cosmos-sdk/codec"
     9  	sdk "github.com/fibonacci-chain/fbc/libs/cosmos-sdk/types"
    10  	sdkerrors "github.com/fibonacci-chain/fbc/libs/cosmos-sdk/types/errors"
    11  	transfertypes "github.com/fibonacci-chain/fbc/libs/ibc-go/modules/apps/transfer/types"
    12  	abci "github.com/fibonacci-chain/fbc/libs/tendermint/abci/types"
    13  	"github.com/fibonacci-chain/fbc/x/common"
    14  	"github.com/fibonacci-chain/fbc/x/erc20/types"
    15  )
    16  
    17  // NewQuerier is the module level router for state queries
    18  func NewQuerier(keeper Keeper) sdk.Querier {
    19  	return func(ctx sdk.Context, path []string, req abci.RequestQuery) ([]byte, error) {
    20  		if len(path) < 1 {
    21  			return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest,
    22  				"Insufficient parameters, at least 1 parameter is required")
    23  		}
    24  
    25  		switch path[0] {
    26  		case types.QueryParameters:
    27  			return queryParams(ctx, keeper)
    28  		case types.QueryTokenMapping:
    29  			return queryTokenMapping(ctx, keeper)
    30  		case types.QueryDenomByContract:
    31  			return queryDenomByContract(ctx, req, keeper)
    32  		case types.QueryContractByDenom:
    33  			return queryContractByDenom(ctx, req, keeper)
    34  		case types.QueryContractTem:
    35  			return queryContractTemplate(ctx, req, keeper)
    36  		default:
    37  			return nil, sdkerrors.Wrap(sdkerrors.ErrUnknownRequest, "unknown query endpoint")
    38  		}
    39  	}
    40  }
    41  
    42  func queryParams(ctx sdk.Context, keeper Keeper) (res []byte, err sdk.Error) {
    43  	params := keeper.GetParams(ctx)
    44  	res, errUnmarshal := codec.MarshalJSONIndent(types.ModuleCdc, params)
    45  	if errUnmarshal != nil {
    46  		return nil, sdk.ErrInternal(sdk.AppendMsgToErr("failed to marshal result to JSON", errUnmarshal.Error()))
    47  	}
    48  	return res, nil
    49  }
    50  
    51  func queryTokenMapping(ctx sdk.Context, keeper Keeper) ([]byte, error) {
    52  	var mappings []types.QueryTokenMappingResponse
    53  	keeper.IterateMapping(ctx, func(denom, contract string) bool {
    54  		mapping := types.QueryTokenMappingResponse{
    55  			Denom:    denom,
    56  			Contract: contract,
    57  		}
    58  
    59  		if types.IsValidIBCDenom(denom) {
    60  			hexHash := denom[len(transfertypes.DenomPrefix+"/"):]
    61  			hash, err := transfertypes.ParseHexHash(hexHash)
    62  			if err == nil {
    63  				denomTrace, found := keeper.transferKeeper.GetDenomTrace(ctx, hash)
    64  				if found {
    65  					mapping.Path = denomTrace.Path
    66  					mapping.BaseDenom = denomTrace.BaseDenom
    67  				}
    68  			}
    69  		}
    70  		mappings = append(mappings, mapping)
    71  		return false
    72  	})
    73  
    74  	res, errUnmarshal := codec.MarshalJSONIndent(types.ModuleCdc, mappings)
    75  	if errUnmarshal != nil {
    76  		return nil, sdk.ErrInternal(sdk.AppendMsgToErr("failed to marshal result to JSON", errUnmarshal.Error()))
    77  	}
    78  	return res, nil
    79  }
    80  
    81  func queryDenomByContract(ctx sdk.Context, req abci.RequestQuery, keeper Keeper) ([]byte, error) {
    82  	var params types.DenomByContractRequest
    83  	err := keeper.cdc.UnmarshalJSON(req.Data, &params)
    84  	if err != nil {
    85  		return nil, common.ErrUnMarshalJSONFailed(sdk.AppendMsgToErr("incorrectly formatted request data", err.Error()))
    86  	}
    87  
    88  	denom, found := keeper.GetDenomByContract(ctx, ethcmm.HexToAddress(params.Contract))
    89  	if !found {
    90  		return nil, fmt.Errorf("coin denom for contract %s is not found", params.Contract)
    91  	}
    92  
    93  	return []byte(denom), nil
    94  }
    95  
    96  func queryContractByDenom(ctx sdk.Context, req abci.RequestQuery, keeper Keeper) ([]byte, error) {
    97  	var params types.ContractByDenomRequest
    98  	err := keeper.cdc.UnmarshalJSON(req.Data, &params)
    99  	if err != nil {
   100  		return nil, common.ErrUnMarshalJSONFailed(sdk.AppendMsgToErr("incorrectly formatted request data", err.Error()))
   101  	}
   102  
   103  	contract, found := keeper.GetContractByDenom(ctx, params.Denom)
   104  	if !found {
   105  		return nil, fmt.Errorf("contract for the coin denom %s is not found", params.Denom)
   106  	}
   107  
   108  	return []byte(contract.String()), nil
   109  }
   110  
   111  func queryContractTemplate(ctx sdk.Context, req abci.RequestQuery, keeper Keeper) ([]byte, error) {
   112  	ret := types.ContractTemplate{}
   113  	proxy, found := keeper.GetProxyTemplateContract(ctx)
   114  	if found {
   115  		ret.Proxy = string(types.MustMarshalCompileContract(proxy))
   116  	}
   117  	imple, found := keeper.GetImplementTemplateContract(ctx)
   118  	if found {
   119  		ret.Implement = string(types.MustMarshalCompileContract(imple))
   120  	}
   121  	data, _ := json.Marshal(ret)
   122  	return data, nil
   123  }