AssetHub: Retrieve balance of assets

[f-squirrel]

Hi folks,

Could you please provide an example of retrieving asset balances in AssetHubs?

[jsdw]

Have a look at this for asset hub config:

https://github.com/paritytech/subxt/blob/master/subxt/examples/setup_config_assethub.rs

And this one for iterating over accounts (which I think will print balance info):

https://github.com/paritytech/subxt/blob/master/subxt/examples/storage_iterating.rs

We have an issue to update examples etc for AssetHub (including providing an AssetHub config out of the box, or similar) but I hope that for now the above will suffice for you :)

[f-squirrel]

@jsdw, I am unsure how to extract assets from the keys.
The code below provides the liquid balance of an asset:

    pub(crate) async fn get_liquid_asset_balance(&self, account: &AccountId32, asset: u32) -> u128 {
        let asset_query = assethub::storage().assets().account(asset, account);
        let result = self
            .client
            .storage()
            .at_latest()
            .await
            .expect("Failed to get the latest block")
            .fetch(&asset_query)
            .await;

        match result {
            Ok(Some(r)) => match r.status {
                subxt_assethub::runtime_types::pallet_assets::types::AccountStatus::Liquid => {
                    r.balance
                }
                other => {
                    log::debug!(
                        "Balance for account: {:?} is in status: {:?}",
                        account,
                        other
                    );
                    0
                }
            },
            Ok(None) => {
                log::debug!("No balance found for account: {:?}", account);
                0
            }
            Err(error) => {
                log::error!(
                    "Failed to get balance for account: {:?}, error: {}",
                    account,
                    error,
                );
                0
            }
        }
    }

[jsdw]

I am unsure how to extract assets from the keys.

Do you mean, as in how to get asset details from the u32 ID? assets.asset(u32) looks like the storage request you'd need to make to get this information offhand :)

[f-squirrel]

It seems I understand even less now:)
So to be clear, I need to know what asset(s) a given account holds and get the assets' balance for the account.

The code that you provided seems to iterate over all assets available in the system.

[jsdw]

To get balance of all assets for an account, it looks like one way you could do it is by iterating over assets.asset storage entries to get details about the available assets, and then call assets.account(ASSETID, ACCOUNTID) with each asset ID to see how many of each asset some account has.

This example does that:

use std::str::FromStr;
use subxt::config::PolkadotConfig;
use codec::Decode;

// Point to a metadata file instead when possible; this just for the example:
#[subxt::subxt(runtime_metadata_insecure_url = "wss://asset-hub-polkadot-rpc.n.dwellir.com")]
pub mod assethub {}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
    // Using PolkadotConfig here for simplicity, but if you submit transactions you'll
    // need to use AssetHub config eg https://github.com/paritytech/subxt/blob/master/subxt/examples/setup_config_assethub.rs
    let api = subxt::OnlineClient::<PolkadotConfig>::from_url("wss://asset-hub-polkadot-rpc.n.dwellir.com").await.unwrap();

    // Get the asset details:
    let assets_info_query = assethub::storage().assets().asset_iter();
    let mut asset_results = api.storage().at_latest().await?.iter(assets_info_query).await?;

    // Account ID you want to check balances for. I just picked one at random.
    let some_account_id = subxt::utils::AccountId32::from_str("12h3CTtEFwZEd4bC8t5RMHD9PTASvWR1xq4sM5Z5EvF9yjt2")?;

    while let Some(Ok(asset_kv)) = asset_results.next().await {
        // The storage API doesn't provide decoded keys when iterating (I'll make this better), so for now
        // we just have to decode the last 4 bytes of the key ourselves to get it:
        let asset_id = u32::decode(&mut &asset_kv.key_bytes[48..])?;

        // Now, with the asset ID we can ask for the balance of it for some account
        let account_balance_query = assethub::storage().assets().account(asset_id, some_account_id.clone());
        let mut balance_info = api.storage().at_latest().await?.fetch(&account_balance_query).await?;

        if let Some(balance_info) = balance_info {
            println!("account {some_account_id} has asset ID {asset_id}: {balance_info:?}");
        }
    }

    Ok(())
}

But honestly I haven't played a ton with these storage entries; I just look them up in https://polkadot.js.org/apps/#/chainstate to see what APIs are available :)

[f-squirrel]

@jsdw, I see. So, the API to retrieve an account's balance is the one I used, but in your example, I can iterate over all assets available in the system.
In my case, I know what assets to expect, so I iterate over a smaller list.

I have two points to mention:

• Is there a plan to be able to retrieve this data more efficiently? Iterating over all assets in the system is an expensive operation. As a user, I would prefer to have a function like storage().account(my_account_id) that returns the DOT balance and assets.
  @jsdw, I happen to see. So, the API to retrieve the URL you provided is for Polkadot, and ATM it does not support assets in the way AssetHub does.

Thank you for the explanation!

[jsdw]

Is there a plan to be able to retrieve this data more efficiently? Iterating over all assets in the system is an expensive operation. As a user, I would prefer to have a function like storage().account(my_account_id) that returns the DOT balance and assets.

Subxt only provides access to the existing pallet and runtime APIs and so there's nothing to do on this side in that regard.

I'd consider raising an issue over in https://github.com/paritytech/polkadot-sdk/ to discuss for this sort of ask. Perhaps we could add a view function like get_assets_for_account(AccountId32) -> Vec<(AssetId, AssetDetails)> that would help, but it depends on how commonplace such a pattern is I think.