App Ids are core to the dev experience on Avail DA, and we highly recommend you understand how they work before you start working with them. You can check out our docs for the same.

Fetch an AppID from Avail DA

On-chain name of method: dataAvailability_appKeys

Parameters

avail-js

parameter	type	optional	description
key	string	true	The `app_id` associated with this key will be fetched

avail-rust

parameter	type	optional	description
key	string	true	The `app_id` associated with this key will be fetched

avail-go

parameter	type	optional	description
key	string	true	The `app_id` associated with this key will be fetched

Return value

On failure, a reason for failure is returned. On sucess, the returned JSON object contains:

Owner: The owner of the app_id
appID: The numerical index of the app_id

Minimal example (Fetch a particular `app_id`)

You will need to set up the dev environment required to run this example. For instructions, check out our docs here.
If you’re sending an extrinsic (i.e conducting a transaction) you will need to replace the demo seed phrase with your own seed phrase. The rest of the code should work as is.

avail-js

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

avail-js


import { SDK, Pallets } from 'avail-js-sdk';
 
export async function getAppIdByKey() {
    // Initialize SDK with Turing endpoint
    const sdk = await SDK.New('wss://turing-rpc.avail.so/ws');
    
    // Get the current block hash
    const blockHash = await sdk.client.bestBlockHash();
    console.log(`Current block hash: ${blockHash}`);
    
    // Get storage at the current block
    const storageAt = await sdk.client.storageAt(blockHash);
    
    // The key to look up
    const appKey = "my Application Key Name!!!";
    
    // Fetch the app keys entry for this key
    const entry = await Pallets.DataAvailabilityStorage.AppKeys.fetch(storageAt, appKey);
    
    if (entry === null) {
        console.log(`No app ID found for key: "${appKey}"`);
    } else {
        console.log(`App ID: ${entry.value.appId}`);
        console.log(`Owner: ${entry.value.owner.toSS58()}`);
        console.log(`Key: ${appKey}`);
        console.log("App Key fetched successfully");
    }
    
    process.exit(0);
}
 
// Execute the function
getAppIdByKey();

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 avail::data_availability::storage::types::app_keys::Param0;
 
pub async fn da_app_keys() -> Result<(), ClientError> {
    
    // Create a new SDK instance
    let sdk = SDK::new("wss://turing-rpc.avail.so/ws").await?;
 
    let key = String::from("My Application Key").as_bytes().to_vec();
    let key = Param0 { 0: key };
 
    let block_hash = sdk.client.best_block_hash().await?;
    let storage = sdk.client.storage().at(block_hash);
    let address = avail::storage().data_availability().app_keys(key);
    let result = storage.fetch(&address).await?;
 
    dbg!(result);
 
    Ok(())
}
 
// Add a main function to call da_app_keys
#[tokio::main]
async fn main() {
    if let Err(e) = da_app_keys().await {
        eprintln!("Error: {:?}", e);
    }
    else {
        println!("App Key fetched successfully");
    }
}

Run the code using:

terminal


cargo run

Sample Response:


result = Some(
    AppKeyInfo {
        owner: AccountId32(
            [
                10,
                255,
                21,
                20,
                123,
                225,
                34,
                49,
                109,
                40,
                40,
                86,
                26,
                184,
                109,
                251,
                201,
                136,
                224,
                246,
                137,
                212,
                142,
                149,
                160,
                242,
                197,
                86,
                117,
                80,
                45,
                110,
            ],
        ),
        id: AppId(
            1,
        ),
    },
)

The list of numbers seperated by commas is merely a different way of representing the Substrate addresses in the AccountId32 format.

avail-go

Inside main.go, add the following code:

avail-go


package main
 
import (
	"fmt"
	"log"
 
	daPallet "github.com/availproject/avail-go-sdk/metadata/pallets/data_availability"
	prim "github.com/availproject/avail-go-sdk/primitives"
	SDK "github.com/availproject/avail-go-sdk/sdk"
)
 
func main() {
	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)
	}
 
	{
		storage := daPallet.StorageAppKeys{}
		keyString := "Citizen Justice"
		key := []byte(keyString)
 
		val, err := storage.Fetch(&blockStorage, key)
		if err != nil {
			log.Fatalf("Failed to fetch app keys: %v", err)
		}
 
		if val.IsSome() {
			entry := val.Unwrap()
			fmt.Println("App Key Owner: ", entry.Value.Owner.ToHuman())
			fmt.Println("App Key AppId: ", entry.Value.AppId)
			fmt.Println("App Key fetched successfully")
		} else {
			fmt.Println("No app keys found for the given key.")
		}
	}
}

Run the code using:

terminal


go run main.go

Another example (Fetch all available `app_ids` registered on Avail DA)

Think of the dataAvailability_appKeys as a method that returns all the app_ids registered on Avail DA as a mapping of their names to their owner and index.
In most cases a dev will be interested in fetching only a particular app_id and not all of them.
We are however including both scenarios here.

avail-js

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

avail-js


import { SDK, Pallets } from 'avail-js-sdk';
 
export async function getAllAppIds() {
    // Initialize SDK with Turing endpoint
    const sdk = await SDK.New('wss://turing-rpc.avail.so/ws');
    
    // Get the current block hash
    const blockHash = await sdk.client.bestBlockHash();
    console.log(`Current block hash: ${blockHash}`);
    
    // Get storage at the current block
    const storageAt = await sdk.client.storageAt(blockHash);
    
    // Fetch all app keys entries
    const entries = await Pallets.DataAvailabilityStorage.AppKeys.fetchAll(storageAt);
    
    console.log(`Total number of app IDs: ${entries.length}`);
    
    // Display all app IDs and their details
    entries.forEach((entry) => {
        console.log(`  App ID: ${entry.value.appId}`);
        console.log(`  Owner: ${entry.value.owner.toSS58()}`);
        
        let keyString = "";
        try {
            keyString = new TextDecoder().decode(entry.key);
            console.log(`  Key (as string): ${keyString}`);
        } catch (e) {
            console.log(`  Key (hex): 0x${Buffer.from(entry.key).toString('hex')}`);
        }
    });
    
    process.exit(0);
}
 
// Execute the function
getAllAppIds();

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::*;
 
pub async fn da_app_keys_iter() -> Result<(), ClientError> {
    
    // Create a new SDK instance
    let sdk = SDK::new("wss://turing-rpc.avail.so/ws").await?;
 
    let block_hash = sdk.client.best_block_hash().await?;
    let storage = sdk.client.storage().at(block_hash);
    let address = avail::storage().data_availability().app_keys_iter();
    let mut results = storage.iter(address).await?;
 
    while let Some(Ok(kv)) = results.next().await {
        let key = (&kv.key_bytes[49..]).to_vec();
        let key = String::from_utf8(key).unwrap();
 
        println!("Key: {:?}", key);
        println!("Value: {:?}", kv.value);
    }
 
    Ok(())
}
 
// Add a main function to call da_app_keys_iter
#[tokio::main]
async fn main() {
    if let Err(e) = da_app_keys_iter().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"
 
	daPallet "github.com/availproject/avail-go-sdk/metadata/pallets/data_availability"
	prim "github.com/availproject/avail-go-sdk/primitives"
	SDK "github.com/availproject/avail-go-sdk/sdk"
)
 
func main() {
	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)
	}
 
	// Fetch all app keys
	{
		storage := daPallet.StorageAppKeys{}
		val, err := storage.FetchAll(&blockStorage)
		if err != nil {
			log.Fatalf("Failed to fetch all app keys: %v", err)
		}
 
		if len(val) == 0 {
			log.Println("No app keys found.")
		} else {
			for i := 0; i < len(val); i++ {
				fmt.Println("App Key Owner: ", val[i].Value.Owner.ToHuman())
				fmt.Println("App Key AppId: ", val[i].Value.AppId)
			}
		}
	}
}

Run the code using:

terminal


go run main.go

Fetch an AppID from Avail DA

Parameters

avail-js

avail-rust

avail-go

Return value

Minimal example (Fetch a particular app_id)

avail-js

avail-rust

Sample Response:

avail-go

Another example (Fetch all available app_ids registered on Avail DA)

avail-js

avail-rust

avail-go

Minimal example (Fetch a particular `app_id`)

Another example (Fetch all available `app_ids` registered on Avail DA)