Setting up a developer environment varies significantly between operating systems, so follow the specific instructions for your OS:

• Windows: Use tools like PowerShell or WSL.

• macOS: Utilize Terminal and Homebrew.

• Linux: Rely on package managers like apt, yum, or dnf depending on your distribution.

Pay careful attention to the detailed steps for your OS to ensure a smooth setup.

Please choose your Operating System from below:

Setting Up a Linux Development Environment for Rust

This guide will help you set up your Linux environment for Rust development, focusing on the necessary steps to install Rust and the required dependencies for developing and validating on the Argochain network.

Prerequisites

Before you begin, ensure your system is up to date and has the necessary tools installed. This guide uses Ubuntu as an example, but the commands can be adapted for other Linux distributions.

Step 1: Update Your System

Open a terminal and update your package lists.

Step 2: Install Required Packages

Install the essential packages:

Step 3: Install Rust

Download and run the rustup installation script to install Rust:

Follow the on-screen instructions to complete the installation.

Step 4: Configure Rust

To update your current shell to include Cargo (Rust's package manager), run:

Verify the Rust installation:

Set Rust to use the stable version by default and update to the latest version:

Step 5: Add Nightly Toolchain and WebAssembly Target

Add the nightly toolchain and the WebAssembly (wasm) target required for Substrate development:

Verify the configuration:

Compile the Argochain Node

Now that Rust is installed and configured, you can compile an Argochain node.

Step 1: Clone the Argochain Repository

Clone the Argochain repository:

Step 2: Compile the Node Template

Compile the Argochain node:

The compilation process may take several minutes.

Hardware Specifications for Optimal Performance

Minimum Specifications:

• CPU: 8 cores

• RAM: 16 GB

• Storage: 500GB SSD

• Network: High-speed internet connection (1 Gbps)

Recommended Specifications:

• CPU: 16 cores

• RAM: 32 GB

• Storage: 1TB SSD

• Network: High-speed internet connection (1 Gbps)

Using ArgoWallet to Bridge AGC to Argochain

1. Create a Phrase in ArgoWallet

Visit ArgoWallet: Open your browser and navigate to argowallet.devolvedai.com.

Create a New Wallet:

• Click on "Create New Wallet".

• Follow the on-screen instructions to generate a new mnemonic phrase. Ensure you write down this phrase and store it in a secure location. This phrase is essential for wallet recovery.

Confirm Your Phrase:

• Confirm the mnemonic phrase as prompted by the wallet interface.

• Once confirmed, your new wallet will be created, and you can proceed to the next step.

Step 2: Import Your Phrase into Polkadot

Open Polkadot.js Extension:

• If you haven't installed the Polkadot.js extension, download and install it.

• Open the Polkadot.js extension in your browser.

Import Account:

• Click on the Polkadot.js extension icon and select "Import Account".

• Choose the "Mnemonic Seed" option.

• Enter the mnemonic phrase you generated in ArgoWallet.

• Set a name and password for your account, then click "Add the account with the generated seed".

Account Verification:

• Your ArgoWallet account is now imported into the Polkadot.js extension.

• Ensure the account is visible in the extension and ready for use.

Step 3: Approve AGC for Bridging

• Visit ArgoWallet: Go back to argowallet.devolvedai.com and log in using your wallet.

Approve AGC:

1. Navigate to the "Bridge" section within ArgoWallet.

2. Select the amount of AGC you want to bridge to Argochain.

3. Click on "Approve". This will initiate a transaction to approve the selected amount of AGC for bridging.

Step 4: Bridge AGC to Argochain

Initiate the Bridge:

• After approving the AGC, navigate to the "Bridge" section again.

• Enter the amount of AGC you wish to bridge to Argochain.

Complete the Bridging Process:

• Follow the on-screen instructions to complete the bridging process.

• Confirm the transaction and wait for the network to process it. This may take a few minutes.

Step 5: Verify the Bridged AGC on Argochain

Check Your Balance:

• Once the transaction is complete, check your AGC balance on Argochain.

• You can do this by accessing the Argochain network through ArgoWallet or any other compatible wallet interface.

Successful Bridging:

• If the balance reflects the bridged AGC, the process is complete.

• You can now use your AGC on Argochain for various activities within the ecosystem.

Setting Up a Windows Development Environment for Rust

To create a suitable development environment for Substrate on a Windows computer, you can use Windows Subsystem for Linux (WSL) to emulate a UNIX operating system. While UNIX-based systems like macOS or Linux offer better environments for building Substrate-based blockchains, using WSL can be a viable alternative. All code examples and command-line instructions in Substrate tutorials and guides are UNIX-based.

Before You Begin

Ensure the following requirements are met:

• Operating System: Microsoft Windows 10, version 2004 or later, or Windows 11

• Internet Connection: Good broadband connection

• Shell Access: Access to a terminal on your local computer

Set Up Windows Subsystem for Linux (WSL)

WSL enables you to emulate a Linux environment on a Windows computer, allowing you to use UNIX commands directly.

Step 1: Enable WSL

1. Open PowerShell or Command Prompt as an administrator.

1. Run the following command to enable WSL:

wsl --install

This command installs the required WSL 2 components, downloads the latest Linux kernel, and installs the Ubuntu Linux distribution by default.

1. To see other available Linux distributions, run:

wsl --list --online

1. Restart your computer to complete the installation.

Step 2: Install Required Packages and Rust

1. Open the Ubuntu application from the Start menu.

1. Create a UNIX user account by providing a username and password.

1. Update the package list:

sudo apt update

1. Install the required packages:

sudo apt install --assume-yes git clang curl libssl-dev llvm python3 python3-pip libudev-dev make protobuf-compiler

1. Download and install Rust:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

1. Follow the prompts for default installation.

1. Update your shell to include Cargo:

source ~/.cargo/env

1. Verify the Rust installation:

rustc --version

1. Set Rust to use the stable version by default and update:

rustup default stable
rustup update

1. Add the nightly toolchain and WebAssembly (wasm) targets:

rustup update nightly
rustup target add wasm32-unknown-unknown --toolchain nightly

1. Verify the configuration:

rustup show
rustup +nightly show

Compile the Argochain Node

Now that Rust is installed and configured, you can compile an Argochain node.

Step 1: Clone the Argochain Repository

Clone the Argochain repository:

git clone https://github.com/devolved-ai/argochain
cd argochain

Step 2: Compile the Argochain Node

Compile the node template:

cargo build --release

The compilation process may take several minutes.

Your development environment is now configured for validation and staking on the Argochain network.

Unbonding is the process of withdrawing your staked tokens from the validator pool. On ArgoChain, there is no minimum bond time, but the unbonding process takes approximately 28 days. This means that once you bond your tokens, you must wait at least 28 days before you can interact with them again whatsoever and that is if you have already initiated the process.

Steps to Unbond

1. Access ArgoScan Explorer:

• Go to ArgoScan Explorer (https://explorer.argoscan.net).

1. Navigate to Staking:

• Go to Network -> Staking -> Accounts.

1. Initiate Unbonding:

• Select the account you wish to unbond from.

• Click on the "Unbond" button and enter the amount of tokens you want to unbond.

1. Confirm Unbonding:

• Confirm the unbonding transaction. Your tokens will now enter the unbonding period.

1. Wait for Unbonding Period:

• The unbonding period is 28 days. During this time, your tokens are still locked and cannot be used.

Staking AGC on Argochain

Step 1: Stake AGC

Visit the Staking Portal:

• Open your browser and navigate to staking.argoscan.net.

Navigate to the Staking Tab:

• Click on the "Staking" tab in the menu.

Choose Your Wallet and Amount:

• Select your wallet from the dropdown menu.

• Enter the amount of AGC you wish to stake.

Sign and Submit:

• Click "Sign and Submit" to initiate the staking transaction.

• Follow the on-screen instructions to complete the staking process.

Step 2: Set Session Keys & Validate

Access Session Keys:

• On the staking page, find your address and click on "Session Keys".

Run the Rotate Keys RPC Call:

• Open a terminal or command prompt.

• Run the following command to generate a session key:

curl -H "Content-Type: application/json" --data '{"jsonrpc":"2.0", "method":"author_rotateKeys", "params":[], "id":1}' http://localhost:9944

• This will produce an output that appears similar to this:

{"jsonrpc": "2.0","result": "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef","id": 1}

Insert Session Keys:

• Copy the number starting with 0x and in this example that would be

0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef

which was generated by the RPC call you made to you node.

• Go back to the "Session Keys" popup on the explorer.

• Paste the copied number into the provided field.

• Click "Sign and Submit" to save the session keys.

Step 3: Validate Your Account

Validate:

• After setting the session keys, the "Session Keys" button will change to "Validate".

• Click "Validate".

• Follow the on-screen instructions to sign and submit the validation transaction.

Step 4: Verify Staking on the Explorer

Visit the Explorer:

• Open your browser and navigate to explorer.argoscan.net.

Navigate to the Staking Page:

• Go to the "Staking" page.

Choose Own Accounts and Waiting:

• Select "Own Accounts" from the dropdown menu.

• Then select "Waiting" to see your staked address and amount.

Wait for the Next Era:

• Your account will be placed into the waiting queue for the next era.

• Each era lasts for one hour.

• After the next era, your account will be added to the active validators and begin earning rewards.

Setting Up a macOS Development Environment for Rust

This guide will help you install Rust and set up a Substrate development environment on Apple macOS computers with either Intel or Apple M1 processors.

Before You Begin

Ensure your computer meets the following requirements:

• Operating System: macOS 10.7 Lion or later

• Processor: At least 2GHz (3GHz recommended)

• Memory: At least 8 GB RAM (16 GB recommended)

• Storage: At least 10 GB available space

• Internet: Broadband connection

Step 1: Install Homebrew

If you don't have Homebrew installed, you should install it to manage packages on macOS.

1. Open the Terminal application.

2. Download and install Homebrew by running:

   Copy

   /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install.sh)"

3. Verify Homebrew installation:

   Copy

   brew --version

Step 2: Install Required Packages

1. Update Homebrew:

   Copy

   brew update

2. Install required packages:

   Copy

   brew install protobuf openssl cmake python git

Step 3: Install Rust

1. Download and run the rustup installation script:

   Copy

   curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

2. Follow the prompts for default installation.

3. Update your current shell to include Cargo:

   Copy

   source ~/.cargo/env

4. Verify Rust installation:

   Copy

   rustc --version

5. Configure Rust to use the stable version and update:

   Copy

   rustup default stable
   rustup update
   rustup target add wasm32-unknown-unknown

6. Add the nightly toolchain and WebAssembly (wasm) targets:

   Copy

   rustup update nightly
   rustup target add wasm32-unknown-unknown --toolchain nightly

7. Verify the configuration:

   Copy

   rustup show
   rustup +nightly show

Compile a Substrate Node

Now that Rust is installed and configured, you can compile a Substrate node.

Step 1: Clone the Node Template Repository

1. Clone the Substrate node template repository:

   Copy

   git clone https://github.com/devolved-ai/argochain
   cd argochain

Step 2: Compile the Node Template

1. Compile the node template:

   Copy

   cargo build --release

   The compilation process may take several minutes.

Your development environment is now set up for Substrate development.

Next Steps

Your local computer is ready for Substrate development activity. For further resources and guides, visit the Substrate Developer Hub.

Regular key rotation is a proactive measure crucial for network security, instilling confidence in participants and stakeholders about the safety and reliability of the blockchain infrastructure. In Substrate-based blockchains, it ensures the smooth operation and protection of the network.

Validator nodes, responsible for block validation and propagation, can routinely update their cryptographic keys through key rotation. This practice mitigates risks of key exposure or unauthorized access, significantly enhancing security. Key rotation is essential for maintaining blockchain integrity and involves periodically updating cryptographic keys across system components, reducing compromise risks and boosting overall security.

Install jq

If you don't have jq installed, you can install it using your package manager. For example, on Ubuntu:

 sudo apt-get install jq

Or, if you're on MacOS:

brew install jq

Overview of rotate_keys.sh:

The script will:

1. Prompt you for the base path of your node.

2. Prompt you for the chain specification file.

3. Generate keys for BABE, GRANDPA, Authority Discovery, and ImOnline.

4. Insert the generated keys into the node configuration.

5. Start the node as a validator with the new keys.

How To Rotate Keys

1. Make the script executable:

   Copy

   chmod +x rotate_keys.sh

1. Run the script with elevated permissions to ensure that the script runs properly :

sudo ./rotate_keys.sh

1. Follow the prompts: The script will prompt you to enter the base path and chain specification file. It will then generate and insert new keys for BABE, GRANDPA, Authority Discovery, and ImOnline consensus mechanisms and start the node as a validator with the new keys.

Rotating keys is a crucial practice to maintain the security of your blockchain network. This procedure helps by minimizing the risk of key compromise, which is essential for safeguarding the network from unauthorized access. Regularly scheduled key rotation ensures that any potentially compromised keys are replaced promptly, reducing the window of opportunity for malicious actors. Consequently, this practice fortifies the overall integrity of the blockchain, providing a more resilient and trustworthy environment for all participants involved.

Updating Boot Nodes in minervaRaw.json

This guide details how to update the boot nodes in the minervaRaw.json file using a provided script. The script reads boot nodes from a bootnodes.txt file and inserts them into the JSON configuration.

Updating the boot nodes in the minervaRaw.json file ensures your blockchain network connects to the correct initial nodes. This is crucial for maintaining proper network functionality and connectivity.

Steps to Update Boot Nodes

Step 1: Make the Script Executable

Navigate to the directory containing your files and make the update_bootnodes.sh script executable by running the following command:

chmod +x update_bootnodes.sh

Step 2: Run the Script

Execute the script to update the boot nodes in the minervaRaw.json file:

./update_bootnodes.sh

Step 3: Verify the Changes

After running the script, open the minervaRaw.json file to ensure that the boot nodes have been correctly inserted.

Example of minervaRaw.json Before and After Running the Script

Before Running the Script

{
  "name": "ArgoChain",
  "id": "argochain",
  "chainType": "Live",
  "bootNodes": [],
  "telemetryEndpoints": [
    [
      "/dns/telemetry.polkadot.io/tcp/443/x-parity-wss/%2Fsubmit%2F",
      0
    ]
  ],
  "protocolId": null,
  "properties": {
    "tokenDecimals": 18,
    "tokenSymbol": "AGC"
  }
}

Assuming the bootnodes.txt file contains:

/dns/node1.argochain.io/tcp/30333/p2p/QmNode1
/dns/node2.argochain.io/tcp/30333/p2p/QmNode2

After Running the Script

The minervaRaw.json file would be updated to:

{
  "name": "ArgoChain",
  "id": "argochain",
  "chainType": "Live",
  "bootNodes": [
    "/dns/node1.argochain.io/tcp/30333/p2p/QmNode1",
    "/dns/node2.argochain.io/tcp/30333/p2p/QmNode2"
  ],
  "telemetryEndpoints": [
    [
      "/dns/telemetry.polkadot.io/tcp/443/x-parity-wss/%2Fsubmit%2F",
      0
    ]
  ],
  "protocolId": null,
  "properties": {
    "tokenDecimals": 18,
    "tokenSymbol": "AGC"
  }
}

Follow these steps to update the boot nodes in your minervaRaw.json file using the script provided. This will help your blockchain network connect to the correct initial nodes.

1. Choose Reliable Validators:

   • Nominate validators with a strong track record of uptime and performance.

2. Regularly Check Rewards:

   • Periodically check and claim your rewards to ensure they are not left unclaimed.

3. Reinvest Rewards:

   • Consider reinvesting your rewards to compound your earnings over time.

The slashing mechanisms in Argochain, are a protocol to penalize validators for misbehavior to ensure network security. The slashing penalties are proportional to the severity of the misconduct and aim to deter bad practices while maintaining network integrity.

Security Threat Levels and Corresponding Punishments

Level 1: Minor Misconduct

○ Example: Occasional unresponsiveness.

○ Penalty: Up to 0.1% of the validator's stake.

○ Calculation: For a validator with 20,000 AGCs, slashing 0.1% results in a penalty of 20 AGCs.

○ Explanation: Minor issues are expected to happen rarely and individually.

Level 2: Moderate Misconduct

○ Example: Repeated unresponsiveness or isolated cases of equivocation.

○ Penalty: Up to 1% of the validator's stake.

○ Calculation: For a validator with 20,000 AGCs, slashing 1% results in a penalty of 200 AGCs.

○ Explanation: These are more severe issues that should cause the validator to reconsider their practices.

Level 3: Serious Misconduct

○ Example: Collusion among validators or hacked validator nodes.

○ Penalty: Up to 10% of the validator's stake.

○ Calculation: For a validator with 20,000 AGCs, slashing 10% results in a penalty of 2,000 AGCs.

○ Explanation: Such misconducts indicate coordinated attacks or significant security risks.

Level 4: Critical Misconduct

○ Example: Major security risks or extensive collusion.

○ Penalty: Up to 100% of the validator's stake.

○ Calculation: For a validator with 20,000 AGCs, slashing 100% results in a penalty of 20,000 AGCs (total stake).

○ Explanation: The highest level of penalty is reserved for actions that threaten the entire network’s security. From the slashed amount 5% goes to the reporter.

Slashing Mechanics

● Validators and Nominators: When a validator is slashed, both the validator and their nominators are penalized proportionally to their stake.

● Encouragement: This system encourages nominators to distribute their support across various validators to minimize risk.

Specific Misconducts

1. Unresponsiveness

○ Detection Method: Validators must submit an "I'm online" heartbeat messag each session.

○ Calculation: If a validator fails to send this, they are marked as inactive.

○ Penalty: A fraction of their stake is slashed based on the number of unresponsive validators:

■ Example: If there are 50 validators and 3 are unresponsive, the penalty is 0.05 * min( (3 * (3−1) / 50), 1) = 0.05 * min( (6 / 50), 1) = 0.05 * 0.12 =0.006 or 0.6%.

2. Grandpa Equivocation and Unjustified Votes ○ Equivocation: A validator signs two or more votes in the same round.

■ Level 2 Misconduct: Minor, accidental equivocations. ○ Unjustified Votes: Voting for a chain incompatible with finalized blocks.

• Detection: Requires another validator to submit a transaction with proof of the unjustified vote.

• Penalty: Up to 10% of the validator's stake.

• Reward: The reporter gets 10% of the slashed amount.

3. Babe Equivocation

○ Equivocation: Producing two or more blocks in the same time slot.

○ Penalty: Similar to Grandpa equivocation, often treated as Level 2 misconduct unless coordinated with others.

Database and Detection Mechanisms

● Off-chain Database: Maintains records of validator misconduct and slashing events.

● Proof of Misconduct: Short proofs (like signed votes) that can be quickly verified on-chain.

● Voting Certificate: When short proof isn’t possible, validators vote on the misconduct, which is more resource-intensive and reserved for severe cases.

Examples and Calculations

Example of Level 2 Misconduct (Repeated Unresponsiveness)

• ○ Validator with 20,000 AGCs.

• ○ Penalty: 1% of 20,000 AGCs = 200 AGCs.

Example of Level 3 Misconduct (Validator Node Hacked)

• ○ Validator with 50,000 AGCs.

• ○ Penalty: 10% of 50,000 AGCs = 5,000 AGCs.

Example of Level 4 Misconduct (Major Collusion)

○ Validator with 100,000 AGCs.

○ Penalty: 100% of 100,000 AGCs = 100,000 AGCs.

Rewards for Reporting

● Levels 1 and 2: The reporter gets 10% of the slashed amount.

● Levels 3 and 4: Reporters (validators) get a proportionate reward shared among all involved nominators.

Misconduct Detection Phases

1. Inspection Phase: Validators check the blob and issue validity statements.

2. Voting Phase: If there's a conflict (validity vs invalidity statements), all validators vote. The decision is based on the majority.

Conclusion

Argochain's slashing mechanisms are designed to penalize validators in a way that reflects the severity of their misconduct. By understanding and adhering to these principles, validators, and nominators can contribute to the network's security and stability.

If you can see something similar in your terminal, CONGRATULATIONS!! Your node is now running and connected to Argochain.

Note: The blockchain has surpassed 2 million blocks, and syncing may take some time. Please be patient while your node catches up to the latest block.

It is strongly recommended to use /var/log/argochain as your base path to ensure that the data remains persistent.

Use /var/log/argochain to ensure log files are preserved during system crashes, enhancing your application's reliability and easing troubleshooting. This practice is essential for tracking events, diagnosing issues, and maintaining operational history.

Now you can view the logs and output as directed by the success message in your terminal:

tail -f /private/var/log/argochain/node.log

Becoming a nominator on Argochain is a vital role that helps secure the network and maintain its decentralization. Nominators select validators they trust to produce blocks and maintain the blockchain, and in return, they earn rewards. This guide will walk you through the process of becoming a nominator and explain the importance of this role.

How to Become a Nominator

1. Prepare Your Wallet

   • Ensure you have at least 4000 AGC in your Argochain wallet.

   • Create or access your wallet using ArgoWallet.

   • Secure your wallet by backing up the seed phrase and private keys.

2. Visit the Staking Portal

   • Open your browser and go to .

   • Connect your wallet to the staking portal.

3. Navigate to the Nominating Section

   • Click on the "Nominating" tab in the menu.

4. Select Validators

   • Choose up to 16 validators you trust based on their performance history, reliability, and community reputation.

   • Enter the amount of AGC you wish to nominate (minimum 4000 AGC).

5. Submit Your Nominations

   • Click "Sign and Submit" to initiate the nomination transaction.

   • Follow the on-screen instructions to complete the process.

6. Verify Your Nominations

   • Visit .

   • Go to the "Nominations" page to verify your nominations.

7. Monitor and Adjust Nominations

   • Regularly check the status of your nominations and the performance of your chosen validators.

   • Adjust your nominations as needed to optimize rewards and maintain network security.

Why Become a Nominator?

1. Network Security:

   • Nominators play a crucial role in maintaining the security and stability of the Argochain network.

   • By selecting trustworthy validators, nominators help ensure that the network remains decentralized and robust against attacks.

2. Earning Rewards:

   • Nominators earn rewards based on the performance of the validators they support.

   • By nominating well-performing validators, you can earn a share of the staking rewards.

3. Decentralization:

   • Contributing to the network's decentralization helps prevent central points of failure.

   • A diverse set of validators, supported by numerous nominators, enhances the resilience of Argochain.

Validators and nominators earn rewards for participating in the network. Rewards can be claimed periodically based on the performance and uptime of the validator.

Steps to Claim Rewards

1. Access ArgoScan Explorer:

   • Go to ArgoScan Explorer (https://explorer.argoscan.net).

2. Navigate to Staking:

   • Go to Network -> Staking -> Payouts.

3. Check Available Rewards:

   • View the rewards available for your account. The rewards are calculated based on your staking activities and the performance of the validator you are supporting.

4. Claim Rewards:

   • Click on the "Claim Rewards" button to initiate the reward claiming process.

5. Confirm Transaction:

   • Confirm the transaction to transfer the rewards to your account.