Query balances on Avail DA

Setting up the dev environment

In this guide we will use Avail’s dedicated SDKs to interact with the Turing testnet. To set up a dev environment for the SDK of your choice, please follow the steps outlined here.

Querying the balance of an account

To query basic information about an account, including it’s balance, you need to call the system_account extrinsic from the system pallet on an Avail node.

avail-js

Inside your-file-name.ts, add the following code:

avail-js


import * as dotenv from 'dotenv';
import { SDK, Pallets } from 'avail-js-sdk';
 
dotenv.config();
 
export async function getAccountBalance() {
    // Initialize SDK with Turing endpoint
    const sdk = await SDK.New('wss://turing-rpc.avail.so/ws');
    
    // Address to check balance for
    const address = "5DDY2yzh8uCysYFAiRSTeQVwtZSKNF49CkQkyPH852xvrYKk";
    console.log(`Checking balance for address: ${address}`);
    
    // Get the current block hash
    const blockHash = await sdk.client.bestBlockHash();
    
    // Get storage at the current block
    const storageAt = await sdk.client.storageAt(blockHash);
    
    // Fetch account information
    const accountInfo = await Pallets.SystemStorage.Account.fetch(storageAt, address);
    
    // Format balances in AVAIL (dividing by 10^18)
    const free = accountInfo.value.accountData.free.toString();
    const reserved = accountInfo.value.accountData.reserved.toString();
    const frozen = accountInfo.value.accountData.frozen.toString();
 
    console.log("The following balances are in the smallest units, divide by 10^18 to get the balance in AVAIL");
    console.log(`Free Balance: ${free}`);
    console.log(`Reserved Balance: ${reserved}`);
    console.log(`Frozen Balance: ${frozen}`);
    
    process.exit(0);
}
 
// Execute the function
getAccountBalance();

Run the code using:

terminal


ts-node your-file-name.ts

avail-rust

Inside main.rs, add the following code:

avail-rust


 
use avail_rust::prelude::*;
use core::str::FromStr;
 
pub async fn system_account() -> Result<(), ClientError> {
 
    // Create a new SDK instance
    let sdk = SDK::new("wss://turing-rpc.avail.so/ws").await?;
 
 
    let account_id = AccountId::from_str("5CqgQkrDcdg5QrtuxT3H7WszrqgrBMhdwRbmMVXQzc4VSiEg").unwrap();
 
    let block_hash = sdk.client.best_block_hash().await?;
    let storage = sdk.client.storage().at(block_hash);
    let address = avail::storage().system().account(account_id);
    let result = storage.fetch(&address).await?;
 
    if let Some(account) = result {
        println!("Consumers: {}", account.consumers);
        println!("Data: {:?}", account.data);
        println!("Nonce: {}", account.nonce);
        println!("Providers: {}", account.providers);
        println!("Sufficients: {}", account.sufficients);
    }
 
    Ok(())
}
 
// Add a main function to call system_account
#[tokio::main]
async fn main() {
    if let Err(e) = system_account().await {
        eprintln!("Error: {:?}", e);
    }
}

Run the code using:

terminal


cargo run

avail-go

Inside main.go, add the following code:

avail-go


package main
 
import (
	"fmt"
	"log"
 
	prim "github.com/availproject/avail-go-sdk/primitives"
	"github.com/availproject/avail-go-sdk/sdk"
 
	syPallet "github.com/availproject/avail-go-sdk/metadata/pallets/system"
	"github.com/availproject/avail-go-sdk/primitives"
)
 
func main() {
 
	// Initialize the SDK
	sdk, err := sdk.NewSDK("https://turing-rpc.avail.so/rpc")
	if err != nil {
		log.Fatalf("Failed to initialize SDK: %v", err)
	}
 
	// Get the latest block hash
	latestBlockHash, err := sdk.Client.BestBlockHash()
	if err != nil {
		log.Fatalf("Failed to get latest block hash: %v", err)
	}
 
	// Initialize the block storage
	blockStorage, err := sdk.Client.StorageAt(prim.Some(latestBlockHash))
	if err != nil {
		log.Fatalf("Failed to get block storage: %v", err)
	}
 
	// Create the account ID
	accountId, err := primitives.NewAccountIdFromAddress("5DDY2yzh8uCysYFAiRSTeQVwtZSKNF49CkQkyPH852xvrYKk")
	if err != nil {
		log.Fatalf("Failed to convert address: %v", err)
	}
 
	// Fetch the account data
	storage := syPallet.StorageAccount{}
	val, err := storage.Fetch(&blockStorage, accountId)
	if err != nil {
		log.Fatalf("Failed to fetch account: %v", err)
	}
 
	// Log the account data
	fmt.Println("Free Balance: ", val.Value.AccountData.Free.ToHuman())
	fmt.Println("Reserved Balance: ", val.Value.AccountData.Reserved.ToHuman())
	fmt.Println("Frozen Balance: ", val.Value.AccountData.Frozen.ToHuman())
 
}

Run the code using:

terminal


go run main.go

If you receive errors related to missing dependencies while trying to execute your code, run:

terminal


go mod tidy

and try again.

AvailApps explorer

The following instructions will guide you on how to query the balance of an account using the AvailApps explorer:

Go to the chains state page on the AvailApps explorer.
The balance of an account can be queried by calling the account(AccountId32) method from within the system pallet. Select the system pallet from the dropdown on the left, and the account(AccountId32) method from the dropdown on the right.

Either paste the address of an account in the AccountId32 field or select an explorer-connected account from the dropdown.
Leave the blockhash field empty (This will query the latest balance of the account), and click on the + button near the top-right.

And that’s it. You just used the AvailApps explorer to query the balance of an account on the Avail network. You can query other methods in a similar way.

Your response should look something like this:

Sample Response:


{
  nonce: '109',
  consumers: '2',
  providers: '1',
  sufficients: '0',
  data: {
    free: '1,000,000,000,000',
    reserved: '100,000,300,000,000,000,000',
    frozen: '100,000,000,000,000,000,000',
    flags: '170,141,183,460,469,231,731,687,303,715,884,105,728'
  }
}
Free balance: 28.3046577073 AVAIL

Fetch account information using a simple `curl` request via the Subscan API

The Subscan API can be used to make API queries to the Subscan indexer to make various kinds of queries.
Subscan supports a variety of Substrate-based chains, including Avail DA mainnet and the Turing testnet.
You can either use their publicly available endpoints for the Avail networks, or use a dedicated endpoint .
The examples below use publicly available Subscan API endpoints for both networks.

You need to have curl installed to run the following examples.

turing-testnet

Open a terminal and run the following command:

terminal


curl --location --request POST 'https://avail.api.subscan.io/api/v2/scan/search' \
--header 'Content-Type: application/json' \
--data-raw '{
    "key": "<your-avail-address>"
}'

Replace <your-avail-address> with the address you want to query.

Sample Response:

JSON response


{
    "code": 0,
    "message": "Success",
    "generated_at": 1741796675,
    "data": {
        "account": {
            "address": "5HbUMBK8SBKH22qrm2sRDtWNtfyT331tUHpKkFMUKyirkJ6G",
            "balance": "169389.0977233184983879",
            "lock": "168914.456888072538284769",
            "balance_lock": "168914.456888072538284769",
            "is_evm_contract": false,
            "account_display": {
                "address": "5HbUMBK8SBKH22qrm2sRDtWNtfyT331tUHpKkFMUKyirkJ6G"
            },
            "substrate_account": null,
            "evm_account": "",
            "registrar_info": null,
            "count_extrinsic": 0,
            "nft_amount": "0",
            "extra": null,
            "display": "",
            "web": "",
            "riot": "",
            "email": "",
            "legal": "",
            "twitter": "",
            "github": "",
            "matrix": "",
            "discord": "",
            "judgements": null,
            "reserved": "13000000000000000000",
            "bonded": "168914456888072538284769",
            "unbonding": "0",
            "democracy_lock": "0",
            "conviction_lock": "0",
            "election_lock": "0",
            "staking_info": null,
            "nonce": 0,
            "role": "validator",
            "stash": "5HbUMBK8SBKH22qrm2sRDtWNtfyT331tUHpKkFMUKyirkJ6G",
            "is_council_member": false,
            "is_techcomm_member": false,
            "is_registrar": false,
            "is_fellowship_member": false,
            "is_module_account": false,
            "assets_tag": null,
            "is_erc20": false,
            "is_erc721": false,
            "vesting": null,
            "proxy": {
                "proxy_account": [
                    {
                        "account_display": {
                            "address": "5HmgLcTCi2trnz4AeEiWs4ngAjALu7o4mFnpKdMBnA8jhFnq"
                        },
                        "proxy_type": "Staking"
                    }
                ]
            },
            "multisig": {
                "multi_account_member": [
                    {
                        "address": "5DfE73hjEYs44JHsuMKzrTMBzkEb6fosaV5xSUEVNjrHwqdB"
                    },
                    {
                        "address": "5DtGLPULvxXoSPvVv2YZdWmCJy8eEYnWj7MwPpdwGgDnFiua"
                    },
                    {
                        "address": "5DyHKiRY2ssTWU4CtbbEPoYFmNKaN2X39KRcgb33fnZqk2Yd"
                    }
                ],
                "threshold": 2
            },
            "delegate": null
        }
    }
}

undefined

Open a terminal and run the following command:

terminal


curl --location --request POST 'https://avail-turing.api.subscan.io/api/v2/scan/search' \
--header 'Content-Type: application/json' \
--data-raw '{
    "key": "<your-avail-address>"
}'

Replace <your-avail-address> with the address you want to query.

Sample Response:

JSON response


{
    "code": 0,
    "message": "Success",
    "generated_at": 1741798906,
    "data": {
        "account": {
            "address": "5DDY2yzh8uCysYFAiRSTeQVwtZSKNF49CkQkyPH852xvrYKk",
            "balance": "16360.7888064893714931",
            "lock": "1131.93873839810825155",
            "balance_lock": "1131.93873839810825155",
            "is_evm_contract": false,
            "account_display": {
                "address": "5DDY2yzh8uCysYFAiRSTeQVwtZSKNF49CkQkyPH852xvrYKk"
            },
            "substrate_account": null,
            "evm_account": "",
            "registrar_info": null,
            "count_extrinsic": 54,
            "nft_amount": "0",
            "extra": null,
            "display": "",
            "web": "",
            "riot": "",
            "email": "",
            "legal": "",
            "twitter": "",
            "github": "",
            "matrix": "",
            "discord": "",
            "judgements": null,
            "reserved": "15100000000000000000",
            "bonded": "1131938738398108251550",
            "unbonding": "0",
            "democracy_lock": "0",
            "conviction_lock": "0",
            "election_lock": "0",
            "staking_info": null,
            "nonce": 54,
            "role": "nominator",
            "stash": "5DDY2yzh8uCysYFAiRSTeQVwtZSKNF49CkQkyPH852xvrYKk",
            "is_council_member": false,
            "is_techcomm_member": false,
            "is_registrar": false,
            "is_fellowship_member": false,
            "is_module_account": false,
            "assets_tag": null,
            "is_erc20": false,
            "is_erc721": false,
            "is_pool_member": true,
            "vesting": null,
            "proxy": {
                "proxy_account": [
                    {
                        "account_display": {
                            "address": "5GvF6GLPuxbseH5qC9w8doUiCMnT4vGvY3Rznu3Fktdw4N45"
                        },
                        "proxy_type": "NonTransfer"
                    }
                ]
            },
            "multisig": {
                "multi_account": [
                    {
                        "address": "5DSCqHHH3whUA3xgkyVSekXB36Gc47SwsJEHLuab5RnFvNua"
                    }
                ]
            },
            "delegate": null,
            "nomination_pool_balance": [
                {
                    "pool_id": 3,
                    "bonded": "100000000000000000000",
                    "unbonding": "0",
                    "claimable": "0"
                }
            ]
        }
    }
}

Query balances on Avail DA

Setting up the dev environment

Querying the balance of an account

avail-js

avail-rust

avail-go

AvailApps explorer

Sample Response:

Fetch account information using a simple curl request via the Subscan API

turing-testnet

Sample Response:

undefined

Sample Response:

Fetch account information using a simple `curl` request via the Subscan API