# Configuration ### Node Script Execution Guidelines **Important Notice**: Avoid executing node scripts with root user privileges. This method is unsupported and could lead to unforeseen complications. **Getting Started**: 1. Obtain the latest script versions from Github. 2. Tailor the configurations to align with your local setup. **About the Scripts**: OneFinity offers customized scripts aimed at facilitating the node installation process, compatible with Mainnet, Devnet, and Testnet networks, ensuring a broad range of accessibility. ### **1. Download the** OneFinity **Scripts**[](https://docs.multiversx.com/validators/nodes-scripts/config-scripts#download-the-multiversx-scripts) ``` cd ~ git clone https://github.com/onefinity/of-chain-scripts ``` ### **2. Configure the scripts correctly**[](https://docs.multiversx.com/validators/nodes-scripts/config-scripts#configure-the-scripts-correctly) #### Setting Up Your Node Environment To successfully install, upgrade, and manage your node, you'll need to make certain configurations. These involve defining a specific user account, installation directory, and network environment on your system. Let's break down these terms: * **`CUSTOM_USER`**: The username on your computer that will be used for running the installation and other related processes. * **`CUSTOM_HOME`**: The directory where your node will be installed. * **`ENVIRONMENT`**: Specifies the OneFinity network you intend to connect to. This can be `mainnet`, `testnet`, or `devnet`. Before proceeding, you'll need to update the `variables.cfg` file to include the necessary details, primarily your username. Here's how to find and set it: **Finding Your Username** Your system's username is crucial for the setup. If you're uncertain of your username, you can quickly find it by executing the following command in your terminal: ```shell whoami ``` This command will display your current username. Remember to accurately record this as it will be crucial for the script configurations to function properly, this will be your *CUSTOM\_USER*. **Configuring the Script** After obtaining your username, open `variables.cfg` and update the placeholders (*CUSTOM\_USER*, *CUSTOM\_HOME*, *ENVIRONMENT*) with your actual user information. This is crucial for your node's functionality. To open the `variables.cfg` file in the `nano` editor, use the following command: ```bash nano variables.cfg ``` ``` cd ~/of-chain-scripts/config nano variables.cfg ``` Change the variables `ENVIRONMENT`, `CUSTOM_HOME` and `CUSTOM_USER` as highlighted in the image below:
To save and exit in **vi** or **vim**: Press `Shift`+`Z` twice.
In **nano**: Press `Ctrl`+`X`, then `Y`, and
### **Grants** elevated **privileges**
To enable `sudo` commands for your user without requiring a password, follow these steps:
1. Open Terminal.
2. Type `sudo visudo -f /etc/sudoers.d/myOverrides` and press Enter. This will allow you to edit the sudoers file securely.
3. Once the file is open in the editor, navigate to the end by pressing `Shift + G`.
4. Press `o` to start a new line. Then, enter the following line, replacing `yourusername` with your actual username (you can find your username by running `whoami`):
```
yourusername ALL=(ALL) NOPASSWD:ALL
```
5. To save and exit, press `Esc`, then `Shift + ZZ` (hold down `Shift` and press `Z` twice).
This configuration will enable your user to execute `sudo` commands without prompting for a password. Ensure you replace `yourusername` with the correct username. Proceed with caution, as this operation grants elevated privileges.
# Installation
To install the OneFinity Network validator node on your local machine, follow these steps. First, ensure you have configured user permissions, script settings, and keys. The Validator script, which you'll use to manage your node, supports Mainnet, Devnet, and Testnet.
### Install Your Node(s)
Run the following commands:
```
cd ~/of-chain-scripts
./script.sh
```
Upon completing the previous step, a menu will appear offering several options. Choose option `1` to proceed with the installation of the node.
```
1) install
2) observing_squad
3) upgrade
4) upgrade_squad
5) upgrade_proxy
6) remove_db
7) start
8) stop
9) cleanup
10) github_pull
11) add_nodes
12) get_logs
13) benchmark
14) quit
Please select an action:1
```
{% hint style="info" %}
NOTE
Alternatively, you can trigger the installation by running this command:
```bash
~/of-chain-scripts/script.sh install
```
{% endhint %}
* Indicate the number of nodes you want to run, i.e. `1`
* Indicate the name of your validator, i.e. `OneVal`
* Exit without starting (we need keys first) by using `14 - quit`
#### **Prepare your keys**[](https://docs.multiversx.com/validators/nodes-scripts/install-update#prepare-your-keys):
Create a new folder "VALIDATOR\_KEYS" to serve as a local backup when updating:
```
cd ~
mkdir -p ~/VALIDATOR_KEYS
```
Generate a certificate file containing your Validator key by running the `keygenerator`:
```
./onefinity-utils/keygenerator
```
Copy the generated `validatorKey.pem` file to the `config` folder of your node(s), and repeat for each node.
```
cp validatorKey.pem ~/onefinify-nodes/node-0/config/
```
{% hint style="info" %}
NOTE
Each node needs its unique `validatorKey.pem` file
{% endhint %}
To ensure your node can restart smoothly after an upgrade, transfer the `validatorKey.pem` file, compressed in a ZIP format, to the `$HOME/VALIDATOR_KEYS/` directory. It's crucial that each node possesses a distinct `validatorKey.pem` file, repeat for each node:
```
zip node-0.zip validatorKey.pem
mv node-0.zip $HOME/VALIDATOR_KEYS/
```
For instructions on backing up and protecting your keys, see the Management section.
#### **Start the node(s)**[](https://docs.multiversx.com/validators/nodes-scripts/install-update#start-the-nodes):
```
~/of-chain-scripts/script.sh start
```
#### **Start the node visual interface**[](https://docs.multiversx.com/validators/nodes-scripts/install-update#start-the-node-visual-interface):
After your node is running, monitor its status through the `TermUI` interface. Go to `$HOME/onefinity-utils`, then launch `TermUI` for each node:
```
cd $HOME/onefinity-utils
./termui -address localhost:8080
```
{% hint style="info" %}
NOTE
When setting up your environment, you will start with your first node, named `node-0`, which operates as a REST API and listens on port `8080` by default. Following `node-0`, you will configure `node-1` to run on port `8081`, and you'll continue this pattern for any subsequent nodes, incrementing the port number by one each time.
{% endhint %}
### **Update your node(s)**[](https://docs.multiversx.com/validators/nodes-scripts/install-update#update-your-nodes):
To upgrade your node, run the provided script and choose one of the available options.
* `10 - github_pull` downloads the latest version of the scripts
* `3 - upgrade`
* `7 - start`
* `14 - quit`
```
~/of-chain-scripts/script.sh
```
These are the basic steps. Please carefully read the on-screen instructions and refer to the script's README file. You can also ask questions in the OneFinity Validators chat.
### Secure Your Node: Protect Your Private Keys
To ensure you maintain control over your node, it is crucial to safeguard your private keys. Without them, your ability to manage your node effectively is compromised. Additionally, if a third party gains access to your private keys, you could face a significant financial loss. Therefore, it's important to exercise caution and prioritize the security of your keys.
#### Creating a Safe Backup
1. It's recommended to store a backup of your private keys in a secure location outside the server running your nodes.
2. Locate your keys within the folder path: `$HOME/onefinity-nodes/node-0/config`. If you operate multiple nodes (referred to as “`n`” nodes), ensure you follow this step for each one.
3. Implement strict access controls and encryption to enhance the security of the backup.
By taking these preventative measures, you can better protect your node and secure your investment.
### **Choosing a custom configuration tag or branch**[](https://docs.multiversx.com/validators/nodes-scripts/install-update#choosing-a-custom-configuration-tag-or-branch)
{% hint style="danger" %}
WARNING
This option should only be used for debugging or testing ahead of a pre-release tag. Use it at your own risk!
{% endhint %}
The power of the scripts set has been leveraged with a new addition: the possibility to tell the scripts a specified tag or branch (not recommended using a branch due to the fact that an unsigned commit might bring malicious code or configs)
To accomplish this, edit the variables.cfg file
```
cd ~/of-chain-scripts/config
nano variables.cfg
MUST BE CONFiRMED WHEN WE HAVE THE NETWORK IN TESTNET
```
locate the `OVERRIDE_CONFIGVER` option and input a value there, something like `tags/T1.3.14.0`. The `tags/` prefix will tell the scripts to use the tag and not search a branch called `T1.3.14.0`. Call the `upgrade` command on the scripts to install the desired configuration version.
Resetting the value to `""` will make the scripts to use the released version.
{% hint style="danger" %}
WARNING
The `OVERRIDE_CONFIGVER` is not backed up when calling `github_pull` operation.
{% endhint %}
# Updates
## OneFinity Node upgrades
OneFinity will regularly perform node upgrades to incorporate new features, improvements, and bug fixes into its network. Unlike hard forks, these upgrades are backward compatible, ensuring no interruption in service. It's crucial for node operators to understand the upgrade process to maintain their nodes effectively and avoid any potential downtime.
#### When to Upgrade
Node operators should upgrade their nodes whenever a new binary is released for the OneFinity network, including the mainnet, testnet, or devnet. These upgrades are essential for keeping nodes up to date and secure.
#### How to Stay Informed
* **Validators Telegram Channel**: Join the OneFinity Validators Telegram channel for real-time updates and community support.
* **Email Notifications**: Subscribe to email notifications from the official GitHub repositories containing the chain configuration files.
* **OneFinity Explorer**: Set up monitoring on This transaction, being a call to the Staking smart contract, communicates through the `Data` field: * `stake` is the name of the smart contract function to be called; * `0002` is the number of nodes (unsigned integer, hex-encoded); * 45e7131ba....294812f004 is the BLS key of the first node, represented as a 192-character-long hexadecimal string; * `67656e65736973` is a reserved placeholder, required after each BLS key; * `ecf6fdbf5....70f1d251f7` is the BLS key of the second node, represented as a 192-character-long hexadecimal string; * `67656e65736973` is the aforementioned reserved placeholder, repeated; * `optional_reward_address_HEX_ENCODED` represents the address of the account set to receive rewards from the staked nodes. This address is converted from its standard Bech32 format into binary, and then encoded again into a hexadecimal string. ### **Changing the reward address**[](https://docs.multiversx.com/validators/staking/staking-smart-contract#changing-the-reward-address) #### Changing the Reward Address Validator nodes generate rewards, which are subsequently deposited into an account. Unless otherwise specified, this account is the one from which the staking transaction originated. During the staking process, node operators have the flexibility to designate a different reward address. The reward address may be updated following the initial staking transaction by executing a specific transaction with the Staking smart contract. It's crucial to know the exact number of nodes declared in the original staking transaction to accurately calculate the gas limit required for modifying the reward address. * An amount of 0 ONE * A gas limit of 6 000 000 gas units × the nodes for which the reward address is changed (as specified by the original staking transaction). * The new reward address. The reward address must be first decoded into binary from its normal Bech32 representation, then re-encoded to base16 (hexadecimal). For example, changing the reward address for two nodes requires the following transaction: ```csharp ChangeRewardAddressTransaction { Sender:
### For the validator pem to interact with the mxpy we need to create a json with the path having the following structure ``` { "validators": [ { "pemFile": "validatorKey.pem" } ] } ``` ### Add a validator ``` mxpy validator stake \ --pem=walletKey.pem \ --value="2500000000000000000000" \ --validators-file=validator.json \ --proxy="https://gateway.validators.onefinity.network" \ --gas-limit 25000000 \ --recall-nonce \ --send ``` ### Unstake a validator ``` mxpy validator unstake \ --pem=walletKey.pem \ --nodes-public-keys address \ --proxy="https://gateway.validators.onefinity.network" \ --gas-limit 25000000 \ --recall-nonce \ --send ``` # Unjail A node can be unjailed with the following command `mxpy validator unjail`\ `--pem=config/walletKey.pem \`\ `--value="2500000000000000000" \`\ `--nodes-public-keys address \` \ `--proxy="https://gateway.validators.onefinity.network" \`\ `--gas-limit 25000000 \`\ `--recall-nonce \`\ `--send` # OneFinity Protocol OneFinity, the first EVM-compatible blockchain utilizing the power of MultiversX's Sovereign Shard technology and infrastructure. {% hint style="warning" %} **Disclaimer** The information provided in this document are subject to change in the final version of OneFinity. Please note that these documents are preliminary and for reference purposes only. {% endhint %} # Overview An overview of the most important ONE premises: **a)** The ONE currency is designed for simplicity and global adoption. Complexity is the most important obstacle for real world adoption. To reach the greatest audience and user base, we’ve completely rethought the OneFinity currency, capturing its essence into a universally appealing and powerful actor in the blockchain space. **b)** The ONE currency is designed as a digital reserve standard and robust store of value A new economics model has been defined to position ONE as the core network token, fundamental to all OneFinity’s internal usage. This token is designed to optimize parameters that lend themselves to creating a robust store of value. OneFinity, will in fact, intend to onboard many new tokens, such as stable coins and EVM-compatible project tokens, new and existing. **c)** Strong staking incentive for validator adoption paired with a max supply limit There are strong staking incentives for validators to secure the OneFinity network. **d)** Adoption reduces this theoretical inflation and increases scarcity One of the most powerful features of the OneFinity economic model is that each transaction fee paid reduces the theoretical limit by substituting inflation with fees, thus making ONE scarcer, ensuring that the max supply limit will never be reached. **e)** A sustainable adoption model growing the entire ONE economy and reinforcing deflation OneFinity offers arguably one of the strongest adoption models in the blockchain space, thanks to the network being able to immediately transition to a fully deflationary model via any adoption scenario. Indeed, the zero-inflation threshold shows that since 10% of the network capability is needed to cross the threshold, with enough adoption OneFinity can exceed this threshold and create a significant amount of value for all the network participants. # Governance Cryptographically secured distributed networks provide a neutral layer of decentralization, immutability, privacy and trust. Smart contracts can thus be used to both run provably fair electronic elections, or to buy them. Given their significant and far-reaching implications designing an effective governance mechanism for decentralized systems is a strenuous task. Mere extrapolations of real-world governance models are proving naive, and many crypto-networks will likely die due to flawed governance once their network will reach a sufficiently high value for a range of decisive attacks to be warranted. Thus, governance requires separate, in-depth consideration. The OneFinity governance model will be outlined in a future paper, to be released at a later stage, after the official launch of the OneFinity Network. Prior to that point, OneFinity will use a robust off-chain governance approach to ensure maximal speed and efficiency. # Protocol Rewards Below is a spreadsheet where you can simulate the firt year revenue for running a node in OneFinity. Please note that this information is merely an example and mainnet number may differ from the ones showed in the document. {% embed url="
]\(
# Roadmap & Tokenomics
OneFinity core team