Read & Write data on Avail DA

BEFORE YOU BEGIN
We recommend you go through these two pages in our docs before proceeding:

Get Testnet Tokens: To help you get set with some AVAIL tokens on the Turing testnet.
Create an AppID: The guide below focusses on reading & submitting data on a particular AppID. It will help to be familiar with the concept.

Setting up the dev environment

In this guide we will use some dedicated libraries to interact with Avail DA. To set up a dev environment for avail-js, please follow the steps outlined here.

Submitting data to Avail DA

avail-js

Create a file named submit-data.ts
Import the dependencies from avail-js-sdk and create a main function:

avail-js


 
import { SDK, WaitFor, Keyring, TransactionOptions } from "avail-js-sdk"
 
const main = async () => {
 
 
}
main()

Initialize a new instance of the SDK inside the main function:

avail-js


 
    // Initialize the SDK with a public Turing testnet endpoint
    // You can always switch it out with your own endpoint
  const providerEndpoint = "wss://turing-rpc.avail.so/ws";
  const sdk = await SDK.New(providerEndpoint)

Initialize a new wallet using a 12-word seed phrase, and configure the params for the transaction:

avail-js


 
  const Alice = "This is a random seed phrase please replace with your own";
  const account = new Keyring({ type: "sr25519" }).addFromUri(Alice)
  const data = "Example data to be submitted to Avail DA"
 
  // You can submit data to any AppID of your choosing
  const options: TransactionOptions = { app_id: 89 }

Submit the transaction by calling the dataAvailability_submitData extrinsic via the avail-js SDK:

avail-js


 
//Submit the transaction
  const result = await sdk.tx.dataAvailability.submitData(data, WaitFor.BlockInclusion, account, options)
	if (result.isErr) {
      console.log(result.reason)
      process.exit(1)
    }
 
// Logging transaction details in the terminal
  console.log("Data=" + result.txData.data)
  console.log("Who=" + result.event.who + ", DataHash=" + result.event.dataHash)
  console.log("TxHash=" + result.txHash + ", BlockHash=" + result.blockHash)

Run the script using the following command:


ts-node submit-data.ts

If everything went well, this is what your terminal should look like:

trying to stake via proxy on Avail DA

avail-rust

Create a file named main.rs
Import the dependencies from avail-rust-sdk and create a submit_data function:

avail-rust


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> {
 
}

Initialize a new instance of the SDK inside the submit_data function:

avail-rust


    // Create a new SDK instance
	let sdk = SDK::new("wss://turing-rpc.avail.so/ws").await?;

Initialize a new wallet using a 12-word seed phrase, and configure the params for the transaction:

avail-rust


    // 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();

Submit the transaction by calling the dataAvailability_submitData extrinsic via the avail-rust SDK:

avail-rust


 
    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);
    }
}

Run the script using the following command:


cargo run

avail-go

Create a file named main.go
Import the dependencies from avail-go-sdk and create a main function:

avail-go


package main
 
import (
	"fmt"
	"log"
	"os"
 
	SDK "github.com/availproject/avail-go-sdk/sdk"
	"github.com/joho/godotenv"
)
 
func main() {
 
}

Initialize a new instance of the SDK inside the main function:

avail-go


	// 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)
	}
 
	// Configure the application ID
	appId := uint32(89)

Pass the seed phrase and data string as params for the transaction:

avail-go


	// Submit data to Avail
	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))

Run the script using the following command:


go run main.go

AvailApps explorer

Go to the extrinsics page on the AvailApps explorer.
Select an account which has funds on the network.
Select the dataAvailability pallet from the dropdown on the left.
Select the submitData extrinsic from the dropdown on the right.
Enter the data you want to submit in the data field.

submitting data using the explorer

Click on Submit Transaction and fill in the details in the pop-up window.

filling out the tx details

The appID should be an integer that represents a valid AppID on the network. To check out how to create an AppID on Avail, refer to this page.

Click on Sign and Submit and approve the transaction in your wallet.

Reading data from Avail DA

You can read back your submitted data from Avail DA using the blockHash and txHash of the transaction.

Create a file named read-data.ts
Import the dependencies from avail-js-sdk and create a main function:

avail-js


 
import { initialize } from "avail-js-sdk"
 
const main = async () => {
  try {
 
} catch (err) {
    console.error(err)
    process.exit(1)
  }}
main()

Initialize a new instance of the SDK inside the main function, and declare the params:

avail-js


 
      //initialize sdk
    const api = await initialize("wss://turing-rpc.avail.so/ws")
 
    // Provide the transaction hash and block hash
    const [txHash, blockHash] = ["0x17463754ef4185f4faba2473535890e4397aa403830f3b5a77295340b9e7cf56", "0x758036aa0db77bb34f6bf23b9fe290900f203ef4547e46c36fa486adbe6488e8"]
    console.log(`Tx Hash: ${txHash}, Block Hash: ${blockHash}`)

Extract the data:

avail-js


 
    // Extracting data
    const block = await api.rpc.chain.getBlock(blockHash)
    const tx = block.block.extrinsics.find((tx) => tx.hash.toHex() == txHash)
    if (tx == undefined) {
      console.log("Failed to find the Submit Data transaction")
      process.exit(1)
    }

Parse the data to extract a string:

avail-js


 
    console.log(JSON.stringify(tx))
    const dataHex = tx.method.args.map((a) => a.toString()).join(", ")
    // Data retrieved from the extrinsic data
    let str = ""
    for (let n = 0; n < dataHex.length; n += 2) {
      str += String.fromCharCode(parseInt(dataHex.substring(n, n + 2), 16))
    }
    console.log(`This is the string that was submitted: ${str}`)

Run the script using the following command:


ts-node read-data.ts

If everything went well, this is what your terminal should look like:

trying to stake via proxy on Avail DA

Complete example

The following code snippet combines the steps above into a single script to submit and fetch data from Avail:

avail-js


 
import { initialize, getKeyringFromSeed } from "avail-js-sdk"
import { ISubmittableResult } from "@polkadot/types/types/extrinsic"
import { H256 } from "@polkadot/types/interfaces/runtime"
const main = async () => {
  try {
    //initialize sdk
    const api = await initialize("wss://turing-rpc.avail.so/ws")
    // get your Avail account
    const account = getKeyringFromSeed("This is a random seed phrase please replace with your own")
    console.log(account.address)
 
    // Data to be submitted
    const data = "Hello World"
 
    // submit the data using dataAvailability.submitData extrinsic
    const txResult = await new Promise<ISubmittableResult>((res) => {
      api.tx.dataAvailability.submitData(data).signAndSend(account, (result: ISubmittableResult) => {
        console.log(`Tx status: ${result.status}`)
        console.log(`Block finalization and data retrieval can take upto 30 seconds...:⏰⏰⏰`)
        if (result.isFinalized || result.isError) {
          res(result)
        }
      })
    })
 
    // Rejected Transaction handling
    if (txResult.isError) {
      console.log(`Transaction was not executed`)
      process.exit(1)
    }
 
    // Passing the transaction hash and block hash to fetch the submitted data
    const [txHash, blockHash] = [txResult.txHash as H256, txResult.status.asFinalized as H256]
    console.log(`Tx Hash: ${txHash}, Block Hash: ${blockHash}`)
 
    // Extracting data
    const block = await api.rpc.chain.getBlock(blockHash)
    const tx = block.block.extrinsics.find((tx) => tx.hash.toHex() == txHash.toHex())
    if (tx == undefined) {
      console.log("Failed to find the Submit Data transaction")
      process.exit(1)
    }
 
    console.log(JSON.stringify(tx))
    const dataHex = tx.method.args.map((a) => a.toString()).join(", ")
 
    // Data retrieved from the extrinsic data
    let str = ""
    for (let n = 0; n < dataHex.length; n += 2) {
      str += String.fromCharCode(parseInt(dataHex.substring(n, n + 2), 16))
    }
 
    console.log(`submitted data: ${str}`)
  process.exit()
} catch (err) {
    console.error(err)
    process.exit(1)
  }}
main()

Estimate fees for your data submission

The avail-js SDK provides a method to estimate the cost of submitting a particular piece of data to Avail DA. Here is how you can use it:

avail-js


 
import { initialize, disconnect } from "avail-js-sdk"
 
const calculateCost = async () => {
      // Initialize the avail sdk providerEndpoint
      const providerEndpoint = await initialize("wss://turing-rpc.avail.so/ws")
 
      // Dummy sender - insert any address
      const sender = "5CDGXH8Q9DzD3TnATTG6qm6f4yR1kbECBGUmh2XbEBQ8Jfa5"
      
      //10^18 decimals to denominate to AVAIL
      const DECIMAL = 1000000000000000000
     
      // Input the data
      let data = "This is a random piece of string data!!!"
 
		  //Get the estimated cost in AVAIL
        const cost = await providerEndpoint.tx.dataAvailability.submitData(data).paymentInfo(sender)
    const costInAvail = (parseInt(cost.partialFee.toString())/DECIMAL).toFixed(6)
        
        console.log(`Estimated Fees: ${costInAvail} AVAIL`)
 
      await disconnect()
  }
  
  calculateCost()

LOOKING FOR MORE EXAMPLES?
This page was written as an introduction to working with data submission/reading on Avail DA. In particular, we used the dataAvailability_submitData extrinsic to submit data to the network. Refer to our API reference for more detailed examples.