---
id: delegation
title: Token Delegation
sidebar_label: Token Delegation
sidebar_position: 3
---

---

## Overview

This page will describe the mechanics of participating in delegation.

At a high level, anyone can delegate their tokens to a staking pool which is run by a validator. This is usually just called "Staking". This is possible even if your tokens are in a lockup contract (as most tokens are during the network's early release). Delegating to a staking pool allows you to receive some staking rewards (which will activate as part of the Phase II rollout and depend on the exact fees charged by the validator) and to participate in protocol governance by adding weight to the vote of the validator whose pool you have delegated to.

You can participate in delegation by using a website (GUI), using the `view` and `call` methods of the command-line interface (CLI) or via sending RPC calls directly. These are described below.

Reminder: If you haven't already, evaluate your token custody options from [this documentation page](token-custody.md).

### Viewing and Choosing Validators

Currently, the staking pool contracts ([code](https://github.com/near/core-contracts/tree/master/staking-pool)) allow validators to select what fee they will charge on rewards earned by pools they run. In the future, updated versions of the staking pool contracts may include more parameters (which is one of the nice features enabled by NEAR's contract-based delegation).

Several community-run lists of validators list who they are, how much stake they have, what their vote was [for the Phase II transition](https://near.org/blog/mainnet-phase-i/) and more. These can be helpful for selecting where to delegate your tokens. As always, do your own diligence.

| Operator           | URL (to copy and paste)                                                                                    |
| ------------------ | ---------------------------------------------------------------------------------------------------------- |
| NEAR Explorer      | [https://explorer.near.org/nodes/validators](https://explorer.near.org/nodes/validators)                   |
| DokiaCapital       | [https://staking.dokia.cloud/staking/near/validators](https://staking.dokia.cloud/staking/near/validators) |
| Stardust NEAR Pool | [https://near-staking.com/](https://near-staking.com)                                                      |
| YOUR OPERATOR      | ADD YOUR LINK HERE                                                                                         |

## GUI-based delegation (via a website or app)

Disclaimer: the list below is community-maintained, and is not an endorsement by NEAR to use any of them. Do your own research before staking your funds with them!

| Provider       | URL (to copy and paste)                                            | Added on                |
| -------------- | ------------------------------------------------------------------ | ----------------------- |
| NEAR Wallet    | [https://help.mynearwallet.com/en/articles/44-how-to-recover-your-mynearwallet-account](https://help.mynearwallet.com/en/articles/44-how-to-recover-your-mynearwallet-account)                 | Oct 11 2020             |
| DokiaCapital   | [https://staking.dokia.cloud](https://staking.dokia.cloud)         | Sept 11 2020            |
| Moonlet Wallet | [https://moonlet.io/near-staking](https://moonlet.io/near-staking) | 15 Oct 2020             |
| add here       | your link                                                          | first come, first serve |

## CLI-based delegation

Disclaimer: the documentation below refers to the Github repository [Core Contracts](https://github.com/near/core-contracts/). Always check the source of the smart contract before delegating your funds to it!

You can use `near-cli` with NEAR Core Contracts to delegation via:

1. Lockup Contract
2. Staking Pool

Before starting, make sure you are running the latest version of [near-cli](https://github.com/near/near-cli), you are familiar with [gas fees](https://docs.near.org/concepts/basics/transactions/gas) and you are sending transactions to the correct NEAR network. By default `near-cli` is configured to work with TestNet. You can change the network to MainNet by issuing the command

```bash
export NODE_ENV=mainnet
```

It will also be helpful to set some variables, which we will use in commands below. On Linux/macOS/Unix:

```
export ACCOUNT_ID=#your account id
export LOCKUP_ID=#your lockup contract address
export POOL_ID=#your staking pool
```

If you're using Windows, you can replace all the `export` commands with `set`:

```
set ACCOUNT_ID=#your account id
```

You can check that you set these correctly with `echo`:

```
echo $ACCOUNT_ID
```

Note that when you set variables with `export` you do not prefix them with the dollar sign, but when you use them elsewhere such as with `echo`, you need the dollar sign.

If you're using a secondary account on a Ledger Nano device, you will also want to create an HD\_PATH variable. For example:

```
export HD_PATH="44'/397'/0'/0'/2'"
```

The default HD path for the NEAR app on Ledger devices is `44'/397'/0'/0'/1'`. See more info on using `near-cli` with Ledger [here](token-custody.md#option-1-ledger-via-cli).

> **Heads up**
>
> Signing a transaction with the wrong Ledger key can help associating multiple accounts of a user, since even failed transactions are recorded to the blockchain and can be subsequently analyzed.

## 1. Lockup Contracts Delegation

The [Lockup Contract](https://github.com/near/core-contracts/tree/master/lockup) is common among NEAR contributors and, essentially, anyone who didn't acquire tokens through an exchange. This contract acts as an escrow that locks and holds an owner's tokens for a lockup period (such as vesting). You can learn more about lockups and their implementation in the [this documentation page](lockups.md).

The owner may want to stake these tokens (including locked ones) to help secure the network and also earn staking rewards that are distributed to the validator. The lockup contract doesn't allow to directly stake from its account, so the owner delegates the tokens using the contract built-in functions.

> **heads up**
>
> The commands below are tested with [build 877e2db](https://github.com/near/core-contracts/tree/877e2db699a02b81fc46f5034642a2ebd06d9f19) of the Core Contracts.
>
> They also use formatting only available on Linux/macOS/Unix. If you are using Windows, you will need to replace dollar variables, `$LOCKUP_ID`, with percent variables, `%LOCKUP_ID%`. And you will need to use all double quotes, so things like `'{"account_id": "'$ACCOUNT_ID'"}'` become `"{\"account_id\": \"%ACCOUNT_ID%\"}\"`.

Before proceeding with the tutorial below, check that you have control of your lockup contract, by issuing the command

```bash
near view $LOCKUP_ID get_owner_account_id ''
```

You should expect a result like:

```
$ near view meerkat.stakewars.testnet get_owner_account_id ''
View call: meerkat.stakewars.testnet.get_owner_account_id()
'meerkat.testnet'
```

Note that this example us using `NEAR_ENV=testnet` with `$LOCKUP_ID` set to `meerkat.stakewars.testnet` and `ACCOUNT_ID` set to `meerkat.testnet`, which matches the returned result above.

You can stake with Lockup contracts in three steps:

1. Set up the staking pool
2. Deposit and stake the tokens
3. Measure the rewards

### a. Set the staking pool

Lockup contracts can stake **to one staking pool at a time**, so this parameter can be changed only while no funds are staked.

You can select the staking pool by calling the method `select_staking_pool` from the lockup contract:

```bash
near call $LOCKUP_ID select_staking_pool '{
  "staking_pool_account_id": "'$POOL_ID'"
}' --accountId $ACCOUNT_ID
```

If using a Ledger:

```bash
near call $LOCKUP_ID select_staking_pool '{
  "staking_pool_account_id": "'$POOL_ID'"
}' --accountId $ACCOUNT_ID --useLedgerKey $HD_PATH
```

You should expect a result like:

```
Scheduling a call: meerkat.stakewars.testnet.select_staking_pool({"staking_pool_account_id": "zpool.pool.f863973.m0"})
Receipts: HEATt32tHqWdjkZoSxLhd43CYVBCUp1cFHexgWBEeKJg, EUP7tncJfKDPpKYdunx2qySZ6JmV3injBigyFBiuD96J, 99hdXWmaTQE7gR5vucxMWFNMw7ZLtzJ6WNMSVJHPGJxh
    Log [meerkat.stakewars.testnet]: Selecting staking pool @zpool.pool.f863973.m0. Going to check whitelist first.
Transaction Id 4Z2t1SeN2rdbJcPvfVGScpwyuGGKobZjT3eqvDu28sBk
To see the transaction in the transaction explorer, please open this url in your browser
https://explorer.testnet.near.org/transactions/4Z2t1SeN2rdbJcPvfVGScpwyuGGKobZjT3eqvDu28sBk
true
```

The `true` statement means that your call was successful, and the lockup contract accepted the `$POOL_ID` parameter.

### b. Deposit and stake the tokens

Lockup contracts can stake their balance, regardless of their vesting schedule. You can proceed in two steps:

1. check the lockup balance
2. stake the balance
3. To know how many tokens you can stake, use the view method `get_balance`:

```
near view $LOCKUP_ID get_balance ''
```

You should expect a result like:

```
$ near view meerkat.stakewars.testnet get_balance ''
View call: meerkat.stakewars.testnet.get_balance()
'100000499656128234500000000'
```

Where the resulting balance (in [yocto](https://www.nist.gov/pml/weights-and-measures/metric-si-prefixes)NEAR) is `100000499656128234500000000` or 100 $NEAR.

> **heads up**
>
> You have to leave 35 $NEAR in the lockup contract for the storage fees. If you have 100 tokens, you can stake up to 65 tokens. If you have 1000 tokens, you can stake up to 965 tokens.
>
> You may want to `npm i -g near-units` to easily convert yoctoNEAR amounts to human-readable representations, and to go from human-typeable numbers to yoctoNEAR. Examples:
>
> ```bash
> near-units -h 100000499656128234500000000 yN
> near-units 965 N
> ```
>
> On Linux/macOS/Unix, you can also use this directly in the following commands:
>
> ```bash
> near call $LOCKUP_ID deposit_and_stake '{
>   "amount": "'$(near-units 965N)'"
> }' --accountId $ACCOUNT_ID --gas $(near-units 200Tgas)
> ```

You may want to set your desired amount-to-stake to a variable:

```
export AMOUNT=# your desired amount to stake
```

To stake the balance, use the call method `deposit_and_stake`:

```bash
near call $LOCKUP_ID deposit_and_stake '{
  "amount": "'$AMOUNT'"
}' --accountId $ACCOUNT_ID --gas 200000000000000
```

If using a Ledger:

```bash
near call $LOCKUP_ID deposit_and_stake '{
  "amount": "'$AMOUNT'"
}' --accountId $ACCOUNT_ID --gas 200000000000000 --useLedgerKey $HD_PATH 
```

> **Heads up**
>
> This sets the gas parameter to 200000000000000 [gas units](https://docs.near.org/concepts/basics/transactions/gas), or 200 Tgas (Teragas), as the near-cli default allocation of 30Tgas is too low.

You should expect a result like:

```
Scheduling a call: meerkat.stakewars.testnet.deposit_and_stake({"amount": "65000000000000000000000000"})
Receipts: BFJxgYMbPLpKy4jae3b5ZJfLuAmpcYCBG2oJniDgh1PA, 9sZSqdLvPXPzpRg9VLwaWjJaBUnXm42ntVCEK1UwmYTp, CMLdB4So6ZYPif8qq2s7zFvKw599HMBVcBfQg85AKNQm
    Log [meerkat.stakewars.testnet]: Depositing and staking 65000000000000000000000000 to the staking pool @zpool.pool.f863973.m0
Receipts: 3VpzWTG9Y2nbZmuJhmsub9bRLnwHCFtnW5NQqcMBWawF, 4BrEKDPmz3mAhnq5tTFYRQp8y9uRxGFwYffJFkPMdQ5P, HJPqqJDTajFfeEA8vFXTLDpxh4PYZCMJ2YLKpWVtwSMF
    Log [meerkat.stakewars.testnet]: Epoch 105: Contract received total rewards of 20383576173536987339742291104 tokens. New total staked balance is 104251712242552700026473040909. Total number of shares 77295581098329153455984430997
    Log [meerkat.stakewars.testnet]: Total rewards fee is 1511304065231935217653387665 stake shares.
    Log [meerkat.stakewars.testnet]: @meerkat.stakewars.testnet deposited 65000000000000000000000000. New unstaked balance is 65000000000000000000000000
    Log [meerkat.stakewars.testnet]: @meerkat.stakewars.testnet staking 64999999999999999999999999. Received 48193095953206307331949682 new staking shares. Total 1 unstaked balance and 48193095953206307331949682 staking shares
    Log [meerkat.stakewars.testnet]: Contract total staked balance is 104316712242552700026473040909. Total number of shares 77343774194282359763316380679
Receipt: FsJLXXEa8Jp8UNyiyG3XQhyHHSWzZ2bCjgWr8kPVjGmG
    Log [meerkat.stakewars.testnet]: The deposit and stake of 65000000000000000000000000 to @zpool.pool.f863973.m0 succeeded
Transaction Id AW9pFb5RjkCjsyu8ng56XVvckvd3drPBPtnqVo6bJhqh
To see the transaction in the transaction explorer, please open this url in your browser
https://explorer.testnet.near.org/transactions/AW9pFb5RjkCjsyu8ng56XVvckvd3drPBPtnqVo6bJhqh
true
```

The `true` statement at the end means the transaction was successful.

### c. Measure the rewards

Since NEAR automatically re-stakes all staking pool rewards, you have to update your staked balance to know the amount of tokens you earned with your validator.

Use the call method `refresh_staking_pool_balance` to check your new balance:

```bash
near call $LOCKUP_ID refresh_staking_pool_balance '' \
  --accountId $ACCOUNT_ID
```

If using a Ledger:

```bash
near call $LOCKUP_ID refresh_staking_pool_balance '' \
  --accountId $ACCOUNT_ID --useLedgerKey $HD_PATH
```

You should expect a result like:

```
$ near call $LOCKUP_ID refresh_staking_pool_balance '' \
  --accountId $ACCOUNT_ID | grep "current total balance"
    Log [meerkat.stakewars.testnet]: The current total balance on the staking pool is 65000000000000000000000000
```

Note that in this example, the result is piped to [grep](https://www.tutorialspoint.com/unix\_commands/grep.htm) (`| grep "current total balance"`) to display only the relevant output.

Please refer to the [Lockup Contract readme](https://github.com/near/core-contracts/tree/master/lockup) if you need to know how to withdraw the staking rewards to your main wallet.

## Unstake and withdraw your lockup tokens

NEAR Protocol automatically re-stakes all the rewards back to the staking pools, so your staked balance increases over time, accruing rewards.

Before starting, it's highly recommended to read the [Lockup contracts documentation](lockups.md) to understand which portion of the tokens is liquid, and which one is still _locked_ even after the three epochs.

If you want to withdraw funds, you have to issue two separate commands:

1. Manually unstake tokens from the staking pool, and wait three epochs
2. Manually withdraw tokens back to your main account

Both these command require the amount in yoctoNEAR, which is the smallest unit of account for NEAR tokens. You can use the table below for the conversion, or install [near-units](https://www.npmjs.com/package/near-units) (`npm i -g near-units`) and use commands like `near-units 1,000N`:

| NEAR     | YoctoNEAR | YoctoNEAR                       |
| -------- | --------- | ------------------------------- |
| `1`      | `1*10^24` | `1000000000000000000000000`     |
| `10`     | `1*10^25` | `10000000000000000000000000`    |
| `100`    | `1*10^26` | `100000000000000000000000000`   |
| `1,000`  | `1*10^27` | `1000000000000000000000000000`  |
| `10,000` | `1*10^28` | `10000000000000000000000000000` |

As an example, if you want to unstake `10` NEAR tokens from the staking pool, you have to call the method `unstake` with `10000000000000000000000000` (`1*10^24`, 10 power 24, or 10 with 24 zeros) as an argument.

### a. Unstake the tokens

Before unstaking any tokens, use the the view method `get_account` introduced above to know what is the available balance:

```
near view $POOL_ID get_account '{"account_id": "'$LOCKUP_ID'"}'
```

You should expect a result like:

```
$ near view zpool.pool.f863973.m0 get_account '{"account_id": "meerkat.stakewars.testnet"}'
View call: zpool.pool.f863973.m0.get_account({"account_id": "meerkat.stakewars.testnet"})
{
  account_id: 'meerkat.stakewars.testnet',
  unstaked_balance: '5',
  staked_balance: '86236099167204810592552675',
  can_withdraw: false
}
```

The result of this method shows:

* An unstaked balance of `5` _yocto_
* A staked balance of `86236099167204810592552675` _yocto_, or `86.23` $NEAR
* `can_withdraw` is `false` (see below)

> **Check your rewards**
>
> From the examples above, the initial stake of 65 NEAR tokens increased to 86.23 tokens, with 21.23 tokens as a reward!

You can unstake an amount of funds that is equal or lower than your `staked_balance`, by calling the metod `unstake`. You may first want to set the amount you want to unstake to a variable `AMOUNT`:

```bash
export AMOUNT=# amount to unstake
```

Check that it looks correct:

```bash
echo $AMOUNT
```

And maybe also using `near-units`:

```bash
near-units -h $AMOUNT yN
```

And now unstake:

```bash
near call $LOCKUP_ID unstake '{
  "amount": "'$AMOUNT'"
}' --accountId $ACCOUNT_ID --gas 200000000000000
```

Or with a Ledger:

```bash
near call $LOCKUP_ID unstake '{
  "amount": "'$AMOUNT'"
}' --accountId $ACCOUNT_ID --gas 200000000000000 --useLedgerKey $HD_PATH
```

You should expect a result like:

```
Scheduling a call: meerkat.stakewars.testnet.unstake({"amount": "42000000000000000000000000"})
Waiting for confirmation on Ledger...
Using public key: ed25519:5JgsX9jWUTS5ttHeTjuDFgCmB5YX77f7GHxuQfaGVsyj
Waiting for confirmation on Ledger...
Ledger app version: 1.1.3
Receipts: D5fCCWa5b5N8X9VtxsbRvGhSSCQc56Jb312DEbG4YY8Z, 72rgHrMb1zkUU2RiEz2EMCAuMWFgRJTf8eovwAUkuo31, A2dvSgxpDXfNZUrDVdpewk1orVTVxCMiicjk7qyNq3dW
    Log [meerkat.stakewars.testnet]: Unstaking 42000000000000000000000000 from the staking pool @zpool.pool.f863973.m0
Receipts: 9MbLXn28nQyL6BopMEUggBD9NA1QfVio9VB3LTNJ6P5b, 5g7F6HehoGZ2DHS7w54xHAjAeHCsHaAsKpVed76MFYru, BKbtF77i1WEqpuFLtEjWerM2LVZW1md9ecQ5UcBpMNXj
    Log [meerkat.stakewars.testnet]: Epoch 162: Contract received total rewards of 9488161121527521670023204339 tokens. New total staked balance is 142388816229749953331375665038. Total number of shares 79574075700231185032355056920
    Log [meerkat.stakewars.testnet]: Total rewards fee is 530246455678218748147822292 stake shares.
    Log [meerkat.stakewars.testnet]: @meerkat.stakewars.testnet unstaking 42000000000000000000000001. Spent 23471725293488513736732361 staking shares. Total 42000000000000000000000002 unstaked balance and 24721370659717793595217321 staking shares
    Log [meerkat.stakewars.testnet]: Contract total staked balance is 142346816229749953331375665038. Total number of shares 79550603974937696518618324559
Receipt: 3DXSx8aMvhwtJUB6mhTueNbDiqz5wYu3xzzYkZrgjw1u
    Log [meerkat.stakewars.testnet]: Unstaking of 42000000000000000000000000 at @zpool.pool.f863973.m0 succeeded
Transaction Id 2rRpdN8AAoySfWsgE7BRtRfz7VFnyFzRhssfaL87rXGf
To see the transaction in the transaction explorer, please open this url in your browser
https://explorer.testnet.near.org/transactions/2rRpdN8AAoySfWsgE7BRtRfz7VFnyFzRhssfaL87rXGf
true
```

The `true` statement at the end means the transaction was successful.

**Wait three epochs, or \~36 hours before using the withdraw command**

For security reasons, NEAR Protocol keeps your unstaked funds locked for three more epochs (\~36 hours). Use again the view method `get_account` to verify if `can_withdraw` is `true`:

```
near view $POOL_ID get_account '{"account_id": "'$LOCKUP_ID'"}'
```

The result should be as follows:

```
View call: zpool.pool.f863973.m0.get_account({"account_id": "meerkat.stakewars.testnet"})
{
  account_id: 'meerkat.stakewars.testnet',
  unstaked_balance: '42000000000000000000000006',
  staked_balance: '44244760537191121230392104',
  can_withdraw: true
}
```

Note that the variable `can_withdraw` is `true`. This means that the `unstaked_balance` of `42000000000000000000000000` yoctoNEAR (42 NEAR tokens) is now available for withdraw.

### b. Withdraw the tokens

Funds can be withdrawn after three epochs (\~36 hours) from the `unstake` command. It is highly recommended to read the [Lockup contracts documentation](lockups.md) to understand which portion of the unstaked tokens is available for transfers, and which is still vesting and unavailable (even after three epochs).

Use the call method `withdraw_all_from_staking_pool`:

```bash
near call $LOCKUP_ID withdraw_all_from_staking_pool '' --accountId $ACCOUNT_ID --gas 200000000000000
```

Or if using a Ledger:

```bash
near call $LOCKUP_ID withdraw_all_from_staking_pool '' --accountId $ACCOUNT_ID --gas 200000000000000 --useLedgerKey $HD_PATH
```

You should expect a result like this one:

```
Scheduling a call: meerkat.stakewars.testnet.withdraw_all_from_staking_pool()
Waiting for confirmation on Ledger...
Using public key: ed25519:5JgsX9jWUTS5ttHeTjuDFgCmB5YX77f7GHxuQfaGVsyj
Waiting for confirmation on Ledger...
Ledger app version: 1.1.3
Receipts: 6dt3HNDrb7jM4F7cRtwgRSfRMWwFmE8BHeZSDghrpQtw, 7pNKTevct7Z4birAPec81LmnSpJSeJXbFq3cBdjFvsnM, A7yJXdaGcFyiBNQimFtHF479Jm6xiXHvfodTbtFf7Rww
    Log [meerkat.stakewars.testnet]: Going to query the unstaked balance at the staking pool @zpool.pool.f863973.m0
Receipts: 2ytgB57D6CJe3vkxdVTiVAytygpTteR4sDmpUNxo5Ltk, CZChcT1uDDxqojnZQq6r7zzx6FE3Z6E5fZ3F23Y1dnyM, GjrWhJgbCAAHUNyvw4QX5YKFpeUVNJ9GpuEdmUXFozeG
    Log [meerkat.stakewars.testnet]: Withdrawing 42000000000000000000000006 from the staking pool @zpool.pool.f863973.m0
Receipts: 9nHoqnQygqKYyyR5KDofkYy5KiJxbu2eymoGUUc2tSR3, 5RvBSb4BuHxRhc5U6nLgsCjAvJ88hJ2jwkr1ramk37mE, 5PDN1EYXnCJrTSU7zzJtmAuj9vvGSVurh94nvfHDHXpa, GTTGm4sXcSWD2gnohMJzD7TQcQxuSe7AFABZKqxPLgau
    Log [meerkat.stakewars.testnet]: Epoch 168: Contract received total rewards of 514182787298700000000 tokens. New total staked balance is 142377784876419564057032272059. Total number of shares 79552334320822393318832070510
    Log [meerkat.stakewars.testnet]: Total rewards fee is 28729510739826825657 stake shares.
    Log [meerkat.stakewars.testnet]: @meerkat.stakewars.testnet withdrawing 42000000000000000000000006. New unstaked balance is 0
Receipt: rS5KjvzkbaxEH7aG8VXyd9EEEfY7PygdLzSZ3W9qf3w
    Log [meerkat.stakewars.testnet]: The withdrawal of 42000000000000000000000006 from @zpool.pool.f863973.m0 succeeded
Transaction Id EjNpoU7BNfEQujckL8JiAP8kYDH1SMLw4wC32tL3uyaH
To see the transaction in the transaction explorer, please open this url in your browser
https://explorer.testnet.near.org/transactions/EjNpoU7BNfEQujckL8JiAP8kYDH1SMLw4wC32tL3uyaH
true
```

The `true` statement confirms the successful withdrawal.

By using again the view method:

```bash
near view $POOL_ID get_account '{"account_id": "'$LOCKUP_ID'"}'
```

The result should be as follows:

```
View call: zpool.pool.f863973.m0.get_account({"account_id": "meerkat.stakewars.testnet"})
{
  account_id: 'meerkat.stakewars.testnet',
  unstaked_balance: '0',
  staked_balance: '44244760947075774431066852',
  can_withdraw: true
}
```

At this point the `unstaked_balance` is `0`, and the funds are back in the lockup contract balance.

> **Heads up**
>
> Lockup contracts allow you to transfer only the unlocked portion of your funds. In the example above, out of the 42 NEAR unstaked, only 21.23 can be transferred to another wallet or exchange.

### c. Change staking pools

To change from one staking pool to another, you must first withdraw all deposits in the currently selected staking pool. Then call `unselect_staking_pool` as follows ([docs](https://github.com/near/core-contracts/blob/215d4ed2edb563c47edd961555106b74275c4274/lockup/README.md)):

```bash
near call $LOCKUP_ID unselect_staking_pool --accountId $ACCOUNT_ID --gas 300000000000000
```

Or if using Ledger:

```bash
near call $LOCKUP_ID unselect_staking_pool --accountId $ACCOUNT_ID --useLedgerKey $HD_PATH --gas 300000000000000
```

## Staking Pool Delegation

Any funds that are not stored inside lockup contracts can be directly delegated to a [staking pool](https://github.com/near/core-contracts/tree/master/staking-pool) by using the call method `deposit_and_stake`:

```bash
near call $POOL_ID deposit_and_stake '' --accountId $ACCOUNT_ID --amount 100
```

Or if using Ledger:

```bash
near call $POOL_ID deposit_and_stake '' --accountId $ACCOUNT_ID --useLedgerKey $HD_PATH --amount 100
```

You should expect a result like:

```
Scheduling a call: valeraverim.pool.f863973.m0.deposit_and_stake() with attached 100 NEAR
Receipts: FEfNuuCSttu7m4dKQPUSgpSFJSB86i6T2sYJWSv7PHPJ, GPYhZsyUuJgvr7gefxac4566DVQcyGs4wSFeydkmRX7D, 8hfcJuwsstnFQ1cgU5iUigvfrq1JcbaKURvKf5shaB4g
    Log [valeraverim.pool.f863973.m0]: Epoch 106: Contract received total rewards of 545371217890000000000 tokens. New total staked balance is 75030000959768421358700000000. Total number of shares 75029067713856889417103116457
    Log [valeraverim.pool.f863973.m0]: Total rewards fee is 54536443439735902364 stake shares.
    Log [valeraverim.pool.f863973.m0]: @meerkat.testnet deposited 100000000000000000000000000. New unstaked balance is 100000000000000000000000000
    Log [valeraverim.pool.f863973.m0]: @meerkat.testnet staking 99999999999999999999999999. Received 99998756169666008195607157 new staking shares. Total 1 unstaked balance and 99998756169666008195607157 staking shares
    Log [valeraverim.pool.f863973.m0]: Contract total staked balance is 75130000959768421358700000000. Total number of shares 75129066470026555425298723614
Transaction Id FDtzMmusJgFbryeVrdQyNvp6XU2xr11tecgqnnSsvyxv
To see the transaction in the transaction explorer, please open this url in your browser
https://explorer.testnet.near.org/transactions/FDtzMmusJgFbryeVrdQyNvp6XU2xr11tecgqnnSsvyxv
''
```

The empty string at the end, `''`, means the call was successful.

If you want to check your staking rewards, use the view method `get_account`:

```bash
near view $POOL_ID get_account '{"account_id": "'$ACCOUNT_ID'"}'
```

You should expect a result like:

```
View call: valeraverim.pool.f863973.m0.get_account({"account_id": "meerkat.testnet"})
{
  account_id: 'meerkat.testnet',
  unstaked_balance: '1',
  staked_balance: '100663740438210643632989745',
  can_withdraw: true
}
```

The staked balance in this example is `100663740438210643632989745`, or `100.66` $NEAR (reminder: you can easily convert these using `near-units -h 100663740438210643632989745yN`).

A pool's rewards only compound if it has been "pinged", which means either having a direct action performed on it (like someone delegating or undelegating) or if the `ping` method is called on it once within a particular epoch. This is important to do if you run a pool and want your delegators to see updated reward balances.

Use the call method `ping` to re-calculate the rewards up to the previous epoch:

```bash
near call $POOL_ID ping '{}' --accountId $ACCOUNT_ID
```

Or if using a Ledger:

```bash
near call $POOL_ID ping '{}' --accountId $ACCOUNT_ID --useLedgerKey $HD_PATH
```

You should expect a result like:

```
Scheduling a call: valeraverim.pool.f863973.m0.ping({})
Transaction Id 4mTrz1hDBMTWZx251tX4M5CAo5j7LaxLiPtQrDvQgcZ9
To see the transaction in the transaction explorer, please open this url in your browser
https://explorer.testnet.near.org/transactions/4mTrz1hDBMTWZx251tX4M5CAo5j7LaxLiPtQrDvQgcZ9
''
```

The `''` result means that your call was successful, and the `get_account` view method will provide updated results.

Note that you can ping any pool, not just one you own.

## Additional links

* [Lockup contracts explained](lockups.md)
* [NEAR Core Contracts on Github](https://github.com/near/core-contracts)
* [NEAR block explorer](https://explorer.near.org)
* [near-cli on Github](https://github.com/near/near-cli)

## Fun Facts

1.  `ping`ing a pool technically removes 2 epochs of future compounding but it's an extremely small amount -- without considering compounding effect of epochs with 9 hour epochs, the reward per epoch is 5% / (365 \* 24 / 9) + 1 or 1.00005136986

    It means this reward on top of reward is what you’re losing, so that's about 1.00000000264 or 0.000000264%... meaning for 10M stake it’s 0.02638862826 NEAR per epoch.

> Got a question?
>
> Ask it on [StackOverflow!](https://stackoverflow.com/questions/tagged/nearprotocol)
