Nominate staked AVAIL tokens to one or more validators

import * as dotenv from 'dotenv';
import { Account, SDK, Pallets } from 'avail-js-sdk';
 
dotenv.config();
 
export async function stakingNominate() {
    // 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);
    
    // Validator targets to nominate
    const targets = [
      "5GNJqTPyNqANBkUVMN1LPPrxXnFouWXoe2wNSmmEoLctxiZY", // Alice Stash
      "5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty", // Bob
    ];
    console.log("Nominating validators:");
    targets.forEach((target, index) => {
      console.log(`  ${index + 1}. ${target}`);
    });
    
    // Create nominate transaction
    const tx = sdk.tx.staking.nominate(targets);
    console.log("Submitting nomination transaction...");
    
    // 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");
    }
    
    console.log("Nomination completed successfully");
    console.log(`Transaction Hash: ${res.txHash}`);
    console.log(`Block Hash: ${res.blockHash}`);
    
    process.exit(0);
}
 
// Execute the function
stakingNominate();

ts-node your-file-name.ts

use dotenvy::dotenv;
use std::env;
use avail_rust::prelude::*;
use core::str::FromStr;
 
pub async fn staking_nominate() -> 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)?;
    
    //Setting the Validator to be nominated, max 16 targets
    let targets = [
        AccountId::from_str("5DqMavSQikX9eMzwHKiC8xS6VWB2yCd5gGQuQq7KheM2Mgc7").expect("Invalid account ID"),
        AccountId::from_str("5FphMk7DhSdq7jXsQCVQthw7XTiCWxdA9ZS6V43rKeJzvya9").expect("Invalid account ID"),
    ];
 
    //Executing the transaction
    let tx = sdk.tx.staking.nominate(&targets);
    let res = tx.execute_and_watch_inclusion(&account, Options::default()).await?;
    assert_eq!(res.is_successful(), Some(true));
    
    println!(
        "Block Hash: {:?}, Block Number: {}, Tx Hash: {:?}, Tx Index: {}",
        res.block_hash, res.block_number, res.tx_hash, res.tx_index
    );
 
    Ok(())
}
 
#[tokio::main]
async fn main() {
    if let Err(e) = staking_nominate().await {
        eprintln!("Error: {:?}", e);
    }
}
 

cargo run

package main
 
import (
	"fmt"
	"log"
	"os"
 
	"github.com/availproject/avail-go-sdk/primitives"
	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)
	}
 
	// Convert the addresses to AccountId
	address1, err := primitives.NewAccountIdFromAddress("5DqMavSQikX9eMzwHKiC8xS6VWB2yCd5gGQuQq7KheM2Mgc7")
	if err != nil {
		log.Fatalf("Failed to convert address1: %v", err)
	}
 
	address2, err := primitives.NewAccountIdFromAddress("5FphMk7DhSdq7jXsQCVQthw7XTiCWxdA9ZS6V43rKeJzvya9")
	if err != nil {
		log.Fatalf("Failed to convert address2: %v", err)
	}
 
	// Create an array of AccountId
	targets := []primitives.MultiAddress{
		address1.ToMultiAddress(),
		address2.ToMultiAddress(),
	}
 
	// Create the nominate transaction
	tx := sdk.Tx.Staking.Nominate(targets)
 
	// 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("Nomination transaction 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