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 /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.

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 /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

Go to the vesting section in Bellydash or directly to:

http://your-domain/vesting.html

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:

1. Contract verification: Verifies that the vesting smart contract exists in the network (address: 0x7199D184EE85d738bB347e0B1d53544007C5d7fC)
2. Retrieve Vesting ID: Calls the recipientVestings(address, 0) function on the contract to check if the given address has an assigned vesting
3. Retrieve details: If vesting exists, calls the getVestingInfo(vestingId) function to retrieve all details
4. 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

Why is wrap/unwrap safe?

✅ Wrap/Unwrap Security:

• 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'.

---