Create a new App ID on Avail DA

import * as dotenv from 'dotenv';
import { Account, SDK, Pallets } from 'avail-js-sdk';
 
dotenv.config();
 
export async function createApplicationKey() {
 
    // Initialize SDK with Turing endpoint
    const sdk = await SDK.New('wss://turing-rpc.avail.so/ws');
    
    // Create account from seed in .env file
    const seed = process.env.SEED;
    if (!seed) {
      throw new Error("SEED environment variable is not set");
    }
    
    // Create account from seed
    const account = Account.new(seed);
    console.log("Account Address: ", account.address);
 
    // Use a fixed key string
    const key = "my Application Key Name";
    
    // Create application key transaction
    const tx = sdk.tx.dataAvailability.createApplicationKey(key);
    console.log("Submitting transaction to create application key...");
    
    // Execute and wait for inclusion
    const res = await tx.executeWaitForInclusion(account, {});
    
    // Check if transaction was successful
    const isOk = res.isSuccessful();
    if (isOk === undefined) {
      throw new Error("Cannot check if transaction was successful");
    }
    else if (!isOk) {
        throw new Error("Transaction failed");
    }
 
    // Extract event data
    if (res.events === undefined) throw new Error("No events found");
 
    const event = res.events.findFirst(Pallets.DataAvailabilityEvents.ApplicationKeyCreated);
    if (event === undefined) throw new Error("ApplicationKeyCreated event not found");
    
    const appId = event.id;
    console.log(`Application created successfully:`);
    console.log(`Owner: ${event.owner}`);
    console.log(`Key: ${event.keyToString()}`);
    console.log(`App Id: ${appId}`);
    console.log(`Transaction Hash: ${res.txHash}`);
 
    process.exit(0);
}
 
// Execute the function
createApplicationKey()

ts-node your-file-name.ts

use dotenvy::dotenv;
use std::env;
use avail_rust::prelude::*;
 
type ApplicationKeyCreatedEvent = avail::data_availability::events::ApplicationKeyCreated;
 
pub async fn create_application_key() -> Result<(), ClientError> {
	
    // Create a new SDK instance
	let sdk = SDK::new("wss://turing-rpc.avail.so/ws").await?;
 
    // Loading seed phrase and creating an account derived from the seed
    dotenv().ok();
    let seed = env::var("SEED").expect("SEED environment variable is not set");
    let account = account::from_secret_uri(&seed)?;
    println!("Account Address: {}", account.public_key().to_account_id());
 
    // Application Key Creation
    // Please note that if an application key with the same `key` already exists, the transaction will fail.
 
    let key = "My Application Key".as_bytes().to_vec();
    let tx = sdk.tx.data_availability.create_application_key(key);
    let res = tx.execute_and_watch_inclusion(&account, Options::default()).await?;
    assert_eq!(res.is_successful(), Some(true), "Transactions must be successful");
 
    let events = res.events.as_ref().unwrap();
    let event = events.find_first::<ApplicationKeyCreatedEvent>().unwrap();
    let Some(event) = event else {
        return Err("Failed to get Application Key Created Event".into());
    };
    let app_id = event.id.0;
    println!("Application Key Created");
    println!("{}",app_id);
 
    Ok(())
}
 
// Add a main function to call create_application_key
#[tokio::main]
async fn main() {
    if let Err(e) = create_application_key().await {
        eprintln!("Error: {:?}", e);
    }
}

cargo run

package main
 
import (
	"fmt"
	"log"
	"os"
 
	daPallet "github.com/availproject/avail-go-sdk/metadata/pallets/data_availability"
	SDK "github.com/availproject/avail-go-sdk/sdk"
	"github.com/joho/godotenv"
)
 
func main() {
	// Load environment variables from .env file
	err := godotenv.Load()
	if err != nil {
		log.Fatal("Error loading .env file")
	}
 
	// Make sure the SEED environment variable is set
	seed := os.Getenv("SEED")
	if seed == "" {
		log.Fatal("SEED environment variable is not set")
	}
 
	// Create an account from the SEED environment variable
	acc, err := SDK.Account.NewKeyPair(seed)
	if err != nil {
		log.Fatalf("Failed to create account: %v", err)
	}
	fmt.Println("Your account Address: " + acc.SS58Address(42))
 
	// Initialize an SDK instance
	sdk, err := SDK.NewSDK("https://turing-rpc.avail.so/rpc")
	if err != nil {
		log.Fatalf("Failed to initialize SDK: %v", err)
	}
 
	// Generate an application key
	// Please note that the transaction will fail if
	// an AppID with the same key already exists
	key := "My new application key"
	tx := sdk.Tx.DataAvailability.CreateApplicationKey([]byte(key))
 
	// Execute the transaction
	res, err := tx.ExecuteAndWatchInclusion(acc, SDK.NewTransactionOptions())
	if err != nil {
		log.Fatalf("Transaction failed: %v", err)
	}
 
	// Check if the transaction was successful
	if !res.IsSuccessful().UnsafeUnwrap() {
		log.Fatal("Transaction was not successful")
	}
 
	fmt.Println("Application Key Created Successfully")
 
	// Printing out all the values of the event ApplicationKeyCreated
	events := res.Events.UnsafeUnwrap()
	eventMyb := SDK.EventFindFirst(events, daPallet.EventApplicationKeyCreated{})
	event := eventMyb.UnsafeUnwrap().UnsafeUnwrap()
	appId := event.Id
	fmt.Println(fmt.Sprintf(`Owner: %v, Key: %v, AppId: %v`, event.Owner.ToHuman(), string(event.Key), appId))
	fmt.Println(fmt.Sprintf(`Block Hash: %v, Block Index: %v, Tx Hash: %v, Tx Index: %v`, res.BlockHash.ToHexWith0x(), res.BlockNumber, res.TxHash.ToHexWith0x(), res.TxIndex))
	fmt.Println("Application Key Created")
}

go run main.go