Overview
Public Testnet on Solana Devnet for stress testing. Real computations; no economic value.As a testnet operator, you’ll set up your own ARX node to participate in the Arcium network. This guide walks you through each step of the process. First, you’ll prepare your environment by installing the necessary tools and generating security keys. Then you’ll get your node registered onchain and configure it to run. Finally, you’ll connect to other nodes in a cluster and start doing computations. By the end, you will:
- Install the Arcium tooling
- Generate required keypairs
- Fund accounts with Devnet SOL
- Initialize onchain node accounts
- Configure for Devnet
- Join or create a testnet cluster
- Deploy your node with Docker
Prerequisites
Before starting, ensure you have the following installed:- Rust: Install from rustup.rs
- Solana CLI: Install from Solana’s documentation
- Docker & Docker Compose: Install from Docker’s documentation
- OpenSSL: Install from OpenSSL’s documentation (usually pre-installed on macOS/Linux)
- Git: For cloning repositories and version control
- A reliable internet connection
- Basic familiarity with command-line tools
Step 1: Set Up Your Workspace
Create a dedicated folder for your node setup to keep everything organized:arcium-node-setup/.
You’ll also need to know your public IP address for the next steps. Here’s a quick way to find it:
Step 2: Install Arcium Tooling
The Arcium tooling suite includes the CLI and ARX node software. Install it using the automated installer:- Check for all required dependencies
- Install
arcup(Arcium’s version manager) - Install the latest Arcium CLI
- Install the ARX node software
Step 3: Generate Required Keypairs
Security is crucial for node operations, so we’ll create three separate keypairs that each handle different aspects of your node’s functionality. Your ARX node needs three different keypairs for secure operation. Create these in yourarcium-node-setup directory:
3.1 Node Authority Keypair
This Solana keypair identifies your node and handles onchain operations:--no-bip39-passphrase flag creates a keypair without a passphrase for easier automation.
3.2 Callback Authority Keypair
This Solana keypair signs callback computations and must be different from your node keypair for security separation:3.3 Identity Keypair
This keypair handles node-to-node communication and must be in PKCS#8 format:Step 4: Fund Your Accounts
Now that you have your keypairs set up, your node and callback accounts need some Devnet SOL to pay for transaction fees. Let’s get their addresses first, then add some funds. Your node and callback accounts need Devnet SOL for transaction fees. Get their public keys first:Step 5: Initialize Node Accounts
Now we’ll register your node with the Arcium network by creating its onchain accounts. This step tells the blockchain about your node and its capabilities. Set your Solana CLI to Devnet once so you can avoid passing
--rpc-url <rpc-url> repeatedly:
solana config set --url https://api.devnet.solana.com init-arx-accs command to initialize all required onchain accounts for your node:
Required Parameters:
--keypair-path: Path to your node authority keypair--callback-keypair-path: Path to your callback authority keypair--peer-keypair-path: Path to your identity keypair (PEM format)--node-offset: Think of this as your node’s unique ID number on the network. Choose a large random number (like 8-10 digits) to make sure it doesn’t conflict with other nodes. If you get an error during setup saying your number is already taken, just pick a different one and try again.--ip-address: Your node’s public IP address--rpc-url: Solana Devnet RPC endpoint
Note: For better reliability, consider using dedicated RPC providers instead of the default public endpoints. See the RPC Provider Recommendations section below.
Step 6: Configure Your Node
Time to tell your node how to behave! The configuration file is like your node’s instruction manual - it specifies which network to connect to, how to communicate with other nodes, and various operational settings. Create anode-config.toml file in your arcium-node-setup directory:
Note: If your node is behind NAT or a cloud firewall, ensure port 8080 is forwarded and allowed inbound on your public IP. Use your public IP for--ip-addressduring initialization;network.addresscontrols the local bind address. Using"0.0.0.0"ensures the process binds to all local interfaces while peers connect to the public IP you registered duringinit-arx-accs.
Step 7: Cluster Operations
Here’s where things get collaborative! Clusters are groups of nodes that work together on computations during stress testing. You can either start your own cluster and invite others to join, or join an existing cluster that someone else created. Clusters are groups of nodes that collaborate on MPC computations during stress testing. You have two options for cluster participation. For concepts and roles, see the Clusters Overview.Option A: Create Your Own Cluster
If you want to create a new cluster and invite other nodes:--offset: Unique identifier for your cluster (different from your node offset)--max-nodes: Maximum number of nodes in the cluster
Option B: Join an Existing Cluster
To join an existing cluster, you need to be invited by the cluster authority. Once invited, accept the invitation:true: Accept the join request (usefalseto reject)--node-offset: Your node’s offset--cluster-offset: The cluster’s offset you’re joining
Step 8: Deploy Your Node
You’re almost there! Now we’ll get your node up and running using Docker, which packages everything your node needs into a clean, isolated environment.Run with Docker (Recommended)
Run the ARX node container:8.1 Prepare Log Directory
Before running Docker, create a local directory and log file for the container to write to:8.2 Start the Container
Before running Docker, verify you’re in the correct directory and have all required files:- The operator keypair uses the same file as your node keypair - this is intentional for simplified testnet setup
- Ensure port 8080 is open in your OS and cloud provider firewalls for inter-node communication
Save the same command as a reusable script for convenience
Save the same command as a reusable script for convenience
Step 9: Verify Node Operation
Check that your node is running correctly:Check Node Status
Check if Node is Active
Monitor Logs
If using Docker:Devnet RPC Provider Recommendations
For better reliability when running your Testnet node, consider using dedicated RPC providers instead of the default public Solana Devnet endpoints.Why Use Dedicated RPC Providers
The default public Solana RPC endpoints have limitations that can affect your node’s reliability:- Transaction Drops: Public RPCs may drop transactions during high network congestion
- Rate Limits: Stricter limits on requests per second
- Reliability: No service level agreements or guaranteed uptime
- Performance: Slower response times compared to dedicated providers
Recommended RPC Providers for Testnet
Free tiers are completely sufficient for testnet participation - paid plans are NOT required. Recommended Free Tier Options:- Helius - helius.xyz (free tier works perfectly for testnet)
- QuickNode - quicknode.com (free tier works perfectly for testnet)
- Available from Helius, Triton, or QuickNode if you want enhanced features
Critical Operations Benefiting from Dedicated RPCs
The following operations are particularly sensitive to transaction reliability on Devnet:- Node account initialization (
init-arx-accs) - Cluster creation and management (
init-cluster) - Cluster joining operations (
join-cluster) - Real-time node operations and computation handling
What to Expect in Public Testnet
Your node is joining a real testing environment! Here’s what you can expect:- Real Computations: Your node will actually perform MPC computations to help stress test the network
- Solana Devnet: Everything runs on Solana’s test network, so no real money is involved
- Stress Testing Purpose: You’re helping test how well the network handles scale and performance
- Variable Activity: Sometimes it’ll be busy, sometimes quiet - depends on what’s being tested
- No Rewards Yet: This is pure testing - staking and rewards aren’t enabled yet
Troubleshooting
Common Issues
1. Node Not Starting- Verify all keypair files exist and are readable
- Check that
node-config.tomlis valid TOML - Ensure your IP address is accessible from the internet
- Verify you have sufficient SOL for transaction fees (at least 1 SOL per account)
- Check that your RPC endpoint is working
- Ensure node offset is unique
- Verify you’ve been invited by the cluster authority
- Check that cluster has available slots
- Ensure your node is properly initialized
- Verify Docker is running
- Check file permissions on mounted volumes
- Ensure ports are not already in use
Getting Help
If you encounter issues:- Check the Arcium Discord for community support
- Review the troubleshooting section in the installation guide
- Ensure you’re using the latest version of Arcium tooling
Security Best Practices
- Never share your private keys
- Store keypairs securely and keep backups
- Use firewalls to restrict network access
- Keep your system and Docker images updated
Next Steps
Once your Testnet node is running successfully:- Join the Community: Connect with other node operators on Discord
- Stay Updated: Keep your Arcium tooling updated for the latest features