package gql import ( "context" "encoding/base64" "strconv" "github.com/cosmos/cosmos-sdk/client" authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" banktypes "github.com/cosmos/cosmos-sdk/x/bank/types" auctiontypes "github.com/tharsis/ethermint/x/auction/types" bondtypes "github.com/tharsis/ethermint/x/bond/types" nstypes "github.com/tharsis/ethermint/x/nameservice/types" ) // DefaultLogNumLines is the number of log lines to tail by default. const DefaultLogNumLines = 50 // MaxLogNumLines is the max number of log lines that can be tailed. const MaxLogNumLines = 1000 type Resolver struct { ctx client.Context logFile string } // Query is the entry point to query execution. func (r *Resolver) Query() QueryResolver { return &queryResolver{r} } type queryResolver struct{ *Resolver } func (q queryResolver) LookupAuthorities(ctx context.Context, names []string) ([]*AuthorityRecord, error) { nsQueryClient := nstypes.NewQueryClient(q.ctx) auctionQueryClient := auctiontypes.NewQueryClient(q.ctx) var gqlResponse []*AuthorityRecord for _, name := range names { res, err := nsQueryClient.Whois(context.Background(), &nstypes.QueryWhoisRequest{Name: name}) if err != nil { return nil, err } nameAuthority := res.GetNameAuthority() gqlNameAuthorityRecord, err := GetGQLNameAuthorityRecord(&nameAuthority) if err != nil { return nil, err } if nameAuthority.AuctionId != "" { auctionResp, err := auctionQueryClient.GetAuction(context.Background(), &auctiontypes.AuctionRequest{Id: nameAuthority.GetAuctionId()}) if err != nil { return nil, err } bidsResp, err := auctionQueryClient.GetBids(context.Background(), &auctiontypes.BidsRequest{AuctionId: nameAuthority.GetAuctionId()}) if err != nil { return nil, err } gqlAuctionRecord, err := GetGQLAuction(auctionResp.GetAuction(), bidsResp.GetBids()) if err != nil { return nil, err } gqlNameAuthorityRecord.Auction = gqlAuctionRecord } gqlResponse = append(gqlResponse, gqlNameAuthorityRecord) } return gqlResponse, nil } func (q queryResolver) ResolveNames(ctx context.Context, names []string) ([]*Record, error) { nsQueryClient := nstypes.NewQueryClient(q.ctx) var gqlResponse []*Record for _, name := range names { res, err := nsQueryClient.ResolveWrn(context.Background(), &nstypes.QueryResolveWrn{Wrn: name}) if err != nil { gqlResponse = append(gqlResponse, nil) } else { gqlRecord, err := getGQLRecord(context.Background(), q, *res.GetRecord()) if err != nil { return nil, err } gqlResponse = append(gqlResponse, gqlRecord) } } return gqlResponse, nil } func (q queryResolver) LookupNames(ctx context.Context, names []string) ([]*NameRecord, error) { nsQueryClient := nstypes.NewQueryClient(q.ctx) var gqlResponse []*NameRecord for _, name := range names { res, err := nsQueryClient.LookupWrn(context.Background(), &nstypes.QueryLookupWrn{Wrn: name}) if err != nil { // Instead of throwing error for name not found, return nil similar to https://github.com/vulcanize/dxns/blob/main/gql/resolver.go#L191 gqlResponse = append(gqlResponse, nil) } else { gqlRecord, err := getGQLNameRecord(res.GetName()) if err != nil { return nil, err } gqlResponse = append(gqlResponse, gqlRecord) } } return gqlResponse, nil } func (q queryResolver) QueryRecords(ctx context.Context, attributes []*KeyValueInput, all *bool) ([]*Record, error) { nsQueryClient := nstypes.NewQueryClient(q.ctx) res, err := nsQueryClient.ListRecords( context.Background(), &nstypes.QueryListRecordsRequest{ Attributes: parseRequestAttributes(attributes), }, ) if err != nil { return nil, err } records := res.GetRecords() gqlResponse := make([]*Record, len(records)) for i, record := range records { gqlRecord, err := getGQLRecord(context.Background(), q, record) if err != nil { return nil, err } gqlResponse[i] = gqlRecord } return gqlResponse, nil } func (q queryResolver) GetRecordsByIds(ctx context.Context, ids []string) ([]*Record, error) { nsQueryClient := nstypes.NewQueryClient(q.ctx) gqlResponse := make([]*Record, len(ids)) for i, id := range ids { // TODO: Implement HasRecord query similar to https://github.com/vulcanize/dxns/blob/main/gql/resolver.go#L325 res, err := nsQueryClient.GetRecord(context.Background(), &nstypes.QueryRecordByIdRequest{Id: id}) if err != nil { gqlResponse[i] = nil } else { record, err := getGQLRecord(context.Background(), q, res.GetRecord()) if err != nil { return nil, err } gqlResponse[i] = record } } return gqlResponse, nil } func (q queryResolver) GetStatus(ctx context.Context) (*Status, error) { nodeInfo, syncInfo, validatorInfo, err := getStatusInfo(q.ctx) if err != nil { return nil, err } numPeers, peers, err := getNetInfo(q.ctx) if err != nil { return nil, err } validatorSet, err := getValidatorSet(q.ctx) if err != nil { return nil, err } diskUsage, err := GetDiskUsage(NodeDataPath) if err != nil { return nil, err } return &Status{ Version: NameServiceVersion, Node: nodeInfo, Sync: syncInfo, Validator: validatorInfo, Validators: validatorSet, NumPeers: numPeers, Peers: peers, DiskUsage: diskUsage, }, nil } func (q queryResolver) GetAccounts(ctx context.Context, addresses []string) ([]*Account, error) { accounts := make([]*Account, len(addresses)) for index, address := range addresses { account, err := q.GetAccount(ctx, address) if err != nil { return nil, err } accounts[index] = account } return accounts, nil } func (q queryResolver) GetAccount(ctx context.Context, address string) (*Account, error) { authQueryClient := authtypes.NewQueryClient(q.ctx) accountResponse, err := authQueryClient.Account(ctx, &authtypes.QueryAccountRequest{Address: address}) if err != nil { return nil, err } var account authtypes.AccountI err = q.ctx.Codec.UnpackAny(accountResponse.GetAccount(), &account) if err != nil { return nil, err } var pubKey *string if account.GetPubKey() != nil { pubKeyStr := base64.StdEncoding.EncodeToString(account.GetPubKey().Bytes()) pubKey = &pubKeyStr } // Get the account balance bankQueryClient := banktypes.NewQueryClient(q.ctx) balance, err := bankQueryClient.AllBalances(ctx, &banktypes.QueryAllBalancesRequest{Address: address}) accNum := strconv.FormatUint(account.GetAccountNumber(), 10) seq := strconv.FormatUint(account.GetSequence(), 10) return &Account{ Address: address, Number: accNum, Sequence: seq, PubKey: pubKey, Balance: getGQLCoins(balance.GetBalances()), }, nil } func (q queryResolver) GetBondsByIds(ctx context.Context, ids []string) ([]*Bond, error) { bonds := make([]*Bond, len(ids)) for index, id := range ids { bondObj, err := q.GetBond(ctx, id) if err != nil { return nil, err } bonds[index] = bondObj } return bonds, nil } func (q *queryResolver) GetBond(ctx context.Context, id string) (*Bond, error) { bondQueryClient := bondtypes.NewQueryClient(q.ctx) bondResp, err := bondQueryClient.GetBondById(context.Background(), &bondtypes.QueryGetBondByIdRequest{Id: id}) if err != nil { return nil, err } bond := bondResp.GetBond() if bond == nil { return nil, nil } return getGQLBond(bondResp.GetBond()) } func (q queryResolver) QueryBonds(ctx context.Context, attributes []*KeyValueInput) ([]*Bond, error) { bondQueryClient := bondtypes.NewQueryClient(q.ctx) bonds, err := bondQueryClient.Bonds(context.Background(), &bondtypes.QueryGetBondsRequest{}) if err != nil { return nil, err } gqlResponse := make([]*Bond, len(bonds.GetBonds())) for i, bondObj := range bonds.GetBonds() { gqlBond, err := getGQLBond(bondObj) if err != nil { return nil, err } gqlResponse[i] = gqlBond } return gqlResponse, nil } // QueryBondsByOwner will return bonds by owner func (q queryResolver) QueryBondsByOwner(ctx context.Context, ownerAddresses []string) ([]*OwnerBonds, error) { ownerBonds := make([]*OwnerBonds, len(ownerAddresses)) for index, ownerAddress := range ownerAddresses { bondsObj, err := q.GetBondsByOwner(ctx, ownerAddress) if err != nil { return nil, err } ownerBonds[index] = bondsObj } return ownerBonds, nil } func (q queryResolver) GetBondsByOwner(ctx context.Context, address string) (*OwnerBonds, error) { bondQueryClient := bondtypes.NewQueryClient(q.ctx) bondResp, err := bondQueryClient.GetBondsByOwner(context.Background(), &bondtypes.QueryGetBondsByOwnerRequest{Owner: address}) if err != nil { return nil, err } ownerBonds := make([]*Bond, len(bondResp.GetBonds())) for i, bond := range bondResp.GetBonds() { bondObj, err := getGQLBond(&bond) if err != nil { return nil, err } ownerBonds[i] = bondObj } return &OwnerBonds{Bonds: ownerBonds, Owner: address}, nil } func (q queryResolver) GetAuctionsByIds(ctx context.Context, ids []string) ([]*Auction, error) { auctionQueryClient := auctiontypes.NewQueryClient(q.ctx) gqlAuctionResponse := make([]*Auction, len(ids)) for i, id := range ids { auctionObj, err := auctionQueryClient.GetAuction(context.Background(), &auctiontypes.AuctionRequest{Id: id}) if err != nil { return nil, err } bidsObj, err := auctionQueryClient.GetBids(context.Background(), &auctiontypes.BidsRequest{AuctionId: id}) if err != nil { return nil, err } gqlAuction, err := GetGQLAuction(auctionObj.GetAuction(), bidsObj.GetBids()) if err != nil { return nil, err } gqlAuctionResponse[i] = gqlAuction } return gqlAuctionResponse, nil }