Merge remote-tracking branch 'origin/main' into development

Bloxster · Bloxster · commit 14a5f49ab23e · 2025-05-05T20:44:47.000+02:00
diff --git a/src/SUMMARY.md b/src/SUMMARY.md
@@ -8,6 +8,8 @@
 
 - [Installation](installation.md)
     - [Linux and MacOS](installation/linux.md)
+        - [Pre-built binaries](installation/prebuilt.md)
+        - [Build Erigon from source](installation/build.md)
     - [Windows](installation/windows.md)
         - [Build executable binaries natively for Windows](installation/build_exec_win.md)
         - [Windows Subsystem for Linux (WSL)](installation/wsl.md)
diff --git a/src/advanced/options.md b/src/advanced/options.md
@@ -198,9 +198,12 @@ GLOBAL OPTIONS:
    --caplin.checkpoint-sync-url value [ --caplin.checkpoint-sync-url value ]        checkpoint sync endpoint
    --caplin.subscribe-all-topics                                                    Subscribe to all gossip topics (default: false)
    --caplin.max-peer-count value                                                    Max number of peers to connect (default: 128)
+   --caplin.max-peer-count value                                                    Max number of peers to connect (default: 128)
    --caplin.enable-upnp                                                             Enable NAT porting for Caplin (default: false)
    --caplin.max-inbound-traffic-per-peer value                                      Max inbound traffic per second per peer (default: "1MB")
    --caplin.max-outbound-traffic-per-peer value                                     Max outbound traffic per second per peer (default: "1MB")
+   --caplin.max-inbound-traffic-per-peer value                                      Max inbound traffic per second per peer (default: "1MB")
+   --caplin.max-outbound-traffic-per-peer value                                     Max outbound traffic per second per peer (default: "1MB")
    --caplin.adaptable-maximum-traffic-requirements                                  Make the node adaptable to the maximum traffic requirement based on how many validators are being ran (default: true)
    --sentinel.addr value                                                            Address for sentinel (default: "localhost")
    --sentinel.port value                                                            Port for sentinel (default: 7777)
@@ -278,3 +281,5 @@ GLOBAL OPTIONS:
    --version, -v                                                                    print the version
 ```
 
+```
+
diff --git a/src/basic-usage.md b/src/basic-usage.md
@@ -20,8 +20,8 @@ The default Consensus Layer utilized is [Caplin](./advanced/caplin.md), the Erig
     --datadir=<your_data_dir>
     ```
 
-* Based on the [type of node](basic/node.md) you want to run you can add ```--prune.mode=archive``` to run a archive node or ```--prune.mode=minimal``` for a minimal node.
-The default node is archive node.
+* Based on the [type of node](basic/node.md) you want to run you can add ```--prune.mode=archive``` to run a archive node, ```--prune.mode=full``` for a full node or ```--prune.mode=minimal``` for a minimal node.
+The default node is full node.
 * ```--chain=mainnet```, add the flag `--chain=sepolia` for Sepolia testnet or `--chain=holesky` for Holesky testnet.
 * ```--http.addr="0.0.0.0" --http.api=eth,web3,net,debug,trace,txpool``` to use RPC and e.g. be able to connect your [wallet](basic/wallet.md).
 * To increase download speed add ```--torrent.download.rate=512mb``` (default is 16mb).
diff --git a/src/basic/disk-space.md b/src/basic/disk-space.md
@@ -3,6 +3,7 @@
 
 # Mainnets
 
+Below is the size of the `--datadir` used by Erigon.
 Below is the size of the `--datadir` used by Erigon.
 
 ## Erigon with Caplin
diff --git a/src/basic/yaml.md b/src/basic/yaml.md
diff --git a/src/getting-started/hw-requirements.md b/src/getting-started/hw-requirements.md
@@ -8,27 +8,63 @@ Additionally, SSDs may experience performance degradation when nearing full capa
 
 See here how you can [optimize storage](/basic/optimizing-storage.md).
 
-## RAID Configuration
 
-When using multiple disks, consider implementing a **RAID 0** configuration to maximize performance and utilize space efficiently. RAID ZFS is not recommended.
+Here is the outline of the hardware requirements for running Erigon on the following networks:
 
-## Disk size
+- Ethereum Mainnet
+- Polygon (formerly Matic)
+- Gnosis (formerly xDai)
 
-Please refer to [disk space required](/basic/disk-space.md) for details. To ensure smooth operation, it is recommended to maintain at least 25% of free disk space. For more detailed guidance on optimizing storage, refer to disk space required.
+Hardware requirements vary depending on whether you're running a Minimal, Full, or Archive node.
 
-## CPU Requirements
+General recommendations for all node types include:
 
-* **Architecture**: 64-bit architecture.
-* **Number of core and threads**: While a powerful CPU can be beneficial, it's not essential for running Erigon. A moderate number of cores and threads should be sufficient. However, we recommend at least 4 cores, or 8 cores for high performance.
+- **Disk Type:** Use high-end NVMe SSDs. RAID or ZFS setups may improve performance for archive nodes.
+- **RAM:** Adequate memory reduces bottlenecks during sync and improves performance under load.
+- **CPU:** 4–8 cores recommended for Full nodes; 8–16 cores for Archive.
+- **Linux**: kernel version > v4
+- When using multiple disks, consider implementing a **RAID 0** configuration to maximize performance and utilize space efficiently. RAID ZFS is not recommended.
 
-## RAM Requirements
-    
-* **Minimum**: 64GB
 
-## Kernel Requirements
+## Minimal Node Requirements
 
-* **Linux**: kernel version > v4
+Minimal nodes are suitable for light operation with pruned state and minimal historical data retention. (`--prune.mode=minimal`)
 
-## Bandwith
+| Network   | Disk Size (Required) | Disk Size (Recommended) | RAM (Required) | RAM (Recommended) |
+|-----------|----------------------|--------------------------|----------------|-------------------|
+| Mainnet   | 500 GB       | 500 GB        | 16 GB           | 64 GB             |
+| Polygon   | 2 TB  | 2 TB        | 32 GB           | 64 GB             |
+| Gnosis    | 250 GB         | 500 GB      | 8 GB           | 16 GB              |
 
-A stable and reliable internet connection is crucial for running a node, especially if you're running a validator node, as downtime can lead to missed rewards or penalties. We recommend a minimum inbound and outbound bandwidth of 20 Mbps, with a stable connection and low latency. For optimal performance, it's best to use an ISP with an uncapped data allowance.
+
+## Full Node Requirements
+
+Full nodes maintain full state with standard pruning and all recent data.  (`--prune.mode=full`)
+
+| Network   | Disk Size (Required) | Disk Size (Recommended) | RAM (Required) | RAM (Recommended) |
+|-----------|----------------------|--------------------------|----------------|-------------------|
+| Mainnet   | 1 TB       | 2 TB    | 16 GB          | 64 GB             |
+| Polygon   | 2 TB   | 4 TB    | 16 GB          | 32 GB             |
+| Gnosis    | 500 GB       | 1 TB          | 8 GB           | 16 GB             |
+
+
+## Archive Node Requirements
+
+Archive nodes retain **all** historical state and require significantly more disk space. These are typically used for block explorers or deep analytical queries. (`--prune.mode=archive`)
+
+| Network   | Disk Size (Required) | Disk Size (Recommended) | RAM (Required) | RAM (Recommended) |
+|-----------|----------------------|--------------------------|----------------|-------------------|
+| Mainnet   | 2 TB     | 4 TB       | 32 GB          | 64 GB            |
+| Polygon   | 6 TB   | 6 TB        | 64 GB          | 128 GB             |
+| Gnosis    | 1 TB           | 2 TB         | 16 GB          | 32 GB             |
+
+
+
+## Bandwidth Requirements
+
+Your internet bandwidth is also an important factor, particularly for sync speed and validator performance.
+
+| Node Type     | Bandwidth (Required) | Bandwidth (Recommended) |
+|---------------|----------------------|--------------------------|
+| Staking/Mining       | 10 Mbps              | 50 Mbps                 |
+| Non-Staking   | 5 Mbps               | 25 Mbps                 |
diff --git a/src/getting-started/tips.md b/src/getting-started/tips.md
diff --git a/src/images/releases.png b/src/images/releases.png
diff --git a/src/installation/build.md b/src/installation/build.md
@@ -0,0 +1,12 @@
+# Build Erigon from source
+*How to build Erigon in Linux and MacOS from source*
+
+The basic Erigon configuration is suitable for most users just wanting to run a node. For building the latest stable release use the following command:
+
+```bash
+git clone --branch release/3.0 --single-branch https://github.com/erigontech/erigon.git
+cd erigon
+make erigon
+```
+
+This should create the binary at `./build/bin/erigon`.
diff --git a/src/installation/docker.md b/src/installation/docker.md
@@ -43,6 +43,7 @@ If you want to start Erigon add the options according to the [basic usage](/basi
 
 ```bash
 docker run -it 36f25992dd1a --chain=holesky --prune.mode=minimal
+docker run -it 36f25992dd1a --chain=holesky --prune.mode=minimal
 ```
 
 To exit the container press `Ctrl+C`; the container will stop.
diff --git a/src/installation/linux.md b/src/installation/linux.md
@@ -1,12 +1,10 @@
-# Linux and MacOS
-*How to install Erigon in Linux and MacOS*
+# Linux and Mac OS
+*How to install and run Erigon 3 on Linux or Mac OS*
 
-The basic Erigon configuration is suitable for most users just wanting to run a node. For building the latest stable release use the following command:
+There are 3 options for running Erigon 3, listed from easiest to most difficult installation:
 
-```bash
-git clone --branch release/3.0 --single-branch https://github.com/erigontech/erigon.git
-cd erigon
-make erigon
-```
+-   [Use pre-built binaries](/installation/prebuilt.md): Download and run the latest stable release of Erigon. This is the easiest option and requires no additional dependencies.
+    
+-   [Use Docker](/installation/docker.md): Run Erigon in a Docker container for isolation from the host system. This avoids dependencies but requires installing Docker.
 
-This should create the binary at `./build/bin/erigon`.
+-  [Build Erigon from source](/installation/build.md): Build the Erigon source code directly on your system. This is the most complex option and requires a working Go environment.
diff --git a/src/installation/prebuilt.md b/src/installation/prebuilt.md
@@ -0,0 +1,36 @@
+# Install Erigon with Pre-built Binaries
+
+You can download and install Erigon v3.0.2 (or whatever the latest is) directly from our GitHub releases page.
+
+## 1. Pick your platform & download
+
+Go at the [Erigon releases page](https://github.com/erigontech/erigon/releases) and select the latest version (or whichever you'd like).
+
+
+<img src="/images/releases.png" alt="Erigon 3" style="display: block; margin: 0 auto; ">
+
+then download the appropriate binary for your system. as shown above.
+- For **Linux**:
+  - `erigon_3.x.x_amd64.deb` for 64-bit Intel/AMD processors
+  - `erigon_3.x.x_arm64.deb` for 64-bit ARM processors
+  - `erigon_v3.x.x_linux_amd64.tar.gz` for 64-bit Intel/AMD processors
+  - `erigon_v3.x.x_linux_arm64.tar.gz` for 64-bit ARM processors
+- For **MacOS**:
+    - `erigon_3.x.x_darwin_amd64.tar.gz` for 64-bit Intel/AMD processors
+    - `erigon_3.x.x_darwin_arm64.tar.gz` for 64-bit ARM processors
+### Checksums
+
+To verify the integrity of the downloaded file, you can use the checksums provided in the `erigon_v3.x.x_checksums.txt` file. This file contains SHA256 checksums for all Erigon binaries.
+
+```bash
+BASE="https://github.com/erigontech/erigon/releases/download/v3.x.x"
+wget $BASE/erigon_v3.x.x_checksums.txt
+# then one of:
+wget $BASE/erigon_3.x.x_amd64.deb
+# or
+wget $BASE/erigon_3.x.x_arm64.deb
+# or
+wget $BASE/erigon_v3.x.x_linux_amd64.tar.gz
+# or
+wget $BASE/erigon_v3.x.x_linux_arm64.tar.gz
+```
diff --git a/src/installation/upgrading-md b/src/installation/upgrading-md
@@ -1 +1,89 @@
 # Upgrading from a previous version
+
+To upgrade Erigon to a newer version when you've originally installed it via Git and manual compilation, you should follow these steps without needing to delete the entire folder:
+
+* **Terminate your Erigon** session by pressing CTRL+C
+
+* **Navigate to your Erigon directory**
+
+* **Fetch the latest changes from the repository**: You need to make sure your local repository is up-to-date with the main GitHub repository. Run:
+
+    ```bash
+    git fetch --tags
+    ```
+
+* **Check out** the [latest version](https://github.com/ledgerwatch/erigon/releases) and switch to it using:
+
+
+    ```bash
+    git checkout <new_version_tag>
+    ```
+
+
+    Replace `<new_version_tag>` with the version tag of the new release, for example:
+
+    ```bash
+    git checkout v3.0.0
+    ```
+
+* **Rebuild Erigon**: Since the codebase has changed, you need to compile the new version. Run:
+
+    ```bash
+    make erigon
+    ```
+
+This process updates your installation to the latest version you specify, while maintaining your existing data and configuration settings in the Erigon folder. You're essentially just replacing the executable with a newer version.
+
+# Docker
+If you're using Docker to run Erigon, the process to upgrade to a newer version of the software is straightforward and revolves around pulling the latest Docker image and then running it. Here's how you can upgrade Erigon using Docker:
+
+* **Pull the Latest Docker Image**: First, find out the tag of the new release from the Erigon Docker Hub page. Once you know the tag, pull the new image:
+
+    ```bash
+    docker pull erigontech/erigon:<new_version_tag>
+    ```
+
+    Replace `<new_version_tag>` with the actual version tag you wish to use. For example:
+    
+    ```bash
+    docker pull erigontech/erigon:v3.0.0-beta2
+    ```
+
+
+* **List Your Docker Images**: Check your downloaded images to confirm the new image is there and get the new image ID:
+
+    ```bash
+    docker images
+    ```
+
+
+* **Stop the Running Erigon Container**: If you have a currently running Erigon container, you'll need to stop it before you can start the new version. First, find the container ID by listing the running containers:
+
+    ```bash
+    docker ps
+    ```
+
+
+    Then stop the container using:
+
+    ```bash
+    docker stop <container_id>
+    ```
+
+    Replace `<container_id>` with the actual ID of the container running Erigon.
+
+* **Remove the Old Container**: (Optional) If you want to clean up, you can remove the old container after stopping it:
+
+    ```bash
+    docker rm <container_id>
+    ```
+
+* **Run the New Image**: Now you can start a new container with the new Erigon version using the new image ID:
+
+    ```bash
+    docker run -it <new_image_id>
+    ```
+
+* **Verify Operation**: Ensure that Erigon starts correctly and connects to the desired network, verifying the logs for any initial errors.
+
+By following these steps, you'll keep your Docker setup clean and up-to-date with the latest Erigon version without needing to manually clean up or reconfigure your environment. Docker's ability to encapsulate software in containers simplifies upgrades and reduces conflicts with existing software on your machine.
