Struct Delegation

pub struct Delegation(pub AccountId);

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

impl Delegation

pub fn view_staked_balance( &self, pool: AccountId, ) -> Result<QueryBuilder<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);

pub fn view_unstaked_balance( &self, pool: AccountId, ) -> Result<QueryBuilder<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);

pub fn view_total_balance( &self, pool: AccountId, ) -> Result<QueryBuilder<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);

pub fn view_balance( &self, pool: AccountId, ) -> Result<MultiQueryBuilder<PostprocessHandler<UserStakeBalance, MultiQueryHandler<(CallResultHandler<u128>, CallResultHandler<u128>, CallResultHandler<u128>)>>>, 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);

pub fn is_account_unstaked_balance_available_for_withdrawal( &self, pool: AccountId, ) -> Result<QueryBuilder<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);

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: near_primitives::views::FinalExecutionOutcomeView = Staking::delegation("alice.testnet".parse()?)
    .deposit("pool.testnet".parse()?, NearToken::from_near(1))?
    .with_signer(Signer::new(Signer::from_ledger())?)
    .send_to_testnet()
    .await?;

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: near_primitives::views::FinalExecutionOutcomeView = 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?;

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: near_primitives::views::FinalExecutionOutcomeView = Staking::delegation("alice.testnet".parse()?)
    .stake("pool.testnet".parse()?, NearToken::from_near(1))?
    .with_signer(Signer::new(Signer::from_ledger())?)
    .send_to_testnet()
    .await?;

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?;

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: near_primitives::views::FinalExecutionOutcomeView = Staking::delegation("alice.testnet".parse()?)
    .unstake("pool.testnet".parse()?, NearToken::from_near(1))?
    .with_signer(Signer::new(Signer::from_ledger())?)
    .send_to_testnet()
    .await?;

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: near_primitives::views::FinalExecutionOutcomeView = Staking::delegation("alice.testnet".parse()?)
    .unstake_all("pool.testnet".parse()?)?
    .with_signer(Signer::new(Signer::from_ledger())?)
    .send_to_testnet()
    .await?;

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: near_primitives::views::FinalExecutionOutcomeView = Staking::delegation("alice.testnet".parse()?)
    .withdraw("pool.testnet".parse()?, NearToken::from_near(1))?
    .with_signer(Signer::new(Signer::from_ledger())?)
    .send_to_testnet()
    .await?;

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: near_primitives::views::FinalExecutionOutcomeView = Staking::delegation("alice.testnet".parse()?)
    .withdraw_all("pool.testnet".parse()?)?
    .with_signer(Signer::new(Signer::from_ledger())?)
    .send_to_testnet()
    .await?;

Trait Implementations

impl Clone for Delegation

fn clone(&self) -> Delegation

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Delegation

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.