# Query Balances

This guide will cover the following query methods:

* `blockxd` & Tendermint RPC
* JSON-RPC
* gRPC

### `blockxd` & Tendermint RPC <a href="#evmosd-tendermint-rpc" id="evmosd-tendermint-rpc"></a>

Upon installation and configuration of the BlockX Daemon, developers can query account balances using `blockxd` with the following CLI command:

```bash
$ blockxd query bank balances $BLOCKXADDRESS --count-total=$COUNTTOTAL --height=$HEIGHT --output=$OUTPUT --node=$NODE
balances:
- amount: "1000000000000000000"
  denom: abcx
- amount: "100000"
  denom: ibc/ED07A3391A112B175915CD8FAF43A2DA8E4790EDE12566649D0C2F97716B8518
pagination:
  next_key: null
  total: "0"
```

where:

* `$BLOCKXADDRESS` is the BlockX address with balances of interest (eg. `blockx1...`).
* (optional) `$COUNTTOTAL` counts the total number of records in all balances to query for.
* (optional) `$HEIGHT` is the specific height to query state at (can error if node is pruning state).
* (optional) `$OUTPUT` is the output format (eg. `text`).
* (optional if running local node) `$NODE` is the Tendermint RPC node information is requested from&#x20;

Details of non-native currencies (ie. not `ablockx`) can be queried with the following CLI command:

```bash
$ blockxd query erc20 token-pair $DENOM --node=$NODE --height=$HEIGHT --output=$OUTPUT
token_pair:
  contract_owner: OWNER_MODULE
  denom: ibc/ED07A3391A112B175915CD8FAF43A2DA8E4790EDE12566649D0C2F97716B8518
  enabled: true
  erc20_address: 0xFA3C22C069B9556A4B2f7EcE1Ee3B467909f4864
```

where `$DENOM` is the denomination of the coin (eg. `ibc/ED07A3391A1...`).

### JSON-RPC <a href="#json-rpc" id="json-rpc"></a>

Developers can query account balances of `ablockx` using the `eth_getBalance` JSON-RPC method in conjunction with [`curl`](https://curl.se/):

```bash
# Request
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getBalance","params":[`$ETHADDRESS`, `$BLOCK`],"id":1}' -H "Content-Type: application/json" $NODE

# Result
{"jsonrpc":"2.0","id":1,"result":"0x36354d5575577c8000"}
```

where:

* `$ETHADDRESS` is the Etherum hex-address the balance is to be queried from. Note that BlockX addresses
* `$BLOCK` is the block number or block hash (eg. `"0x0"`). The reasoning for this parameter is due to [EIP-1898](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1898.md).
* (optional if running local node) `$NODE` is the JSON-RPC node information is requested from&#x20;

Developers can also query account balances of `x/erc20`-module registered coins using the `eth_call` JSON-RPC method in conjunction with [`curl`](https://curl.se/):

```bash
# Request
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_call","params":[{"from":`SENDERCONTRACTADDRESS`, "to":`ERCCONTRACTADDRESS`, "data":`$DATA`}, `$BLOCK`],"id":1}'  -H "Content-Type: application/json" $NODE

# Result
{"jsonrpc":"2.0","id":1,"result":"0x"}
```

where:

* `$SENDERCONTRACTADDRESS` is the Ethereum hex-address this smart contract call is sent from.
* `$ERCCONTRACTADDRESS` is the Ethereum hex-address of the ERC-20 contract corresponding to the coin denomination being queried.
* `$DATA` is the hash of the [`balanceof` ](https://docs.openzeppelin.com/contracts/2.x/api/token/erc20#ERC20)method signature and encoded parameters. `balanceOf` is a required method in every ERC-20 contract, and the encoded parameter is the address which is having its balance queried. For additional information, see the [Ethereum Contract ABI](https://docs.soliditylang.org/en/v0.8.13/abi-spec.html).
* `$BLOCK` is the block number or block hash (eg. `"0x0"`). The reasoning for this parameter is due to [EIP-1898](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1898.md).
* (optional if running local node) `$NODE` is the JSON-RPC node information is requested from&#x20;

### gRPC <a href="#grpc" id="grpc"></a>

Developers can use [`grpcurl`](https://github.com/fullstorydev/grpcurl) with the `AllBalances` endpoint to query account balance by address for all denominations:

```bash
# Request
grpcurl $OUTPUT -d '{"address":`$BLOCKXADDRESS`}' $NODE cosmos.bank.v1beta1.Query/AllBalances

# Result
{
  "balances": [
    {
      "denom": "stake",
      "amount": "1000000000"
    }
  ],
  "pagination": {
    "total": "1"
  }
}
```

where:

* `$BCXADDRESS` is the BlockX address with balances of interest (eg. `"blockx1..."`).
* `$NODE` is the Cosmos gRPC node information is requested&#x20;
* (optional) `$OUTPUT` is the output format (eg. `plaintext`).

State can also be queried using gRPC within a Go program. The idea is to create a gRPC connection, then use the [Protobuf](https://developers.google.com/protocol-buffers)-generated client code to query the gRPC server.

```go
import (
    "context"
    "fmt"

  "google.golang.org/grpc"

    sdk "github.com/cosmos/cosmos-sdk/types"
  "github.com/cosmos/cosmos-sdk/types/tx"
)

func queryState() error {
    myAddress, err := GetBlockXAddressFromBech32("blockx1...") // blockx address with balances of interest.
    if err != nil {
        return err
    }

    // Create a connection to the gRPC server.
    grpcConn := grpc.Dial(
        "https://grpc.bd.blockxnet.com:9090", // your gRPC server address.
        grpc.WithInsecure(), // the SDK doesn't support any transport security mechanism.
    )
    defer grpcConn.Close()

    // This creates a gRPC client to query the x/bank service.
    bankClient := banktypes.NewQueryClient(grpcConn)
    bankRes, err := bankClient.AllBalances(
        context.Background(),
        &banktypes.QueryAllBalancesRequest{Address: myAddress},
    )
    if err != nil {
        return err
    }

    fmt.Println(bankRes.GetBalances()) // prints the account balances.

    return nil
}
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.blockxnet.com/dapp-developers/guides/query-balances.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.