Create a new nomination pool with a specific pool ID

import { SDK, WaitFor, Keyring, BN } from "avail-js-sdk"
 
const main = async () => {
  const providerEndpoint = "wss://turing-rpc.avail.so/ws";
  const sdk = await SDK.New(providerEndpoint);
 
  const Alice = 'This is a random seed phrase please replace with your own';
  const account = new Keyring({ type: "sr25519" }).addFromUri(Alice);
  const amount = new BN(10).pow(new BN(18)).mul(new BN(10000)) // 10_000 Avail
 
  const root: string = "5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY" // Alice
  const nominator: string = "5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY" // Alice
  const bouncer: string = "5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY" // Alice
  const poolId = 0
 
  const result = await sdk.tx.nominationPools.createWithPoolId(
    amount,
    root,
    nominator,
    bouncer,
    poolId,
    WaitFor.BlockInclusion,
    account,
  )
  if (result.isErr) {
    console.log(result.reason)
    process.exit(1)
  }
 
  console.log(JSON.stringify(result, null, 4))
  process.exit()
}
main()

ts-node your-file-name.ts

use dotenvy::dotenv;
use std::env;
use avail_rust::prelude::*;
use core::str::FromStr;
 
pub async fn nomination_pools_create_with_pool_id() -> 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 amount to bond and the pool id
	let amount = 10_000_000_000_000_000_000_000u128; // 10_000 Avail tokens
    let pool_id = 1; // You need to use a pool id that is not already in use
 
    //Setting the root, nominator and bouncer
    let root = account.public_key().to_account_id(); //Setting the root to be the account itself
 
    let nominator = AccountId::from_str("5DDY2yzh8uCysYFAiRSTeQVwtZSKNF49CkQkyPH852xvrYKk").unwrap();
    let bouncer = AccountId::from_str("5D7LgWT5J6MVRa6PvTTXUfd9VvggEcguvPnnWAGK44CJKFEq").unwrap();
 
    //Executing the transaction
    let tx = sdk.tx.nomination_pools.create_with_pool_id(amount, root, nominator, bouncer, pool_id);
    let res = tx.execute_and_watch_inclusion(&account, Options::new()).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) = nomination_pools_create_with_pool_id().await {
        eprintln!("Error: {:?}", e);
    }
}

cargo run

package main
 
import (
	"fmt"
	"log"
	"os"
 
	"github.com/availproject/avail-go-sdk/metadata"
	"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)
	}
 
	// Set the amount, pool ID, and addresses
	amount, err := metadata.NewBalanceFromString("1000000000000000000000000") // Example amount
	if err != nil {
		log.Fatalf("Failed to create balance: %v", err)
	}
	poolId := uint32(1)
 
	rootAddress, err := primitives.NewAccountIdFromAddress("5DqMavSQikX9eMzwHKiC8xS6VWB2yCd5gGQuQq7KheM2Mgc7")
	if err != nil {
		log.Fatalf("Failed to convert root address: %v", err)
	}
	nominatorAddress, err := primitives.NewAccountIdFromAddress("5FphMk7DhSdq7jXsQCVQthw7XTiCWxdA9ZS6V43rKeJzvya9")
	if err != nil {
		log.Fatalf("Failed to convert nominator address: %v", err)
	}
	bouncerAddress, err := primitives.NewAccountIdFromAddress("5G9fM7DhSdq7jXsQCVQthw7XTiCWxdA9ZS6V43rKeJzvya9")
	if err != nil {
		log.Fatalf("Failed to convert bouncer address: %v", err)
	}
 
	// Convert addresses to MultiAddress
	root := rootAddress.ToMultiAddress()
	nominator := nominatorAddress.ToMultiAddress()
	bouncer := bouncerAddress.ToMultiAddress()
 
	// Create the CreateWithPoolId transaction
	tx := sdk.Tx.NominationPools.CreateWithPoolId(amount, root, nominator, bouncer, poolId)
 
	// 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("CreateWithPoolId transaction successful")
	fmt.Printf("Block Hash: %v, Block Number: %v, Tx Hash: %v, Tx Index: %v\n", res.BlockHash.ToHexWith0x(), res.BlockNumber, res.TxHash.ToHexWith0x(), res.TxIndex)
}

go run main.go