github.com/lino-network/lino@v0.6.11/x/developer/querier.go (about)

     1  package developer
     2  
     3  import (
     4  	"fmt"
     5  
     6  	wire "github.com/cosmos/cosmos-sdk/codec"
     7  	sdk "github.com/cosmos/cosmos-sdk/types"
     8  	abci "github.com/tendermint/tendermint/abci/types"
     9  
    10  	linotypes "github.com/lino-network/lino/types"
    11  	"github.com/lino-network/lino/x/developer/model"
    12  	"github.com/lino-network/lino/x/developer/types"
    13  )
    14  
    15  // creates a querier for developer REST endpoints
    16  func NewQuerier(dm DeveloperKeeper) sdk.Querier {
    17  	cdc := wire.New()
    18  	wire.RegisterCrypto(cdc)
    19  	return func(ctx sdk.Context, path []string, req abci.RequestQuery) (res []byte, err sdk.Error) {
    20  		switch path[0] {
    21  		case types.QueryDeveloper:
    22  			return queryDeveloper(ctx, cdc, path[1:], req, dm)
    23  		case types.QueryDeveloperList:
    24  			return queryDeveloperList(ctx, cdc, path[1:], req, dm)
    25  		case types.QueryIDA:
    26  			return queryIDA(ctx, cdc, path[1:], req, dm)
    27  		case types.QueryIDABalance:
    28  			return queryIDABalance(ctx, cdc, path[1:], req, dm)
    29  		case types.QueryAffiliated:
    30  			return queryAffiliated(ctx, cdc, path[1:], req, dm)
    31  		case types.QueryReservePool:
    32  			return queryReservePool(ctx, cdc, req, dm)
    33  		case types.QueryIDAStats:
    34  			return queryIDAStats(ctx, cdc, path[1:], req, dm)
    35  		default:
    36  			return nil, sdk.ErrUnknownRequest(
    37  				fmt.Sprintf("unknown developer query endpoint: %s", path[0]),
    38  			)
    39  		}
    40  	}
    41  }
    42  
    43  func queryDeveloper(ctx sdk.Context, cdc *wire.Codec, path []string, req abci.RequestQuery, dm DeveloperKeeper) ([]byte, sdk.Error) {
    44  	if err := linotypes.CheckPathContentAndMinLength(path, 1); err != nil {
    45  		return nil, err
    46  	}
    47  	developer, err := dm.GetDeveloper(ctx, linotypes.AccountKey(path[0]))
    48  	if err != nil {
    49  		return nil, err
    50  	}
    51  	res, marshalErr := cdc.MarshalJSON(developer)
    52  	if marshalErr != nil {
    53  		return nil, types.ErrQueryFailed()
    54  	}
    55  	return res, nil
    56  }
    57  
    58  func queryDeveloperList(ctx sdk.Context, cdc *wire.Codec, path []string, req abci.RequestQuery, dm DeveloperKeeper) ([]byte, sdk.Error) {
    59  	developers := dm.GetLiveDevelopers(ctx)
    60  	devmap := make(map[string]model.Developer)
    61  	for _, dev := range developers {
    62  		devmap[string(dev.Username)] = dev
    63  	}
    64  	res, marshalErr := cdc.MarshalJSON(devmap)
    65  	if marshalErr != nil {
    66  		return nil, types.ErrQueryFailed()
    67  	}
    68  	return res, nil
    69  }
    70  
    71  func queryIDABalance(ctx sdk.Context, cdc *wire.Codec, path []string, req abci.RequestQuery, dm DeveloperKeeper) ([]byte, sdk.Error) {
    72  	if err := linotypes.CheckPathContentAndMinLength(path, 2); err != nil {
    73  		return nil, err
    74  	}
    75  	dev := linotypes.AccountKey(path[0])
    76  	user := linotypes.AccountKey(path[1])
    77  	price, err := dm.GetMiniIDAPrice(ctx, dev)
    78  	if err != nil {
    79  		return nil, err
    80  	}
    81  	bank, err := dm.GetIDABank(ctx, dev, user)
    82  	if err != nil {
    83  		return nil, err
    84  	}
    85  
    86  	idaAmount := bank.Balance.Quo(price.Int).ToDec().Quo(sdk.NewDec(linotypes.Decimals)).String()
    87  	res, marshalErr := cdc.MarshalJSON(types.QueryResultIDABalance{
    88  		Amount:   idaAmount,
    89  		Unauthed: bank.Unauthed,
    90  	})
    91  	if marshalErr != nil {
    92  		return nil, types.ErrQueryFailed()
    93  	}
    94  	return res, nil
    95  }
    96  
    97  func queryIDA(ctx sdk.Context, cdc *wire.Codec, path []string, req abci.RequestQuery, dm DeveloperKeeper) ([]byte, sdk.Error) {
    98  	if err := linotypes.CheckPathContentAndMinLength(path, 1); err != nil {
    99  		return nil, err
   100  	}
   101  	app := linotypes.AccountKey(path[0])
   102  	ida, err := dm.GetIDA(ctx, app)
   103  	if err != nil {
   104  		return nil, err
   105  	}
   106  	res, marshalErr := cdc.MarshalJSON(ida)
   107  	if marshalErr != nil {
   108  		return nil, types.ErrQueryFailed()
   109  	}
   110  	return res, nil
   111  }
   112  
   113  func queryAffiliated(ctx sdk.Context, cdc *wire.Codec, path []string, req abci.RequestQuery, dm DeveloperKeeper) ([]byte, sdk.Error) {
   114  	if err := linotypes.CheckPathContentAndMinLength(path, 1); err != nil {
   115  		return nil, err
   116  	}
   117  	app := linotypes.AccountKey(path[0])
   118  	accounts := dm.GetAffiliated(ctx, app)
   119  	res, marshalErr := cdc.MarshalJSON(accounts)
   120  	if marshalErr != nil {
   121  		return nil, types.ErrQueryFailed()
   122  	}
   123  	return res, nil
   124  }
   125  
   126  func queryReservePool(ctx sdk.Context, cdc *wire.Codec, req abci.RequestQuery, dm DeveloperKeeper) ([]byte, sdk.Error) {
   127  	pool := dm.GetReservePool(ctx)
   128  	res, marshalErr := cdc.MarshalJSON(pool)
   129  	if marshalErr != nil {
   130  		return nil, types.ErrQueryFailed()
   131  	}
   132  	return res, nil
   133  }
   134  
   135  func queryIDAStats(ctx sdk.Context, cdc *wire.Codec, path []string, req abci.RequestQuery, dm DeveloperKeeper) ([]byte, sdk.Error) {
   136  	if err := linotypes.CheckPathContentAndMinLength(path, 1); err != nil {
   137  		return nil, err
   138  	}
   139  	app := linotypes.AccountKey(path[0])
   140  	stats, err := dm.GetIDAStats(ctx, app)
   141  	if err != nil {
   142  		return nil, err
   143  	}
   144  	res, marshalErr := cdc.MarshalJSON(stats)
   145  	if marshalErr != nil {
   146  		return nil, types.ErrQueryFailed()
   147  	}
   148  	return res, nil
   149  }