Submit new data to Avail DA

import * as dotenv from 'dotenv';
import { Account, SDK, Pallets } from 'avail-js-sdk';
 
dotenv.config();
 
export async function submitData() {
    // 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);
 
    // Replace with your own AppID
    const appId = 89;
    console.log(`Submitting data to App Id: ${appId}`);
    
    // Create data submission transaction
    const data = "My Data Submission";
    const tx = sdk.tx.dataAvailability.submitData(data);
    console.log("Submitting transaction with data...");
    
    // Execute and wait for inclusion with app_id
    const res = await tx.executeWaitForInclusion(account, { app_id: appId });
    
    // 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");
 
    // Transaction Details
    console.log(
      `Block Hash: ${res.blockHash}, Block Number: ${res.blockNumber}, Tx Hash: ${res.txHash}, Tx Index: ${res.txIndex}`
    );
 
    // Find DataSubmitted event
    const event = res.events.findFirst(Pallets.DataAvailabilityEvents.DataSubmitted);
    if (event === undefined) throw new Error("DataSubmitted event not found");
    
    console.log(`Data submitted successfully:`);
    console.log(`Who: ${event.who}`);
    console.log(`DataHash: ${event.dataHash}`);
    
    console.log("Data submission completed successfully");
    process.exit(0);
}
 
// Execute the function
submitData();

ts-node your-file-name.ts

use dotenvy::dotenv;
use std::env;
use avail_rust::prelude::*;
 
type DataSubmissionCall = avail::data_availability::calls::types::SubmitData;
 
pub async fn submit_data() -> 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());
 
    // Please note that the tx will fail if this application key does not exist
    let my_application_key = 1;
 
    // Data Submission
    let data = String::from("My Data").into_bytes();
    let options = Options::new().app_id(my_application_key);
    let tx = sdk.tx.data_availability.submit_data(data);
    let res = tx.execute_and_watch_inclusion(&account, options).await?;
    assert_eq!(res.is_successful(), Some(true), "Transactions must be successful");
 
    println!(
        "Block Hash: {:?}, Block Number: {}, Tx Hash: {:?}, Tx Index: {}",
        res.block_hash, res.block_number, res.tx_hash, res.tx_index
    );
 
    // Decoding
    let decoded = res.decode_as::<DataSubmissionCall>().await?;
    let Some(decoded) = decoded else {
        return Err("Failed to get Data Submission Call data".into());
    };
 
    let data = to_ascii(decoded.data.0).unwrap();
    println!("Call data: {:?}", data);
 
    println!("Data Submission finished correctly");
 
    Ok(())
}
 
// Add a main function to call submit_data
#[tokio::main]
async fn main() {
    if let Err(e) = submit_data().await {
        eprintln!("Error: {:?}", e);
    }
}

cargo run

package main
 
import (
	"fmt"
	"log"
	"os"
 
	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)
	}
 
	// Submit data to Avail
	appId := uint32(89)
	tx := sdk.Tx.DataAvailability.SubmitData([]byte("Submitting some data using avail-go-sdk"))
	res, err := tx.ExecuteAndWatchInclusion(acc, SDK.NewTransactionOptions().WithAppId(appId))
	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")
	}
 
	// Printing out all the values of the transaction
	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))
 
}

go run main.go