Unbond AVAIL tokens from Avail DA

On-chain name of extrinsic: staking_unbond

Parameters

avail-js

parameter	type	optional	description
value	BN	false	amount of tokens to unbond
waitFor	WaitFor	false	wait for block inclusion or finalization
account	KeyringPair	false	account that will send and sign the transaction
options	SignerOptions	true	used to overwrite existing signer options

parameter	type	optional	description
value	u128	false	amount of tokens to unbond
waitFor	WaitFor	false	wait for block inclusion or finalization
account	KeyringPair	false	account that will send and sign the transaction
options	SignerOptions	true	used to overwrite existing signer options

parameter	type	optional	description
amount	Ucompact	false	amount of tokens to unbond
WaitForInclusion	WaitFor	false	wait for block inclusion or finalization
api	API	false	api for avail chain
Seed	Mnemonic	false	seed of the account that needs to sign the transaction

Returns

On failure, a reason of failure is returned. On Success, Unbonded event, transaction hash and block hash is returned.

Minimal example

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, 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 value = new BN(10).pow(new BN(18)) // one Avail
 
  const result = await sdk.tx.staking.unbond(value, WaitFor.BlockInclusion, account)
  if (result.isErr) {
    console.log(result.reason)
    process.exit(1)
  }
 
  console.log("Stash=" + result.event.stash + ", Amount=" + result.event.amount)
  console.log("TxHash=" + result.txHash + ", BlockHash=" + result.blockHash)
 
  process.exit()
}
main()

Run the code using:


ts-node your-file-name.ts

avail-rust

Inside src/main.rs, paste the following code:

avail-rust


use avail_rust::{Keypair, Nonce, Options, SecretUri, WaitFor, SDK};
use core::str::FromStr;
 
#[tokio::main]
async fn main() -> Result<(), String> {
	let sdk = SDK::new("wss://turing-rpc.avail.so/ws").await.unwrap();
 
	let alice = "This is a random seed phrase please replace with your own";
	let secret_uri = SecretUri::from_str(alice).unwrap();
	let account = Keypair::from_uri(&secret_uri).unwrap();
	let value = 1_000_000_000_000_000_000u128; // 1 Avail
    let options = Options::new().nonce(Nonce::BestBlockAndTxPool);
 
	let result = sdk
		.tx
		.staking
		.unbond(value, WaitFor::BlockInclusion, &account, Some(options))
		.await?;
 
	println!(
		"Stash={}, Amount={:?}",
		result.event.stash, result.event.amount
	);
	println!(
		"TxHash={:?}, BlockHash={:?}",
		result.tx_hash, result.block_hash
	);
 
	Ok(())
}

Run the code using:


cargo run

avail-go

Inside main.go, paste the following code:

avail-go


package main
 
import (
	"math/big"
 
	"github.com/availproject/avail-go-sdk/src/config"
	"github.com/availproject/avail-go-sdk/src/sdk"
	"github.com/availproject/avail-go-sdk/src/sdk/tx"
	"github.com/availproject/avail-go-sdk/src/sdk/types"
 
	"fmt"
)
 
func main() {
	config, err := config.LoadConfig()
	if err != nil {
		fmt.Printf("cannot load config:%v", err)
	}
	api, err := sdk.NewSDK(config.ApiURL)
	if err != nil {
		fmt.Printf("cannot create api:%v", err)
	}
	WaitFor := sdk.BlockInclusion
 
	bondAmount := new(big.Int)
	bondAmount.SetString("100000000000000000000", 10)
 
	// Convert big.Int to types.UCompact
	bondAmountUCompact := types.NewUCompact(bondAmount)
	BlockHash, txHash, err := tx.Unbond(api, config.Seed, WaitFor, bondAmountUCompact)
	if err != nil {
		fmt.Printf("cannot submit Transaction:%v", err)
	}
	fmt.Printf("Transaction submitted successfully with block hash: %v\n and ext hash:%v", BlockHash.Hex(), txHash.Hex())
}

Run the code using:


go run main.go

If you receive errors related to missing dependencies while trying to execute your code, run:


go mod tidy

and try again.