Struct Delegation

Source

pub struct Delegation(pub AccountId);

Expand description

A wrapper struct that simplifies interactions with the Staking Pool standard on behalf of the account.

Delegation is a wrapper that provides the functionality to manage user account stake in the staking pool.

Tuple Fields§

§0: AccountId

Implementations§

Source §

impl Delegation

Source

pub const fn account_id(&self) -> &AccountId

Returns the underlying account ID for this delegation.

§Example

use near_api::*;

let delegation = Staking::delegation("alice.testnet".parse()?);
let account_id = delegation.account_id();
println!("Account ID: {}", account_id);

Source

pub fn as_account(&self) -> Account

Converts this delegation to an Account for account-related operations.

§Example

use near_api::*;

let delegation = Staking::delegation("alice.testnet".parse()?);
let account = delegation.as_account();
let account_info = account.view().fetch_from_testnet().await?;
println!("Account balance: {}", account_info.data.amount);

Source

pub fn view_staked_balance( &self, pool: AccountId, ) -> Result<RequestBuilder<PostprocessHandler<NearToken, CallResultHandler<u128>>>, BuilderError>

Prepares a new contract query (get_account_staked_balance) for fetching the staked balance (NearToken) of the account on the staking pool.

The call depends that the contract implements StakingPool

§Example

use near_api::*;

let balance = Staking::delegation("alice.testnet".parse()?)
    .view_staked_balance("pool.testnet".parse()?)?
    .fetch_from_testnet()
    .await?;
println!("Staked balance: {:?}", balance);

Source

pub fn view_unstaked_balance( &self, pool: AccountId, ) -> Result<RequestBuilder<PostprocessHandler<NearToken, CallResultHandler<u128>>>, BuilderError>

Prepares a new contract query (get_account_unstaked_balance) for fetching the unstaked(free, not used for staking) balance (NearToken) of the account on the staking pool.

The call depends that the contract implements StakingPool

§Example

use near_api::*;

let balance = Staking::delegation("alice.testnet".parse()?)
    .view_unstaked_balance("pool.testnet".parse()?)?
    .fetch_from_testnet()
    .await?;
println!("Unstaked balance: {:?}", balance);

Source

pub fn view_total_balance( &self, pool: AccountId, ) -> Result<RequestBuilder<PostprocessHandler<NearToken, CallResultHandler<u128>>>, BuilderError>

Prepares a new contract query (get_account_total_balance) for fetching the total balance (NearToken) of the account (free + staked) on the staking pool.

The call depends that the contract implements StakingPool

§Example

use near_api::*;

let balance = Staking::delegation("alice.testnet".parse()?)
    .view_total_balance("pool.testnet".parse()?)?
    .fetch_from_testnet()
    .await?;
println!("Total balance: {:?}", balance);

Source

pub fn view_balance( &self, pool: AccountId, ) -> Result<MultiRequestBuilder<PostprocessHandler<UserStakeBalance, MultiQueryHandler<(CallResultHandler<NearToken>, CallResultHandler<NearToken>, CallResultHandler<NearToken>)>>>, BuilderError>

Returns a full information about the staked balance (UserStakeBalance) of the account on the staking pool.

This is a complex query that requires 3 calls (get_account_staked_balance, get_account_unstaked_balance, get_account_total_balance) to the staking pool contract. The call depends that the contract implements StakingPool

§Example

use near_api::*;

let balance = Staking::delegation("alice.testnet".parse()?)
    .view_balance("pool.testnet".parse()?)?
    .fetch_from_testnet()
    .await?;
println!("Balance: {:?}", balance);

Source

pub fn is_account_unstaked_balance_available_for_withdrawal( &self, pool: AccountId, ) -> Result<RequestBuilder<CallResultHandler<bool>>, BuilderError>

Prepares a new contract query (is_account_unstaked_balance_available) for checking if the unstaked balance of the account is available for withdrawal.

Some pools configures minimum withdrawal period in epochs, so the balance is not available for withdrawal immediately.

The call depends that the contract implements StakingPool

§Example

use near_api::*;

let is_available = Staking::delegation("alice.testnet".parse()?)
    .is_account_unstaked_balance_available_for_withdrawal("pool.testnet".parse()?)?
    .fetch_from_testnet()
    .await?;
println!("Is available: {:?}", is_available);

Source

pub fn deposit( &self, pool: AccountId, amount: NearToken, ) -> Result<ConstructTransaction, BuilderError>

Prepares a new transaction contract call (deposit) for depositing funds into the staking pool. Please note that your deposit is not staked, and it will be allocated as unstaked (free) balance.

Please note that this call will deposit your account tokens into the contract, so you will not be able to use them for other purposes.

The call depends that the contract implements StakingPool

§Example

use near_api::*;

let result = Staking::delegation("alice.testnet".parse()?)
    .deposit("pool.testnet".parse()?, NearToken::from_near(1))?
    .with_signer(Signer::new(Signer::from_ledger())?)
    .send_to_testnet()
    .await?;

Source

pub fn deposit_and_stake( &self, pool: AccountId, amount: NearToken, ) -> Result<ConstructTransaction, BuilderError>

Prepares a new transaction contract call (deposit_and_stake) for depositing funds into the staking pool and staking them.

Please note that this call will deposit your account tokens into the contract, so you will not be able to use them for other purposes. Also, after you have staked your funds, if you decide to withdraw them, you might need to wait for the two lockup period to end.

Mandatory lockup before able to unstake
Optional lockup before able to withdraw (depends on the pool configuration)

The call depends that the contract implements StakingPool

§Example

use near_api::*;

let result = Staking::delegation("alice.testnet".parse()?)
    .deposit_and_stake("pool.testnet".parse()?, NearToken::from_near(1))?
    .with_signer(Signer::new(Signer::from_ledger())?)
    .send_to_testnet()
    .await?;

Source

pub fn stake( &self, pool: AccountId, amount: NearToken, ) -> Result<ConstructTransaction, BuilderError>

Prepares a new transaction contract call (stake) for staking funds into the staking pool.

Please note that this call will use your unstaked balance. This means that you have to have enough balance already deposited into the contract. This won’t use your native account tokens, but just reallocate your balance inside the contract. Please also be aware that once you have staked your funds, you might not be able to withdraw them until the lockup periods end.

Mandatory lockup before able to unstake
Optional lockup before able to withdraw (depends on the pool configuration)

The call depends that the contract implements StakingPool

§Example

use near_api::*;

let result = Staking::delegation("alice.testnet".parse()?)
    .stake("pool.testnet".parse()?, NearToken::from_near(1))?
    .with_signer(Signer::new(Signer::from_ledger())?)
    .send_to_testnet()
    .await?;

Source

pub fn stake_all( &self, pool: AccountId, ) -> Result<ConstructTransaction, BuilderError>

Prepares a new transaction contract call (stake_all) for staking all available unstaked balance into the staking pool.

Please note that once you have staked your funds, you might not be able to withdraw them until the lockup periods end.

Mandatory lockup before able to unstake
Optional lockup before able to withdraw (depends on the pool configuration)

The call depends that the contract implements StakingPool

§Example

use near_api::*;

Staking::delegation("alice.testnet".parse()?)
    .stake_all("pool.testnet".parse()?)?
    .with_signer(Signer::new(Signer::from_ledger())?)
    .send_to_testnet()
    .await?;

Source

pub fn unstake( &self, pool: AccountId, amount: NearToken, ) -> Result<ConstructTransaction, BuilderError>

Prepares a new transaction contract call (unstake) for unstaking funds and returning them to your unstaked balance.

The contract will check if the minimum epoch height condition is met.

The call depends that the contract implements StakingPool

§Example

use near_api::*;

let result = Staking::delegation("alice.testnet".parse()?)
    .unstake("pool.testnet".parse()?, NearToken::from_near(1))?
    .with_signer(Signer::new(Signer::from_ledger())?)
    .send_to_testnet()
    .await?;

Source

pub fn unstake_all( &self, pool: AccountId, ) -> Result<ConstructTransaction, BuilderError>

Prepares a new transaction contract call (unstake_all) for unstaking all available staked balance and returning them to your unstaked balance.

The contract will check if the minimum epoch height condition is met.

The call depends that the contract implements StakingPool

§Example

use near_api::*;

let result = Staking::delegation("alice.testnet".parse()?)
    .unstake_all("pool.testnet".parse()?)?
    .with_signer(Signer::new(Signer::from_ledger())?)
    .send_to_testnet()
    .await?;

Source

pub fn withdraw( &self, pool: AccountId, amount: NearToken, ) -> Result<ConstructTransaction, BuilderError>

Prepares a new transaction contract call (withdraw) for withdrawing funds from the staking pool into your account.

Some pools configures minimum withdrawal period in epochs, so the balance is not available for withdrawal immediately.

The call depends that the contract implements StakingPool

§Example

use near_api::*;

let result = Staking::delegation("alice.testnet".parse()?)
    .withdraw("pool.testnet".parse()?, NearToken::from_near(1))?
    .with_signer(Signer::new(Signer::from_ledger())?)
    .send_to_testnet()
    .await?;

Source

pub fn withdraw_all( &self, pool: AccountId, ) -> Result<ConstructTransaction, BuilderError>

Prepares a new transaction contract call (withdraw_all) for withdrawing all available staked balance from the staking pool into your account.

Some pools configures minimum withdrawal period in epochs, so the balance is not available for withdrawal immediately.

The call depends that the contract implements StakingPool

§Example

use near_api::*;

let result = Staking::delegation("alice.testnet".parse()?)
    .withdraw_all("pool.testnet".parse()?)?
    .with_signer(Signer::new(Signer::from_ledger())?)
    .send_to_testnet()
    .await?;