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 the next available App ID on Avail DA

On-chain name of method: dataAvailability_nextAppId

app_ids, once registered, cannot be claimed by another dev. You can use this method to fetch the next available app_id for your awesome rollup :)

Parameters

avail-js

None

Returns

app_id: The next available App ID

Minimal example (Fetch the next available `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 getNextAppId() {
    // 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 the next available app ID
    const nextAppId = await Pallets.DataAvailabilityStorage.NextAppId.fetch(storageAt);
    
    console.log(`Next available App ID is: ${nextAppId}`);
    
    process.exit(0);
}
 
// Execute the function
getNextAppId();

Run the code using:

terminal


ts-node your-file-name.ts

Sample Response:

avail-rust

Inside main.rs, add the following code:

avail-rust


use avail_rust::prelude::*;
 
pub async fn da_next_app_id() -> 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().next_app_id();
    let result = storage.fetch_or_default(&address).await?;
 
    println!("Next available App ID is: {:?}", result);
    Ok(())
}
 
// Add a main function to call da_next_app_id
#[tokio::main]
async fn main() {
    if let Err(e) = da_next_app_id().await {
        eprintln!("Error: {:?}", e);
    }
}

Run the code using:

terminal


cargo run

Sample Response:


Some(
    AppId(
        99,
    ),
)

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)
	}
 
	// Call the StorageNextAppId function
	storage := daPallet.StorageNextAppId{}
	nextAppId, err := storage.Fetch(&blockStorage)
	if err != nil {
		log.Fatalf("Failed to fetch next app ID: %v", err)
	}
 
	fmt.Printf("Next available App ID is: %v\n", nextAppId)
}

Run the code using:

terminal


go run main.go

Fetch the next available App ID on Avail DA

Parameters

avail-js

avail-rust

avail-go

Returns

Minimal example (Fetch the next available app_id)

avail-js

Sample Response:

avail-rust

Sample Response:

avail-go

Minimal example (Fetch the next available `app_id`)