How to Run an Arbitrum One Full Node? An Easy Setup Guide

With the breaking news of the Dencun upgrade the capability of Ethereum and the Layer 2 networks has been significantly increased. To benefit from decreased gas fees on the L2 networks as the Arbitrum One, as well as to implement other Dencun consequences into your dApp, the connection to the Arbitrum full node is required.

That’s why NOWNodes is always here to help you by providing the necessary knowledge for you to get started running your own full nodes or simplifying this process by offering our robust blockchain-as-a-service solution. In this comprehensive and easy guide we’ll dive deeper into the Arbitrum Network to get an idea of what kind of nodes and special technologies exist there, what is the most suitable for a specific Web3 development needs, and of course will break down the process of running a full node. Stay tuned! 🙌

What is the Arbitrum Network?

The Arbitrum network is a suite of Ethereum scaling solutions developed by Offchain Labs, aimed at improving the throughput and reducing the costs of Ethereum transactions. The Arbitrum Network stands out from other blockchain networks due to its unique approach to scaling. Unlike many other solutions that rely on complex sharding or layer-2 protocols, the Arbitrum Network employs a technique called Optimistic Rollup. This technique allows the majority of transactions to be processed off-chain, reducing the burden on the Ethereum network and significantly improving scalability.

Another distinguishing feature of the Arbitrum Network is its compatibility with existing Ethereum smart contracts. Developers can seamlessly port their applications to the Arbitrum Network without the need for extensive modifications. This interoperability ensures a smooth transition for existing Ethereum projects and encourages the adoption of the Arbitrum Network.

Why Would You Need to Run an Arbitrum Full Node?

Running a full node on the Arbitrum network not only strengthens the network’s decentralization and security but also offers node operators direct benefits. These include improved privacy, as transactions can be broadcast without relying on third-party services, and the ability to interact with the network in a trustless manner, ensuring the integrity of your transactions and smart contracts. 

However, keeping in mind that it’s extremely resource-intensive and time-consuming, as well as there are no any incentives to run an Arbitum full node, it’s highly recommended to use third-party node providers like NOWNodes in cases when you just need to access the Arbitrum network.

Types of Arbitrum Chains and Technologies

Being an innovative Layer 2 blockchain or Ethereum scaling solution, Arbitrum implements lots of groundbreaking technologies such as Arbitrum Nitro, Arbitrum Nova, AnyTrust, Arbitrum One, and so on. This set of characteristics might get you confused on the first phases of getting into the Arbitrum blockchain. Here’s all the information you should know about Arbitrum Network specifications.

What Is the Arbitrum Nitro?

So, first in line is Arbitrum Nitro. Arbitrum Nitro is not the type of node, as it is the tech stack that enhances the capabilities of both Arbitrum One and Nova full nodes. 

Before the August of 2022 when the Nitro tech stack came out, Arbitrum Classic was being utilized. This technology used a custom Arbitrum Virtual Machine (“AVM”), that was allowed to create an execution environment as close to the EVM as possible which operates as a Layer 2 to Ethereum base network. 

In the Arbitrum Nitro, similar goals are being achieved by the different technologies. This current Arbitrum tech stack runs a fork of Geth and uses WebAssembly (WASM) as its underlying Virtual Machine for fraud proofs. Basically, this core feature of Nitro allows Geth’s EVM implementation to be used directly. That makes Arbitrum Nitro improve over Arbitrum Classic in several ways, such as:

• Significantly lower gas fees
• Dedicated Contexts for Execution and Fault-Proving
• Enhanced Calldata Compression
• Improved Ethereum compatibility
• Expanded Geth Tracing
• And many other benefits.

Arbitrum One

The Arbitrum One is the first Arbitrum Rollup Chain running on the Ethereum mainnet.

Arbitrum One is built on Optimistic Rollup technology, which allows for Ethereum transactions to be executed off-chain on the Arbitrum network, with only the transaction data (not the execution) being posted on Ethereum. This significantly reduces fees and increases transaction throughput while inheriting the security properties of Ethereum.

As it was mentioned before Arbitrum One implements a Nitro technology stack. With a “Geth-at-the-core” architecture Nitro tech stack opens the doors for Arbitrum One to advanced calldata compression, reduced gas fees, distinct contexts for common execution and fault-proving, Ethereum L1 gas compatibility, and many more exciting features.

Accessing Arbitrum One chain by connecting to its full nodes allows Web3 developers to build a wide range of decentralized applications (dApps), supporting general Ethereum contracts and transactions without modifications. Arbitrum One is a brilliant chain for building DeFi platforms such as Exchanges, Wallets, and other dApps that allow users to process tons of transactions interacting with the ETH L1 network. 

Arbitrum Nova

Arbitrum Nova is a high-performance alternative to Arbitrum One’s chain. It is the first Arbitrum AnyTrust Chain running on the Ethereum mainnet. It introduces cheaper transactions and is a great thing for Web3 gaming and social network development use cases. 

While Arbitrum One is based on a completely trustless Optimistic Rollup protocol, Arbitrum Nova implements another protocol, but a partly trustless one called AnyTrust. The primary difference between Arbitrum One and Nova is that the AnyTrust protocol used in Nova introduces an additional trust assumption in the form of the data availability committee (DAC). The DAC plays a crucial role in accelerating the storage, batching, and submission of Layer 2 (L2) transaction data to Ethereum’s Layer 1 (L1).

As was mentioned before, Arbitrum Nova is optimized for applications that can tolerate a slightly different security model in exchange for performance, such as games or social media platforms on the blockchain. So, if you’re a developer eager to create a new way of people interactivity through revolutionary Web3 games and social media, Arbitrum Nova could become your best friend.

Access Arbitrum One RPC Full Nodes with NOWNodes

As it’s stated in Arbitum’s official documentation: “There is no protocol level incentive to run an Arbitum full node.” So, if you are willing to run the Arbitrum full node just to access the Arbitrum network, there’s a better option to do this by using 3rd party node providers such as NOWNodes! By connecting to Arbitrum full nodes with NOWNodes you’ll be provided with benefits in several ways such as:

• Significantly lower your operational costs, as running your own full node will definitely take a lot of financial investments.
• Access the greatest number of blockchain full nodes, WSS, and explorers with just a single API key! 
• Troubleproof Operation: 99.95% API uptime
• Constantly increasing number of supported blockchains. 
• 24/7 Agreed Service Support Time (ASST)
• API Response Time <1 sec

Moreover, if you have a concern about the privacy of your Arbitrum nodes, NOWNodes is glad to offer you a DEDICATED RPC full node API which no one but you would have access to.

With NOWNodes, you can access Arbitrum One Nitro full node in a few simple steps.

1. Visit the NOWNodes website (https://nownodes.io/) and create an account. 
2. Verify it using your email only (no KYC is required). 
3. Choose a tariff plan tailored to your specific development needs!
4. The next step is to pick the desired blockchains to access.
   1. If you’re choosing a PRO plan or higher, you can get instant access to any node available.
   2. By utilizing a START free plan you will be provided with the option to choose 5 blockchains. If you are looking for the Arbitrum mainnet, don’t forget to add it to the list. 
5. On the “DASHBOARD” page find and press the “ADD API KEY” button to generate an Arbitrum API key.
6. Explore the methods from the “DOCS” page to connect to the Arbitrum One full node and interact with the Arbitrum mainnet network. 
7. Finally, when the registration process is complete it’s time to make some requests! 
8. Use the provided Arbitrum Endpoint arbitrum.nownodes.io and your API key to make it happen. 

Moreover, by choosing NOWNodes as your node provider you can make sure that your Arbitrum as well as the other blockchain nodes are constantly being monitored 24/7, which means that you definitely won’t miss up on any important updates. 

Arbitrum One Full Node Requirements

So, if you’re brave enough to jump into the waters of the complexities of running your own Arbitrum One full nodes, here’s a step-by-step guide for you to do it. Let’s start by preparing our environment. 

Prerequisites

Hardware Requirements

• A modern, multi-core CPU: the minimum is 4 core CPU, but it’s better to have superior versions, like Intel i7 or AMD Ryzen 7 (at least 8 cores, 16 threads) or even newer versions
• RAM: At least 16GB of RAM. The golden rule: if it’s possible to have a better version – go for it (64GB of RAM would be perfect)
• SSD: A fast SSD with a minimum of 1TB+ free space.
• Internet Connection: A stable, high-speed internet connection and uninterrupted power supply is crucial! 

Software Requirements

• Docker: The latest versions of Docker and Docker Compose.
• Latest Docker Image: offchainlabs/nitro-node:v2.3.2-064fa11 (required for the latest version of Arbitrum Nitro v2.3.2)
• An Ethereum node synced with the mainnet (can be through third-party services like NOWNodes).
• Database snapshot: Here’s the link for Arbitrum database snapshots  
• Ethereum L1 and L2 configurations: L1 RPC URL and L2 chain id or name

Setting Up Arbitrum Database Snapshot:

Let’s start by setting the Arbitrum database snapshot. To access all the snapshots use the link provided before. On the first step of startup, you should utilize the parameter --init.url to initialize the Nitro database. Here’s an example: 

--init.url="https://snapshot.arbitrum.foundation/arb1/nitro-pruned.tar"

If you’re setting up multiple nodes, it’s more efficient to download the snapshot image once and host it locally for all your nodes.

For setting more then one Arbitrum node, as well as to run an Arbitrum One Classic node you should use the required parameter: 

--init.url="file:///path/to/snapshot/in/container/snapshot-file.tar due to the presence of classic blocks. However, for running just an Arbitrum One Nitro node this param is optional.

Connecting Your Arbitrum Full Node to the Ethereum Mainnet

Layer 1

To connect your Arbitrum One Full Node to the L1 ETH Mainnet use the parameter --parent-chain.connection.url=<Layer 1 Ethereum RPC URL> for the execution layer. If you’re using NOWNodes as your Ethereum node provider (we hope you do 😉), you can replace <Layer 1 Ethereum RPC URL> with the provided NOWNodes ETH endpoint eth.nownodes.io

Since Ethereum recently has met the new era of Dencun, all the Arbitrum full nodes have to be updated for it as well. That is why your node should run ArbOS 20 which is compatible with all the ETH Dencun EIPs. To do so use the parameter --parent-chain.blob-client.beacon-url=<Layer 1 Ethereum Beacon RPC URL> for the consensus layer. As the NOWNodes provides access to the ETH Beacon nodes you can replace <Layer 1 Ethereum Beacon RPC URL> with the NOWNodes ETH endpoint eth.nownodes.io 

Layer 2

The next step is to configure the Ethereum L2 chain. You can do so with the use of the --chain.id= parameter. Using --chain.id=<L2 chain ID> or --chain.name=<L2 chain name> parameters are essential when setting up and running an Arbitrum One full node as it specifies which Layer 2 (L2) chain your node will connect to (eg. Arbitrum One, Nova, Sepolia Testnet, and so on). This ensures your node is part of the correct Arbitrum network, aligning with the specific chain data and transactions you intend to interact with or validate. There are 2 ways to do this: by L2 chain ID RPC endpoint or by its name.  

<L2 chain ID>

As was mentioned earlier you can set up which L2 Arbitrum network you will run by the utilizing --chain.id=<L2 chain ID>. As the Arbitrum One node is the one we wish to start running today, your Chain ID for it will be 42161. For obtaining other Chain IDs you can visit this page on Arbitrum Official Documentation. 

<L2 chain name>

The alternative method is to utilize the -chain.name=<L2 chain name> parameter to set the L2 chain from its name. You should replace <L2 chain name> with: arb1, nova, sepolia-rollup or goerli-rollup (in our case arb1 is your option) 

Setting Up Important Ports

When running services like an Arbitrum full node, specific ports are designated for certain types of network communication, such as handling remote procedure calls, sequencer data, or real-time updates via WebSocket. Here are all the important ports that you could need: 

• RPC: 8547
• ETH RPC: 8545
• Sequencer Feed: 9642
• WebSocket: 8548
  • WS port 8548 needs extra args to be opened. Please use these flags:
    • --ws.port=8548
    • --ws.addr=0.0.0.0
    • --ws.origins=*

Moreover, if you wish to change the default RPC port, you are free to do this by adding the argument to docker-compose.yml under command:. The useful command for this reason is: 

--http.port=<desired-port> 

How to Configure and Run an Arbitrum One Full Node

Finally, when all the preparational steps are done and required parameters are set, it’s time to put it all together to configure and run your node. There are two ways to do it: by using Docker directly or with Docker Compose.

Running an Arbitrum Node with Docker Compose

Docker Compose allows you to define and run multi-container Docker applications. So, it’s a great option for you, if you’re willing to run multiple Arbitrum nodes.

So, to run an Arbitrum One full node with Docker Compose you need to write a docker-compose.yml file that specifies the required parameters, network settings, and etc. Here’ the example:

version: '3.3'
services:
    one-nitro-node:
        network_mode: host
        image: 'offchainlabs/nitro-node:v2.3.2-064fa11'
        user: 1000:1000
        restart: always
        stop_grace_period: 30s
        volumes:
            - '/home/$USER/arbitrum-node/data/:/home/user/.arbitrum'	
#            - '/home/$USER/arbitrum-node/snapdata/:/arbitrum-node/snapdata/'
        ports:
            - '0.0.0.0:8547:8547'
            - '0.0.0.0:8548:8548'
        command:
        - --init.url="https://snapshot.arbitrum.foundation/arb1/nitro-pruned.tar"
        - --l1.url=https://eth.nownodes.io/<your_api-key>
        - --l2.chain-id=42161 
        - --http.api=net,web3,eth,debug 
        - --http.corsdomain=* 
        - --http.addr=0.0.0.0 
        - --http.vhosts=*
        - --node.batch-poster.post-4844-blobs=true
        logging:
          driver: json-file
          options:
            max-size: 10m
            max-file: "10"

This example of the YAML file sets up the environment your Arbitrum node needs to operate correctly within Docker, automating the deployment and management process. It also includes the --node.batch-poster.post-4844-blobs parameter that enables your node to use data blobs, aligning with Ethereum’s EIP-4844 improvements. Make sure to replace $USER with your actual username on the host system or ensure it’s correctly interpreted in your environment.

Finally, when the YAML file is uploaded to your Docker Compose, use the docker-compose up command to start running the Arbitrum One node.

docker-compose up -d

Additionally, you can view logs for your node using docker-compose logs command. It is crucial for monitoring and debugging your Arbitrum One full node.

docker compose logs -f one-nitro-node

Logs provide insight into the behavior and state of your node, helping you troubleshoot issues, monitor system performance, and ensure everything is running as expected.

Running an Arbitrum Node with Docker

Using Docker directly to run an Arbitrum One full node involves executing Docker commands in the terminal to pull the Arbitrum image, create a container, and run it. Here are the steps you’d follow:

Pull the Image: First, you need to pull the Arbitrum Docker image from the Docker Hub using the docker pull command, specifying the image version, name and tag.

docker pull offchainlabs/nitro-node:v2.3.2-064fa11

Run the Container: Next, use the docker run command to start a new container from the image. Make sure to specify all the required parameters described before. Here’s an example of the command:

docker run --rm -it  -v /some/local/dir/arbitrum:/home/user/.arbitrum -p 0.0.0.0:8547:8547 -p 0.0.0.0:8548:8548 offchainlabs/nitro-node:v2.3.2-064fa11 --parent-chain.connection.url https://eth.nownodes.io/<your_api-key> --chain.id=42161 --http.api=net,web3,eth --http.corsdomain=* --http.addr=0.0.0.0 --http.vhosts=*

So, that ware the example of two ways of running an Arbitrum One full node. There’re some pros and cons for each method. Docker Compose simplifies the process of managing multi-container applications. If your setup involves only a single container, Docker commands might be sufficient. However, for more complex setups, Docker Compose makes it easier to manage. Just choose the preferable method and run it!

Optional Configurations

There are many optional configurations that could be added to your Arbitrum One full node, including: 

Pruning

Pruning a full node involves deleting out-of-date, unnecessary data on your Arbitrum full node to conserve disk space and enhance node efficiency. This process removes state data from blocks beyond the most recent 128. 

To enable pruning on your node you can utilize the --init.prune option with “full” as your node type. Note that during the pruning operation, the node will not handle RPC requests.

Watchtower mode

Watchtower mode helps monitor and manage the Docker containers automatically. It ensures that your node is always running the latest version of the software by checking for updates and applying them without manual intervention, thus enhancing security and reliability. 

Actually, the watchtower mode will be set up on your Arbitrum full node automatically. So, congratulations that you don’t need to do it by yourself. The node will log an error containing the string found incorrect assertion in watchtower mode if some disagreement on the on-chain activities occurs. However, running a node in watchtower mode will bring additional outgoings. So, if you don’t need it, you can easily turn it off by using the --node.staker.enable=false parameter.

Conclusion

So, by following this comprehensive step-by-step guide, you have learned how to install and fully configure an Arbitrum One full node. NOW you’re ready to contribute to the Arbitrum network by bringing your node to the party. 

NOWNodes is always glad to make complex processes like running an Arbitrum node easy by explaining it in our dev guides, as well as by offering a robust and simple-to-connect solution for accessing the blockchain nodes! Delegating such responsibilities for running a node to experts in this sphere will not only lead to the funds saving and decentralization of your project infrastructure but will also let you focus on what’s most important – building innovative dApps and DeFi platforms! 

Let’s take it to the next layer together with Arbitrum #NOW