DEV Community

Cover image for From Regtest to Mainnet: Setting Up a Voltage Cloud LND Node
Susan Githaiga
Susan Githaiga

Posted on

From Regtest to Mainnet: Setting Up a Voltage Cloud LND Node

#voltagegpu #bitcoin #backend #blockchain

Welcome to Part 7, where we finally graduate from fake test Bitcoin to using real BTC.

In the previous six parts, everything ran locally on regtest: a sandboxed Bitcoin network where blocks are instant, coins are free, and nothing has real consequences. That was perfect for building and learning.

Now we're going live.

In this article, I'll walk you through:

  • Why we're using Voltage Cloud for our mainnet node
  • Creating and configuring an LND node on mainnet using Voltage Cloud
  • Downloading your node credentials (macaroon + TLS cert)
  • Updating the service's .env to point to your Voltage node instead of the local Docker one
  • Verifying the connection works end-to-end

Why Voltage Cloud?

Running your own mainnet Lightning node from scratch means syncing the entire Bitcoin blockchain (>600GB), managing your own hardware, keeping it online 24/7, and handling LND upgrades yourself. That's a lot of infrastructure overhead when what you really want to do is build.

Voltage Cloud handles all of that. You get a fully managed LND node with:

  • A public REST and gRPC API endpoint your service can talk to
  • TLS certificate and macaroons downloaded straight from the dashboard
  • No hardware, no blockchain sync, no babysitting

For a learning project moving to mainnet, it's the right call.

⚠️ This is mainnet. Real Bitcoin, real money. Start with a small amount that you're comfortable losing while testing. This project is still in the experimental phase.

Step 1: Create a Voltage Account

Go to account.voltage.cloud and sign up.

After signing up, you'll land on the dashboard where you can create your first team and then your first node.

Step 2: Create Your LND Node

From the dashboard, click New Instance → Lightning Node.

New Instance → Lightning Node

Click on Launch a node

on Launch a node

You'll be asked to configure:

Setting What to choose
Network Mainnet
Node Type Standard (covers most use cases)
Region Closest to you
Node Name Something unique. This becomes your API endpoint URL
Password Strong password. Voltage cannot recover this for you.

Back up your password immediately. Voltage does not have access to it. If you lose it, your node is gone.

Click Create Node and leave the browser tab open.

Voltage will provision your node through several stages, ie; wallet creation, syncing, initialising. You'll see the progress in a modal.

Wait until the status shows Running.

running mainnet node

Step 3: Download Your Node Credentials

Once your node is running, you need two files to connect your service to it:

TLS Certificate: encrypts the connection between your service and the node
Admin Macaroon: authenticates your API calls (think of it as a session token baked with permissions)

To get your TLS certificate, go to the left sidebar and navigate to:
Manage Access → App Instructions

To download your admin.macaroon file, open the Voltage dashboard and go to:
Manage Access (left sidebar)

Manage lightning node Access

Download:

  • tls.cert
  • admin.macaroon

Save them somewhere safe. For this project, I put mine in backend/creds/:

backend/
├── creds/
│   ├── tls.cert
│   └── admin.macaroon     ← never commit this to Git
├── src/
├── docker-compose.yml
└── ...
Enter fullscreen mode Exit fullscreen mode

Make sure that you add these files to your .gitignore file

Screenshot: Voltage Manage Access page showing download options

Step 4: Note Your API Endpoint

Still on the node dashboard, under Home. It will look like:

your-node-name.m.voltageapp.io
Enter fullscreen mode Exit fullscreen mode

API Endpoint

The REST API runs on port 8080 and gRPC on port 10009. Our service uses REST, so the full base URL is:

https://your-node-name.m.voltageapp.io:8080
Enter fullscreen mode Exit fullscreen mode

Step 5: Update Your .env

Open backend/.env. You'll be replacing the local Docker LND settings with your Voltage node details.

Before (regtest/local):

LND_HOST=localhost
LND_PORT=8080
LND_MACAROON_PATH=./docker/lnd/data/chain/bitcoin/regtest/admin.macaroon
LND_TLS_CERT_PATH=./docker/lnd/tls.cert
BITCOIN_NETWORK=regtest
Enter fullscreen mode Exit fullscreen mode

After (mainnet/Voltage):

LND_HOST=your-node-name.m.voltageapp.io
LND_PORT=8080
LND_MACAROON_PATH=./creds/admin.macaroon
LND_TLS_CERT_PATH=./creds/tls.cert
BITCOIN_NETWORK=mainnet
Enter fullscreen mode Exit fullscreen mode

Also update your Bitcoin Core connection if you're running a separate mainnet Bitcoin node or swap to a public mempool API for fee estimation depending on your setup.

Step 6: Verify the Connection

Start your backend:

cd backend && npm run dev
Enter fullscreen mode Exit fullscreen mode

Then hit the Lightning info endpoint:

curl http://localhost:3000/api/v1/lightning/info
Enter fullscreen mode Exit fullscreen mode

A successful response will show your Voltage node's public key, alias, and crucially "network": "mainnet":

{
  "data": {
    "alias": "your-node-name",
    "identity_pubkey": "03abc...",
    "network": "mainnet",
    "synced_to_chain": true,
    "block_height": 895210
  }
}
Enter fullscreen mode Exit fullscreen mode

If you see synced_to_chain: false, give it a few minutes. Voltage nodes sync quickly but may not be instant right after creation.

What's Different on Mainnet

A few things behave differently now compared to regtest:

You can't mine blocks on demand. Transactions wait for real confirmations. The CPFP broadcast endpoint now submits to the live Bitcoin mempool.

Invoices are real. When the service generates a Lightning invoice, it can be paid by any mainnet Lightning wallet like Muun, Phoenix, Zeus, anything. No more self-payments not allowed errors because you only have one node.

Fees are real. The fee estimation your service returns reflects actual current mempool conditions, not a synthetic regtest environment.

The lnbc... invoice string you copy from the UI is a real payable invoice.

What We've Built Across This Series

It's worth taking a moment to look back at how far this has come:

  • Parts 1–2: Understanding what anchor outputs are and why Lightning needs them
  • Part 3: Setting up the backend, Bitcoin RPC, and Docker environment
  • Part 4: Integrating LND for invoice creation and payment verification
  • Part 5: Building the CPFP transaction constructor and broadcast endpoint
  • Part 6: Walking through the React frontend end-to-end on regtest
  • Part 7 (this article): Moving the whole thing to mainnet with a real hosted LND node

The full source code is on GitHub and the deployed frontend is live at ln-anchor-outputs.netlify.app.

Thanks for following along. If you've been building with me from Part 1, you now have a working Lightning-powered fee bumping service running on the real Bitcoin network.

That's not nothing.

Top comments (0)