# Run a validator (https://docs-dmpho5eos-ton-core-docs.vercel.app/llms/ecosystem/nodes/cpp/run-validator/content.md)
This guide explains how to run a validator TON node with MyTonCtrl from scratch.
## Step 1: Prepare environment [#step-1-prepare-environment]
### 1.1 Maintain costs and expenses [#11-maintain-costs-and-expenses]
* 200 TON per month on the validator hot wallet for its operational transactions.
* Validator deposit stake [1 400 000 TON \~ 4 000 000 TON](#step-4-set-optimal-stake-for-validator) to cover both validation rounds.
* 100 TB/month traffic at a peak load.
### 1.2 Minimal hardware requirements [#12-minimal-hardware-requirements]
* 8-core / 16-thread CPU (for example, Intel Xeon E-2388G or equivalent)
* 128 GB RAM
* 2 × 1.92 TB NVMe SSD, each with 250,000+ read IOPS and 83,000+ write IOPS
* 1 Gbit/s network connectivity
* Fixed (static) public IP address
A 1 Gbit/s network connection is recommended to ensure reliable performance during peak load conditions. The average expected bandwidth usage is approximately 100 Mbit/s.
Validators must carefully consider IOPS disk requirements, as insufficient storage performance can severely impact validator stability and overall network health. Prefer faster NVMe drives — validator performance depends heavily on disk speed.
### 1.3 Software requirements [#13-software-requirements]
* Ubuntu 22.04 LTS or 24.04 LTS: check with `cat /etc/os-release`
* Python 3.10 or higher: check with `python3 --version`
* Clang 21.0.0 or higher: check with `clang --version`
```bash
cat /etc/os-release
python3 --version
clang --version
```
If running `clang --version` shows a version of 21 or higher, skip the steps below.
Ubuntu 22.04
Ubuntu 24.04
```bash
sudo apt install lsb-release wget software-properties-common gnupg
wget https://apt.llvm.org/llvm.sh
chmod +x llvm.sh
sudo ./llvm.sh 21 clang
```
```bash
wget -qO- https://apt.llvm.org/llvm-snapshot.gpg.key | sudo tee /etc/apt/trusted.gpg.d/llvm-snapshot.asc
echo "deb [signed-by=/etc/apt/trusted.gpg.d/llvm-snapshot.asc] http://apt.llvm.org/noble/ llvm-toolchain-noble-21 main" | sudo tee /etc/apt/sources.list.d/llvm.list
sudo apt -y update
sudo apt install -y clang-21
```
Update the default `clang` in the system:
```bash
sudo update-alternatives --install /usr/bin/clang clang /usr/bin/clang-21 200
sudo update-alternatives --install /usr/bin/clang++ clang++ /usr/bin/clang++-21 200
```
### 1.4 Port forwarding for validator [#14-port-forwarding-for-validator]
Configure the network on the server according to the following:
* All outgoing connections are allowed.
* A static external IP address.
* [One UDP port open for incoming connections.](#2-4-verify-validators-port)
### 1.5 Follow network announcements [#15-follow-network-announcements]
Subscribe and follow the instructions provided for validators in the following Telegram channels:
| Channel | Network |
| ---------------------------------------------- | ----------- |
| [`@tonstatus`](https://t.me/tonstatus) | TON Mainnet |
| [`@testnetstatus`](https://t.me/testnetstatus) | TON Testnet |
Do not ignore announcements in these channels. Validators that violate the maintenance rules are fined and excluded from the network.
### 1.6 Prepare validator user [#16-prepare-validator-user]
Prepare and log in a user for the validator.
1. Create a non-root user
```bash
# Create a non-root validator user
sudo adduser
sudo usermod -aG sudo
```
2. Switch to it by reconnecting to the server via `ssh`
```bash
#reconnect as the new user
exit
ssh @
```
### 1.7 Benchmark server performance [#17-benchmark-server-performance]
Before installing, verify that the server meets performance requirements. Inadequate disk or network performance is the most common cause of validator instability.
#### Network latency [#network-latency]
Check latency to TON beacon nodes. Expect approximately 50 milliseconds to the nearest beacon and up to 300 milliseconds to the farthest:
```bash
ping beacon-eu-01.toncenter.com -c 6
ping beacon-apac-01.toncenter.com -c 6
```
#### Disk IOPS [#disk-iops]
Install `fio` and run a random read/write benchmark:
```bash
sudo apt install -y fio
fio --randrepeat=1 --ioengine=libaio --max-jobs=16 --direct=1 --gtod_reduce=1 --name=test --bs=4k --iodepth=64 --readwrite=randrw --rwmixread=75 --size=10G --filename=/tmp/bench
rm /tmp/bench
```
Run the benchmark on the same disk where validator data will be stored (`/var/ton-work/`). If `/tmp` is on a different filesystem, replace `/tmp/bench` with a path on the target drive.
Minimum acceptable results:
| Metric | Minimum |
| ------ | ------------------- |
| Read | 250k IOPS, 981 MB/s |
| Write | 83k IOPS, 327 MB/s |
If disk performance is below these thresholds, the validator may fail to keep up with the network. Upgrade storage before proceeding.
#### Network bandwidth [#network-bandwidth]
Verify network throughput with `speedtest-cli`:
```bash
sudo apt install -y speedtest-cli
speedtest-cli
```
Ensure download and upload speeds meet the [1 Gbit/s requirement](#1-2-minimal-hardware-requirements).
### 1.8 Harden server security [#18-harden-server-security]
A compromised validator server puts staked funds at risk. Apply these hardening steps before exposing the server to the network.
#### SSH hardening [#ssh-hardening]
Apply the following SSH configuration changes in `/etc/ssh/sshd_config`:
* Enable key-based authentication and disable password login:
```text
PasswordAuthentication no
PubkeyAuthentication yes
```
* Disable root login:
```text
PermitRootLogin no
```
* Change the default SSH port:
```text
Port
```
`` — a non-default port number (for example, `2222`).
* Restrict SSH access to specific IP addresses using the `Match Address` directive:
```text
Match Address
AllowUsers
```
Restart the SSH service after changes:
```bash
sudo systemctl restart sshd
```
#### Firewall configuration [#firewall-configuration]
Enable the firewall and allow only the SSH port. The validator UDP port is added after installation in [step 2.5](#2-5-check-validators-port).
```bash
sudo ufw allow /tcp
sudo ufw enable
sudo ufw status
```
#### Additional security measures [#additional-security-measures]
* Use a unique, strong password for the root user.
* Set a GRUB bootloader password to prevent unauthorized boot modifications.
* Enable Fail2ban for SSH brute-force protection:
```bash
sudo apt install -y fail2ban
sudo systemctl enable fail2ban
sudo systemctl start fail2ban
```
* Configure two-factor authentication for SSH using `libpam-google-authenticator` or a similar PAM module.
#### Encrypt sensitive directories (optional) [#encrypt-sensitive-directories-optional]
For additional protection, store validator keys and configuration on an encrypted partition. Create an encrypted volume and symlink the [backup directories](#5-5-organize-validator-backup) from it.
After moving directories to the encrypted partition, create symlinks in their original locations so that MyTonCtrl and the validator service continue to function without path changes.
## Step 2: Validator node installation [#step-2-validator-node-installation]
### 2.1 Download validator installer (MyTonCtrl) [#21-download-validator-installer-mytonctrl]
Run:
```shell
wget https://raw.githubusercontent.com/ton-blockchain/mytonctrl/master/scripts/install.sh
```
### 2.2 Run validator installation [#22-run-validator-installation]
Run the validator installation. Installation takes approximately 20 minutes:
Mainnet
Testnet
```shell
sudo bash install.sh -m single-nominator -n mainnet
```
```shell
sudo bash install.sh -m single-nominator -n testnet
```
To reduce synchronization time from hours to minutes, download a pre-built database dump instead of syncing from peers. Check the [dump index](https://dump.ton.org/) for available snapshots.
1. Install `aria2` and `plzip` if not already present:
```bash
sudo apt install -y aria2 plzip
```
2. Stop the validator and MyTonCore services:
```bash
sudo systemctl stop mytoncore.service
sudo systemctl stop validator.service
```
3. Download and extract the dump:
```bash
cd /var/ton-work/
aria2c -x 16 https://dump.ton.org/dumps/latest.tar.lz
mv /var/ton-work/db /var/ton-work/db_old
mkdir /var/ton-work/db
plzip -d -c /var/ton-work/latest.tar.lz | tar -xvf - -C /var/ton-work/db
```
4. Restore configuration and keys from the original database:
```bash
cp /var/ton-work/db_old/config.json /var/ton-work/db/config.json
cp -r /var/ton-work/db_old/keyring /var/ton-work/db/keyring
sudo chown -R validator:validator /var/ton-work/db
```
5. Start the services again:
```bash
sudo systemctl start validator.service
sudo systemctl start mytoncore.service
```
### 2.3 Verify status results [#23-verify-status-results]
Launch MyTonCtrl with the command `mytonctrl`. Then, check synchronization using the `status` command:
```sh
mytonctrl
MyTonCtrl> status
```
Verify that the correct modes are enabled:
```bash
MyTonCtrl> status_modes
```
Expected output should show `validator` and `single-nominator` as enabled, with all other modes disabled.
Initially, the status shows "Local validator initial sync status: downloading blockchain state x", which indicates that the node has started synchronization.
There are also other status messages in the very beginning of the synchronization, such as "starting", "init block seqno", "last key block is x", "downloading all shard states", "mc seqno" - all these statuses are fine.
### 2.4 Verify validator's port [#24-verify-validators-port]
Print `engine.addr` port configuration `config.json` file:
```bash
grep -A5 '"addrs"' -n /var/ton-work/db/config.json | grep '"port"' | head -1
```
### 2.5 Check validator's port [#25-check-validators-port]
Make sure UDP `engine.addr` port is allowed with the following command:
```bash
sudo ufw status
```
If the port is filtered (absent in allowed), open this port:
```bash
sudo ufw allow /udp
```
Then make sure with `sudo ufw status`.
### 2.6 Verify node synchronization [#26-verify-node-synchronization]
Wait until the node is fully synchronized, which takes approximately 3 hours (depending on the network connection). During this process, `Local validator initial sync status` shows the current synchronization phase. Once the displayed value drops below 20, the initial synchronization is complete and `Local validator out of sync` should show ≤ 3 seconds.
Set up [alert bot](/llms/ecosystem/nodes/cpp/integrating-with-prometheus/content.md) to receive a notification when the node is synchronized.
## Step 3: Configure validator [#step-3-configure-validator]
When installing, MyTonCtrl automatically creates a validator wallet. Top up and activate (deploy) this wallet so MyTonCtrl can operate the single nominator pool smart contract with it.
### 3.1 Get validator wallet address [#31-get-validator-wallet-address]
```sh
MyTonCtrl> wl
```
Find the wallet named `validator_wallet_001` and its address.
### 3.2 Back-up validator wallet secret key [#32-back-up-validator-wallet-secret-key]
This private key is required to restore access to the funds stored in the validator wallet. It is not involved in managing rewards or staking.
Make a backup of the validator wallet secret key:
```sh
MyTonCtrl> ew validator_wallet_001
```
Import this secret key with [`iw`](/llms/ecosystem/nodes/cpp/mytonctrl/wallet/content.md) command.
### 3.3 Explore validator wallet [#33-explore-validator-wallet]
Explore validator wallet by address with [Tonviewer](https://tonviewer.com/):
### 3.4 Credit validator wallet [#34-credit-validator-wallet]
Ensure precise handling of operations, carefully verifying the addresses for `single_nominator_pool`, `owner_address`, and `validator_wallet`. Any incorrect deposit processing may result in the permanent and unrecoverable loss of funds.
Credit the validator wallet. Ensure that at least 200 TON per month is available in the validator’s wallet to cover operational fees.
### 3.5 Activate the wallet [#35-activate-the-wallet]
Activate (deploy on-chain) validator wallet, run:
```sh
MyTonCtrl> aw validator_wallet_001
```
That also reflects in Tonviewer; the status will be displayed as `Active`
### 3.6 Create a pool [#36-create-a-pool]
Create a [single nominator pool](https://docs.ton.org/v3/documentation/smart-contracts/contracts-specs/single-nominator-pool) for secure stake management. As the `owner-address`, specify the beneficiary wallet address that will stake the owner's funds and receive rewards.
Use a cold wallet (e.g., Ledger) for the `owner-address` and store its seed phrase securely to keep funds safe. If access to the owner's wallet is lost, access to stake and rewards funds cannot be recovered.
```bash
MyTonCtrl> new_single_pool
```
If a single-nominator pool is already created, import it with:
```bash
MyTonCtrl> import_pool
```
### 3.7 Print pool list [#37-print-pool-list]
Explore pool addresses using `pools_list` command:
```bash
MyTonCtrl> pools_list
```
At the moment, the pool hasn't been deployed yet, and Explorer will display this as `Nonexist` status
### 3.8 Activate pool [#38-activate-pool]
Activate the single pool nominator contract:
```bash
MyTonCtrl> activate_single_pool
```
### 3.9 Verify activated pool [#39-verify-activated-pool]
Make sure the pool becomes activated with `pools_list`:
```bash
MyTonCtrl> pools_list
```
[Blockchain explorer](/llms/ecosystem/explorers/overview/content.md) should also display the now-deployed contract with `Active` status.
After activation, verify the following in a [blockchain explorer](/llms/ecosystem/explorers/overview/content.md):
1. The pool contract code hash matches the [official single nominator pool contract](https://github.com/orbs-network/single-nominator/blob/main/README.md).
2. The owner address stored in the pool matches the address specified during creation.
Skipping these checks may result in funds being sent to an incorrect or malicious contract.
### 3.10 Test deposit to pool [#310-test-deposit-to-pool]
Ensure precise handling of operations, carefully verifying the addresses for `single_nominator_pool`, `owner_address`, and `validator_wallet`. Any incorrect deposit processing may result in the permanent and unrecoverable loss of funds.
Test deposit to stake workflow. Any user can deposit to the pool via a standard direct TON transfer. Credit decent sum around 10 TON:
### 3.11 Test withdrawal from pool [#311-test-withdrawal-from-pool]
Test withdrawal workflow. Only the [owner's cold wallet](#3-6-create-a-pool) can request a withdrawal.
Send a withdrawal request, a message with `w` comment from `owner` wallet to the single nominator pool address:
Insert the single nominator pool address to `SINGLE_NOMINATOR_ADDRESS` and send this message from the owner's wallet.
```js title="Not runnable"
import {
Address,
beginCell,
internal,
storeMessageRelaxed,
toNano,
} from "@ton/core";
async function main() {
const single_nominator_address = Address.parse("SINGLE_NOMINATOR_ADDRESS");
const WITHDRAW_OP = 0x1000;
const amount = 50000;
const messageBody = beginCell()
.storeUint(WITHDRAW_OP, 32)
.storeUint(0, 64)
.storeCoins(amount)
.endCell();
const internalMessage = internal({
to: single_nominator_address,
value: toNano("1"),
bounce: true,
body: messageBody,
});
}
```
Once the deposit is restored (except 1 TON reserve on the single nominator pool) to the owner's wallet, that means validator are set securely and ready for real stake:
## Step 4: Set optimal stake for validator [#step-4-set-optimal-stake-for-validator]
Top up the single nominator pool with the effective validation stake. In the next elections, MyTonCtrl will automatically use this pool for staking. Aim for a stake that places the validator between positions 200 and 250 in the [validator index](https://tonscan.org/validators).
If the pool's balance is sufficient to participate in both rounds `balance > min_stake_amount * 2`, MyTonCtrl will automatically participate in both rounds using `stake = balance / 2`, unless the stake is manually set using the `set stake` command. This behavior differs from using a nominator pool but resembles staking with a validator wallet.
### 4.1 Retrieve stakes for last two cycles [#41-retrieve-stakes-for-last-two-cycles]
Check the current validator stakes on [tonscan.org/validators](https://tonscan.org/validators) and the minimum network stake in the [network config](https://tonviewer.com/config).
Retrieve `min_stake` and `max_stake` from [Validation API](https://elections.toncenter.com/getValidationCycles?return_participants=false\&offset=0\&limit=2) for two last cycles.
For example:
```json title="Not runnable"
"cycle_id" : 1764052744,
"min_stake": 701812111528562, // ~ 701 812 TON
"max_stake": 2008570202020000, // ~ 2 008 570 TON
```
```json title="Not runnable"
"cycle_id" : 1764052745,
"min_stake": 674810775114391, // ~ 674 811 TON
"max_stake": 2024432325343173, // ~ 2 024 432 TON
```
Values retrieved in nanotons, divide this by 109 to get TON units.
### 4.2 Retrieve stakes boundary values [#42-retrieve-stakes-boundary-values]
To cover the approximate expected stake for odd and even cycles, choose the maximum between the two `min_stake` and the maximum between the two `max_stake`.
For example:
```text title="Not runnable"
// largest within 701 812 TON and 674 811 TON
avg_min_stake = 701812
// largest within 2 008 570 TON and 2 024 432 TON
avg_max_stake = 2024432
```
### 4.3 Calculate effective stakes [#43-calculate-effective-stakes]
*Effective* stands for winning elections for both odd and even cycles.
Effective stake for two cycles is a value between the doubled maximum and the minimum average stakes:
```text title="Not runnable"
avg_min_stake * 2 <= effective_stake <= avg_max_stake * 2
```
For example:
```text title="Not runnable"
// twice the average minimum stake
min_expected_effective_stake = 1403624
// twice the average maximum stake
max_expected_effective_stake = 4048864
```
Then, the effective stake is approximately:
```text title="Not runnable"
1403624 TON <= effective_stake <= 4048864 TON
```
### 4.4 Deposit effective stake [#44-deposit-effective-stake]
Ensure precise handling of operations, carefully verifying the addresses for `single_nominator_pool`, `owner_address`, and `validator_wallet`.
Any incorrect deposit processing may result in the permanent and unrecoverable loss of funds.
Deposit effective stake to the single nominator pool address.
### 4.5 Track first cycle progress [#45-track-first-cycle-progress]
In the next election cycle (odd/even), MyTonCtrl will send half of the stake from the single nominator pool. Track this with a [blockchain explorer](/llms/ecosystem/explorers/overview/content.md).
### 4.6 Track second cycle progress [#46-track-second-cycle-progress]
In the next paired election cycle (even/odd), MyTonCtrl will send the second half of the stake from the single nominator pool. Track this with a [blockchain explorer](/llms/ecosystem/explorers/overview/content.md).
### 4.7 Verify entire staking cycle [#47-verify-entire-staking-cycle]
The reward for the odd validation cycle will be returned to the single nominator pool, combined with the stake. Verify this with a blockchain explorer. A few minutes after the reward is accepted, MyTonCtrl initiates a re-stake of this stake, including the reward.
**Legend**
1. Stake for odd cycle.
2. Reward for odd cycle.
3. Reinvestment of the odd cycle stake, including the reward in the next odd cycle.
### 4.8 Switch to daily maintenance [#48-switch-to-daily-maintenance]
Make sure pair stakes are appropriately circulated, then focus on monitoring validator health and updates.
## Step 5: Maintain validator [#step-5-maintain-validator]
### 5.1 Fund the validator hot wallet [#51-fund-the-validator-hot-wallet]
Keep at least 600 TON on the validator hot wallet. This should be enough to cover operational fees for approximately 3 months.
To check the current balance:
```bash
MyTonCtrl> wl
```
### 5.2 Top up the single nominator pool [#52-top-up-the-single-nominator-pool]
Before sending funds to the pool:
* Verify that the pool address is correct and uses the **bounceable** format.
* Confirm that the pool smart contract is still active and not frozen. A pool can become frozen if the entire balance is consumed by storage fees between creation and funding.
* Follow the [test deposit and withdrawal procedure](#3-10-test-deposit-to-pool) before depositing the full stake.
By default, MyTonCtrl splits the pool balance 50/50 between odd and even validation cycles. Ensure the total stake is sufficient to participate in both cycles: `balance > min_stake * 2`.
If the pool does not pick up the deposit automatically, push it manually:
```bash
MyTonCtrl> mg validator_wallet_001 5
```
`` — the bounceable address of the single nominator pool.
### 5.3 Withdraw funds from the pool [#53-withdraw-funds-from-the-pool]
Only the owner wallet can withdraw funds. Follow the [test withdrawal procedure](#3-11-test-withdrawal-from-pool) using the same method.
### 5.4 Follow the TON announcements channel [#54-follow-the-ton-announcements-channel]
Follow the [`@tonstatus`](https://t.me/tonstatus) channel, turn on notifications, and be prepared for urgent updates.
### 5.5 Organize validator backup [#55-organize-validator-backup]
Back up the following paths to an encrypted, off-site location:
* `/var/ton-work/db/config.json`
* `/var/ton-work/db/keyring`
* `/var/ton-work/keys`
* `/usr/local/bin/mytoncore` (includes wallet files such as `validator_wallet_001.pk` and `validator_wallet_001.addr`)
Store backups in an encrypted format in a secure location. Loss of these files means loss of access to the validator and staked funds.
Alternatively, use the built-in MyTonCtrl backup:
```bash
MyTonCtrl> create_backup
```
### 5.6 Set up alerting [#56-set-up-alerting]
Set up alerting in MyTonCtrl to get a notification of critical issues with the validator. For more information, see [MyTonCtrl private alerting bot](/llms/ecosystem/nodes/cpp/mytonctrl/alerting/content.md) or check [MyTonCtrl public alerting bot](https://t.me/validators).
### 5.7 Set up monitoring [#57-set-up-monitoring]
Set up monitoring dashboards for RAM, disk, network, CPU usage, and other metrics.
* For on-chain validator metrics, use the [`ton-validators-metrics` system](https://github.com/the-ton-tech/ton-validators-metrics).
* For system-level metrics, [integrate Prometheus with `node_exporter` with MyTonCtrl](/llms/ecosystem/nodes/cpp/integrating-with-prometheus/content.md).
* For technical assistance, contact [`@mytonctrl_help_bot`](https://t.me/mytonctrl_help_bot).
### 5.8 Monitor the efficiency [#58-monitor-the-efficiency]
Set up dashboards to monitor validators using the APIs provided below.
1. Track penalized validators on each round with [`@tonstatus_notifications`](https://t.me/tonstatus_notifications).
2. Use [Validation API](https://elections.toncenter.com/docs) to obtain information about current and past validation rounds (cycles) - including the timing of rounds, which validators participated, their stakes, and more. Information regarding current and past elections for each validation round is also available.
3. Use this [API](https://toncenter.com/api/qos/index.html#/) to obtain information about the efficiency of validators over time.
This API analyzes data from the catchain to provide an estimate of a validator's efficiency. It serves as an alternative to the `checkloadall` utility.
Unlike `checkloadall`, limited to validation rounds, this API supports any time interval for efficiency analysis.
**Workflow**
1. Check ADNL address of the validator:
```bash
MyTonCtrl> status
```
2. To the API, provide the ADNL address of the validator along with a time interval (`from_ts`, `to_ts`). For accurate results, choose a sufficient interval, such as 18 hours ago to the present moment.
3. Retrieve the result. If the efficiency percentage is below 90%, the validator is malfunctioning.
4. The validator must actively participate in validation and use the same ADNL address throughout the specified time period. For example, if a validator contributes to validation every second round, indicate the intervals during which they participated. Failing to do so may result in an inaccurate underestimate. This requirement applies not only to masterchain validators (with an index \< 100) but also to other validators (with an index > 100).
### 5.9 Learn slashing policy [#59-learn-slashing-policy]
If a validator processes less than 90% of the expected blocks during a validation round, they will be fined 101 TON.
Learn more about the [slashing policy](/llms/v3/documentation/nodes/validation/staking-incentives/content.md).
### 5.10 Maintain validator [#510-maintain-validator]
Stay vigilant on updates, monitor health status, and efficiency stability with dashboards.
## Verify [#verify]
After completing the setup, confirm the validator is operating correctly:
```bash
MyTonCtrl> status
```
Check the following indicators:
| Indicator | Expected value |
| -------------------------------- | --------------------------------------- |
| Local validator out of sync | ≤ 3 seconds |
| Masterchain out of sync | ≤ 3 seconds |
| Validator efficiency | Above 90% |
| Validator index | Visible in status output |
| Validator participation position | Between 200 and 250 for optimal staking |
Validator efficiency may show 0% at the beginning of a cycle until the validator signs its first blocks. This is normal behavior.
Confirm that the validator participates in elections and recovers stakes on time by checking the pool balance in a [blockchain explorer](/llms/ecosystem/explorers/overview/content.md). For greater observability, [set up the monitoring](#5-7-set-up-monitoring) of various validator metrics.
## Troubleshoot common issues [#troubleshoot-common-issues]
### Node is not synchronizing [#node-is-not-synchronizing]
* Verify that the validator UDP port is open: `sudo ufw status`.
* Check network connectivity to beacon nodes: `ping beacon-eu-01.toncenter.com -c 6`.
* Ensure disk IOPS meet minimum requirements. Re-run the [benchmark](#disk-iops).
* Check service logs: `journalctl -u validator -f`.
### Validator efficiency is below 90% [#validator-efficiency-is-below-90]
* Confirm the node is fully synchronized (`Local validator out of sync` ≤ 3 seconds).
* Check disk performance. Slow storage is the most common cause of low efficiency.
* Verify that no other resource-intensive processes compete for CPU or RAM.
* Review hardware against [minimum requirements](#1-2-minimal-hardware-requirements).
### Pool is not participating in elections [#pool-is-not-participating-in-elections]
* Confirm that the pool is activated: `MyTonCtrl> pools_list` should show `Active` status.
* Verify the pool has sufficient balance for at least one cycle: `balance > min_stake`.
* Check that `single-nominator` mode is enabled: `MyTonCtrl> status_modes`.
* Ensure the validator wallet has enough TON for operational fees.
### Stake was not returned after a validation cycle [#stake-was-not-returned-after-a-validation-cycle]
* Wait for the full cycle to complete. Stake recovery is not immediate.
* Check the elector contract status using a [blockchain explorer](/llms/ecosystem/explorers/overview/content.md).
* Contact [`@mytonctrl_help_bot`](https://t.me/mytonctrl_help_bot) if the stake is not returned after the cycle ends.
### Pool contract is frozen [#pool-contract-is-frozen]
A pool contract may freeze if its entire balance is consumed by storage fees. This happens when too much time passes between pool creation and funding. Ensure you fund the pool promptly after activation.
## Support [#support]
Contact technical support [`@mytonctrl_help_bot`](https://t.me/mytonctrl_help_bot). This bot is for validators only and will not assist with questions for regular nodes.