Fetch information on the active era

On-chain name of method: staking_activeEra

Parameters

avail-js

None

Returns

index: The index of the active era
start: The timestamp when the active era started

Minimal example (Fetch the active era)

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, BN } from "avail-js-sdk";
 
export async function getActiveEra() {
  // 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 active era information
  const activeEra = await Pallets.StakingStorage.ActiveEra.fetch(storageAt);
 
  if (!activeEra) {
    console.log("No active era found");
    process.exit(1);
  }
 
  // Log all properties of activeEra
  console.log("\nAll Active Era Properties:");
  for (const [key, value] of Object.entries(activeEra)) {
    console.log(`${key}: ${value}`);
  }
 
  process.exit(0);
}
 
// Execute the function
getActiveEra();

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 staking_active_era() -> 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().staking().active_era();
    let result = storage.fetch(&address).await?;
 
    dbg!(result);
 
    Ok(())
}
 
#[tokio::main]
async fn main() {
    if let Err(e) = staking_active_era().await {
        eprintln!("Error: {:?}", e);
    }
}

Run the code using:

terminal


cargo run

Sample Response:


result = Some(
    ActiveEraInfo {
        index: 174,
        start: Some(
            1726523440000,
        ),
    },
)

avail-go

Inside main.go, add the following code:

avail-go


package main
 
import (
	"fmt"
	"log"
 
	staPallet "github.com/availproject/avail-go-sdk/metadata/pallets/staking"
	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 the active era
	{
		storage := staPallet.StorageActiveEra{}
		val, err := storage.Fetch(&blockStorage)
		if err != nil {
			log.Fatalf("Failed to fetch active era: %v", err)
		}
 
		fmt.Println("Active Era: ", val.Unwrap())
	}
}

Run the code using:

terminal


go run main.go