Add-ons - Tools

In this section you'll find additional tools available in Bellydash:

📦 Snapshot (Fast Synchronization)

Download a blockchain snapshot file to quickly synchronize your Redbelly Network node. This guide will walk you through the process step by step.

ℹ️ Information

This guide assumes a scenario where you're starting a node from scratch. You already have a server meeting the minimum requirements for Redbelly Network nodes and have completed the necessary steps described in the Node setup and onboarding section of the official documentation. After completing the installation process, your node starts synchronizing from block 0.

How to use snapshot?

To speed up the node synchronization process, you can use a snapshot. Follow these steps:

Step 1: Stop the node

First, stop the Redbelly node service:

sudo systemctl stop redbelly.service

Verify that the service has been stopped:

sudo systemctl status redbelly.service

Step 2: Backup the nodekey file

⚠️ Warning: Backup the nodekey file!

The file /opt/redbelly/rbn/database/nodekey contains your node's unique identity. Applying a snapshot will overwrite the entire /opt/redbelly/rbn/database directory, which means your nodekey will be lost if you don't create a backup.

Before applying a snapshot, always backup the nodekey to preserve node identity:
sudo cp -p /opt/redbelly/rbn/database/nodekey /opt/redbelly/rbn/nodekey.backup
Important: After extracting the snapshot, you must restore the nodekey file before starting redbelly.service to preserve node identity.

Step 3: Remove the old database directory

Before extracting the snapshot, you must remove the old database directory:

sudo rm -rf /opt/redbelly/rbn/database

This step ensures that the snapshot will be extracted to a clean directory without conflicts with old database files.

Step 4: Download and extract the snapshot

You can download and extract the snapshot using one of two methods:

Option 1: Quick (one-liner)

This option downloads and extracts the snapshot in one step, but does not verify the checksum. It's recommended to use this option only when you're sure of connection stability.

wget -O - https://redbelly-snapshot.mynode.uk/latest.tar | sudo tar -x -C /opt/redbelly/rbn

You can simultaneously set appropriate permissions in case of UID/GID changes:

wget -O - https://redbelly-snapshot.mynode.uk/latest.tar \
  | sudo tar -x -C /opt/redbelly/rbn && \
sudo chown -R rbnuser:rbnuser /opt/redbelly/rbn && \
sudo chmod -R 700 /opt/redbelly/rbn

Option 2: Secure (recommended)

This option provides file integrity verification before extraction. It is slower than the quick one‑liner because the system must read the entire snapshot file to compute its SHA‑256 checksum before extraction. The duration depends mainly on the file size and your disk performance. Additionally, after the checksum is verified, the archive still needs to be extracted as a separate step, while the quick method performs extraction on‑the‑fly during download.

Download the snapshot file and checksum:

wget https://redbelly-snapshot.mynode.uk/latest.tar -O /tmp/latest.tar
wget https://redbelly-snapshot.mynode.uk/latest.sha256 -O /tmp/latest.sha256

Verify file integrity:

cd /tmp
sha256sum -c latest.sha256

Expected result: latest.tar: OK

⚠️ Note

If checksum verification fails, do not extract the file. Download the snapshot again.

Extract the snapshot directly to the /opt/redbelly/rbn directory:

sudo tar -xf latest.tar -C /opt/redbelly/rbn

The extraction process may take some time depending on snapshot size and disk speed.

After downloading and extracting the snapshot (using either option), set correct permissions:

sudo chown -R rbnuser:rbnuser /opt/redbelly/rbn && \
sudo chmod -R 700 /opt/redbelly/rbn

Step 5: Restore the nodekey file

After extracting the snapshot, restore the saved nodekey file to preserve node identity:

sudo cp -p /opt/redbelly/rbn/nodekey.backup /opt/redbelly/rbn/database/nodekey

Step 6: Start the node

Start the node service again:

sudo systemctl start redbelly.service

Check if the service started successfully:

sudo systemctl status redbelly.service

Step 7: Verify synchronization

Monitor your node to ensure it's synchronizing correctly:

sudo tail -f /var/log/redbelly/rbn_logs/rbbc_logs.log

Your node should start from the snapshot block height and continue synchronizing from there. Synchronization should be much faster than starting from genesis.

✅ Success

Your node should now synchronize much faster, starting from the snapshot block height instead of synchronizing from genesis. Monitor the logs to ensure everything is working correctly.

Additional Information

What is a snapshot?

A blockchain snapshot is a compressed archive containing the complete blockchain state at a specific block height. It contains all account balances, contract states, and other blockchain data up to that point.

Instead of downloading and processing all blocks from genesis (block 0), you can use a snapshot to quickly update your node. This significantly shortens the time required for initial synchronization.

When to use snapshots?

Snapshots are particularly useful in the following scenarios:

Setting up a new node: Quickly synchronize a new node without waiting hours or days
Resetting a node: After problems or corruption, start fresh from a known good state
Testing and development: Quickly reset test environments to a specific state

Snapshot Updates

Snapshots are regularly updated to provide the latest starting point. Always use the latest snapshot for best results. The snapshot date and block height are usually included in the filename or metadata.

ℹ️ Note

Currently, snapshots are limited to updates every Sunday at midnight UTC to minimize operational costs.

💰 Checking and (optionally) Claiming Vesting

ℹ️ Information

We recommend using TokenOps, the official tool for monitoring and claiming bonuses for node operators: https://app.tokenops.xyz/

In the past, operators reported problems accessing the site, and not everyone is familiar with direct contract interaction from block explorers to custom scripts run in the terminal. This was the idea behind creating these tools.

Bellydash offers a tool for checking available token vesting and claiming them. This feature allows secure management of rewards from your Redbelly Network node.

What is vesting?

Vesting is a mechanism for gradual token unlocking. Instead of receiving all tokens at once, they are released over time according to a schedule defined in the smart contract. You receive tokens in the form of wRBNT (wrapped RBNT), which you can then convert to RBNT.

How to check available vesting?

The vesting check process is simple and secure:

Step 1: Open the vesting page

Find the icon on the dashboard and click it to open the vesting page.

Step 2: Enter wallet address

In the "Wallet address" field, enter the Ethereum address (0x...) of your reward wallet from the Redbelly node. This is the address configured in your node as the reward recipient.

Step 3: Click "Check"

After clicking the "Check" button, the system will query the official vesting smart contract via RPC proxy to the Redbelly Network. This is a read-only operation – it doesn't require wallet connection or transaction signing.

How does checking work?

The system performs the following steps:

Contract verification: Verifies that the vesting smart contract exists in the network (address: 0x7199D184EE85d738bB347e0B1d53544007C5d7fC)
Retrieve Vesting ID: Calls the recipientVestings(address, 0) function on the contract to check if the given address has an assigned vesting
Retrieve details: If vesting exists, calls the getVestingInfo(vestingId) function to retrieve all details
Calculate available tokens: The system calculates how many tokens are currently available to claim based on:
- Vesting start date
- Vesting end date
- Cliff release timestamp (the moment from which tokens become available)
- Already claimed tokens
- Current time

Check Results

✅ If the address has vesting:

You'll see a table with the following information:

Vesting ID – Unique identifier of your vesting
Recipient – Recipient address (your wallet address)
Start – Vesting start date
End – Vesting end date
Linear vest amount – Total token amount in vesting
Already claimed – Already claimed tokens
Rate – Daily vesting rate (how many tokens are released per day)
Currently claimable – Currently available wRBNT tokens to claim

❌ If the address does NOT have vesting:

You'll see a message:

It looks like the address is not in the recipient list.

This means the address is not on the list.

Make sure you're using the correct reward wallet associated with your Redbelly node.

Familiarize yourself with 'Impact of node jailing on vesting schedule' and 'Impact of tombstoning on vesting schedule'.

Official Vesting Smart Contract

All operations are performed on the official Redbelly Network vesting smart contract:

Contract Address: 0x7199D184EE85d738bB347e0B1d53544007C5d7fC
Block Explorer: View contract on Routescan

Why is this safe?

Read-only: The "Check" operation performs only blockchain reads. It doesn't require wallet connection or transaction signing. There's no possibility of losing funds.
Official contract: All queries are directed to the official smart contract deployed by the Redbelly Network team. The contract address is hardcoded in the application and cannot be changed.
Contract verification: Before each operation, the system verifies that the contract exists in the network by calling eth_getCode.
Direct connection: Queries are sent directly to the Redbelly Network via RPC proxy, without intermediaries.

💵 Claiming Tokens (Claim)

Note Claiming tokens (claim) is only an option. You can check available vesting without needing to claim tokens.

If you have tokens available to claim, you'll see a "Claim X wRBNT" button in the results section. Claiming tokens requires wallet connection and transaction signing.

Claiming Process:

1. Click the "Claim" button

After clicking the button, a modal will open requesting wallet connection. Important: You must connect the wallet that corresponds to the vesting address (recipient address).

2. Connect wallet

Click "Connect Wallet" and select your wallet (MetaMask, Rabby, etc.). Accept the connection in your wallet.

3. Network verification

The system will automatically check if you're connected to the Redbelly Network (Chain ID: 151). If not, you'll be prompted to switch networks in your wallet.

4. Address verification

Critical security: The system verifies that the connected wallet corresponds to the vesting recipient address. If addresses don't match, the transaction cannot even be initiated – the system will display an error message before the possibility of signing the transaction.

5. Sign transaction

After successful verification, click "Claim Now". You'll see a "Sign Transaction" ✍️ screen with the following security tips:

⚠️ Before approving, verify the transaction details in your wallet:

Your address should appear as sender (from) – Make sure the address displayed in the wallet as sender is your reward wallet address.

Recipient (to) should be the official Redbelly vesting contract – The contract address is always the same and never changes. The official vesting contract address is: 0x7199D184EE85d738bB347e0B1d53544007C5d7fC

If any address displayed in the wallet is different, cancel the transaction – Do not sign the transaction if the sender (from) or recipient (to) address differs from the expected one.

⚠️ Remember: After signing the transaction in your wallet, it cannot be canceled or stopped. The transaction will be sent to the network and processed. Make sure all data is correct before signing.

6. Waiting for confirmation

After signing the transaction, you'll see information that the transaction is being processed. This usually takes a few seconds. After confirmation, you'll receive a success notification along with a link to the transaction in the block explorer.

Why is claiming safe?

✅ Claiming Security

Address verification: The system checks if the connected wallet corresponds to the address authorized to claim tokens. You cannot claim tokens to a different address.

Network verification: Transactions can only be executed on the Redbelly Network (Chain ID: 151). There's no possibility of executing transactions on other networks.

Official contract: The transaction is sent directly to the official vesting smart contract. The contract address is hardcoded and cannot be changed.

Signing in wallet: All transactions are signed exclusively in your wallet. The application doesn't have access to your private keys.

Direct distribution: After successful claiming, tokens are sent directly from the contract to your wallet. They don't pass through any intermediate accounts.

No other operations possible: The vesting contract only supports the claim() function. There's no possibility of performing other operations, such as transfer, approve, etc.

🔄 wRBNT vs RBNT – Wrap and Unwrap

ℹ️ Information

Using wrap/unwrap functions in Bellydash is completely optional. We recommend primarily using officially supported DEXes and Redbelly ecosystem tools, as they are the main place for token exchange.

The wrap/unwrap function was added solely as a convenience for operators looking for a quick and direct way to convert tokens. It's not a mechanism replacing exchanges nor a trading tool, just a simple and safe way to exchange RBNT ↔ wRBNT if needed.

Tokens received from vesting are in the form of wRBNT (wrapped RBNT), not RBNT. wRBNT is an ERC-20 token wrapped version of the native RBNT token that can be transferred to other chains (e.g., Ethereum).

How to convert wRBNT to RBNT (Unwrap)?

Use the Wrap/Unwrap button if it's available to you, which allows token conversion.

Enter the amount of wRBNT you want to convert to RBNT. The system will automatically display exactly the same amount of RBNT (the exchange rate is always 1:1).

Click the "Unwrap" button to start the conversion process. You'll be asked to sign a transaction in your wallet.

Sign the transaction in your wallet. After confirmation, wRBNT will be converted to RBNT and you'll receive native RBNT tokens.

ℹ️ How does unwrap work?

The unwrap process calls the withdraw(amount) function on the official wRBNT smart contract. The contract:

Decreases your wRBNT balance stored in its storage by the specified amount

Sends an equivalent amount of native RBNT directly to your wallet

The exchange rate is always 1 wRBNT = 1 RBNT.

How to convert RBNT to wRBNT (Wrap)?

Use the Wrap/Unwrap button if it's available to you, which allows token conversion.

Enter the amount of RBNT you want to convert to wRBNT. The system will automatically display exactly the same amount of wRBNT (the exchange rate is always 1:1).

Click the "Wrap" button to start the conversion process. You'll be asked to sign a transaction in your wallet.

Sign the transaction in your wallet. After confirmation, RBNT will be converted to wRBNT and you'll receive wRBNT tokens.

ℹ️ How does wrap work?

The wrap process calls the deposit() function on the official wRBNT smart contract. The contract:

Receives the native RBNT sent in the transaction

Increases your wRBNT balance in its storage by an equivalent amount

Thanks to this, you see a new amount of wRBNT in your wallet

This works exactly like WETH on Ethereum.
The exchange rate is always 1 RBNT = 1 wRBNT.

Official wRBNT Smart Contract

All wrap/unwrap operations are performed on the official wRBNT smart contract:

wRBNT Contract Address: 0x6ed1F491e2d31536D6561f6bdB2AdC8F092a6076
Block Explorer: View contract on Routescan

Wrap/Unwrap Security

✅ Why is wrap/unwrap safe?

Official contract: All operations are performed on the official wRBNT smart contract. The contract address is hardcoded in the application and cannot be changed.

Network verification: Operations can only be performed on the Redbelly Network (Chain ID: 151). There's no possibility of executing transactions on other networks.

Direct exchange: Tokens are exchanged directly from the contract. They don't pass through any intermediate accounts nor are stored in the application.

Exact amount: The contract processes exactly the amount you enter. It doesn't modify the amount nor charge additional fees.

Signing in wallet: All transactions are signed exclusively in your wallet. The application doesn't have access to your private keys or tokens.

Limited functions: The Bellydash tool uses only deposit() (wrap) and withdraw() (unwrap). There's no possibility of performing other operations through this tool, such as transfer, approve, swap to other tokens, etc.

Security Summary

🛡️ All vesting operations are safe because

Vesting checking performs only reads, doesn't require wallet or signing

Claiming requires address and network verification before executing the transaction

Wrap/unwrap works only with the official wRBNT contract on the Redbelly Network

All transactions are signed exclusively in your wallet

There's no possibility of performing other operations beyond claim, wrap, and unwrap

Tokens are sent directly from contracts to your wallet

Contract addresses are hardcoded and cannot be changed

Frequently Asked Questions

Why do I receive wRBNT instead of RBNT?

Vesting pays out tokens in the form of wRBNT because it's an ERC-20 standard token. This allows smart contracts to manage balances predictably, unlock funds, and perform vesting operations.

Native RBNT doesn't have an ERC-20 interface, so the vesting contract uses wRBNT to ensure full compatibility and security. You can convert wRBNT to RBNT at any time through the unwrap function (1:1 rate).

Can I claim only part of the tokens?

No. The vesting contract provides only one claim operation, claim all available tokens. Partial claiming is not supported by this contract.

Can I use other blockchains?

No. Vesting, claiming, and wrap/unwrap work exclusively on the Redbelly Network (Chain ID: 151).

Can I perform other operations with tokens?

Within Bellydash tools, only the following operations are available:

claim (vesting claim),
wrap (RBNT → wRBNT),
unwrap (wRBNT → RBNT).

If you want to perform other operations on tokens (e.g., transfer, swap), you can do so:

directly in your wallet, or
using other ecosystem applications.

What if my address doesn't have vesting?

Make sure you're using the correct reward wallet associated with your Redbelly node.

Familiarize yourself with 'Impact of node jailing on vesting schedule' and 'Impact of tombstoning on vesting schedule'.

Automated Node Configuration Scripts

If you prefer not to manually edit system files and want the configuration done automatically by prepared scripts, you can use the quick setup path below.
Note: These scripts require administrator privileges and make changes to your node configuration and firewall — use them at your own responsibility.

⚠️ Important Notice — Read Before Running the Scripts

The scripts below automate system‑level configuration. They modify service files, restart your node, and update firewall rules.

Before running anything, read each script line‑by‑line.
Make sure you understand what it does and confirm that the actions match your environment.

If you are unsure about any part of a script, you can simply copy its contents and paste it into a trusted AI assistant (such as ChatGPT or Copilot) to get an explanation of what each command does. This is a safe way to verify the logic before executing anything on your server.

These scripts are intended for users who are comfortable with system-level changes and accept full responsibility for the modifications performed.

Execution Order:

setup-monitoring.sh
check-node-health.sh
(optional) diagnose.sh

1. setup-monitoring.sh — Automated Node Configuration

This script automatically performs the following tasks:

Creates a backup of the redbelly.service file
Modifies the ExecStart section and adds parameters:
- --statusserver.addr=0.0.0.0
- --statusserver.port=6539
- --prometheus.addr=127.0.0.1
Reloads systemd
Restarts the node
Opens port 6539 in the firewall (or restricts it to a specified IP)

Prerequisites:

Root or sudo access
The redbelly.service must be installed
Required tools: curl, netstat (from net-tools package), bc (will be installed automatically if missing)

📖 Review the script code before running:

View script on GitHub

Download and run directly on your VPS:

# Download the script from GitHub
curl -O https://raw.githubusercontent.com/U00A3/bellydashDocs/main/static/scripts/setup-monitoring.sh

# Make it executable
chmod +x setup-monitoring.sh

# Run with sudo
sudo bash setup-monitoring.sh

What the script does:

Checks for required tools and installs them if missing
Locates the redbelly.service file in standard systemd locations
Creates a timestamped backup in /tmp/mynode-backup-YYYYMMDD-HHMMSS/
Checks if monitoring is already configured (prompts for confirmation if found)
Adds monitoring parameters to the service file
Reloads systemd daemon
Configures firewall (supports UFW, firewalld, and iptables)
Restarts the service and verifies it's running
Tests the monitoring endpoint locally

Backup location: The script creates a backup before making any changes. If you need to restore:

sudo cp /tmp/mynode-backup-YYYYMMDD-HHMMSS/redbelly.service /etc/systemd/system/redbelly.service
sudo systemctl daemon-reload
sudo systemctl restart redbelly.service

2. check-node-health.sh — Quick Health Check

This script performs a quick health check of your node:

Verifies if the node service is active
Checks if the status server responds locally
Verifies if port 6539 is open and listening
Tests the /status endpoint for correct data
Checks if Prometheus /metrics endpoint is working
Displays node information (current block, sync status, balance)
Checks system resources (RAM, disk usage)
Analyzes recent logs for errors

📖 Review the script code before running:

View script on GitHub

Download and run directly on your VPS:

# Download the script from GitHub
curl -O https://raw.githubusercontent.com/U00A3/bellydashDocs/main/static/scripts/check-node-health.sh

# Make it executable
chmod +x check-node-health.sh

# Run the health check
bash check-node-health.sh

What the script checks:

Service Status: Verifies redbelly.service is active and running
Port Status: Checks if port 6539 is listening (uses ss or netstat)
API Response: Tests local connection to /status endpoint
Node Information: Displays:
- Current block height
- Synchronization status (synchronized or synchronizing)
- Node balance (in RBNT)
- Balance status (sufficient, low, or too low)
System Resources:
- RAM usage percentage
- Disk usage percentage
Log Analysis: Checks for recent errors in:
- Service logs (journalctl)
- Application logs (/var/log/redbelly/rbn_logs/rbbc_logs.log)

Output: The script provides a color-coded summary:

✅ Green: Everything is working correctly
⚠️ Yellow: Warning or needs attention
❌ Red: Error detected

At the end, it displays:

Node health summary
Monitoring dashboard URL (https://mynode.uk)
Next steps for monitoring
Useful commands for troubleshooting

3. diagnose.sh — Comprehensive Diagnostics (Optional)

This script performs a comprehensive diagnostic analysis of your node:

System information (OS, kernel, uptime, resources)
Service status and configuration
Network status and port checks
Firewall configuration analysis
Node API testing with detailed information
Performance metrics (CPU, memory, disk, load average)
Log analysis (service and application logs)
Generates recommendations for fixing issues
Creates a detailed diagnostic report

📖 Review the script code before running:

View script on GitHub

Download and run directly on your VPS:

# Download the script from GitHub
curl -O https://raw.githubusercontent.com/U00A3/bellydashDocs/main/static/scripts/diagnose.sh

# Make it executable
chmod +x diagnose.sh

# Run diagnostics
bash diagnose.sh

What the script analyzes:

System Information:
- Hostname, OS version, kernel
- System uptime
- CPU cores, RAM, disk space
Service Status:
- Whether service is enabled and active
- Service uptime
- Recent errors if service failed
Service Configuration:
- Location of service file
- Verification of monitoring parameters:
  - statusserver.addr
  - statusserver.port
  - prometheus.addr
Network Status:
- Port 6539 listening status
- Process using the port
- Other Redbelly ports
- Local connection tests to /status and /metrics endpoints
Firewall Configuration:
- UFW status and rules
- firewalld status and rules
- iptables rules
- Provides fix commands if port is blocked
Node API Test:
- Detailed node information:
  - Current block
  - Synchronization status
  - Signing address
  - Balance (in RBNT)
  - Network governor count
- Balance status assessment
Performance Metrics:
- CPU usage
- Memory usage
- Disk usage
- Load average
- Redbelly process resource usage
Log Analysis:
- Recent errors in service logs
- Recent warnings in service logs
- Application log errors
- Log file size
Recommendations:
- Action items based on detected issues
- Specific commands to fix problems
Diagnostic Report:
- Saves a comprehensive report to /tmp/mynode-diagnostic-YYYYMMDD-HHMMSS.log
- Includes all system information, logs, and status
- Can be shared for support purposes

Diagnostic Report: The script automatically generates a detailed diagnostic report saved to:

/tmp/mynode-diagnostic-YYYYMMDD-HHMMSS.log

This report includes:

System information
Service status
Network configuration
Recent logs
Disk and memory usage

You can share this file when requesting support.

Quick Start Guide

For first-time setup:

# Step 1: Download all scripts from GitHub
curl -O https://raw.githubusercontent.com/U00A3/bellydashDocs/main/static/scripts/setup-monitoring.sh
curl -O https://raw.githubusercontent.com/U00A3/bellydashDocs/main/static/scripts/check-node-health.sh
curl -O https://raw.githubusercontent.com/U00A3/bellydashDocs/main/static/scripts/diagnose.sh

# Make scripts executable
chmod +x setup-monitoring.sh check-node-health.sh diagnose.sh

# Step 2: Configure monitoring
sudo bash setup-monitoring.sh

# Step 3: Verify everything is working
bash check-node-health.sh

If you encounter issues:

# Run comprehensive diagnostics
bash diagnose.sh

# Check the diagnostic report
cat /tmp/mynode-diagnostic-*.log

Regular maintenance:

# Quick health check
bash check-node-health.sh

Troubleshooting

Script requires sudo but I don't have it:

setup-monitoring.sh requires root privileges to modify system files
Contact your system administrator or use manual configuration

Service file not found:

Ensure redbelly.service is installed
Check: systemctl list-unit-files | grep redbelly
Verify service file exists in standard locations

Port 6539 not opening:

Check firewall configuration manually
Verify service is running: systemctl status redbelly.service
Check logs: journalctl -u redbelly.service -n 20

Monitoring not responding after setup:

Run check-node-health.sh for quick diagnosis
Run diagnose.sh for comprehensive analysis
Check service logs: journalctl -u redbelly.service -f

Need to restore from backup:

# Find your backup directory
ls -la /tmp/mynode-backup-*

# Restore the service file
sudo cp /tmp/mynode-backup-YYYYMMDD-HHMMSS/redbelly.service /etc/systemd/system/redbelly.service

# Reload and restart
sudo systemctl daemon-reload
sudo systemctl restart redbelly.service

Security Notes

Scripts require administrator privileges — review the code before running
Backups are created automatically before any modifications
Firewall rules are configured to allow external access to port 6539
Monitoring endpoint is accessible on 0.0.0.0:6539 (all interfaces)
Prometheus metrics are restricted to 127.0.0.1 (localhost only)

Additional Resources

Monitoring Dashboard: https://mynode.uk
Service Logs: journalctl -u redbelly.service -f
Application Logs: tail -f /var/log/redbelly/rbn_logs/rbbc_logs.log
Service Status: systemctl status redbelly.service
Quick Health Check: bash check-node-health.sh
Full Diagnostics: bash diagnose.sh

📦 Snapshot (Fast Synchronization)​

How to use snapshot?​

Step 1: Stop the node​

Step 2: Backup the nodekey file​

Step 3: Remove the old database directory​

Step 4: Download and extract the snapshot​

Step 5: Restore the nodekey file​

Step 6: Start the node​

Step 7: Verify synchronization​

Additional Information​

💰 Checking and (optionally) Claiming Vesting​

What is vesting?​

How to check available vesting?​

Step 1: Open the vesting page​

Step 2: Enter wallet address​

Step 3: Click "Check"​

How does checking work?​

Check Results​

Official Vesting Smart Contract​

Why is this safe?​

💵 Claiming Tokens (Claim)​

Claiming Process:​

Why is claiming safe?​

🔄 wRBNT vs RBNT – Wrap and Unwrap​

How to convert wRBNT to RBNT (Unwrap)?​

How to convert RBNT to wRBNT (Wrap)?​

Official wRBNT Smart Contract​

Wrap/Unwrap Security​

Security Summary​

Frequently Asked Questions​

Automated Node Configuration Scripts​

Execution Order:​

1. setup-monitoring.sh — Automated Node Configuration​

2. check-node-health.sh — Quick Health Check​

3. diagnose.sh — Comprehensive Diagnostics (Optional)​

Quick Start Guide​

Troubleshooting​

Security Notes​

Additional Resources​

📦 Snapshot (Fast Synchronization)

How to use snapshot?

Step 1: Stop the node

Step 2: Backup the nodekey file

Step 3: Remove the old database directory

Step 4: Download and extract the snapshot

Step 5: Restore the nodekey file

Step 6: Start the node

Step 7: Verify synchronization

Additional Information

💰 Checking and (optionally) Claiming Vesting

What is vesting?

How to check available vesting?

Step 1: Open the vesting page

Step 2: Enter wallet address

Step 3: Click "Check"

How does checking work?

Check Results

Official Vesting Smart Contract

Why is this safe?

💵 Claiming Tokens (Claim)

Claiming Process:

Why is claiming safe?

🔄 wRBNT vs RBNT – Wrap and Unwrap

How to convert wRBNT to RBNT (Unwrap)?

How to convert RBNT to wRBNT (Wrap)?

Official wRBNT Smart Contract

Wrap/Unwrap Security

Security Summary

Frequently Asked Questions

Automated Node Configuration Scripts

Execution Order:

1. setup-monitoring.sh — Automated Node Configuration

2. check-node-health.sh — Quick Health Check

3. diagnose.sh — Comprehensive Diagnostics (Optional)

Quick Start Guide

Troubleshooting

Security Notes

Additional Resources