From 596e6f039c52e8ec2a88d8cab79a20a84df507a0 Mon Sep 17 00:00:00 2001 From: Rogzy Date: Sat, 21 Mar 2026 19:02:30 +0100 Subject: [PATCH 01/10] feat: LNP 404 full course harmonization (Loic Morel style) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Rewrite all 11 chapters from AI-summary to Loic Morel writing style - Add 66 code blocks (CLI commands, config files, bash snippets) - Add Introduction part with Course overview chapter - Add prerequisites, curriculum overview, documentation links - Remove all em dashes, normalize Unicode hyphens - Add missing course.yml fields: type, teaching_format, license - Set test_only: false for mainnet preview - 518 lines → 1640 lines (3x content expansion) Source material: 11 Whisper transcripts + 5 Lightning Labs reference docs Co-Authored-By: Claude Opus 4.6 (1M context) --- courses/lnp404/course.yml | 5 +- courses/lnp404/en.md | 1661 +++++++++++++++++++++++++++++++------ 2 files changed, 1392 insertions(+), 274 deletions(-) diff --git a/courses/lnp404/course.yml b/courses/lnp404/course.yml index 96c64a6683a..8c207f6f066 100644 --- a/courses/lnp404/course.yml +++ b/courses/lnp404/course.yml @@ -1,9 +1,12 @@ id: 068234ae-1524-4947-9cb0-ea741b7f7c0f topic: protocol subtopic: lightning +type: practice level: intermediate hours: 16 -test_only: true +teaching_format: self_paced +license: CC-BY-SA-V4 +test_only: false professors_id: - 303993a1-6506-4c25-b0b6-6d3f0497859b diff --git a/courses/lnp404/en.md b/courses/lnp404/en.md index 5b0d2974d7a..7f422ca52b1 100644 --- a/courses/lnp404/en.md +++ b/courses/lnp404/en.md @@ -1,22 +1,101 @@ --- name: Navigating Your Node with Terminal -goal: Take a deep dive into your lightning node with Terminal +goal: Master the management and optimization of your Lightning node using Lightning Terminal (LitD) objectives: - - Install and connect your Lightning node using Terminal tools and commands. - - Monitor your node’s health and receive actionable recommendations for optimization. - - Analyze channels, forwards, and peer insights to improve node efficiency and reliability. - - Interpret liquidity and accounting reports for better decision-making. + - Install Lightning Terminal and connect to your existing LND node in remote mode + - Monitor your node's health with the six-metric diagnostic framework + - Analyze routing performance through forwards, channel insights, and peer analytics + - Automate fee management with the Autofees algorithm and understand its privacy architecture + - Manage liquidity through Loop In, Loop Out, and Auto Loop with budget controls + - Open multiple channels efficiently using batch transactions + - Operate a multi-node infrastructure from a single Terminal dashboard + - Set up virtual LND accounts with granular permissions and spending limits + - Build a complete Lightning node from scratch using the Run LITD repository --- -# A Journey into your Lightning Node +# A Journey into Your Lightning Node -Navigating Your Node with Terminal is a comprehensive journey into managing, optimizing, and understanding your Bitcoin Lightning node through the power of the command line. -From installation to advanced multi-node management, this course equips you with the practical skills and theoretical knowledge needed to operate your Lightning setup like a pro. You’ll explore key tools such as Lightning Terminal (LND, Loop, Pool, and Faraday) and learn to analyze your node’s health, liquidity, fees, and network interactions directly from the terminal. +Running a Lightning node is one thing. Managing it effectively is another challenge entirely. Whether you are routing payments across the network, running a merchant setup, or simply experimenting on testnet, the operational demands of a Lightning node go far beyond the initial installation: monitoring channel health, balancing liquidity, optimizing fee policies, and keeping your infrastructure secure and resilient. -By the end, you’ll not only understand how to maintain and scale your Lightning operation. +This is where **Lightning Terminal** comes in. Developed by Lightning Labs, Lightning Terminal (also known as **LitD**, for Lightning Terminal Daemon) is an all-in-one management stack that bundles several essential tools into a single binary: **Loop** for liquidity swaps, **Pool** for the channel marketplace, **Faraday** for accounting and analytics, **Taproot Assets**, and optionally **LND** itself. In other words, rather than managing five separate daemons and their inter-process communications, you run one program that ties everything together through a unified web interface. + +This course is built around the demo series by **Hannah Rosenberg** from Lightning Labs. Each chapter pairs a video walkthrough with detailed written content, including the actual CLI commands, configuration files, and procedures you will need. This is a hands-on, practice-focused course: you will spend most of your time in the terminal and in the Terminal web interface, working with real tools on real (or testnet) infrastructure. + +### Prerequisites + +To follow this course comfortably, you should have: + +- A basic understanding of how the Lightning Network works (channels, routing, invoices) +- Familiarity with the Linux command line (`ssh`, `nano`, `systemctl`, `git`) +- An existing LND node running on testnet or mainnet (for the first 10 chapters), or a fresh Ubuntu server (for the final chapter, which builds everything from scratch) +- Go 1.21+ and Node.js installed on your machine (for compiling LitD from source) + +If you have never set up a Lightning node before, we recommend starting with the [LNP 202 course](https://planb.academy/courses/lnp202), which walks you through the initial setup of your first Lightning node. + +### Course structure + +The course is organized in three parts: + +**Part 1: Getting Started with Terminal** + +We begin by installing LitD and connecting to the Terminal web interface. From there, we explore the Health Checks framework to evaluate your node's performance across six key metrics, then dive into the financial analytics dashboard to understand your routing revenue, channel efficiency, and network position. The part concludes with Autofees, an automated fee management system that adjusts your channel policies based on historical traffic patterns. + +**Part 2: Managing Your Node's Network** + +In this part, we move into active node management. You will learn how to operate multiple Lightning nodes from a single Terminal dashboard, open channels efficiently using batch transactions, manage your liquidity through Loop swaps (both manual and automated), and leverage Peer Insights to make data-driven decisions about your channel partnerships. + +**Part 3: Advanced Features and Full Node Setup** + +The final part covers advanced topics: the Liquidity Report for diagnosing silent routing problems, LND Accounts for creating sandboxed virtual wallets with granular permissions, and a comprehensive from-scratch installation walkthrough using the Run LITD repository. This last chapter is the most code-intensive in the course, covering server hardening, Bitcoin Core installation, LitD compilation, wallet initialization, and systemd service management. + +### Documentation and resources + +Throughout this course, we reference the official Lightning Labs documentation extensively. Here are the key resources you may want to bookmark: + +- [Lightning Terminal docs](https://docs.lightning.engineering/lightning-network-tools/lightning-terminal) +- [Loop docs](https://docs.lightning.engineering/lightning-network-tools/loop) +- [Pool docs](https://docs.lightning.engineering/lightning-network-tools/pool) +- [LND docs](https://docs.lightning.engineering/lightning-network-tools/lnd) +- [Run LITD repository](https://github.com/lightninglabs/lightning-terminal) +- [Lightning Node Connect](https://docs.lightning.engineering/lightning-network-tools/lightning-terminal/lightning-node-connect) + +Ready to take full control of your Lightning node? Let's get started. +++ +# Introduction +a1f3d9c2-7b4e-4c8a-9d5f-2e6b8c0d4a7e + +## Course overview +f4e2a1b3-5c6d-4e8f-9a0b-1d3c5e7f2a4b + +Welcome to the LNP 404 course! Together, we will explore how to manage, optimize, and understand your Bitcoin Lightning node through the power of **Lightning Terminal** (LitD), an all-in-one management stack developed by Lightning Labs. + +This course is built around the demo series by **Hannah Rosenberg** from Lightning Labs. Each chapter pairs a video walkthrough with detailed written content, including the actual CLI commands, configuration files, and procedures you will need. + +### Part 1: Getting Started with Terminal + +We begin by installing LitD and connecting to the Terminal web interface. From there, we explore the Health Checks framework to evaluate your node's performance across six key metrics, then dive into the financial analytics dashboard to understand your routing revenue, channel efficiency, and network position. The part concludes with Autofees, an automated fee management system that adjusts your channel policies based on historical traffic patterns. + +### Part 2: Managing Your Node's Network + +In this part, we move into active node management. You will learn how to operate multiple Lightning nodes from a single Terminal dashboard, open channels efficiently using batch transactions, manage your liquidity through Loop swaps (both manual and automated), and leverage Peer Insights to make data-driven decisions about your channel partnerships. + +### Part 3: Advanced Features and Full Node Setup + +The final part covers advanced topics: the Liquidity Report for diagnosing silent routing problems, LND Accounts for creating sandboxed virtual wallets with granular permissions, and a comprehensive from-scratch installation walkthrough using the Run LITD repository. + +### Documentation and resources + +- [Lightning Terminal docs](https://docs.lightning.engineering/lightning-network-tools/lightning-terminal) +- [Loop docs](https://docs.lightning.engineering/lightning-network-tools/loop) +- [Pool docs](https://docs.lightning.engineering/lightning-network-tools/pool) +- [LND docs](https://docs.lightning.engineering/lightning-network-tools/lnd) +- [Run LITD repository](https://github.com/lightninglabs/lightning-terminal) +- [Lightning Node Connect](https://docs.lightning.engineering/lightning-network-tools/lightning-terminal/lightning-node-connect) + +Ready to take full control of your Lightning node? Let's get started. + # First steps of installing your Lightning Node d74ec352-1a5d-466d-a06d-571fc9f99937 @@ -25,358 +104,993 @@ By the end, you’ll not only understand how to maintain and scale your Lightnin ![video](https://www.youtube.com/watch?v=XibPhZtNQak) -### Lightning Terminal Remote Mode Overview -Lightning Terminal (LitD) is a unified management stack for Lightning nodes, bundling Loop, Pool, Faraday, Taproot Assets, and optionally LND. It can run in **integrated mode** (shipping with LND) or **remote mode**, where it connects to an already-running LND instance. This chapter focuses on **remote mode**, ideal for maintaining an established node without reconfiguring your infrastructure. +Running a Lightning node is one thing. Managing it with confidence is something else entirely. In this first chapter, we will install **Lightning Terminal**, the all-in-one management interface developed by Lightning Labs, and we will connect it to an existing LND node. By the end of this chapter, you will have a running `litd` daemon, a proper configuration file, a systemd service that survives reboots, and a secure browser connection to Terminal on the web. + +Let's go! + +### What is Lightning Terminal? -#### System Requirements & Preparation -LitD requires up‑to‑date development tools: -- Go 1.21.3+ -- Node.js 2.1.5+ -Verifying running services ensures compatibility—typically `bitcoind` and `lnd` are active, while `litd` is not yet present. Remote mode requires `rpcmiddleware.enable=true` in the LND config, enabling LitD to authenticate and communicate with LND. +Before we touch the command line, let's understand what we are about to install. **Lightning Terminal (LitD)** is a unified management stack that bundles several powerful tools into a single binary: -#### Repository Setup & Compilation -To install LitD from source: -1. Clone `lightning-terminal` from GitHub. -2. Checkout the latest stable release (e.g., `v0.12.2-alpha`). -3. Run `make install` to compile Go code, build UI assets, and install the binary. -Running `litd` confirms the installation is accessible system‑wide. +- **LND** (optionally, if you do not already have it running) +- **Lightning Loop** for submarine swaps between on-chain and off-chain Bitcoin +- **Lightning Pool** for buying and selling inbound channel liquidity +- **Faraday** for financial reporting and channel analytics +- **Taproot Assets Protocol** for asset issuance over Lightning -#### Configuring lit.conf -A dedicated data folder (usually `~/.lit`) stores configuration and node metadata. Inside it, a `lit.conf` file defines operation parameters: -- `lnd-mode=remote` -- `network=testnet` -- `remote.lnd.rpcserver=` -- `remote.lnd.macaroonpath=` -- `remote.lnd.tlspath=` -- `uipassword=` -- `httpslisten=0.0.0.0:8443` +In other words, `litd` is the gateway between a browser-based management interface and your Lightning node's gRPC API. Anyone who has access to `litd` can monitor and manage the node, which is why we will pay careful attention to authentication and security throughout this chapter. -These settings securely bind LitD to your pre‑existing LND instance and expose the HTTPS UI interface. +### Two Deployment Modes -### Running LitD with systemd -Creating `/etc/systemd/system/litd.service` turns LitD into a managed background service. -Key entries: -- Start only **after LND** (`After=lnd.service`). -- `Restart=always` for resilience. -- Proper user permissions for file access. +LitD supports two ways of running alongside LND: -Enabling the service ensures LitD autostarts on reboot and stays active like any other core system component. +| Mode | Description | When to use | +|------|-------------|-------------| +| **Integrated mode** | LitD ships with its own embedded LND instance | Fresh installations where you want everything in a single process | +| **Remote mode** | LitD connects to an already-running LND instance | Existing nodes where you want to add Terminal without reconfiguring LND | -### Accessing the Terminal Interface -Once active, browse to: +In this course, we will use **remote mode**, which is the ideal approach when you already have a production or testnet LND node running. Remote mode lets you enhance your existing setup with Loop, Pool, Faraday, and the Terminal web interface without touching your LND installation. + +### Prerequisites + +Installing `litd` from source requires up-to-date development tools. Before proceeding, verify that you have recent versions of both Go and Node.js on your machine: + +```bash +go version +``` + +You should see something like `go1.21.3` or newer. + +```bash +node --version +``` + +You should see `v20.x` or newer (the exact version matters less than being reasonably current). + +You will also need a running Bitcoin backend (typically `bitcoind`) and a functioning LND node. Let's confirm that both processes are active: + +```bash +ss -tlnp | grep -E 'bitcoind|lnd|litd' +``` + +You should see `bitcoind` and `lnd` listening on their respective ports. If `litd` already appears, you may have a previous installation; stop it before continuing. + +### Cloning and Compiling LitD + +Now that our environment is ready, let's install LitD from source. We begin by cloning the official Lightning Labs repository: + +```bash +git clone https://github.com/lightninglabs/lightning-terminal.git +cd lightning-terminal +``` + +Next, we check out the latest stable release. As of this writing, that is version `v0.12.2-alpha`: + +```bash +git checkout v0.12.2-alpha +``` + +Then we compile and install the binary with a single command: + +```bash +make install +``` + +This step compiles the Go backend, builds the UI assets, and places the `litd` binary in your `$GOPATH/bin` directory. It typically takes a few minutes. Once it completes, confirm that `litd` is accessible system-wide: + +```bash +litd --version ``` -https://:8443 + +If the version string prints correctly, the installation is complete. Let's move on to configuration. + +### Preparing the LND Configuration + +Before `litd` can communicate with your existing LND node, we need to verify one critical setting in your LND configuration file. Open it: + +```bash +nano ~/.lnd/lnd.conf ``` -Expect browser warnings on testnet unless proper SSL certificates are configured. The UI password defined in `lit.conf` grants access. -Terminal supports: -1. **Local browser access** (direct LitD UI) -2. **Remote access** through terminal.lightning.engineering using **Lightning Node Connect (LNC)**. +Look for the following line (or add it if it is missing): -LNC acts as an encrypted, mailbox‑mediated communication layer for secure remote management without exposing LND ports. Pairing occurs using a one‑time phrase generated by the UI or CLI. +```ini +rpcmiddleware.enable=true +``` + +This setting enables the **RPC Middleware Interceptor**, which allows `litd` to authenticate and communicate with LND. Without it, `litd` will fail to connect in remote mode, and you may encounter cryptic macaroon errors. Save and close the file, then restart LND if you had to modify this setting. -#### Command-Line Session Control -`litcli` enables advanced session administration: -- Create sessions (`litcli sessions add`) -- Specify types (admin, readonly, etc.) -- Label sessions for tracking -- Produce pairing strings for automation or remote setups +### Creating the LitD Configuration File -This is essential for multi‑admin environments or tooling that integrates with Terminal’s APIs. +Rather than passing dozens of flags on the command line each time we start `litd`, we will create a dedicated configuration file. First, let's create the data directory: -#### Key Takeaways -- LitD remote mode lets you enhance an existing LND node with Loop, Pool, Faraday, and more **without modifying your LND installation**. -- Source installation ensures transparency and customization. -- Proper `lit.conf` and systemd integration make LitD production‑ready. -- Terminal + LNC provide secure, flexible local and remote node management. +```bash +mkdir -p ~/.lit +``` +Now create the configuration file: + +```bash +nano ~/.lit/lit.conf +``` + +Here is a complete configuration for remote mode. We will walk through each section: + +```ini +# LitD operation mode +lnd-mode=remote + +# Network (change to mainnet for production) +network=testnet + +# UI password (use a strong, unique password on production nodes) +uipassword=YourSecurePasswordHere + +# Remote LND connection settings +remote.lnd.rpcserver=localhost:10009 +remote.lnd.macaroonpath=~/.lnd/data/chain/bitcoin/testnet/admin.macaroon +remote.lnd.tlscertpath=~/.lnd/tls.cert + +# HTTPS listen address for the Terminal UI +httpslisten=0.0.0.0:8443 +``` + +Let's examine what each block does: + +1. **`lnd-mode=remote`** tells `litd` that we already have an LND node running. From `litd`'s perspective, LND is a remote service it connects to, even when both run on the same machine. + +2. **`network=testnet`** ensures `litd` operates on the correct network. If you are running mainnet, change this accordingly. A network mismatch will produce macaroon authentication errors that can be difficult to diagnose. + +3. **`uipassword`** sets the password for the browser-based Terminal UI. On a production machine, use a password generated by a password manager. + +4. **The three `remote.lnd.*` lines** tell `litd` how to talk to LND: the RPC server address, the path to the admin macaroon for authentication, and the path to the TLS certificate. Note that the macaroon path includes the network name (`testnet` in our case). + +5. **`httpslisten=0.0.0.0:8443`** instructs `litd` to listen for HTTPS connections on port 8443 from any network interface. This is the port we will use to access the Terminal UI in a browser. + +### Setting Up a Systemd Service + +We could start `litd` manually with a simple command like `litd --uipassword=YourPassword`, but that approach lacks resilience. If the machine reboots at 2 AM, your Terminal connection disappears. A systemd service solves this problem elegantly. + +Create the service file: + +```bash +sudo nano /etc/systemd/system/litd.service +``` + +Paste the following configuration: + +```ini +[Unit] +Description=LitD Lightning Terminal Daemon +Requires=lnd.service +After=lnd.service + +[Service] +ExecStart=/home//go/bin/litd +User= +Group= +Type=simple +Restart=always +RestartSec=120 + +[Install] +WantedBy=multi-user.target +``` + +Replace `` with your actual Linux username. A few points worth noting: + +- **`Requires=lnd.service`** and **`After=lnd.service`** ensure that `litd` starts only after LND is up and running. Since `litd` depends on LND's RPC interface, starting it before LND would cause connection failures. +- **`Restart=always`** with a **`RestartSec=120`** delay means that if `litd` crashes, systemd will wait two minutes and then restart it automatically. +- The `ExecStart` path should point to wherever `make install` placed the `litd` binary (typically `$GOPATH/bin/litd`). + +Now enable and start the service: + +```bash +sudo systemctl enable litd +sudo systemctl start litd +``` + +Verify that `litd` is running and listening on the expected port: + +```bash +ss -tlnp | grep 8443 +``` + +If you see `litd` listening on port 8443, the daemon is operational. You can also check its status at any time with: + +```bash +sudo systemctl status litd +``` + +### Accessing the Terminal UI + +With `litd` running, open a browser and navigate to: + +``` +https://:8443 +``` + +If you have not configured a domain name or SSL certificate (which is typical on testnet), your browser will display a security warning about the self-signed certificate. This is expected; proceed past the warning for testing purposes. On a production node, you would configure a proper TLS certificate. + +Enter the UI password you defined in `lit.conf`, and you will see the Terminal interface. From here, you have access to all the management tools we will explore throughout this course: health checks, channel management, Loop, Pool, Autofees, and more. + +### Connecting to Terminal on the Web + +The local UI is useful, but Lightning Terminal truly shines when accessed through **Terminal on the web** at `terminal.lightning.engineering`. This hosted interface connects to your node remotely using **Lightning Node Connect (LNC)**, an encrypted communication protocol that works even when your node sits behind Tor or NAT. + +Here is how LNC works at a high level: your `litd` daemon makes an outgoing connection to a web proxy (the "mailbox"). Because the connection is outgoing, you do not need to open any ports on your firewall. The proxy server sees only encrypted blobs; Lightning Labs cannot inspect your private channel balances, HTLCs, or on-chain data. The connection is authenticated using a **one-time pairing phrase**, a set of 10 words that you should treat with the same care as a password. + +#### Connecting via the UI + +From the local Terminal interface, click the connection button to initiate an LNC session. The interface will generate a 10-word pairing phrase. Copy this phrase, then navigate to `terminal.lightning.engineering` in your browser. Paste the phrase, set a session password, and you are connected. + +#### Connecting via the Command Line + +For automation or headless setups, you can generate the connection string directly from the command line using `litcli`: + +```bash +litcli --network=testnet sessions add --label default --type admin +``` + +This command creates a new administrative session and outputs a connection string. You can then paste this string into the Terminal web interface to establish the connection. Note that `litcli` supports several session types beyond `admin`, including read-only sessions for monitoring dashboards. + +**Important:** The connection string is equivalent to an administrative private key for your node. Never broadcast it publicly, and never reuse a pairing phrase after it has been consumed. + +### Summary + +Let's recap what we have accomplished in this chapter. We installed `litd` from source by cloning the Lightning Labs repository and running `make install`. We verified that `rpcmiddleware.enable=true` is set in our LND configuration. We created a dedicated `lit.conf` file with all the parameters needed for remote mode operation. We set up a systemd service so that `litd` starts automatically and survives reboots. Finally, we connected to Terminal on the web using Lightning Node Connect. + +In the next chapter, we will explore what Terminal reveals about our node's health and discover how the health check system evaluates routing performance across six key metrics. ## Health Checks and Recommendations ceb149b0-473b-4264-8bc3-b64ec8717aac ![video](https://www.youtube.com/watch?v=ZyZKFmKW_dU) -### Understanding Lightning Terminal's Optimization Tools +Now that we have Lightning Terminal installed and connected, let's explore the first thing it shows us: the health of our node. In this chapter, we will examine how Terminal evaluates your node across six diagnostic metrics, what each metric actually measures, and how the **Recommended Channels** feature suggests new peers that benefit both your node and the broader Lightning Network. + +### Why Health Checks Matter + +Running a Lightning node is not simply a matter of keeping software online. A routing node must maintain sufficient channels, balanced liquidity, stable connections, and quality peers in order to forward payments reliably. Without a systematic way to evaluate these factors, operators are left guessing about their node's effectiveness. + +Terminal's **Health Checks** provide exactly this systematic evaluation. Think of them as a diagnostic report for your node, covering six dimensions of routing performance. However, and this is an important nuance, these checks are designed specifically for routing nodes. If your node specializes in sending payments (a consumer wallet) or receiving payments (a merchant endpoint), it may not score well on all six checks, and that is perfectly fine. The checks measure routing capability, not general usefulness. + +### Exploring Your Node's Health + +When you connect to Terminal on the web, the homepage displays a summary of your node's health status at the top. To get a more detailed view, navigate to the **Explore** tab and search for your node by alias or public key: + +1. Copy your node's public key from the homepage +2. Click the **Explore** tab +3. Paste your public key into the search field + +This brings up a detailed profile of your node, including its overall score, current capacity, age, number of good peers, and centrality measure. Below these summary statistics, you will find the six individual health checks. -Lightning Terminal provides comprehensive tools for monitoring and optimizing your Lightning Network node's performance. This chapter explores the Health Checks feature and the Recommended Channels system, two essential components for maintaining a well-functioning routing node. While these features are currently available for mainnet nodes, understanding their principles and metrics will help you make informed decisions about your node's configuration and network participation. +### The Six Health Checks -#### The Health Checks Framework +Let's walk through each check and understand what it measures: -The Health Checks feature offers a systematic evaluation of your node's performance across six key metrics. When you access your node through Terminal's web interface, you'll find a summary at the top indicating whether your node passes all checks. For detailed analysis, navigate to the Explore tab and search for your node using its alias or public key. This displays your node's score along with comprehensive information including current capacity, node age, peer quality, and centrality measures. +**1. Node Is Online** -It's crucial to understand that Health Checks are designed primarily for routing nodes. These metrics evaluate how well your node can facilitate payments across the network, requiring consistent uptime, adequate channel capacity, and reliable peer connections. However, if your node specializes in sending or receiving payments rather than routing, you may not score highly on these checks, and that's perfectly acceptable. The key is aligning your node's configuration with its intended purpose. +This is the most fundamental check. A routing node must be reachable on the network to forward payments. If your node experiences frequent downtime, it cannot route payments, and peers will eventually close their channels with you. For routing nodes, consistent uptime is not optional; it is the foundation upon which everything else depends. -### Core Health Check Metrics +**2. Plenty of Channels** -The six metrics evaluate different aspects of node performance: +A routing node needs a sufficient number of active channels to create viable payment paths. A node with only one or two channels cannot meaningfully participate in routing because there are too few paths through it. Terminal evaluates whether your node has enough active channels to function as a useful routing intermediary. Around 14 active channels is generally considered adequate connectivity for routing operations. -**Online Status**: The most fundamental check verifying your node is online. For routing nodes, consistent uptime is non-negotiable since you cannot facilitate payments when offline. +**3. Good Routing Capacity** -**Channel Count**: Evaluates whether your node maintains sufficient active channels for effective routing. Approximately fourteen active channels demonstrates adequate connectivity for routing operations. +Having many channels is necessary but not sufficient. Each channel must also have **adequate capacity in both directions** to route payments of reasonable size. In other words, a channel where all the balance sits on one side cannot forward payments in the depleted direction. This check evaluates whether your channels collectively provide enough bidirectional capacity to handle typical routing requests. -**Routing Capacity**: Examines whether channels have sufficient capacity in both directions to route payments successfully. A channel might exist but becomes less useful if balance is heavily skewed to one side. +**4. Many Healthy Channels** -**Channel Health and Stability**: These metrics assess whether channels remain active with regular activity and maintain consistent uptime. The system specifically evaluates public channels, so private channels with lower activity won't negatively impact scores. +Beyond capacity, Terminal evaluates whether your channels are actually healthy. A **healthy channel** is one that remains active, has reasonable capacity, and sees some activity over time. This check focuses specifically on public channels (channels that are announced to the network graph). Private channels, which are typically used for mobile wallets or merchant endpoints, are not factored into this metric. -**Peer Quality**: Evaluates whether your public channels connect to other well-performing routing nodes. This recognizes that node effectiveness depends on both your performance and the quality of network connections. +**5. Channel Stability** -### Leveraging Recommended Channels +Do your channels stay open and active, or do they frequently go offline? This check penalizes nodes whose channels are unstable, where peers disconnect often or where channels are opened and closed in rapid succession. Stability signals to the network that your node is a reliable routing partner. -The Recommended Channels feature provides curated suggestions for new channel partners that benefit both your node and the broader Lightning Network. Access this feature from the channels tab to see potential peers with information including network rank, alias, centrality measures, and total capacity. +**6. Many Good Peers** -These recommendations serve dual purposes: identifying stable peers that would benefit from additional well-connected partners, and promoting network health by encouraging connections that decentralize routing paths and allocate capital where most needed. When you open a channel to a recommended node, you contribute to overall Lightning Network resilience and efficiency. +This is the most demanding check. It evaluates not just your own node's performance, but the quality of the nodes you connect to. Your public channels should reach out to **other well-performing routing nodes**. A node that connects only to poorly maintained or unreliable peers inherits some of that unreliability, because payments that route through your node depend on your peers being available and well-connected too. -The recommended nodes represent carefully selected candidates based on performance history and network position. Click on any recommendation to view detailed information including activity duration, peer count, and specific Health Checks passed. This transparency allows informed decisions about channel partnerships that align with your node's strategy and capacity allocation goals. +In Terminal's terminology, a **"stable peer"** is a node that passes five of the six health checks, typically all checks except this last one ("many good peers"). This definition becomes important for the Recommended Channels feature, which we will explore next. -### Optimizing Your Node's Performance +### Understanding Your Scores -Regular monitoring of Health Check performance and thoughtful selection of new channel partners from the recommended list optimizes your node's effectiveness while supporting network growth. Understanding these tools empowers active management of your node's health and contribution to the Lightning Network's continued expansion and decentralization. +Each health check includes a link to more detailed documentation. If you pass some checks but fail others, these links provide actionable guidance on how to improve. Here is a general diagnostic approach: -By leveraging both Health Checks for performance assessment and Recommended Channels for strategic growth, you can maintain a well-functioning node that serves both your operational goals and the broader network's needs. +| Failed Check | Likely Cause | Action | +|-------------|-------------|--------| +| Node is online | Uptime issues | Investigate network stability, configure systemd for auto-restart | +| Plenty of channels | Too few connections | Open additional channels to well-connected peers | +| Good routing capacity | Channels depleted on one side | Rebalance using Loop (covered in a later chapter) | +| Many healthy channels | Inactive or undersized channels | Close inactive channels, open larger ones | +| Channel stability | Frequent opens/closes or peer disconnections | Choose more stable peers, investigate network issues | +| Many good peers | Connected to poorly performing nodes | Open channels to recommended peers (see below) | + +### Recommended Channels + +Scroll down on the Channels tab of the homepage, and you will find the **Recommended Channels** section. This feature identifies nodes on the network that would benefit from a well-connected peer, and it suggests that you be that peer. + +The recommendation logic works as follows: Terminal identifies "stable peers," nodes that pass five of six health checks (everything except "many good peers"). These are reliable, well-maintained nodes that simply need better-connected partners to reach their full routing potential. When you open a channel to one of these recommended nodes, the benefit operates on three levels: + +1. **Your node** gains a new, reliable routing partner +2. **The recommended peer** may pass its final health check, becoming a fully healthy routing node +3. **The network as a whole** benefits from more decentralized routing paths and better capital allocation + +For each recommended node, Terminal displays its rank, alias, centrality score, and total capacity. You can click on any recommendation to view detailed information, including how long the node has been active, how many peers it has, and which health checks it passes. + +It is worth noting that opening a channel to a recommended peer does not guarantee that the peer will pass its final health check. Success also depends on the capacity you allocate to the channel and ongoing maintenance of that channel's liquidity balance. + +### Summary + +In this chapter, we explored Terminal's Health Checks framework and the Recommended Channels feature. We learned that the six health checks evaluate routing-specific performance: uptime, channel count, bidirectional capacity, channel health, stability, and peer quality. We also discovered how the recommendation system identifies stable peers that would benefit from new connections, creating a virtuous cycle of network improvement. + +In the next chapter, we will dive into the data that Terminal provides about your node's financial performance, routing activity, and channel-level analytics. ## Insights, Forwards, and Channels 37799ff2-ca5a-4db4-aa21-fed5a5420be4 ![video](https://www.youtube.com/watch?v=Mv7wMwnr-Sw) -### Financial Performance and Node Analytics +Now that we understand how Terminal evaluates our node's health, let's explore the financial and operational data it provides. The Terminal Web homepage is effectively your node's command center, consolidating routing data, profitability metrics, and channel analytics into a single interface. In this chapter, we will examine the four key performance indicators, the forwarding log, the top routes analysis, and the channel management tools that make Terminal such a powerful operational dashboard. + +### The Four Key Performance Indicators + +At the top of the Terminal homepage, you will find four metrics that provide an instant snapshot of your node's financial performance: + +| Metric | What It Measures | +|--------|-----------------| +| **Spent Satoshis** | Total operational costs: on-chain fees for opening and closing channels, routing fees paid when sending payments, rebalancing costs | +| **Earned Satoshis** | Revenue generated from forwarding payments through your node | +| **Net Profit** | Earned Satoshis minus Spent Satoshis | +| **ROI (Return on Investment)** | Net Profit relative to the total capital locked in your channels | + +These four numbers tell you, at a glance, whether your node is operating at a profit or a loss. If you are running a routing node with the goal of earning fees, this is where you assess whether your strategy is working. If your node is not optimized for routing (perhaps it exists primarily to support a specific application or service), a negative ROI is not necessarily a problem; it simply reflects a different use case. + +You can adjust the **time period** for these metrics using the controls at the top of the dashboard. This allows you to isolate specific periods, which is particularly useful when evaluating the impact of a fee policy change or a new channel opening. + +### Profit and Loss Breakdown + +For deeper financial analysis, click through to the **Profit and Loss breakdown**. This view itemizes your revenue sources and expense categories, providing granular visibility into where your satoshis are flowing. The breakdown shows: + +- How you have been **earning fees** (which channels and routes generate the most revenue) +- How you have been **spending satoshis** (channel opening costs, routing fees, rebalancing expenses) + +One of the most practical features here is the **CSV export** button. You can download your complete profit and loss data and import it into a spreadsheet for external accounting, tax reporting, or more sophisticated financial modeling. For operators who manage multiple nodes or need to report to stakeholders, this bridges the gap between node management and traditional bookkeeping. + +### Top Routes + +Below the KPI summary, you will find the **Top Routes** section. This is where Terminal reveals the specific payment pathways that drive the majority of your forwarding volume and fee revenue. + +Understanding your top routes is strategically important. If a particular channel combination consistently generates the highest fees, that tells you several things: those channels have adequate liquidity, the fee rates are attracting traffic, and the peers on either end are active routing participants. These are the channels you want to pay the most attention to when it comes to liquidity management. + +The analysis breaks down further into **Top Outbound** and **Top Inbound** categories. This distinction helps you understand the directionality of your traffic: + +- **Top Outbound** channels are the ones through which payments most frequently leave your node. These channels tend to drain your local (outbound) balance over time. +- **Top Inbound** channels are the ones through which payments most frequently arrive at your node. These channels accumulate local balance over time. + +Understanding these flow patterns is crucial for anticipating liquidity needs. If a high-earning outbound channel is steadily draining, you know you will eventually need to replenish its local balance (using Loop In, for example) to keep the revenue flowing. + +### The Forwards Log + +Scrolling down further, you reach the **Forwards** section. This is a comprehensive log of every payment your node has forwarded, displayed both as a time-series graph and as a detailed event list. + +The graph provides a visual overview of routing activity over time. You can adjust the time window to zoom in on specific periods of interest. Below the graph, each forwarding event is logged individually, showing: + +- The timestamp of the forward +- The amount forwarded +- The fee earned for facilitating that payment + +This level of detail creates an audit trail that is invaluable for troubleshooting. If you notice a drop in forwarding activity, you can correlate it with specific events: a channel going offline, a fee policy change, or a liquidity imbalance that developed on a key route. + +### The Channels Tab + +Let's now turn to the **Channels** tab, which represents the operational core of Terminal Web. At the top level, you will see aggregate statistics: + +- **Total channels** (active and inactive) +- **Total outbound capacity** (your ability to send or route outward) +- **Total inbound capacity** (your ability to receive or route inward) -Terminal Web serves as the primary command center for Lightning Network node operators, consolidating complex routing data into a streamlined financial interface. The dashboard’s homepage is anchored by four key performance indicators (KPIs) that provide an instant health check of the node's operations: **Return on Investment (ROI)**, **Net Profit**, **Earned Satoshis**, and **Spent Satoshis**. +But the real power of this tab lies in the **per-channel liquidity visualization**. For each channel, Terminal displays a visual bar showing the balance distribution between local (outbound) and inbound liquidity. At a glance, you can see: -These metrics are dynamically calculated to offer a transparent view of profitability. "Spent Satoshis" aggregates all operational costs, such as on-chain transaction fees for opening and closing channels, as well as costs associated with rebalancing liquidity. Conversely, "Earned Satoshis" tracks the revenue generated from forwarding payments for other network participants. The platform automatically synthesizes these figures into a Net Profit value, while the ROI metric contextualizes this profit against the total capital locked in channels. +- Channels that are **local-heavy** (full of outbound liquidity, depicted on the left side of the bar) +- Channels that are **remote-heavy** (full of inbound liquidity, depicted on the right side of the bar) +- Channels that are **well-balanced** (liquidity distributed roughly evenly) -To support deeper analysis, the dashboard allows operators to adjust the timeframe of these metrics, enabling the isolation of specific periods to evaluate the impact of fee policy changes or market volatility. A dedicated Profit and Loss (P&L) breakdown feature itemizes revenue sources and expense categories, offering granular visibility into financial flows. For operators integrating with external accounting software or performing complex modeling, this data can be exported directly to CSV formats, bridging the gap between node management and traditional bookkeeping. +This visual representation is far more efficient than reading through numerical tables. In a few seconds, you can scan all your channels and identify which ones need attention. -### Routing Intelligence and Traffic Analysis +### Per-Channel Analytics -Beyond high-level financials, Terminal Web provides critical insights into the actual movement of funds through the node via its routing analysis tools. The **Top Routes** feature is essential for strategic optimization; it identifies the specific pathways and channel combinations that drive the majority of the node's forwarding volume. Recognizing these high-value routes allows operators to prioritize liquidity maintenance where it generates the most significant return. +Click on any individual channel, and Terminal reveals detailed metrics: -This analysis is segmented into "Top Outbound" and "Top Inbound" categories. This distinction helps operators understand the directionality of their traffic—identifying which peers are primarily sources of liquidity versus those that act as sinks. Understanding these flow patterns is crucial for preempting liquidity exhaustion on critical paths. Additionally, the dashboard maintains a comprehensive **Forwards Log**, which visualizes routing activity over time and provides a detailed history of individual forwarding events. Each entry logs the amount forwarded and the specific fee earned, creating an audit trail that is invaluable for troubleshooting failed routes or validating the effectiveness of fee adjustments. +- **Satoshis earned** through that specific channel +- **ROI** for channels you opened (comparing earned fees against the on-chain cost of opening the channel) +- **Peer information** including the node alias and public key +- **Channel status** (active or inactive) +- **Total capacity** of the channel -### Channel Management and Liquidity Visualization +The ROI calculation is particularly valuable for evaluating past decisions. If you opened a channel and the fees it has generated exceed the on-chain cost of creating it, that channel is profitable. If not, you may want to consider whether to keep it open or reallocate that capital elsewhere. -The Channels tab represents the operational core of Terminal Web, offering a detailed inventory of every peer connection. At the top level, it presents aggregate statistics, including the total count of active versus inactive channels and the node's overall inbound and outbound capacity. However, the most practical tool for daily operations is the **Liquidity Visualization**. +### Channel Actions -Rather than displaying raw numbers, Terminal Web utilizes visual bars to represent the balance distribution of each channel. This makes it immediately apparent which channels are "local-heavy" (full of outbound liquidity) or "remote-heavy" (full of inbound liquidity). This visual scan is far more efficient than parsing numerical tables, allowing operators to quickly identify channels that require rebalancing to maintain routing efficiency. +From the channel detail view, you can take direct action: -#### Advanced Channel Actions -Terminal Web goes beyond passive monitoring by integrating actionable controls directly into the analytics interface. Each channel displays a calculated ROI—specifically for channels initiated by the local operator—comparing earned fees against the on-chain cost of opening the channel. This per-channel profitability metric is decisive when determining whether to keep a connection alive. From this same interface, operators can execute critical lifecycle actions: they can adjust fee policies to influence traffic flow or initiate channel closures for underperforming peers. The system also logs all channel lifecycle events—opens, cooperative closes, and force closes—providing a historical context that helps operators refine their peer selection strategy over time. +- **Update the fee policy** for that specific channel. If a channel is underperforming, adjusting its fee rate may attract more routing traffic. If it is being depleted too quickly, raising the fee can slow the drain. +- **Close the channel** if it is consistently inactive or unprofitable. Closing an underperforming channel frees up capital that can be redeployed to a more productive peer. + +Terminal also logs all **channel lifecycle events**, including opens, cooperative closes, and force closes. This history appears in the **Channel Actions** section and provides context for understanding changes in your channel count over time. If you notice your channel count dropped unexpectedly, check this log to see whether a peer force-closed on you, or whether an old inactive channel was cleaned up. + +### Summary + +In this chapter, we explored Terminal's financial dashboard and channel management tools. We examined the four KPIs that summarize node profitability (Spent Sats, Earned Sats, Net Profit, ROI), the Top Routes analysis for identifying high-value payment paths, the Forwards log for auditing individual routing events, and the Channels tab for visual liquidity management and per-channel analytics. + +In the next chapter, we will discover how to automate one of the most time-consuming aspects of node management: fee adjustment. The Autofees feature can significantly reduce your operational overhead while improving both fee earnings and liquidity balance. ## Autofees c6264c0b-10f6-4261-8d1e-47593168d8ca ![video](https://www.youtube.com/watch?v=wglBEUtXgTo) -### Automating Channel Fees with Lightning Terminal +If you have been managing a Lightning routing node for any length of time, you know that fee management is one of the most persistent operational challenges. Set your fees too high, and traffic stops flowing through your channels. Set them too low, and you underprice your liquidity, draining your outbound capacity without earning adequate compensation. In this chapter, we will explore **Autofees**, a Terminal feature that automates fee adjustments on a per-peer basis, adapting dynamically to changes in demand and routing flows. + +### Why Automate Fees? + +Manual fee management requires constant attention. Each channel has its own traffic patterns, each peer behaves differently, and market conditions shift over time. An operator managing dozens of channels would need to monitor each one individually, compare forwarding volumes, evaluate whether current fees are capturing enough value, and adjust accordingly. This is time-consuming and error-prone. + +Autofees addresses this by applying an intelligent algorithm that observes your node's routing history and adjusts fees incrementally. The goal is twofold: **stabilize traffic** to prevent the feast-or-famine pattern that many routing nodes experience, and **prevent underpricing of liquidity** so that your outbound capacity is not drained without fair compensation. + +### How the Algorithm Works + +The Autofees engine does not apply random or uniform adjustments. It operates on a comparative analysis of historical performance, and it works on a **per-peer basis**, not as a blanket policy across your entire node. + +Here is the core mechanism: + +1. **Establish a baseline.** The algorithm examines the forwarding traffic of your **top five earning peers over the past 60 days**. This establishes a reference throughput: how much volume, under what conditions, generated the best returns. + +2. **Compare recent activity.** The algorithm then looks at forwarding traffic from the **past few days** and compares it against this 60-day baseline. + +3. **Adjust accordingly.** + - If recent traffic **exceeds** the baseline, the algorithm interprets this as a demand surge and may incrementally **increase fees** to capture more revenue. + - If recent traffic **falls below** the baseline, the algorithm interprets this as a demand slump and may **decrease fees** to attract more routing volume. + +4. **Liquidity protection.** When a channel reaches approximately **7/8ths depletion** (only 1/8 of its capacity remaining on one side), fees increase mildly to signal scarcity and discourage further draining. + +Updates occur in **small increments every three days**. This conservative pacing minimizes network gossip overhead (since fee policy changes must be broadcast to the network) and prevents the algorithm from overreacting to short-term fluctuations. + +In other words, Autofees behaves like a patient, data-driven operator who checks each channel's performance every few days and makes small, targeted adjustments based on what the numbers say. + +### Privacy Architecture + +A natural concern when enabling any automated tool is: what data does it access, and who can see it? Autofees is designed with the **principle of least privilege** in mind. + +When you enable Autofees, Terminal establishes a dedicated **Lightning Node Connect (LNC)** session with strictly limited permissions: + +| Access Type | Scope | +|------------|-------| +| **Read** | Forwarding history, channel balances, current fee policies | +| **Write** | Fee policy updates only (cannot spend funds, close channels, or alter other node settings) | + +This means the Autofees session cannot move your money, cannot close your channels, and cannot modify anything beyond fee rates. The session is visible in `litd` and can be revoked at any time. + +To further protect your privacy, `litd` employs a **Privacy Mapper** that obfuscates sensitive data before it leaves your node. Specifically: + +- **Channel IDs** are mapped to random values +- **Channel points** are obfuscated +- **Node public keys** are obfuscated +- **Amounts in forwarding data** are randomly altered to break amount correlation +- **Timestamps in forwarding data** are randomly altered to break time correlation + +The Privacy Mapper ensures that the external algorithm can optimize fee calculations without knowing your node's specific identity or topology. You can inspect these mappings at any time using the command line: + +```bash +litcli privacy +``` + +This command lets you manually convert between real and privacy-mapped values for debugging purposes. + +### Configuration Prerequisites + +Before enabling Autofees, you need to verify two configuration items. + +**Required: Enable RPC Middleware** + +Open your LND configuration file: -Managing a Lightning Network node involves a constant trade-off between liquidity and revenue. If fees are too high, traffic stops; if fees are too low, the node operator underprices their liquidity and drains their outbound capacity without sufficient compensation. Lightning Terminal’s **Auto-Fees** feature addresses this by automating fee adjustments. +```bash +nano ~/.lnd/lnd.conf +``` + +Ensure this line is present: + +```ini +rpcmiddleware.enable=true +``` + +Without this setting, Autofees cannot intercept and modify fee policies. If you followed the installation in Chapter 1.1, you already have this configured. + +**Recommended: Set a High Initial Fee Rate** + +Lightning Labs recommends setting a relatively high default fee rate before enabling Autofees: + +```ini +bitcoin.feerate=2500 +``` + +The reasoning is strategic: the algorithm can safely **lower** fees from a high starting point to find the optimal rate. If you start with a low fee rate, the algorithm has limited upward room and your channels may be drained before fees adjust sufficiently. Starting high is the conservative approach; the algorithm will find the right level by adjusting downward. + +**Important side effect:** Enabling Autofees automatically sets the channel **CLTV delta to 100 blocks**. The CLTV delta (CheckLockTimeVerify) is the number of blocks your node requires for HTLC timeout. A value of 100 is reasonable for most routing nodes, but you should be aware of this automatic change. + +### Enabling Autofees -Instead of requiring the operator to manually tune channel policies daily, Auto-Fees employs an intelligent algorithm designed to stabilize routing traffic. The system dynamically adapts to changing market conditions, aiming to maximize fee revenue while maintaining a healthy flow of payments. This automation allows operators to move away from micromanagement and focus on high-level strategy, preventing the common issue of underpricing liquidity during periods of high demand. +With the prerequisites in place, enabling Autofees takes just a few clicks in the Terminal interface: -### Algorithmic Logic and Traffic Analysis +1. Navigate to the **Loop** tab in Terminal +2. Click **Autopilot** +3. Click **Enable** +4. Review the per-channel toggles and adjust as needed +5. Click **Save** -The Auto-Fees engine does not apply random adjustments; it operates on a comparative analysis of historical performance. When enabled, the system establishes a performance baseline by analyzing the forwarding traffic of the node’s **top five earning peers** over a roughly 60-day period. +That is it. The algorithm begins working immediately, establishing its baseline from your historical forwarding data. -Once this baseline is established, the algorithm monitors forwarding activity from the immediate past (the last few days) and compares it against the historical trend. -* **Demand Surges:** If recent traffic exceeds the baseline, the algorithm may incrementally increase fees to capture more revenue from the high demand. -* **Demand Slumps:** If traffic drops below the baseline, the algorithm may lower fees to attract routing volume and re-establish flow. +### Per-Peer Granularity -Crucially, this logic is applied on a **per-peer basis**. The system does not enforce a blanket policy across the entire node but rather tailors adjustments to the specific routing dynamics of each channel relationship. Despite this automation, the operator retains ultimate sovereignty; manual overrides are always possible, allowing the user to lock specific fees for strategic peers regardless of the algorithm’s suggestions. +One of the most practical aspects of Autofees is that you can **enable or disable it on a per-channel basis**. After enabling the feature globally, scroll down to see the list of your channels with individual toggles. -### Privacy Architecture and Security +This allows a hybrid management approach: -A primary concern for node operators using automated tools is the security of their node credentials and the privacy of their routing data. Auto-Fees is architected to operate with the principle of least privilege using **Lightning Node Connect (LNC)**. +- **Automated channels**: Enable Autofees for channels where you are unsure of the optimal fee rate or where manual management is too time-consuming +- **Manual channels**: Keep Autofees disabled for strategic peers where you have a specific fee policy in mind (for example, a channel to Loop's node where you want a fixed rate) -When Auto-Fees is activated, Terminal establishes a dedicated, isolated LNC session. This session is restricted by strict permissions: -* **Read Access:** Limited to forwarding history, channel balances, and current fee policies. -* **Write Access:** Strictly limited to updating fee policies. It cannot spend funds, close channels, or alter other node settings. +Even with Autofees enabled, you retain the ability to **manually override any fee rate at any time**. The algorithm will respect your manual changes and factor them into subsequent adjustments. -To further protect operator data, LitD employs a **Privacy Mapper**. Before any data leaves the local node environment to be processed by the Auto-Fees logic, the Privacy Mapper obfuscates sensitive identifiers such as Channel IDs, Channel Points, and Node Public Keys. This ensures that the external logic can optimize the math without exposing the node’s specific identity or topology map to the central server. Operators can verify this obfuscation via the LitD command-line interface and revoke the session at any time. +### Operational Best Practices -### Configuration and Activation +A few guidelines to get the most out of Autofees: -Implementing Auto-Fees requires specific node configurations to function correctly. The most critical prerequisite is enabling the RPC middleware in the `lnd.conf` file. Without setting `rpcmiddleware.enable=true`, the Terminal cannot intercept and modify the fee policies. +- **Do not restart Autofees unnecessarily.** Restarting the feature causes the algorithm to re-establish its baseline, which can lead to false double-counting of forwarding data across overlapping periods. +- **Be patient.** The algorithm updates every three days. Give it at least two to three weeks to establish meaningful patterns before evaluating its performance. +- **Algorithm improvements are deployed server-side.** You do not need to upgrade `litd` to receive the latest version of the Autofees algorithm. Improvements are delivered through Terminal automatically. +- **Monitor the results.** Use the Insights and Forwards data we explored in the previous chapter to evaluate whether Autofees is improving your fee revenue and liquidity balance over time. -**Recommended Baseline:** -Lightning Labs recommends setting a default `base_fee_msat` of approximately **2,500 millisatoshis** in the configuration. This specific value provides the algorithm with necessary "headroom"—a middle ground that allows the system flexibility to adjust fees both upward and downward as needed without hitting floor or ceiling constraints immediately. +### Summary -**Enabling the Feature:** -Once the configuration is set, activation is handled via the Terminal UI: -1. Navigate to the **Loop** tab. -2. Select **Autopilot**. -3. Click **Enable**. +In this chapter, we explored Autofees, Terminal's automated fee management feature. We learned that the algorithm establishes a 60-day baseline from your top-earning peers, compares recent traffic against that baseline, and makes small per-peer adjustments every three days. We examined the privacy architecture, including the dedicated LNC session with restricted permissions and the Privacy Mapper that obfuscates your node's identity. We configured the prerequisites (`rpcmiddleware.enable=true` and a high initial fee rate) and walked through the activation process in the Terminal UI. -The interface provides granular control, allowing operators to toggle Auto-Fees on or off for individual channels. This allows for a hybrid management style, where stable, high-volume channels are managed automatically, while experimental or strategic private channels remain under manual control. +With Autofees running, your node can adapt to changing market conditions without constant manual intervention, freeing you to focus on higher-level strategy: choosing peers, managing liquidity through Loop, and expanding your routing capacity through Pool. These are exactly the topics we will cover in the chapters ahead. + +# Managing Your Node's Network +b6bc2556-170a-4992-8046-a8756d91a6b6 ## Multi-Node Connections 9f6f9bf3-999e-4dad-9d2d-0b725178d754 ![video](https://www.youtube.com/watch?v=SGY9h8JW4go) -### Unified Infrastructure Management +As your Lightning infrastructure grows, a natural question arises: how do we manage multiple nodes without juggling separate browser sessions, bookmarks, and login credentials for each one? Whether you are running a mainnet routing node alongside a testnet playground, maintaining redundant backups, or overseeing nodes for different organizations, the overhead of context-switching between isolated dashboards quickly becomes a bottleneck. + +Lightning Terminal solves this with its **multi-node connection system**. In this chapter, we will explore how to generate connection strings for multiple nodes, onboard them into a single Terminal workspace, and switch between them instantly. The process is remarkably straightforward, but the security implications deserve careful attention. + +### Generating a Connection String + +The foundation of every Terminal connection is the **connection string**, a cryptographic pairing phrase generated by Lightning Node Connect (LNC). Because LNC works through outgoing connections to a web proxy, you do not need to open any ports on your firewall or modify your Tor configuration. The node reaches out to the proxy; the proxy never reaches in. -Lightning Terminal has evolved from a single-node utility into a comprehensive infrastructure management platform. The **Multi-Node Interface** enables operators to oversee distinct Lightning Network nodes—whether they are redundant backups, separate routing nodes, or nodes operating on different networks (e.g., Mainnet vs. Testnet)—from a single, unified dashboard. +You can generate connection strings through the LitD web interface, but the command line gives us more explicit control over the session parameters. Let's examine the `litcli` command that creates a new administrative session: -This architecture eliminates the friction of logging in and out of different browser sessions or managing multiple disparate URLs. The integration is designed to be lightweight yet robust; adding a new node does not dilute the functionality available. Whether an operator manages two nodes or a dozen, the full suite of Terminal tools—Loop for liquidity, Pool for leasing, and health monitoring—remains fully accessible for every specific instance connected to the workspace. +```bash +litcli --network=testnet sessions add --label="Routing-Node-East" --type=admin +``` + +Let's break down each parameter: + +- `--network=testnet` specifies the network this node operates on (use `mainnet` for production nodes). +- `sessions add` tells `litcli` to create a new LNC session. +- `--label="Routing-Node-East"` assigns a human-readable name that will appear in the Terminal dropdown, helping you distinguish nodes at a glance. +- `--type=admin` grants full administrative privileges over the node. For read-only monitoring, you could use `--type=readonly` instead. + +When you execute this command, `litcli` outputs a connection string. In other words, this string is the cryptographic key that authorizes Terminal to communicate with your node. It looks something like a long encoded phrase, and it is the only thing standing between an attacker and full administrative access to your channels and funds. + +**This point is critical**: treat every connection string with the same care you would give a private key. Never paste it into a public chat, never transmit it over an unencrypted channel, and never store it in plaintext alongside other credentials. Once you have used it to pair with Terminal, the string is consumed and cannot be reused, but until that moment, anyone who possesses it can connect. + +### Connecting Your First Node + +With the connection string in hand, we navigate to the Terminal web interface and click the **Connect My Node** button. After pasting the string, Terminal prompts us to create a **session password**. This is a critical secondary security layer: even if someone gains access to the browser or device running Terminal, they cannot interact with your node without entering this password. + +In other words, the connection string authenticates the node-to-proxy link, while the session password protects the local browser session. Together, they form a two-factor model that keeps your node secure. -### Generating Connection Credentials +Once the password is confirmed, Terminal establishes the encrypted connection. You will see your node's dashboard populate with its channels, balances, health checks, and routing data. At this point, the first node is fully onboarded. -The foundation of the multi-node setup is the **Connection String**. Because Terminal operates securely over Lightning Node Connect (LNC), it does not require opening ports on your firewall. Instead, each node must generate a unique, cryptographic pairing phrase that authorizes the Terminal interface to communicate with the Lightning Terminal Daemon (LitD). +### Adding Additional Nodes -Operators can generate these strings via the LitD UI, but the Command Line Interface (CLI) offers granular control for power users. Using the `litcli` tool, an operator creates a session by defining specific parameters: -* **Network:** Specifies if the node is on `mainnet` or `testnet`. -* **Label:** Assigns a human-readable alias (e.g., "Routing-Node-East") to distinguish the node in the UI. -* **Type:** Defines the permission scope, typically set to "admin" for full management capabilities. +To add a second (or third, or tenth) node, we follow the exact same procedure on the other machine. Let's say we have a second testnet node. We SSH into it and generate another connection string: -#### Security Implications -The generated connection string contains the authentication data necessary to administer the node. It functions effectively as a private key for administrative access. Consequently, these strings must be handled with extreme care—never shared in public forums or transmitted over unencrypted channels. Possession of the string grants the holder the ability to manipulate the node's channels and funds through the Terminal interface. +```bash +litcli --network=testnet sessions add --label="L402-Fun-Node" --type=admin +``` + +Back in the Terminal interface, we click **Add Node** in the header area, paste the new connection string, and set a password for this session. Terminal treats each connection independently, maintaining separate authentication tokens and session states. + +After confirmation, both nodes are now available in your workspace. + +### Context Switching Between Nodes -### The Connection Workflow and Context Switching +Once multiple nodes are onboarded, the **node selector dropdown** in the Terminal header becomes your primary navigation tool. Clicking it reveals a list of all connected nodes, identified by the labels you assigned during session creation. -Connecting the first node establishes the baseline workspace. The operator selects "Connect My Node" and pastes the generated connection string. Crucially, Terminal enforces a secondary security layer: **The Session Password**. Upon pasting the string, the user must define a local password. This ensures that even if the physical device running the browser is compromised, the active Terminal session cannot be used to interact with the node without this second factor of authentication. +When you select a different node, the entire dashboard context refreshes instantly: -Adding subsequent nodes follows an identical pattern via the "Add Node" option in the interface's header. Terminal treats each connection independently, maintaining separate authentication tokens and session states for each node. +- **Metrics update**: ROI, net profit, earned sats, and spent sats reflect the selected node's data. +- **Channel list refreshes**: you see only the peers and channels associated with the active node. +- **Tool state changes**: the Loop, Pool, and Autopilot interfaces update to show swaps, auctions, and fee configurations relevant to the currently selected node. -**Operational Context Switching:** -Once multiple nodes are onboarded, the **Node Selector** dropdown becomes the primary navigation tool. Switching between nodes is instantaneous. When a new node is selected, the entire dashboard context shifts. -* **Metrics Update:** ROI, net profit, and routing history immediately reflect the selected node's data. -* **Channel Management:** The channel list refreshes to show peers associated only with the active node. -* **Tool State:** Loop and Pool interfaces update to show swaps and auctions relevant to the currently selected entity. +This efficient switching mechanism allows operators to maintain situational awareness across their entire fleet. If you notice a liquidity imbalance on one node, you can address it immediately, then switch to another node to check on a pending channel opening, all without leaving the Terminal workspace. -This efficient switching mechanism allows operators to maintain high-level situational awareness across their entire fleet, rapidly responding to liquidity imbalances or alerts on any specific node without leaving the command center. +### Summary + +In this chapter, we saw how to generate LNC connection strings via `litcli`, onboard multiple nodes into a single Terminal session, and switch between them using the node selector dropdown. The key takeaway is that **multi-node management requires no additional infrastructure**: the same LNC protocol that secures a single connection scales seamlessly to many. In the next chapter, we will put these connected nodes to work by opening channels efficiently using batch transactions. + +--- ## Opening Channels & Batching c7e83bd9-df1c-4763-8401-488b733d835c ![video](https://www.youtube.com/watch?v=VmvwM-zv2i0) -### The Economics of Batch Opens +Now that we can manage our nodes from a single interface, let's examine one of the most important operations any node operator performs: opening payment channels. More specifically, we will learn how to open multiple channels simultaneously using a single on-chain transaction, a feature called **batch opens**. -In the Lightning Network, every payment channel is anchored by an on-chain Bitcoin transaction. Traditionally, establishing a robust node with multiple peers required a separate transaction for each channel. This approach is inefficient, consuming significant block space and incurring separate mining fees for every single connection. +To understand why this matters, we first need to appreciate the cost structure of channel creation. -Lightning Terminal solves this with **Batch Opens**. This feature allows node operators to aggregate multiple channel openings into a single on-chain transaction. +### Why Batching Matters -The technical advantage is substantial. Instead of broadcasting five separate transactions to open five channels (paying overhead bytes for inputs and signatures five times), a batch open consumes a single UTXO (or set of UTXOs) and creates multiple outputs—one for each channel—within the same transaction envelope. This consolidation drastically reduces the cost per channel, making it a critical strategy for liquidity management during periods of high on-chain fee pressure. It also optimizes the node's UTXO set, preventing the fragmentation of wallet funds into "dust" outputs. +Every Lightning payment channel is anchored by an on-chain Bitcoin transaction. This transaction creates a **2-of-2 multisignature output** that locks funds cooperatively between you and your peer. Traditionally, if you wanted to open five channels, you would broadcast five separate transactions to the Bitcoin network, each one consuming its own inputs, paying its own mining fees, and occupying its own block space. -### Configuring the Batch Workflow +This approach is wasteful for two reasons. First, each transaction carries overhead bytes for its inputs, signatures, and metadata, so you pay miner fees five times for work that could largely be consolidated. Second, if you are spending from a single large UTXO, each individual transaction produces a change output, fragmenting your wallet into progressively smaller pieces. Over time, this **UTXO fragmentation** leads to higher fees on future transactions because spending many small UTXOs requires more input data than spending one large one. -The process begins in the Terminal dashboard via the **Open Channel** interface. To initiate a batch, the operator requires the public identity keys of the target peers. +**Batch opens solve both problems at once.** By aggregating multiple channel openings into a single transaction, you consume one set of inputs, pay one mining fee (amortized across all channels), and produce a clean set of outputs: one per channel, plus a single change output returning the remainder to your wallet. -The workflow is iterative: -1. **Peer Identification:** Enter the Public Key of the first peer. Terminal validates the node's existence on the network. -2. **Capacity Allocation:** Define the channel size in satoshis. This determines the liquidity locked into that specific connection. -3. **Parameter Setup:** Configure initial routing fees (Base Fee and Fee Rate) and visibility settings (Public vs. Private). +In other words, if opening five channels individually might cost you 5,000 satoshis in total fees, batching them together might cost only 1,500 satoshis for the same result. The savings scale with the number of channels and the prevailing fee environment. -#### Channel Visibility and Fees -A critical decision point during configuration is the channel's visibility. **Public Channels** are broadcast to the network graph, enabling random nodes to route payments through them, generating fee revenue. **Private Channels** remain unannounced, visible only to the two direct peers. These are ideal for mobile wallets or merchant terminals that do not intend to route third-party traffic. Similarly, initial fee settings dictate the channel's competitiveness; while defaults are provided, experienced operators tune these metrics based on the specific peer's reliability and location in the network topology. +### Preparing for a Batch Open -### Execution and On-Chain Verification +Before you begin, you need two things: -The true utility of the batch feature is the **"Add Channel"** function. Rather than finalizing the transaction after configuring one peer, the operator stacks additional peers into the same session. As new channels are added, the marginal cost of each addition is negligible compared to the base cost of the transaction. +1. **Sufficient on-chain funds** in your LND wallet to cover the total capacity of all channels plus the mining fee. +2. **The public keys** of the peers you want to connect with. You can find these through the Terminal Explorer tab, through Lightning network explorers like [1ML](https://1ml.com/) or [Amboss](https://amboss.space/), or by asking the node operator directly. -Once the batch is fully assembled, the operator sets the **Mining Fee**. This fee pays the Bitcoin miners to confirm the aggregate transaction. Because this single fee is amortized across all new channels, the effective cost per channel drops significantly. +A public key (also called a **node identity key**) is a 66-character hexadecimal string that uniquely identifies a node on the Lightning Network. It looks something like this: -**Verification:** -After the transaction is broadcast, the channels enter a "pending" state until confirmed. Verification can be performed via any block explorer. A properly executed batch transaction will display a distinct structure: -* **Inputs:** One or more UTXOs from the node's wallet. -* **Outputs:** Multiple outputs of equal or varying values (representing the funded channels). -* **Change Output:** A single output returning any remaining funds to the node's internal wallet. +``` +02e7a7d3c1e6055b7b7457d95e04d9bbd24f200fd4a58daca7beee7bc776e17440 +``` + +### Walking Through the Batch Workflow + +Let's open two channels simultaneously using the Terminal interface. Here is the step-by-step process: + +**Step 1: Initiate the first channel.** +Click the **Open Channel** button on the Terminal homepage. Paste the public key of your first target peer into the search field. Terminal validates that this node exists on the network and is reachable. + +**Step 2: Set the channel capacity.** +Define how many satoshis you want to commit to this channel. For example, we might allocate 1,000,000 satoshis (0.01 BTC): + +``` +Channel capacity: 1,000,000 sats +``` + +This amount becomes the total capacity of the channel, initially sitting entirely on your side as outbound liquidity. + +**Step 3: Configure fees and visibility.** +Terminal presents two important configuration options: + +- **Fee settings**: the base fee and fee rate that your node will charge for routing payments through this channel. You can accept the defaults or tune them based on your routing strategy. +- **Channel visibility**: choose between a public or a private channel. + +**Public channels are broadcast** to the network graph, meaning any node can discover them and attempt to route payments through them. This is the standard choice for routing nodes that want to earn forwarding fees. + +**Private channels remain unannounced.** Only you and your direct peer know the channel exists. This is appropriate for mobile wallets, merchant terminals, or any situation where you want to send and receive without advertising your channel to the wider network. + +**Step 4: Add another channel to the batch.** +Here is where the magic happens. Instead of clicking "Submit," click **Add Channel**. This stacks a second channel into the same pending transaction. Paste the public key of your second peer, configure the capacity, fees, and visibility just as before. + +You can repeat this step as many times as you need. Each additional channel adds minimal marginal cost to the transaction. + +**Step 5: Set the mining fee and broadcast.** +Once all channels are queued, Terminal presents a final screen where you select the **mining fee rate** for the entire batch transaction. A higher fee rate means faster confirmation; a lower fee rate saves money but may take longer to confirm. Choose based on your urgency. -This on-chain footprint confirms that the batch logic was executed correctly, locking funds into the 2-of-2 multisignature addresses required for the Lightning channels while maximizing capital efficiency. +Click the **Batch Open Channels** button to broadcast the transaction. + +### Verifying on a Block Explorer + +After broadcasting, the channels enter a **pending confirmation** state while the transaction awaits confirmation. You can verify the batch structure by looking up the transaction on any block explorer. A properly executed batch transaction will show: + +- **Transaction inputs**: one or more UTXOs from your LND wallet. +- **Channel outputs**: multiple outputs of varying sizes (one per channel, each matching the capacity you specified). +- **Change output returned**: a single output returning the remaining funds to your wallet. + +For example, if you opened two channels of 1,000,000 sats each from a 5,000,000 sat UTXO, the transaction would show: + +``` +Input: 5,000,000 sats (your UTXO) +Output: 1,000,000 sats (Channel 1 - 2-of-2 multisig) +Output: 1,000,000 sats (Channel 2 - 2-of-2 multisig) +Output: 2,999,500 sats (change back to your wallet, minus fees) +``` + +This confirms that both channels were funded from a single transaction, exactly as intended. + +### Summary + +In this chapter, we learned that batch opens aggregate multiple channel openings into a single on-chain transaction, reducing fees and preventing UTXO fragmentation. We walked through the Terminal workflow for configuring each channel's capacity, fees, and visibility, then stacking them into one batch. In the next chapter, we will explore what happens after channels are open: how to manage their liquidity over time using Lightning Loop. + +--- ## Lightning Loop f2642efb-a485-4bc9-b571-d8e901e3e8b1 ![video](https://www.youtube.com/watch?v=kYlfHqQnpVM) -### Liquidity Management with Loop Out +Now that we know how to open channels efficiently, we face the ongoing challenge that defines Lightning node operation: **liquidity management**. A channel does not stay balanced on its own. Every payment that flows through it shifts the balance, and over time, channels inevitably become lopsided. When all the funds sit on your side, you can send but cannot receive. When all the funds sit on your peer's side, you can receive but cannot send. Either way, the channel's utility drops significantly. + +The traditional solution was to close the unbalanced channel and open a new one, which is expensive and slow. **Lightning Loop** provides a far better alternative: it lets you rebalance channels without closing them, using a cryptographic technique called **submarine swaps**. + +In this chapter, we will explore Loop Out, Loop In, and the powerful Auto Loop automation system. + +### Understanding Submarine Swaps -Terminal’s Loop feature is a specialized tool for managing Lightning Network liquidity, specifically designed to rebalance channels without the costly and time-consuming process of closing and reopening them. A healthy routing node requires balanced channels to facilitate traffic in both directions. When a channel becomes "lopsided"—holding all funds on one side—its utility drops significantly. +Before we dive into the interface, let's take a moment to understand the mechanism that makes Loop possible. A **submarine swap** is an atomic exchange between on-chain Bitcoin and off-chain Lightning Bitcoin. "Atomic" means that either both sides of the swap complete, or neither does. There is no scenario where one party takes the money and disappears. -**Loop Out** is the primary mechanism for acquiring **inbound liquidity**. This is necessary when a channel’s local balance is full, meaning the node can send payments but cannot receive them. +The swap uses Hash Time-Locked Contracts (HTLCs) on both layers: -By executing a Loop Out, the operator sends funds via Lightning to the Loop server, which then returns an equivalent amount of Bitcoin to the operator's on-chain wallet. This effectively "empties" the local side of the channel, creating space to receive new payments. Terminal simplifies this with a visual slider interface; operators drag the slider to the desired target balance (e.g., 50%), and the system calculates the required swap amount. +1. One party creates a secret value (called the **preimage, or secret**) and shares only its hash. +2. An on-chain HTLC locks funds that can be claimed by revealing the preimage, or refunded after a timeout. +3. A Lightning HTLC locks funds on the other side, gated by the same hash. +4. When one party reveals the preimage to claim one side, the other party can use that same preimage to claim the other side. -**Cost Considerations:** -Operators must account for three distinct fee components: -1. **Service Fee:** Paid to the Loop provider. -2. **Routing Fees:** Paid to the network to route the payment to the Loop server. -3. **Miner Fees:** Paid to confirm the on-chain settlement transaction. +In other words, the swap is cryptographically bound so that both legs must settle together. This is what makes Loop **non-custodial and trustless**: the Loop server never takes custody of your funds. -### Refilling Capacity with Loop In +### Loop Out: Creating Inbound Liquidity -**Loop In** serves the inverse function. It is utilized when a channel has been depleted of local funds (high remote balance), leaving the node unable to route outgoing payments. To fix this, the operator pushes on-chain Bitcoin into the channel, converting it into off-chain Lightning liquidity. +**Loop Out** is the operation you use when a channel is full on your side (high local balance, low remote balance). You can send payments through this channel, but you cannot receive them. To fix this, Loop Out moves funds from your Lightning channel to an on-chain address, freeing up space on the remote side. -**Prerequisites and Timing:** -Unlike Loop Out, a Loop In operation requires the operator to hold sufficient *on-chain* Bitcoin reserves. The Terminal interface validates wallet balances in real-time before authorizing the swap. +Here is what happens step by step: -A critical variable in Loop In operations is the **Confirmation Target**. Since the operation relies on an initial on-chain transaction, the operator can choose between speed and cost. -* **Low Confirmation Target:** Higher miner fees, faster liquidity availability. -* **High Confirmation Target:** Lower miner fees, slower settlement. +1. You initiate a Loop Out for a specified amount. +2. The Loop server creates an on-chain HTLC locked to a hash. +3. Your node routes a Lightning payment (locked to the same hash) to the Loop server through the target channel. +4. The Loop server reveals the preimage to claim the Lightning payment. +5. You use that preimage to sweep the on-chain HTLC to your Bitcoin address. -This flexibility allows operators to prioritize urgent liquidity needs or optimize for cost savings during periods of low network congestion. +The net result: your Lightning channel now has more room on the remote side (inbound liquidity), and you received the equivalent amount on-chain. -### Automated Liquidity via Auto Loop +**Using Loop Out in Terminal:** -While manual loops are useful for spot-adjustments, high-volume nodes require constant maintenance. **Auto Loop** transforms this manual process into a set-and-forget background service. It utilizes the "Autopilot" engine to monitor channel balances and execute swaps automatically when specific thresholds are breached. +In the Terminal interface, navigate to the **Loop tab** in the header. You will see a list of your channels, and you can filter by those with **low inbound** balance. Select the channel you want to rebalance, then drag the slider to your desired target balance (for example, 50% for a roughly balanced channel). -Auto Loop operates at three hierarchical levels: -* **Node Level:** Balances the aggregate liquidity of the entire node. -* **Peer Level:** Manages the total balance across all channels shared with a specific peer. -* **Channel Level:** Micro-manages the liquidity of a single, high-priority channel. +Click the **Next button**, and Terminal presents the fee breakdown: -#### The Budget System -To prevent runaway costs, Auto Loop is governed by a strict **Budget System**. Operators define a `Total Budget` that caps the amount of fees the system can spend within a specific cycle (e.g., Daily, Weekly, or Monthly). +- **Loop service fee**: paid to the Loop server for facilitating the swap. +- **On-chain fees**: paid to miners for confirming the settlement transaction. +- **Lightning routing fees**: paid to intermediate nodes for routing the payment to the Loop server. -Additionally, specific constraints ensure efficiency: -* **Minimum Loop Size:** Prevents the system from executing "dust" loops that are eaten up by fees. -* **Maximum Fee:** Establishes a hard ceiling on the cost of any individual swap. +You also have access to **advanced options**, including the ability to specify a custom on-chain address where you want the funds delivered (instead of your LND wallet's default address). -The Autopilot dashboard provides a live view of these operations, allowing operators to pause the service during volatile market conditions or adjust budgets as their node's revenue grows. +If the fees look acceptable, click the **Submit button** to execute the swap. + +**Via CLI:** + +For operators who prefer the command line, you can also execute Loop Out directly: + +```bash +loop out --channel 735057608151793668 --conf_target 250 \ + --label "rebalance-east-node" --max_swap_routing_fee 2500 \ + --addr bc1qvnfuf2zvg6mrfyjhc8h4c7ge9a7ywfrav52qru \ + --amt 1000000 +``` + +Key parameters: + +| Flag | Purpose | +|------|---------| +| `--channel` | Force the swap through a specific channel (by short channel ID) | +| `--conf_target` | Desired confirmation speed in blocks (higher = lower fee) | +| `--label` | Human-readable tag for identifying the swap later | +| `--max_swap_routing_fee` | Cap on Lightning routing fees in satoshis | +| `--addr` | Custom destination for the on-chain funds | +| `--amt` | The swap amount in satoshis | + +You can check current minimum/maximum amounts and fee estimates before committing: + +```bash +loop terms +loop quote out 1000000 +``` + +### Loop In: Restoring Outbound Liquidity + +**Loop In** serves the inverse function. Use it when a channel has been depleted on your side (low local balance, high remote balance), leaving you unable to send or route outgoing payments. + +In a Loop In, you send on-chain Bitcoin to the Loop server, and it sends you the equivalent amount over Lightning, pushing funds back to your side of the channel. + +**Before you begin**: unlike Loop Out, a Loop In requires that you hold sufficient **on-chain Bitcoin reserves**. If your LND wallet does not have enough funds, Terminal will alert you before proceeding. You may need to reduce the swap amount or deposit more on-chain Bitcoin first. + +**Using Loop In in Terminal:** + +Filter your channels by **low outbound** balance, select the target channel, and drag the slider to your desired balance. Click the **Next button** and choose the **One-time manual** loop option. + +An important setting here is the **confirmation target**. Since Loop In begins with an on-chain transaction, you can trade speed for cost: + +- A **low confirmation target** (e.g., 3 blocks) means higher miner fees but faster liquidity availability. +- A **high confirmation target** (e.g., 100 blocks) means lower miner fees but a longer wait before the swap completes. + +Choose based on how urgently you need the outbound capacity. + +**Via CLI:** + +```bash +loop in --last_hop 02e7a7d3c1e6055b7b7457d95e04d9bbd24f200fd4a58daca7beee7bc776e17440 \ + --amt 500000 +``` + +The `--last_hop` flag is particularly useful: it specifies which peer should deliver the final Lightning payment, giving you precise control over which channel receives the new outbound capacity. + +### Auto Loop: Automated Liquidity Management + +Manual loops are effective for spot adjustments, but high-volume routing nodes need continuous rebalancing. Executing loops by hand every time a channel drifts out of balance is neither scalable nor practical. This is where **Auto Loop** transforms liquidity management into a background service. + +Auto Loop monitors your channel balances and **automatically dispatches swaps** when they breach configured thresholds. It operates at three hierarchical levels: + +1. **Node level**: balances the aggregate liquidity across your entire node. +2. **Peer level**: manages the total balance across all channels shared with a specific peer (useful when you have multiple channels with the same counterparty). +3. **Channel level**: micro-manages the liquidity of a single, high-priority channel. + +**Enabling Auto Loop in Terminal:** + +In the Loop tab, select a channel and click the **Next button**. Instead of choosing "One-time manual," select the **Auto Loop** option. Terminal then presents the budget configuration: + +**The budget system** is the safety mechanism that prevents Auto Loop from spending unlimited fees on your behalf. You configure: + +- **Minimum loop size**: the threshold below which Auto Loop will not execute a swap (prevents tiny, fee-inefficient "dust" loops). +- **Maximum fee per swap**: a hard ceiling on what any individual swap can cost. +- **Total budget amount**: the maximum satoshis Auto Loop can spend on fees (service fees + on-chain fees + routing fees combined) within a given period. +- **Budget period**: how often the budget refreshes. Options include 1 day, 3 days, 7 days, 14 days, or 28 days. + +For example, you might configure: "I am willing to spend up to 50,000 satoshis in total fees every 7 days to keep this channel balanced." + +**Via CLI, the equivalent configuration looks like this:** + +```bash +# Enable Autoloop +loop setparams --autoloop=true + +# Set a liquidity rule for a specific channel +loop setrule 735057608151793668 --incoming_threshold=25 --outgoing_threshold=25 + +# Configure the budget: 100,000 sats refreshing every 7 days +loop setparams --autobudget=100000 --autobudgetrefreshperiod=604800s + +# Set fee limits +loop setparams --sweepconf=250 --maxswapfee=1 --maxroutingfee=1 +``` + +The `--incoming_threshold` and `--outgoing_threshold` parameters define the minimum percentage of channel capacity that must remain as inbound and outbound liquidity, respectively. When either side falls below its threshold, Auto Loop triggers a swap to restore the balance. + +**Monitoring Auto Loop:** + +Once active, the Autopilot dashboard (accessible via the **Autopilot toggle** button at the top of the Loop tab) shows you: + +- Whether Auto Loop is currently active or paused. +- How many loops have been performed recently. +- The current budget consumption. +- A history of all automated swaps. + +You can **pause Auto Loop at any time** without losing your configuration. You can also adjust the budget, fee limits, or thresholds on the fly. Just remember to click the **Save button** after making changes. + +A useful CLI command for debugging is `loop suggestswaps`, which shows what Auto Loop *would* dispatch without actually executing anything: + +```bash +loop suggestswaps +``` + +This is essentially a dry run that lets you verify your rules and budgets are configured correctly before enabling automation. + +**Please note**: Autoloop parameters are **not persisted across restarts** of the `loopd` daemon. If you restart your node, you will need to reconfigure your Autoloop settings. + +### Summary + +In this chapter, we explored the three modes of Lightning Loop: manual Loop Out (to create inbound liquidity), manual Loop In (to restore outbound liquidity), and Auto Loop (to automate the entire process). The underlying mechanism, submarine swaps, ensures that all operations are trustless and non-custodial. The budget system gives you precise control over costs, and the three-tier hierarchy (node, peer, channel) lets you tailor your liquidity strategy to your specific needs. In the next chapter, we will look at how to evaluate the peers you are connected to using Terminal's Peer Insights feature. + +--- ## Peer Insights 27d09714-6496-4451-bb08-1927e0148d1e ![video](https://www.youtube.com/watch?v=4x1V_G_DlKo) -### Peer Insights: Network Intelligence +Up to this point, we have learned how to connect nodes, open channels efficiently, and manage liquidity. But there is a question we have not yet addressed: how do we evaluate whether a particular peer is worth connecting to, and how do we measure the value of our existing relationships? Making good peering decisions is one of the most consequential aspects of running a routing node, because **the quality of your peers directly determines the quality of your routing**. + +Lightning Terminal's **Peer Insights** feature, available in the Explorer tab, provides the intelligence layer we need to make these decisions. It operates on two tiers: general reconnaissance data available for any public node on the network, and detailed performance analytics available only for nodes with whom you already share a channel. + +### The Explorer Tab + +When you navigate to the **Explorer tab** with a node connected to Terminal, you see a ranked list of top-performing nodes on the network. This list goes beyond simple capacity rankings. Terminal augments each entry with contextual badges, small visual indicators that surface useful information at a glance. + +For example, you might see a badge indicating that a node has **open liquidity orders** in the Pool marketplace (we will explore Pool in a later chapter). Another badge might tell you that a particular node is already **your peer**, meaning you have at least one channel open with them. + +Each node entry also displays key metrics: -Lightning Terminal’s **Peer Insights** is a robust intelligence layer integrated directly into the Explorer tab. It is designed to move node operators beyond basic connectivity metrics (like capacity and channel count) toward a deeper understanding of network behavior and peer value. +- **Total channel capacity**: the total Bitcoin locked in the node's channels. +- **Node age on network**: how long the node has been active on the network. +- **Number of peers**: how many other nodes it is connected to. +- **Centrality score**: a measure of how critical this node is to the overall network topology. A high centrality score means many shortest paths between other nodes pass through this one, making it an important routing hub. +- **Health check status**: whether the node passes Terminal's six health checks. -The feature operates on a tiered information architecture. At the base level, it provides general reconnaissance data for any node on the public network, useful for scouting potential partners. At the advanced level, it unlocks detailed performance analytics for nodes with whom you already maintain open channels. This dual capability allows operators to assess the "reputation" and strategic value of a peer before opening a channel, and then monitor the actual ROI of that relationship over time. +These metrics allow you to quickly scan for stable, well-connected candidates before committing capital to a new channel. -### Visual Indicators and Network Scouting +### Searching for a Specific Node -The primary interface for Peer Insights is the **Explorer Tab**. This dashboard presents a ranked list of top-performing nodes, but augments this list with contextual "badges" or visual indicators overlaid on the node entries. +Beyond browsing the ranked list, you can search for any node on the network by pasting its public key into the search field: -These indicators allow for rapid scanning of the network landscape. For example, specific badges highlight whether a node has open liquidity orders in the Pool marketplace or if it is currently connected to your node. -* **Health Check:** Instantly communicates operational uptime and reliability. -* **Centrality Score:** Indicates how critical that node is to the overall network topology. -* **Capacity & Age:** Establishes the scale and longevity of the node’s operations. +``` +02e7a7d3c1e6055b7b7457d95e04d9bbd24f200fd4a58daca7beee7bc776e17440 +``` -By filtering through these metrics, an operator can quickly identify stable, high-capacity nodes that are actively seeking liquidity, making them ideal candidates for new channel openings. +Terminal will pull up a detailed profile for that node, displaying its capacity, age, peer count, centrality, and health check results. This is useful when someone recommends a peer or when you want to evaluate a node before opening a channel with it. -### Analyzing Fee Strategies +### The Fee Distribution Graph -One of the most sophisticated tools within Peer Insights is the **Fee Distribution Graph**. This visualization decompresses the complex fee policies of a target node across its entire channel portfolio. +One of the most powerful analytical tools in Peer Insights is the **fee distribution graph**. This visualization shows you how a node has priced its channels, giving you a window into its routing philosophy. The graph uses a dual-axis design: -* **Horizontal Axis:** Represents fee rates (parts per million or ppm). -* **Vertical Axis:** Represents the number of channels. -* **Split View:** Inbound fees are plotted above the axis; outbound fees are plotted below. -This visual clustering reveals the peer's routing philosophy. For example, if a node has a tight cluster of channels priced at 100ppm but a few outliers at 1000ppm, it suggests a tiered strategy where scarce liquidity is priced at a premium. Conversely, a flat distribution suggests a "set-and-forget" passive management style. Understanding these patterns is crucial when setting your own fees; pricing your channel competitively against a peer's existing connections ensures your node remains an attractive hop for routing. +- **Horizontal axis (x)**: fee rates, from low on the left to high on the right. +- **Vertical axis (y)**: the number of channels. +- **Split view**: the upper portion shows **inbound fee distribution**, and the lower portion shows **outbound fee distribution**. + +Each bar on the graph represents a group of channels clustered at a similar fee rate. By hovering over a bar, you can see exactly how many channels fall within that fee range. + +Let's say you are examining a node with 16 channels. The graph might show: + +- 15 channels with outbound fee rates clustered between 660 and 1,000 ppm (parts per million). +- 1 channel with a significantly lower outbound fee. +- 5 channels with low inbound fees, 6 with moderate inbound fees, 2 with higher inbound fees, and 3 outliers with very high inbound fees. + +What does this tell us? The tight clustering of outbound fees suggests this operator actively manages their fee policy and has settled on a consistent strategy for most channels. The single low-fee outlier might be a strategic channel to a high-volume peer where the operator is willing to accept lower margins for reliable throughput. The spread in inbound fees suggests different peers have set different inbound rates on their end of the channels. + +**Why this matters for you**: if you are about to open a channel with this node, the fee distribution graph helps you set competitive fees. If most of their outbound channels are priced at 800 ppm, and you set yours at 2,000 ppm, routing algorithms will likely prefer cheaper paths and your channel may see little traffic. Conversely, if you set your fees too low, you might attract more traffic than you can sustain, depleting your channel quickly. + +This data is available for **any public node on the network**, not just your peers. It is all derived from the public network graph. ### Peer-Specific Performance Analytics -For existing partners, Peer Insights unlocks a granular history of the relationship. While general network explorers can only guess at routing volume, Terminal leverages your node's local data to display exact interaction metrics. +For nodes with whom you already share a channel, Peer Insights unlocks an additional layer of data: your actual interaction history. While the fee distribution graph shows public information anyone can see, **performance analytics draw from your node's private forwarding data** to show the real value of the relationship. Key metrics include: -* **Forwarding Events:** The total count of payments routed through this specific peer. -* **Volume Routed:** The cumulative amount of satoshis moved. -* **Fees Earned:** The direct revenue generated by this relationship. -This data transforms abstract channel management into evidence-based strategy. If a channel has high capacity but zero forwarding events over a month, the analytics will make this inefficiency obvious, signaling a need for fee adjustment or channel closure. Conversely, high-volume, low-fee peers can be identified as candidates for fee increases. By centralizing this data, Peer Insights allows operators to treat their node not just as a piece of software, but as a portfolio of financial assets that requires active optimization. +- **Number of channels**: how many channels you share with this peer. +- **Total forwards**: the count of payments that have been routed through your shared channels. +- **Volume routed**: the cumulative amount of satoshis that have flowed through the connection. +- **Fees earned**: the direct revenue this peer relationship has generated for your node. + +For instance, you might discover that a peer with whom you have a single channel has routed 1,400,000 satoshis across just 3 forwarding events, earning you 136.5 satoshis in fees. That is useful context: a small number of forwards, but each one carrying significant volume. + +This data transforms abstract channel management into **evidence-based decision making**. Consider these scenarios: + +- A channel has high capacity but zero forwarding events over the past month. The analytics make this inefficiency obvious, signaling that you should either adjust fees, close the channel, or investigate why traffic is avoiding this route. +- A channel shows consistently high volume and steady fee earnings. This peer is valuable, and you might consider opening an additional channel to increase capacity, or you might raise fees slightly to capture more revenue without discouraging traffic. +- A peer generates high volume but at very low fees. You can evaluate whether the revenue justifies the capital locked in the channel, or whether that capital would earn more deployed elsewhere. + +### Putting It All Together + +Peer Insights brings together three layers of intelligence: + +1. **Network-wide scouting** (Explorer tab rankings, badges, health checks) for discovering potential new peers. +2. **Fee analysis** (the fee distribution graph) for understanding a node's pricing strategy before and after you connect. +3. **Relationship analytics** (forwarding events, volume, earnings) for measuring the real return on each channel. + +Together, these tools allow you to treat your node not just as a piece of software, but as a portfolio of financial relationships that require active monitoring and optimization. The best routing nodes are not simply the ones with the most channels or the most capacity; they are the ones whose operators make informed decisions about where to deploy their capital, informed by exactly the kind of data that Peer Insights provides. + +### Summary + +In this chapter, we explored the Peer Insights feature in Terminal's Explorer tab. We learned how to scout potential peers using capacity, centrality, and health check data; how to analyze a node's fee strategy using the fee distribution graph; and how to evaluate existing peer relationships using forwarding metrics. These tools give you the intelligence foundation for making sound channel management decisions. In the next part of the course, we will continue building on these skills by examining liquidity reports and advanced node accounting. # Last Steps 2e886890-62f7-4453-9c6f-9b397a280b75 @@ -386,133 +1100,534 @@ This data transforms abstract channel management into evidence-based strategy. I ![video](https://www.youtube.com/watch?v=7ga-8AhCNK4) -### Visualizing Liquidity Health +### Why Liquidity Visibility Matters + +Throughout this course, we have explored many facets of Lightning node management: health checks, fee automation, channel opening strategies, and submarine swaps. All of these tools share one underlying concern, the management of liquidity. Now, let us turn to a feature that synthesizes this concern into a single diagnostic view. + +The fundamental challenge of **liquidity management on the Lightning Network** is that failure is silent. When your node lacks sufficient capacity in the right direction, payments do not fail with a loud error on your side. They simply route around you. The senders find alternative paths, and you, the operator, never see the revenue that could have been yours. In other words, the most costly liquidity problems are the ones you do not know you have. + +Lightning Terminal addresses this with the **Liquidity Report**, accessible from the main dashboard. This tool provides a comprehensive visualization of your node's ability to receive, send, and route payments of various sizes. If you are not already very familiar with the concepts of inbound and outbound liquidity, I recommend reviewing the [Lightning Labs documentation on understanding liquidity](https://docs.lightning.engineering) before continuing, as this chapter builds directly on those fundamentals. + +### The Routable Liquidity Chart + +The primary instrument in the Liquidity Report is the **Routable Liquidity Chart**. This chart breaks your node's total capacity into its two critical components: + +- **Inbound liquidity**: the funds sitting on the remote side of your channels, representing your ability to receive payments. +- **Outbound liquidity**: the funds sitting on your local side, representing your ability to send payments or initiate the first hop of a routed payment. + +The chart offers two viewing modes. The **Cumulative View** aggregates all your channels into a single ratio, letting you assess the overall balance at a glance. For instance, you might immediately see that your node is heavily skewed toward inbound capacity, with relatively little outbound. Whether this distribution is desirable depends entirely on your use case: a merchant receiving payments benefits from strong inbound liquidity, while a routing node needs a healthy balance of both. -Managing liquidity is arguably the most complex aspect of running a Lightning node because failure is often silent. Unlike a crashed server or a rejected transaction, poor liquidity manifests as "invisible" problems—payments that simply route around your node because they cannot find a path, leaving you unaware of the lost revenue. +The **Detailed View** breaks the same data down by individual channels. This is where you begin to identify specific channels that may need rebalancing, either through manual intervention or through the Loop operations we covered earlier in the course. -Lightning Terminal addresses this with the **Liquidity Report**, accessible via the **Loop** tab. This tool provides a diagnostic visualization of your node's ability to route payments and receive funds. +I recommend visiting the Liquidity Report regularly. Because silent liquidity problems accumulate gradually (a channel slowly depleting over weeks, for example), periodic review is the most reliable way to catch issues before they become costly. -The primary tool here is the **Routable Liquidity Chart**. It breaks down capacity into its two critical components: -* **Inbound Liquidity:** The ability to receive funds (remote balance). -* **Outbound Liquidity:** The ability to send funds (local balance). +### The Simulation Engine -The chart offers two viewing modes to help operators assess their standing. The **Cumulative View** provides a high-level ratio assessment, useful for quickly spotting gross imbalances (e.g., a node that is 90% outbound and only 10% inbound). The **Detailed View** breaks this data down by individual channels, allowing for specific troubleshooting. +Liquidity is not a static property. A node that routes a 500,000 satoshi payment with ease might completely fail when confronted with a 15,000,000 satoshi transaction. The capacity exists in aggregate, but no single channel may be large enough to carry the larger payment. -### Simulating Payment Scenarios +To help operators reason about this, the Liquidity Report includes a **simulation engine** with three preset payment sizes: -Liquidity is not static; it behaves differently depending on the size of the payment being routed. A node might be perfectly capable of routing a 1,000 satoshi micropayment but completely fail to route a 5,000,000 satoshi transaction. The Liquidity Report includes a **Simulation Engine** to test these variances. +- `500,000 sats` +- `5,000,000 sats` +- `15,000,000 sats` -Operators can toggle between three preset payment sizes: **500k sats**, **5M sats**, and **15M sats**. -As you adjust these settings, the dashboard dynamically updates two key metrics: -1. **Routable Liquidity Chart:** Visually demonstrates which channels "drop off" and become unusable as the payment size increases. -2. **Estimated Last Hop Fee:** Projects the cost for an external user to route a payment of that specific size to your node. +As you toggle between these settings, two elements of the dashboard update dynamically: -This feature is critical for capacity planning. It helps operators identify "bottleneck" channels that appear healthy on the surface but lack the depth required to handle larger, higher-fee transactions. +1. **The Routable Liquidity Chart** adjusts to show which channels remain viable at each payment size. Channels that lack sufficient depth simply disappear from the visualization, making bottlenecks immediately visible. +2. **The Estimated Last Hop Fee** recalculates to project what it would cost an external sender to route a payment of that size through your node. -### Analyzing Performance by Fee Rate +This simulation capability is essential for capacity planning. If you expect your node to handle large-value payments (perhaps because you serve as a routing hub for business clients), you can verify that you actually have channels deep enough to support those transactions. If the chart goes blank at `5,000,000 sats`, you know exactly where to focus your next channel opening or Loop operation. -Beyond raw capacity, the report analyzes liquidity through the lens of **Fee Rates**. The **Routable Inbound Chart** plots your channels along an X-axis representing fee rates (parts per million), while the Y-axis displays channel density. +### Analyzing Routing Quality by Fee Rate -This dual-perspective chart (Channel Count vs. Percentage) reveals the "quality" of your routing options. It helps answer specific strategic questions: -* **Availability:** Do I have inbound liquidity available at low fee rates, or is my capacity expensive to access? -* **Dead Zones:** Are there fee ranges where I have zero routable capacity? +Beyond raw capacity, the Liquidity Report analyzes your channels through the lens of fee rates. The **Routable Inbound Chart**, located below the main liquidity visualization, plots your channels along two axes: -#### Identifying Hidden Issues -The ultimate goal of these reports is to detect **Systematic Inefficiencies**. For example, the chart might reveal that while you have ample total liquidity, it is all concentrated in high-fee channels that the network routing algorithms ignore for standard payments. Alternatively, it might show that your low-fee channels are constantly depleted. +- **X-axis**: the fee rate (in parts per million) associated with each channel. +- **Y-axis**: two perspectives are available. The **Channel Count** view shows how many channels fall into each fee range, while the **Channel Percentage** view shows the proportion of your total routing capacity available at each fee rate. -By correlating payment sizes with fee rates, the Liquidity Report transforms node management from a reactive process (fixing stuck channels) to a proactive strategy. It allows the operator to rebalance channels specifically to fill the gaps in their routing profile, capturing the fee revenue that was previously bypassing their node entirely. +This dual-perspective chart reveals the quality of your routing options, not just the quantity. It helps you answer specific strategic questions: + +- **Do I have inbound liquidity at competitive fee rates?** If all your capacity is concentrated in high-fee channels, the network's routing algorithms may consistently bypass you in favor of cheaper paths. +- **Are there dead zones in my fee distribution?** The chart may highlight fee ranges where you have zero routable capacity, marked with an attention indicator for channels that need intervention. + +Watch how this chart changes as you adjust the simulated payment size. You may discover that your node handles small payments across many fee ranges, but only a handful of channels can support medium or large payments. This insight allows you to rebalance or open new channels specifically to fill the gaps in your routing profile. + +### Summary + +The Liquidity Report transforms node management from a reactive process (fixing problems after they manifest) into a proactive strategy. By combining the routable liquidity visualization, the payment size simulation engine, and the fee rate analysis chart, you gain the ability to detect silent inefficiencies and address them before they cost you revenue. As we will see in the next chapter, this kind of granular control extends even further when we introduce virtual accounts on top of your node. ## LND Accounts 0d31ef81-4e77-4c5e-adc5-081df64c27ec ![video](https://www.youtube.com/watch?v=G1rv9dZQO5o) -### LND Accounts: Virtual Off-Chain Infrastructure +### The Problem of Shared Access + +Now that we understand how to monitor and optimize a node's liquidity, let us examine a different operational challenge: sharing that node's capabilities with multiple users or applications. + +In a typical LND deployment, any application that connects to the node receives broad access to its full balance and channel infrastructure. A mobile wallet, a tipping bot, and a merchant point-of-sale system might all authenticate with the same administrative macaroon. If any one of these applications is compromised, the attacker gains access to everything. This is a fragile security model, and it becomes increasingly dangerous as more services depend on a single node. + +Lightning Terminal solves this with a feature called **LND Accounts**. These are **virtual off-chain accounts** layered on top of a single LND node, each with its own authentication token, spending limits, and permission scope. Let us explore how they work and why they matter. + +### Understanding the Architecture -Lightning Terminal (LitD) introduces a powerful primitive known as **LND Accounts**. These are virtual, off-chain accounts layered on top of a single Lightning Network Daemon (LND) node. Unlike independent nodes that manage their own channels and private keys, LND Accounts function as partitioned entities within the host node's existing infrastructure. +It is crucial to understand what an LND Account is and, equally important, what it is not. An LND Account does not possess its own on-chain wallet, its own Lightning channels, or its own private keys. All cryptographic key management and liquidity remain under the control of the host LND node. The "account" is a logic layer: a virtual partition that tracks a balance and enforces access rules. -It is crucial to understand the architectural distinction: an LND Account does not possess its own on-chain wallet or Lightning channels. Instead, the primary LND node retains custody of all cryptographic keys and manages the underlying liquidity. The "account" is essentially a logic layer that tracks a virtual balance and enforces specific access rules managed by the host. This design allows operators to share their node's liquidity and connectivity with multiple users or applications without fragmenting the node’s capital or spinning up redundant infrastructure. +In other words, the host node operator retains full custody of the underlying funds. The account holder enters a trust relationship with the node operator regarding the availability of those funds. This is, by design, a custodial arrangement at the account level. The operator manages the real channels and liquidity; the account holder operates within a sandboxed environment defined by the operator. -### Security Architecture and Resource Segregation +This architecture is powered by the **RPC Middleware Interceptor**, which intercepts every API call made with an account macaroon and filters the responses accordingly. When an account holder queries their balance, for example, they see only their virtual allocation, not the node's full channel balance. On-chain balance always returns `0`. The channel list returns empty. Payment and invoice histories are filtered to show only transactions belonging to that specific account. -The primary value proposition of LND Accounts is **Risk Containment** via segregation. In a standard deployment, connecting multiple applications (e.g., a mobile wallet, a tipping bot, and a merchant store) to a single LND node often grants them broad access to the node’s full balance. If one application is compromised, the entire node's funds are at risk. +### Security Through Segregation -LND Accounts solve this by creating distinct, sandboxed environments for each application. -* **Granular Permissions:** Each account operates under a specific macaroon (authentication token) with restricted scopes. -* **Budget Allocations:** Operators can assign strict spending limits (e.g., 100,000 sats). Even if the application tries to spend more, the LND node will reject the request at the protocol level. -* **Expiration Enforcement:** Accounts can be configured with time-locks (e.g., 90 days), ensuring that temporary access grants automatically expire, preventing "zombie" permissions from becoming long-term vulnerabilities. +The primary value of LND Accounts is **risk containment through resource segregation**. Each account operates as a distinct, sandboxed environment with three layers of constraint: -This layered security model reduces the "blast radius" of a security breach. If a specific account credential is stolen, the attacker is limited strictly to that account's remaining budget and permissions, leaving the core node and other accounts untouched. +- **Granular permissions**: each account operates under a specific **macaroon authentication token** (native to LND) with restricted permission scopes. The standard account macaroon includes permissions like `info:read`, `invoices:read`, `invoices:write`, `offchain:read`, `offchain:write`, and `onchain:read`. +- **Budget allocations**: operators assign a strict spending limit in satoshis. Even if the connected application attempts to spend more, LND rejects the request at the protocol level. +- **Expiration enforcement**: accounts can be configured with time-limited validity (for example, 90 days). Once the expiration passes, the account's connection string ceases to function, preventing "zombie" permissions from becoming long-term vulnerabilities. -### Configuration and Connection Workflow +This layered model reduces what security professionals call the "blast radius" of a breach. If a specific account credential is stolen, the attacker is limited strictly to that account's remaining budget and permissions. The core node, other accounts, and the underlying channel infrastructure remain untouched. -Creating and managing these accounts is handled directly through the Lightning Terminal interface, specifically under the **Lightning Node Connect (LNC)** tab. +### Creating an Account via the Terminal UI -The workflow moves beyond simple connection strings into **Custodial Account** configuration: -1. **Session Initialization:** The operator starts by creating a new session and selecting "Custom" permissions rather than a standard admin access level. -2. **Parameter Definition:** The interface prompts for critical constraints. The operator defines the **Balance Allocation** (the spending limit in satoshis) and the **Expiration Date**. -3. **Generation:** The system generates a proprietary connection string (pairing phrase) or QR code. +Let us walk through the practical workflow for creating an LND Account using the Lightning Terminal web interface. We will use the **Lightning Node Connect** tab, which handles both standard connections and custodial account creation. -**Connectivity:** -These accounts connect via **Lightning Node Connect (LNC)**. This protocol establishes an encrypted, end-to-end connection between the user (or application) and the node without requiring the operator to open ports on their router or expose their IP address. +1. Navigate to the **Lightning Node Connect** tab in the LitD UI. +2. Click **Create a new session** and assign it a descriptive name (for example, `AccountsDemo`). +3. Under **Permission Types**, select **Custom Type** rather than a standard admin or read-only preset. +4. In the permissions panel, select **Custodial Account**. Notice that this selection reveals additional fields: a **balance allocation** (the spending limit in satoshis) and an **expiration date**. +5. Define the budget and expiration (for example, 100,000 sats with a 90-day expiry). +6. Click the **Submit button**. -**Practical Use Cases:** -This functionality is ideal for onboarding trusted peers or testing environments. For example, a node operator can create an account for a friend to experiment with Lightning payments. The friend downloads a compatible wallet, scans the QR code, and immediately has access to the Lightning Network using the operator's liquidity, but is strictly limited to the funds allocated in the virtual account. Similarly, developers can spin up separate accounts for different microservices, ensuring that a bug in one service cannot drain the wallet of another. +The system generates a **Lightning Node Connect pairing phrase** (and optionally a QR code) that encapsulates the account's connection credentials. This pairing phrase can be shared with the intended user or application. + +**Important to note**: custodial accounts created this way connect exclusively through Lightning Node Connect. They cannot be used with the Terminal web interface directly; they are designed for wallet applications, browser extensions, or custom integrations. + +### Creating an Account via the CLI + +For operators who prefer command-line workflows, accounts can also be created using `litcli`: + +```bash +litcli accounts create 50000 --save_to /tmp/user.macaroon +``` + +This command creates an account with a 50,000 satoshi budget and saves the corresponding macaroon to the specified path. You can then inspect the macaroon to verify its permissions: + +```bash +lncli printmacaroon --macaroon_file /tmp/user.macaroon +``` + +To list all existing accounts and their IDs: + +```bash +litcli accounts list +``` + +If you need to create an LNC session specifically tied to an account: + +```bash +litcli sessions add --label pointofsale --type account --account_id d64dbc31b28edf66 +``` + +And to test the account by querying the channel balance through its restricted macaroon: + +```bash +lncli --macaroonpath=/tmp/user.macaroon channelbalance +``` + +If a macaroon is lost but the account still exists, it can be reconstructed by baking a new base macaroon and adding the account-specific caveat: + +```bash +lncli bakemacaroon info:read invoices:read invoices:write offchain:read offchain:write onchain:read peers:read --save_to tmp.macaroon +lncli constrainmacaroon --custom_caveat_name account --custom_caveat_condition tmp.macaroon accounts.macaroon +rm tmp.macaroon +``` + +### Practical Use Cases + +This functionality opens several practical scenarios: + +- **Onboarding friends or family**: a node operator creates an account with a modest budget and shares the QR code. The recipient downloads a compatible wallet (such as Zeus), scans the code, and immediately has access to the Lightning Network using the operator's liquidity, without needing to manage channels or understand the underlying infrastructure. +- **Application isolation**: a developer running multiple microservices against a single node can create separate accounts for each service. A bug in one service cannot drain the wallet of another. +- **Enhanced security model**: when multiple applications connect to a single LND node, each receives its own constrained account rather than sharing a single administrative macaroon. Application A has its own permissions and budget; Application B has its own permissions and budget. A compromise of one does not affect the other. + +### Summary + +LND Accounts extend the capabilities of a single Lightning node by introducing **virtual off-chain partitions** with isolated budgets, permissions, and expiration policies. Whether configured through the Terminal UI or the command line, they provide a practical security layer for operators who share their node's infrastructure with multiple users or applications. In the next and final chapter, we will bring everything together by building a complete LitD node from scratch. ## RUN LITD: Building a Node from Scratch 710c2090-e905-4141-8b12-7a81d7c276a1 ![video](https://www.youtube.com/watch?v=lopHP_nF0tE) -### LITD Architecture and Repository Structure +### Why Build a Node from Scratch? -The Lightning Terminal Daemon (LITD) is a unified binary that bundles the core Lightning Network Daemon (LND) with essential operational tools: **Loop** (liquidity swaps), **Pool** (liquidity marketplace), **Faraday** (accounting/analytics), and **Taproot Assets**. By running these components as a single integrated system, developers and node operators avoid the complexity of managing five distinct daemons and their inter-process communications. +Throughout this course, we have worked with an already-running Lightning Terminal instance, exploring its features one by one. Now, in this final technical chapter, we will go through the entire process of building a LitD node from a bare server. This is where all the concepts we have studied converge into a single, hands-on deployment. -To streamline deployment, the community utilizes the **Run LITD** repository. Inspired by Alex Bosworth’s "Run LND," this repository is optimized for speed and standardized configuration. It offers three distinct implementation pathways depending on the operator's need for control: -1. **Automated Scripts:** Bash scripts that handle the end-to-end installation (ideal for rapid testing). -2. **Manual Checklists:** Step-by-step guides for operators who need to audit every command. -3. **Example Configurations:** Reference files for `bitcoin.conf`, `lit.conf`, and systemd services. +As we discussed in the very first chapter, **Lightning Terminal Daemon (LitD)** is a unified binary that bundles LND with Loop, Pool, Faraday, and Taproot Assets into a single integrated system. By running LitD rather than managing five separate daemons, we dramatically simplify the operational complexity of a full Lightning Labs stack. -### Hardware Prerequisites and Installation Stages +To streamline this deployment, we will use the **Run LitD** repository, a community resource inspired by Alex Bosworth's well-known "Run LND" guide. The Run LitD repository provides three complementary pathways: -Before deployment, operators must provision a server meeting minimum specifications. The scripts are tested specifically on **Ubuntu 24.04**. A baseline configuration requires at least **4GB of RAM** and sufficient storage. -* **Pruned Node:** ~80GB storage (sufficient for most Lightning operations). -* **Archival Node:** ~1TB+ storage (required only if you need a full historical copy of the blockchain). +1. **Automated bash scripts**: handle the end-to-end installation (ideal for rapid testing and development environments). +2. **Manual checklists**: step-by-step notes for operators who want to audit every command before executing it. +3. **Example configuration files**: reference `bitcoin.conf`, `lit.conf`, and `systemd` service files that can be adapted to any environment. -The installation workflow is divided into three sequential stages: -1. **Server Preparation:** Secures the environment by creating a dedicated user, configuring SSH keys, and disabling root login/password authentication. -2. **Bitcoin Core Setup:** Installs the Bitcoin backend. The repository supports both **Binary** (faster, pre-compiled) and **Source** (auditable, slower) installation methods. -3. **LITD Deployment:** Compiles or downloads the LITD binary. For source installations, this step automatically handles dependencies like Go, Node.js, and Yarn. +**Important disclaimer**: as noted in the repository itself, these scripts are designed for developers who want to spin up a node quickly for testing purposes. If you are building a production node with real funds, take the time to read through every script, audit every configuration line, and follow your own security best practices. Do not blindly trust any automation when real money is at stake. -### Configuration, Wallet Ops, and Service Management +### Server Requirements and Prerequisites -Unlike a standalone LND setup, LITD uses a unified configuration file located in the `.lit` directory. This introduces a specific syntax requirement: standard LND parameters must be prefixed with `lnd.`. For example, a setting that is `alias=MyNode` in LND becomes `lnd.alias=MyNode` in `lit.conf`. This separation allows the daemon to route configurations to the correct internal sub-server (e.g., specific settings for Loop or Faraday). +These scripts have been tested on **Ubuntu 24.04**. If you are running a different distribution, the process will likely work with minor adjustments, but be prepared for occasional differences in package names or paths. -**Wallet Initialization:** -Once the software is installed, the operator must manually start LITD to generate the wallet seed. The setup scripts include a secure password management mechanism that enables **Auto-Unlock**. This allows LITD to automatically decrypt the wallet upon system reboot, ensuring the node comes back online immediately after power failures or maintenance without manual intervention. +Here are the baseline hardware requirements: -**Systemd Integration:** -The final setup script wraps both Bitcoin Core and LITD in `systemd` service files. This transforms them into background services that start on boot (`systemctl enable litd`). Verification involves checking the service status logs to ensure the node is successfully syncing with the blockchain and that all bundled sub-servers (Loop, Pool) are active and communicating. +| Resource | Minimum | Notes | +|----------|---------|-------| +| **RAM (minimum)** | 4 GB | Sufficient for a pruned node with LitD | +| **Storage (pruned)** | ~80 GB | Default configuration in the scripts | +| **Storage (archival)** | ~1 TB+ | Only if you need full blockchain history | +| **Operating system** | Ubuntu 24.04 | Tested target; other Debian-based systems may work | -# Conclusion -90cfdd76-7deb-4162-87a5-24bb845ba786 +Note that the scripts configure a **pruned Bitcoin node** by default. If you want to run a full archival node, look for the pruning configuration line in the Bitcoin setup script and adjust it accordingly. For full archival nodes, you may also want to configure an external data store for the blockchain data; the Run LitD repository includes notes on how to do this. + +The installation proceeds in three stages, each handled by a separate script: + +1. **Server Preparation** (`server_setup.sh`): creates a dedicated user, configures SSH keys, disables root login and password authentication. +2. **Bitcoin Core Setup** (binary or source script): installs Bitcoin Core with signature verification. +3. **LitD Deployment** (two or three scripts depending on method): installs dependencies, compiles LitD from source, configures `lit.conf`, initializes the wallet, and sets up `systemd` services. + +### Stage 1: Server Preparation + +We begin by logging into our fresh Ubuntu server as root. The first task is to clone the Run LitD repository: + +```bash +git clone https://github.com/lightninglabs/run-litd.git +``` +Navigate into the repository and examine the scripts: +```bash +cd run-litd +ls scripts/ +``` + +The server setup script handles basic security hardening. Before running it, ensure it is executable: + +```bash +chmod +x scripts/server_setup.sh +``` + +Since we are logged in as root, we run it directly: + +```bash +./scripts/server_setup.sh +``` + +The script will prompt you for several pieces of information: + +1. **Sudo password for the new `ubuntu` user**: this creates a non-root user that will own all subsequent operations. +2. **SSH public keys**: paste the public keys you want to authorize for this user. Each key should be on its own line. Press Enter after the last key, then Ctrl+D to confirm. + +Once the script completes, it will have: +- Created a new `ubuntu` user with sudo privileges +- Configured SSH key-based authentication for that user +- Disabled root login over SSH +- Disabled password-based authentication + +At this point, log out of the root session and reconnect as the new `ubuntu` user: + +```bash +ssh ubuntu@ +``` + +After logging back in, move the repository to the new user's home directory and fix ownership: + +```bash +sudo mv /root/run-litd /home/ubuntu/ +sudo chown -R ubuntu:ubuntu /home/ubuntu/run-litd +``` + +### Stage 2: Installing Bitcoin Core + +With the server secured, we install the Bitcoin backend. The repository offers two methods: + +- **Binary installation**: downloads the pre-compiled Bitcoin Core binary and verifies signatures. Faster, suitable when the focus is on LitD rather than Bitcoin Core itself. +- **Source installation**: compiles Bitcoin Core from source. More thorough and auditable, but slower. + +For this walkthrough, we will use the binary method. Make the script executable and run it with `sudo`: + +```bash +chmod +x scripts/bitcoin_setup_binary.sh +sudo ./scripts/bitcoin_setup_binary.sh +``` + +The script performs the following operations automatically: +- Downloads the specified version of Bitcoin Core +- Verifies cryptographic signatures for security +- Installs the binary to the appropriate system path +- Creates the Bitcoin data directory with correct permissions +- Generates a `bitcoin.conf` configuration file +- Creates and enables a `systemd` service for `bitcoind` + +During execution, the script will output an **RPC connection string** (containing the `rpcuser` and `rpcpassword`). This is critical: + +``` +rpcuser=yourgenerateduser +rpcpassword=yourgeneratedpassword +``` + +**Copy this connection string immediately and store it safely.** You will need it when configuring LitD in the next stage. If you lose it or encounter connection errors between Bitcoin Core and LitD later, you can regenerate it by following the instructions in the repository's checklist. + +The script will also ask you to select a network: + +- **mainnet (production)**: for use with real bitcoin +- **signet (testing)**: recommended when learning + +For our demonstration, we select **signet for testing**. After the script completes, verify that Bitcoin Core is running: + +```bash +sudo systemctl status bitcoind +``` + +You should see the service active and running. Bitcoin Core will begin synchronizing with the blockchain in the background. + +### Stage 3: Installing LitD from Source + +Now we arrive at the core of this chapter: installing Lightning Terminal Daemon. We will compile from source, which provides a complete understanding of what is happening on the server. The repository also offers a binary download script if you prefer speed over transparency. + +The LitD source installation is divided into two (or three) scripts that run sequentially. + +#### Script 1: Install Dependencies + +The first script installs the build dependencies: **Go, Node.js, and Yarn**. + +```bash +chmod +x scripts/litd_setup_1.sh +sudo ./scripts/litd_setup_1.sh +``` + +This script: +- Installs the Go programming language (required to compile LitD and LND) +- Configures the `GOPATH` environment variable +- Installs Node.js (required for building the web UI) +- Installs Yarn (the package manager used by the Terminal frontend) + +Because the Go path configuration modifies the shell environment, log out and log back in after this script completes: + +```bash +exit +ssh ubuntu@ +``` + +Then verify that all dependencies were installed correctly: + +```bash +go version +``` + +You should see the installed Go version. Then check Node.js and Yarn: + +```bash +node --version +yarn --version +``` + +If all three commands return version numbers, the dependencies are properly installed and we can proceed. + +#### Script 2: Compile and Configure LitD + +The second script is the most substantial. It clones the Lightning Terminal repository, compiles the binary from source, and generates the configuration file. + +```bash +chmod +x scripts/litd_setup_2.sh +sudo ./scripts/litd_setup_2.sh +``` + +The compilation process takes approximately 5 to 10 minutes depending on your server's resources. Once complete, the script prompts you for configuration parameters: + +1. **Network selection**: enter `signet` (or `mainnet`, matching your Bitcoin Core configuration). +2. **RPC connection string**: paste the `rpcuser` and `rpcpassword` that you saved during the Bitcoin Core setup. Be careful with copy-paste errors here; a mismatched credential is the most common cause of connection failures between Bitcoin Core and LitD. +3. **UI password**: choose a password for the Lightning Terminal web interface. +4. **Node alias**: a human-readable name for your node (for example, `my-litd-node`). + +The script creates the configuration file at `~/.lit/lit.conf`. Let us examine what a typical configuration looks like: + +```ini +# Lightning Terminal configuration +lnd-mode=integrated + +# UI +uipassword=YOUR_SECURE_PASSWORD + +# LND settings (note the lnd. prefix) +lnd.bitcoin.active=1 +lnd.bitcoin.signetseednode=x.x.x.x +lnd.bitcoin.node=bitcoind +lnd.bitcoind.rpchost=127.0.0.1 +lnd.bitcoind.rpcuser=yourgenerateduser +lnd.bitcoind.rpcpass=yourgeneratedpassword +lnd.bitcoind.zmqpubrawblock=tcp://127.0.0.1:28332 +lnd.bitcoind.zmqpubrawtx=tcp://127.0.0.1:28333 +lnd.alias=my-litd-node + +# Taproot Assets settings can be added here +``` + +Notice the critical syntax: when running in **integrated mode**, all LND parameters must be prefixed with `lnd.`. A setting that would be `alias=my-litd-node` in a standalone `lnd.conf` becomes `lnd.alias=my-litd-node` in `lit.conf`. This prefix system allows the daemon to route each setting to the correct internal sub-server (LND, Loop, Pool, Faraday, or Taproot Assets). + +#### Wallet Initialization + +Before running the final setup script, we must initialize the LND wallet. This is a manual step that generates the cryptographic seed for your node. + +Open two terminal windows connected to your server. In the first window, start LitD manually: + +```bash +litd +``` + +LitD will start up but pause, indicating that it needs a wallet to be created or unlocked. In the second terminal window, create the wallet: + +```bash +lncli --network=signet create +``` + +**Note on network mismatch**: the `--network` flag must match your configured network. If there is a mismatch (for example, using `--network=mainnet` when LitD is configured for signet), you may encounter a macaroon error. + +The wallet creation process will prompt you for: + +1. **Wallet password**: enter the password (twice for confirmation). This is the password LitD will use to unlock the wallet on startup. +2. **New seed or existing seed**: select the option to create a new seed. +3. **Optional passphrase encryption**: you can skip this for testing environments. + +The system then displays your **24-word recovery seed**: + +``` +abandon ability able about above absent absorb abstract absurd abuse access accident ... +``` + +**Back up this seed immediately using your preferred secure backup method.** This seed is the master key to all funds on this node. If you lose it and your server fails, your funds are unrecoverable. + +#### Auto-Unlock Configuration + +The setup scripts include a mechanism for **automatic wallet unlocking**. During installation, a file is created containing the wallet password. This allows LitD to decrypt the wallet automatically on system reboot, ensuring your node comes back online after power failures or maintenance without manual intervention. + +The password file is stored securely with restricted permissions. You can verify its location and contents (on a test node) with: + +```bash +cat ~/.lit/wallet_password +``` + +In a production environment, you should carefully evaluate the security trade-offs of auto-unlock. Storing the password on disk means that anyone with root access to the server can unlock the wallet. For high-value nodes, you may prefer manual unlock after each reboot. + +After the wallet is initialized, stop LitD gracefully in the first terminal (Ctrl+C) and proceed to the final script. + +#### Script 3: Systemd Services and Final Configuration + +The third and final script wraps everything into `systemd` services and applies final configuration updates: + +```bash +chmod +x scripts/litd_setup_3.sh +sudo ./scripts/litd_setup_3.sh +``` + +This script: +- Updates the `lit.conf` with any remaining settings +- Creates a `systemd` service file for LitD at `/etc/systemd/system/litd.service` +- Enables and starts the LitD service + +Upon completion, the script displays a confirmation message. Verify that both services are running: + +```bash +sudo systemctl status bitcoind +sudo systemctl status litd +``` + +Both should show as active. You can also check the LitD logs for any errors: + +```bash +sudo journalctl -u litd -f +``` + +### Exploring the Installed System + +Now that our node is fully operational, let us take a moment to examine the file system structure that the scripts have created. + +The key directories are: + +| Path | Contents | +|------|----------| +| `~/.bitcoin/` | Bitcoin Core data directory and `bitcoin.conf` | +| `~/.lnd/` | LND data (channels, macaroons, wallet) | +| `~/.lit/` | LitD configuration (`lit.conf`) and TLS certificate | +| `~/.tapd/` | Taproot Assets daemon data | + +To inspect the Bitcoin Core configuration: + +```bash +cat ~/.bitcoin/bitcoin.conf +``` + +To inspect the LitD configuration: + +```bash +cat ~/.lit/lit.conf +``` + +The `systemd` service files are located at: + +```bash +ls /etc/systemd/system/bitcoind.service /etc/systemd/system/litd.service +``` + +These services are configured to start automatically on boot and restart on failure. This is essential for node reliability: you do not want to be manually restarting services at 3 AM because of a brief power interruption. + +To manage the services: + +```bash +# Stop LitD +sudo systemctl stop litd + +# Start LitD +sudo systemctl start litd + +# Restart LitD (after config changes) +sudo systemctl restart litd + +# View recent logs +sudo journalctl -u litd --since "10 minutes ago" +``` + +### Summary + +In this chapter, we have walked through the complete process of building a Lightning Terminal node from a bare Ubuntu server. We progressed through three stages: server hardening (SSH, dedicated user, disabled root access), Bitcoin Core installation (binary download with signature verification), and LitD compilation from source (Go, Node.js, Yarn dependencies, followed by the build and configuration). We initialized the wallet, configured auto-unlock for resilience, and wrapped everything in `systemd` services for production-grade process management. + +This is the culmination of everything we have covered in this course. You now have a fully operational LitD node with access to LND, Loop, Pool, Faraday, and Taproot Assets, all manageable from the Lightning Terminal web interface or via the command line. The health checks, autofees, liquidity reports, and account management features we explored in earlier chapters are all available on this node, ready to be configured according to your operational needs. + +# Conclusion +90cfdd76-7deb-4162-87a5-24bb845ba786 ## Ratings & Reviews dd13ca51-9c2c-4cb8-bdfc-c452f205229a - true - ## Final Exam - 2a19c10e-ced6-11f0-8ab2-cf79e817a351 true ## Conclusion 8cf6f7c4-a520-40e6-a198-42fdd0d78f3b +Over the course of LNP 404, we have progressively explored the full Lightning Terminal stack, moving from initial installation and connection all the way through to building a complete node from scratch. + +In **Part 1**, we established the foundations: installing LitD, connecting via Lightning Node Connect, understanding health checks, navigating the dashboard's insights and forwarding data, and configuring Autofees for dynamic fee management. + +In **Part 2**, we expanded our operational toolkit: managing multiple nodes from a single interface, opening channels efficiently through batch transactions, using Lightning Loop for non-custodial liquidity swaps, and leveraging Peer Insights to make informed decisions about channel partners. + +In **Part 3**, we completed the picture with the Liquidity Report (a diagnostic tool for silent liquidity problems), LND Accounts (virtual off-chain partitions for sharing node access securely), and the full Run LitD deployment walkthrough that tied every concept together in practice. + +The Lightning Network is still a rapidly evolving system. The tools we have covered in this course, particularly Lightning Terminal, Loop, Pool, Faraday, and Taproot Assets, continue to receive updates and new features. I encourage you to consult the official documentation at [docs.lightning.engineering](https://docs.lightning.engineering) regularly, and to experiment with the features on signet or testnet before deploying changes to a production node. + +If you found this course helpful, I would be very grateful if you could take a few moments to rate it and share your feedback. Your input helps improve the material for future students and supports the Plan B Network's mission to make Bitcoin education accessible to everyone. + +Thank you for following this course, and congratulations on reaching the end. You now have both the conceptual understanding and the practical skills to operate a Lightning node with confidence. Let's keep building. true From 6099695aeeb47d6f0174f69de47214d0dc360f7d Mon Sep 17 00:00:00 2001 From: Rogzy Date: Sat, 21 Mar 2026 23:36:57 +0100 Subject: [PATCH 02/10] update: LNP 404 introduction section - Add "Why this course matters" section at top - Add "What you will learn" with concrete skills bullet points - Combine 3 part descriptions into single "Curriculum" subsection - Add "Prerequisites and tools" with languages/tools used - Link Hannah Rosenberg to professor profile Co-Authored-By: Claude Opus 4.6 (1M context) --- courses/lnp404/en.md | 39 ++++++++++++++++++++++++++++++++------- 1 file changed, 32 insertions(+), 7 deletions(-) diff --git a/courses/lnp404/en.md b/courses/lnp404/en.md index 7f422ca52b1..624676215f5 100644 --- a/courses/lnp404/en.md +++ b/courses/lnp404/en.md @@ -69,24 +69,49 @@ Ready to take full control of your Lightning node? Let's get started. ## Course overview f4e2a1b3-5c6d-4e8f-9a0b-1d3c5e7f2a4b +### Why this course matters + +Running a Lightning node means you are part of the payment infrastructure of Bitcoin. But without proper tooling, operating a node is like flying blind: you cannot see which channels are profitable, where liquidity is stuck, or whether your fee policies are competitive. Most node operators leave money on the table simply because they lack visibility into their own operations. + +This course gives you that visibility and the tools to act on it. + Welcome to the LNP 404 course! Together, we will explore how to manage, optimize, and understand your Bitcoin Lightning node through the power of **Lightning Terminal** (LitD), an all-in-one management stack developed by Lightning Labs. -This course is built around the demo series by **Hannah Rosenberg** from Lightning Labs. Each chapter pairs a video walkthrough with detailed written content, including the actual CLI commands, configuration files, and procedures you will need. +This course is built around the demo series by [Hannah Rosenberg](https://planb.academy/professors/hannah-rosenberg) from Lightning Labs. Each chapter pairs a video walkthrough with detailed written content, including the actual CLI commands, configuration files, and procedures you will need. -### Part 1: Getting Started with Terminal +### What you will learn -We begin by installing LitD and connecting to the Terminal web interface. From there, we explore the Health Checks framework to evaluate your node's performance across six key metrics, then dive into the financial analytics dashboard to understand your routing revenue, channel efficiency, and network position. The part concludes with Autofees, an automated fee management system that adjusts your channel policies based on historical traffic patterns. +By the end of this course, you will be able to: -### Part 2: Managing Your Node's Network +- Install, configure, and run Lightning Terminal on your own infrastructure +- Diagnose node performance issues using health checks and liquidity reports +- Automate fee management so your channels stay competitive without manual tuning +- Rebalance liquidity through Loop swaps (manual and automated) with budget controls +- Open multiple channels in a single on-chain transaction to save fees +- Manage a fleet of Lightning nodes from one unified dashboard +- Create sandboxed virtual accounts with spending limits for apps and users +- Build a complete Lightning node from scratch on a fresh Ubuntu server -In this part, we move into active node management. You will learn how to operate multiple Lightning nodes from a single Terminal dashboard, open channels efficiently using batch transactions, manage your liquidity through Loop swaps (both manual and automated), and leverage Peer Insights to make data-driven decisions about your channel partnerships. +These are the operational skills that separate a passive node operator from someone who runs a professional, revenue-generating Lightning infrastructure. + +### Curriculum -### Part 3: Advanced Features and Full Node Setup +**Part 1: Getting Started with Terminal** covers installation, the Health Checks diagnostic framework, financial analytics (ROI, forwards, channel insights), and the Autofees algorithm for automated fee management. -The final part covers advanced topics: the Liquidity Report for diagnosing silent routing problems, LND Accounts for creating sandboxed virtual wallets with granular permissions, and a comprehensive from-scratch installation walkthrough using the Run LITD repository. +**Part 2: Managing Your Node's Network** covers multi-node management from a single dashboard, batch channel openings, Lightning Loop for liquidity management (Loop In, Loop Out, Auto Loop), and Peer Insights for data-driven channel decisions. + +**Part 3: Advanced Features and Full Node Setup** covers the Liquidity Report for diagnosing silent routing problems, LND Accounts for sandboxed virtual wallets, and a comprehensive from-scratch node build using the Run LITD repository. + +### Prerequisites and tools + +This course assumes familiarity with the Linux command line (`bash`, `ssh`, `nano`, `systemctl`, `git`) and a basic understanding of how the Lightning Network works (channels, routing, invoices). You will work primarily with **Go**, **Node.js**, and **systemd** configuration files. All commands shown use `bash` on Ubuntu. + +You will need either an existing LND node (testnet or mainnet) for the first 10 chapters, or a fresh Ubuntu server for the final chapter. If you have never set up a Lightning node before, I recommend starting with the [LNP 202 course](https://planb.academy/courses/lnp202). ### Documentation and resources +Throughout this course, we reference the official Lightning Labs documentation: + - [Lightning Terminal docs](https://docs.lightning.engineering/lightning-network-tools/lightning-terminal) - [Loop docs](https://docs.lightning.engineering/lightning-network-tools/loop) - [Pool docs](https://docs.lightning.engineering/lightning-network-tools/pool) From e18738be43153920aee97678262f815487f23971 Mon Sep 17 00:00:00 2001 From: Rogzy Date: Sat, 21 Mar 2026 23:43:33 +0100 Subject: [PATCH 03/10] update: move welcome before 'why this course matters' Co-Authored-By: Claude Opus 4.6 (1M context) --- courses/lnp404/en.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/courses/lnp404/en.md b/courses/lnp404/en.md index 624676215f5..80f87ed9a2e 100644 --- a/courses/lnp404/en.md +++ b/courses/lnp404/en.md @@ -69,16 +69,16 @@ Ready to take full control of your Lightning node? Let's get started. ## Course overview f4e2a1b3-5c6d-4e8f-9a0b-1d3c5e7f2a4b +Welcome to the LNP 404 course! Together, we will explore how to manage, optimize, and understand your Bitcoin Lightning node through the power of **Lightning Terminal** (LitD), an all-in-one management stack developed by Lightning Labs. + +This course is built around the demo series by [Hannah Rosenberg](https://planb.academy/professors/hannah-rosenberg) from Lightning Labs. Each chapter pairs a video walkthrough with detailed written content, including the actual CLI commands, configuration files, and procedures you will need. + ### Why this course matters Running a Lightning node means you are part of the payment infrastructure of Bitcoin. But without proper tooling, operating a node is like flying blind: you cannot see which channels are profitable, where liquidity is stuck, or whether your fee policies are competitive. Most node operators leave money on the table simply because they lack visibility into their own operations. This course gives you that visibility and the tools to act on it. -Welcome to the LNP 404 course! Together, we will explore how to manage, optimize, and understand your Bitcoin Lightning node through the power of **Lightning Terminal** (LitD), an all-in-one management stack developed by Lightning Labs. - -This course is built around the demo series by [Hannah Rosenberg](https://planb.academy/professors/hannah-rosenberg) from Lightning Labs. Each chapter pairs a video walkthrough with detailed written content, including the actual CLI commands, configuration files, and procedures you will need. - ### What you will learn By the end of this course, you will be able to: From 618faccab5bc44ebe7bead92a40781371aa93fc9 Mon Sep 17 00:00:00 2001 From: Rogzy Date: Sat, 21 Mar 2026 23:46:04 +0100 Subject: [PATCH 04/10] fix: remove horizontal rules between chapters (rendered as visible dashes) Co-Authored-By: Claude Opus 4.6 (1M context) --- courses/lnp404/en.md | 5 ----- 1 file changed, 5 deletions(-) diff --git a/courses/lnp404/en.md b/courses/lnp404/en.md index 80f87ed9a2e..03762378ad0 100644 --- a/courses/lnp404/en.md +++ b/courses/lnp404/en.md @@ -753,7 +753,6 @@ This efficient switching mechanism allows operators to maintain situational awar In this chapter, we saw how to generate LNC connection strings via `litcli`, onboard multiple nodes into a single Terminal session, and switch between them using the node selector dropdown. The key takeaway is that **multi-node management requires no additional infrastructure**: the same LNC protocol that secures a single connection scales seamlessly to many. In the next chapter, we will put these connected nodes to work by opening channels efficiently using batch transactions. ---- ## Opening Channels & Batching c7e83bd9-df1c-4763-8401-488b733d835c @@ -846,8 +845,6 @@ This confirms that both channels were funded from a single transaction, exactly In this chapter, we learned that batch opens aggregate multiple channel openings into a single on-chain transaction, reducing fees and preventing UTXO fragmentation. We walked through the Terminal workflow for configuring each channel's capacity, fees, and visibility, then stacking them into one batch. In the next chapter, we will explore what happens after channels are open: how to manage their liquidity over time using Lightning Loop. ---- - ## Lightning Loop f2642efb-a485-4bc9-b571-d8e901e3e8b1 @@ -1023,8 +1020,6 @@ This is essentially a dry run that lets you verify your rules and budgets are co In this chapter, we explored the three modes of Lightning Loop: manual Loop Out (to create inbound liquidity), manual Loop In (to restore outbound liquidity), and Auto Loop (to automate the entire process). The underlying mechanism, submarine swaps, ensures that all operations are trustless and non-custodial. The budget system gives you precise control over costs, and the three-tier hierarchy (node, peer, channel) lets you tailor your liquidity strategy to your specific needs. In the next chapter, we will look at how to evaluate the peers you are connected to using Terminal's Peer Insights feature. ---- - ## Peer Insights 27d09714-6496-4451-bb08-1927e0148d1e From 75ef2b1ea40fb381f4571dedf2adc13cf069a01a Mon Sep 17 00:00:00 2001 From: Rogzy Date: Sun, 22 Mar 2026 01:13:54 +0100 Subject: [PATCH 05/10] feat: add 7 curated screenshots to LNP404 course Screenshots extracted from video lectures and filtered from 126 raw captures down to 7 essential UI screenshots (login, dashboard, health checks, channels). Terminal commands kept as code blocks instead. Co-Authored-By: Claude Opus 4.6 (1M context) --- courses/lnp404/assets/en/001.webp | Bin 0 -> 177936 bytes courses/lnp404/assets/en/002.webp | Bin 0 -> 20644 bytes courses/lnp404/assets/en/003.webp | Bin 0 -> 23028 bytes courses/lnp404/assets/en/004.webp | Bin 0 -> 32112 bytes courses/lnp404/assets/en/005.webp | Bin 0 -> 45564 bytes courses/lnp404/assets/en/006.webp | Bin 0 -> 40632 bytes courses/lnp404/assets/en/007.webp | Bin 0 -> 33964 bytes courses/lnp404/en.md | 1681 +++++------------------------ 8 files changed, 280 insertions(+), 1401 deletions(-) create mode 100644 courses/lnp404/assets/en/001.webp create mode 100644 courses/lnp404/assets/en/002.webp create mode 100644 courses/lnp404/assets/en/003.webp create mode 100644 courses/lnp404/assets/en/004.webp create mode 100644 courses/lnp404/assets/en/005.webp create mode 100644 courses/lnp404/assets/en/006.webp create mode 100644 courses/lnp404/assets/en/007.webp diff --git a/courses/lnp404/assets/en/001.webp b/courses/lnp404/assets/en/001.webp new file mode 100644 index 0000000000000000000000000000000000000000..6d5fb81511330f9974ba6213bc4c7c49009d9e7c GIT binary patch literal 177936 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

m;Uw59 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

4U2^ElY19~Gz_R88QR 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 literal 0 HcmV?d00001 diff --git a/courses/lnp404/assets/en/002.webp b/courses/lnp404/assets/en/002.webp new file mode 100644 index 0000000000000000000000000000000000000000..3592b718931d77fa37b431e4b3852c4564699366 GIT binary patch literal 20644 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 literal 0 HcmV?d00001 diff --git a/courses/lnp404/assets/en/003.webp b/courses/lnp404/assets/en/003.webp new file mode 100644 index 0000000000000000000000000000000000000000..0acc982b6cc892dd74fc6508082bab564ae4d9df GIT binary patch literal 23028 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 literal 0 HcmV?d00001 diff --git a/courses/lnp404/assets/en/005.webp b/courses/lnp404/assets/en/005.webp new file mode 100644 index 0000000000000000000000000000000000000000..245c01e98354a832ae4034d7748c2181ff457a7d GIT binary patch literal 45564 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 JoJl%nE+t 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 literal 0 HcmV?d00001 diff --git a/courses/lnp404/assets/en/006.webp b/courses/lnp404/assets/en/006.webp new file mode 100644 index 0000000000000000000000000000000000000000..5ef27fc135a67355fabcdce635497830d086c1f6 GIT binary patch literal 40632 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 apWsKWb5O@VZoK5D|BZ0_&msQ*UH=1ASReWT literal 0 HcmV?d00001 diff --git a/courses/lnp404/assets/en/007.webp b/courses/lnp404/assets/en/007.webp new file mode 100644 index 0000000000000000000000000000000000000000..e9ee776697d0b5695152b626a2e8a1b54c19e847 GIT binary patch literal 33964 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 literal 0 HcmV?d00001 diff --git a/courses/lnp404/en.md b/courses/lnp404/en.md index 03762378ad0..364fc8ccc22 100644 --- a/courses/lnp404/en.md +++ b/courses/lnp404/en.md @@ -1,126 +1,22 @@ --- name: Navigating Your Node with Terminal -goal: Master the management and optimization of your Lightning node using Lightning Terminal (LitD) +goal: Take a deep dive into your lightning node with Terminal objectives: - - Install Lightning Terminal and connect to your existing LND node in remote mode - - Monitor your node's health with the six-metric diagnostic framework - - Analyze routing performance through forwards, channel insights, and peer analytics - - Automate fee management with the Autofees algorithm and understand its privacy architecture - - Manage liquidity through Loop In, Loop Out, and Auto Loop with budget controls - - Open multiple channels efficiently using batch transactions - - Operate a multi-node infrastructure from a single Terminal dashboard - - Set up virtual LND accounts with granular permissions and spending limits - - Build a complete Lightning node from scratch using the Run LITD repository + - Install and connect your Lightning node using Terminal tools and commands. + - Monitor your node’s health and receive actionable recommendations for optimization. + - Analyze channels, forwards, and peer insights to improve node efficiency and reliability. + - Interpret liquidity and accounting reports for better decision-making. --- -# A Journey into Your Lightning Node +# A Journey into your Lightning Node -Running a Lightning node is one thing. Managing it effectively is another challenge entirely. Whether you are routing payments across the network, running a merchant setup, or simply experimenting on testnet, the operational demands of a Lightning node go far beyond the initial installation: monitoring channel health, balancing liquidity, optimizing fee policies, and keeping your infrastructure secure and resilient. +Navigating Your Node with Terminal is a comprehensive journey into managing, optimizing, and understanding your Bitcoin Lightning node through the power of the command line. +From installation to advanced multi-node management, this course equips you with the practical skills and theoretical knowledge needed to operate your Lightning setup like a pro. You’ll explore key tools such as Lightning Terminal (LND, Loop, Pool, and Faraday) and learn to analyze your node’s health, liquidity, fees, and network interactions directly from the terminal. -This is where **Lightning Terminal** comes in. Developed by Lightning Labs, Lightning Terminal (also known as **LitD**, for Lightning Terminal Daemon) is an all-in-one management stack that bundles several essential tools into a single binary: **Loop** for liquidity swaps, **Pool** for the channel marketplace, **Faraday** for accounting and analytics, **Taproot Assets**, and optionally **LND** itself. In other words, rather than managing five separate daemons and their inter-process communications, you run one program that ties everything together through a unified web interface. - -This course is built around the demo series by **Hannah Rosenberg** from Lightning Labs. Each chapter pairs a video walkthrough with detailed written content, including the actual CLI commands, configuration files, and procedures you will need. This is a hands-on, practice-focused course: you will spend most of your time in the terminal and in the Terminal web interface, working with real tools on real (or testnet) infrastructure. - -### Prerequisites - -To follow this course comfortably, you should have: - -- A basic understanding of how the Lightning Network works (channels, routing, invoices) -- Familiarity with the Linux command line (`ssh`, `nano`, `systemctl`, `git`) -- An existing LND node running on testnet or mainnet (for the first 10 chapters), or a fresh Ubuntu server (for the final chapter, which builds everything from scratch) -- Go 1.21+ and Node.js installed on your machine (for compiling LitD from source) - -If you have never set up a Lightning node before, we recommend starting with the [LNP 202 course](https://planb.academy/courses/lnp202), which walks you through the initial setup of your first Lightning node. - -### Course structure - -The course is organized in three parts: - -**Part 1: Getting Started with Terminal** - -We begin by installing LitD and connecting to the Terminal web interface. From there, we explore the Health Checks framework to evaluate your node's performance across six key metrics, then dive into the financial analytics dashboard to understand your routing revenue, channel efficiency, and network position. The part concludes with Autofees, an automated fee management system that adjusts your channel policies based on historical traffic patterns. - -**Part 2: Managing Your Node's Network** - -In this part, we move into active node management. You will learn how to operate multiple Lightning nodes from a single Terminal dashboard, open channels efficiently using batch transactions, manage your liquidity through Loop swaps (both manual and automated), and leverage Peer Insights to make data-driven decisions about your channel partnerships. - -**Part 3: Advanced Features and Full Node Setup** - -The final part covers advanced topics: the Liquidity Report for diagnosing silent routing problems, LND Accounts for creating sandboxed virtual wallets with granular permissions, and a comprehensive from-scratch installation walkthrough using the Run LITD repository. This last chapter is the most code-intensive in the course, covering server hardening, Bitcoin Core installation, LitD compilation, wallet initialization, and systemd service management. - -### Documentation and resources - -Throughout this course, we reference the official Lightning Labs documentation extensively. Here are the key resources you may want to bookmark: - -- [Lightning Terminal docs](https://docs.lightning.engineering/lightning-network-tools/lightning-terminal) -- [Loop docs](https://docs.lightning.engineering/lightning-network-tools/loop) -- [Pool docs](https://docs.lightning.engineering/lightning-network-tools/pool) -- [LND docs](https://docs.lightning.engineering/lightning-network-tools/lnd) -- [Run LITD repository](https://github.com/lightninglabs/lightning-terminal) -- [Lightning Node Connect](https://docs.lightning.engineering/lightning-network-tools/lightning-terminal/lightning-node-connect) - -Ready to take full control of your Lightning node? Let's get started. +By the end, you’ll not only understand how to maintain and scale your Lightning operation. +++ -# Introduction -a1f3d9c2-7b4e-4c8a-9d5f-2e6b8c0d4a7e - -## Course overview -f4e2a1b3-5c6d-4e8f-9a0b-1d3c5e7f2a4b - -Welcome to the LNP 404 course! Together, we will explore how to manage, optimize, and understand your Bitcoin Lightning node through the power of **Lightning Terminal** (LitD), an all-in-one management stack developed by Lightning Labs. - -This course is built around the demo series by [Hannah Rosenberg](https://planb.academy/professors/hannah-rosenberg) from Lightning Labs. Each chapter pairs a video walkthrough with detailed written content, including the actual CLI commands, configuration files, and procedures you will need. - -### Why this course matters - -Running a Lightning node means you are part of the payment infrastructure of Bitcoin. But without proper tooling, operating a node is like flying blind: you cannot see which channels are profitable, where liquidity is stuck, or whether your fee policies are competitive. Most node operators leave money on the table simply because they lack visibility into their own operations. - -This course gives you that visibility and the tools to act on it. - -### What you will learn - -By the end of this course, you will be able to: - -- Install, configure, and run Lightning Terminal on your own infrastructure -- Diagnose node performance issues using health checks and liquidity reports -- Automate fee management so your channels stay competitive without manual tuning -- Rebalance liquidity through Loop swaps (manual and automated) with budget controls -- Open multiple channels in a single on-chain transaction to save fees -- Manage a fleet of Lightning nodes from one unified dashboard -- Create sandboxed virtual accounts with spending limits for apps and users -- Build a complete Lightning node from scratch on a fresh Ubuntu server - -These are the operational skills that separate a passive node operator from someone who runs a professional, revenue-generating Lightning infrastructure. - -### Curriculum - -**Part 1: Getting Started with Terminal** covers installation, the Health Checks diagnostic framework, financial analytics (ROI, forwards, channel insights), and the Autofees algorithm for automated fee management. - -**Part 2: Managing Your Node's Network** covers multi-node management from a single dashboard, batch channel openings, Lightning Loop for liquidity management (Loop In, Loop Out, Auto Loop), and Peer Insights for data-driven channel decisions. - -**Part 3: Advanced Features and Full Node Setup** covers the Liquidity Report for diagnosing silent routing problems, LND Accounts for sandboxed virtual wallets, and a comprehensive from-scratch node build using the Run LITD repository. - -### Prerequisites and tools - -This course assumes familiarity with the Linux command line (`bash`, `ssh`, `nano`, `systemctl`, `git`) and a basic understanding of how the Lightning Network works (channels, routing, invoices). You will work primarily with **Go**, **Node.js**, and **systemd** configuration files. All commands shown use `bash` on Ubuntu. - -You will need either an existing LND node (testnet or mainnet) for the first 10 chapters, or a fresh Ubuntu server for the final chapter. If you have never set up a Lightning node before, I recommend starting with the [LNP 202 course](https://planb.academy/courses/lnp202). - -### Documentation and resources - -Throughout this course, we reference the official Lightning Labs documentation: - -- [Lightning Terminal docs](https://docs.lightning.engineering/lightning-network-tools/lightning-terminal) -- [Loop docs](https://docs.lightning.engineering/lightning-network-tools/loop) -- [Pool docs](https://docs.lightning.engineering/lightning-network-tools/pool) -- [LND docs](https://docs.lightning.engineering/lightning-network-tools/lnd) -- [Run LITD repository](https://github.com/lightninglabs/lightning-terminal) -- [Lightning Node Connect](https://docs.lightning.engineering/lightning-network-tools/lightning-terminal/lightning-node-connect) - -Ready to take full control of your Lightning node? Let's get started. - # First steps of installing your Lightning Node d74ec352-1a5d-466d-a06d-571fc9f99937 @@ -129,988 +25,372 @@ Ready to take full control of your Lightning node? Let's get started. ![video](https://www.youtube.com/watch?v=XibPhZtNQak) -Running a Lightning node is one thing. Managing it with confidence is something else entirely. In this first chapter, we will install **Lightning Terminal**, the all-in-one management interface developed by Lightning Labs, and we will connect it to an existing LND node. By the end of this chapter, you will have a running `litd` daemon, a proper configuration file, a systemd service that survives reboots, and a secure browser connection to Terminal on the web. - -Let's go! - -### What is Lightning Terminal? - -Before we touch the command line, let's understand what we are about to install. **Lightning Terminal (LitD)** is a unified management stack that bundles several powerful tools into a single binary: - -- **LND** (optionally, if you do not already have it running) -- **Lightning Loop** for submarine swaps between on-chain and off-chain Bitcoin -- **Lightning Pool** for buying and selling inbound channel liquidity -- **Faraday** for financial reporting and channel analytics -- **Taproot Assets Protocol** for asset issuance over Lightning - -In other words, `litd` is the gateway between a browser-based management interface and your Lightning node's gRPC API. Anyone who has access to `litd` can monitor and manage the node, which is why we will pay careful attention to authentication and security throughout this chapter. - -### Two Deployment Modes - -LitD supports two ways of running alongside LND: - -| Mode | Description | When to use | -|------|-------------|-------------| -| **Integrated mode** | LitD ships with its own embedded LND instance | Fresh installations where you want everything in a single process | -| **Remote mode** | LitD connects to an already-running LND instance | Existing nodes where you want to add Terminal without reconfiguring LND | - -In this course, we will use **remote mode**, which is the ideal approach when you already have a production or testnet LND node running. Remote mode lets you enhance your existing setup with Loop, Pool, Faraday, and the Terminal web interface without touching your LND installation. - -### Prerequisites - -Installing `litd` from source requires up-to-date development tools. Before proceeding, verify that you have recent versions of both Go and Node.js on your machine: - -```bash -go version -``` - -You should see something like `go1.21.3` or newer. - -```bash -node --version -``` - -You should see `v20.x` or newer (the exact version matters less than being reasonably current). - -You will also need a running Bitcoin backend (typically `bitcoind`) and a functioning LND node. Let's confirm that both processes are active: - -```bash -ss -tlnp | grep -E 'bitcoind|lnd|litd' -``` - -You should see `bitcoind` and `lnd` listening on their respective ports. If `litd` already appears, you may have a previous installation; stop it before continuing. - -### Cloning and Compiling LitD - -Now that our environment is ready, let's install LitD from source. We begin by cloning the official Lightning Labs repository: - -```bash -git clone https://github.com/lightninglabs/lightning-terminal.git -cd lightning-terminal -``` - -Next, we check out the latest stable release. As of this writing, that is version `v0.12.2-alpha`: - -```bash -git checkout v0.12.2-alpha -``` - -Then we compile and install the binary with a single command: - -```bash -make install -``` - -This step compiles the Go backend, builds the UI assets, and places the `litd` binary in your `$GOPATH/bin` directory. It typically takes a few minutes. Once it completes, confirm that `litd` is accessible system-wide: +### Lightning Terminal Remote Mode Overview +Lightning Terminal (LitD) is a unified management stack for Lightning nodes, bundling Loop, Pool, Faraday, Taproot Assets, and optionally LND. It can run in **integrated mode** (shipping with LND) or **remote mode**, where it connects to an already-running LND instance. This chapter focuses on **remote mode**, ideal for maintaining an established node without reconfiguring your infrastructure. -```bash -litd --version -``` - -If the version string prints correctly, the installation is complete. Let's move on to configuration. - -### Preparing the LND Configuration - -Before `litd` can communicate with your existing LND node, we need to verify one critical setting in your LND configuration file. Open it: +#### System Requirements & Preparation +LitD requires up‑to‑date development tools: +- Go 1.21.3+ +- Node.js 2.1.5+ +Verifying running services ensures compatibility—typically `bitcoind` and `lnd` are active, while `litd` is not yet present. Remote mode requires `rpcmiddleware.enable=true` in the LND config, enabling LitD to authenticate and communicate with LND. -```bash -nano ~/.lnd/lnd.conf -``` - -Look for the following line (or add it if it is missing): - -```ini -rpcmiddleware.enable=true -``` +#### Repository Setup & Compilation +To install LitD from source: +1. Clone `lightning-terminal` from GitHub. +2. Checkout the latest stable release (e.g., `v0.12.2-alpha`). +3. Run `make install` to compile Go code, build UI assets, and install the binary. +Running `litd` confirms the installation is accessible system‑wide. -This setting enables the **RPC Middleware Interceptor**, which allows `litd` to authenticate and communicate with LND. Without it, `litd` will fail to connect in remote mode, and you may encounter cryptic macaroon errors. Save and close the file, then restart LND if you had to modify this setting. +![LNP404](assets/en/001.webp) -### Creating the LitD Configuration File +#### Configuring lit.conf +A dedicated data folder (usually `~/.lit`) stores configuration and node metadata. Inside it, a `lit.conf` file defines operation parameters: +- `lnd-mode=remote` +- `network=testnet` +- `remote.lnd.rpcserver=` +- `remote.lnd.macaroonpath=` +- `remote.lnd.tlspath=` +- `uipassword=` +- `httpslisten=0.0.0.0:8443` -Rather than passing dozens of flags on the command line each time we start `litd`, we will create a dedicated configuration file. First, let's create the data directory: +These settings securely bind LitD to your pre‑existing LND instance and expose the HTTPS UI interface. -```bash -mkdir -p ~/.lit -``` +### Running LitD with systemd +Creating `/etc/systemd/system/litd.service` turns LitD into a managed background service. +Key entries: +- Start only **after LND** (`After=lnd.service`). +- `Restart=always` for resilience. +- Proper user permissions for file access. -Now create the configuration file: +Enabling the service ensures LitD autostarts on reboot and stays active like any other core system component. -```bash -nano ~/.lit/lit.conf +### Accessing the Terminal Interface +Once active, browse to: ``` - -Here is a complete configuration for remote mode. We will walk through each section: - -```ini -# LitD operation mode -lnd-mode=remote - -# Network (change to mainnet for production) -network=testnet - -# UI password (use a strong, unique password on production nodes) -uipassword=YourSecurePasswordHere - -# Remote LND connection settings -remote.lnd.rpcserver=localhost:10009 -remote.lnd.macaroonpath=~/.lnd/data/chain/bitcoin/testnet/admin.macaroon -remote.lnd.tlscertpath=~/.lnd/tls.cert - -# HTTPS listen address for the Terminal UI -httpslisten=0.0.0.0:8443 +https://:8443 ``` +Expect browser warnings on testnet unless proper SSL certificates are configured. The UI password defined in `lit.conf` grants access. -Let's examine what each block does: - -1. **`lnd-mode=remote`** tells `litd` that we already have an LND node running. From `litd`'s perspective, LND is a remote service it connects to, even when both run on the same machine. +![LNP404](assets/en/002.webp) -2. **`network=testnet`** ensures `litd` operates on the correct network. If you are running mainnet, change this accordingly. A network mismatch will produce macaroon authentication errors that can be difficult to diagnose. +Terminal supports: +1. **Local browser access** (direct LitD UI) +2. **Remote access** through terminal.lightning.engineering using **Lightning Node Connect (LNC)**. -3. **`uipassword`** sets the password for the browser-based Terminal UI. On a production machine, use a password generated by a password manager. +LNC acts as an encrypted, mailbox‑mediated communication layer for secure remote management without exposing LND ports. Pairing occurs using a one‑time phrase generated by the UI or CLI. -4. **The three `remote.lnd.*` lines** tell `litd` how to talk to LND: the RPC server address, the path to the admin macaroon for authentication, and the path to the TLS certificate. Note that the macaroon path includes the network name (`testnet` in our case). +![LNP404](assets/en/003.webp) -5. **`httpslisten=0.0.0.0:8443`** instructs `litd` to listen for HTTPS connections on port 8443 from any network interface. This is the port we will use to access the Terminal UI in a browser. +#### Command-Line Session Control +`litcli` enables advanced session administration: +- Create sessions (`litcli sessions add`) +- Specify types (admin, readonly, etc.) +- Label sessions for tracking +- Produce pairing strings for automation or remote setups -### Setting Up a Systemd Service +This is essential for multi‑admin environments or tooling that integrates with Terminal’s APIs. -We could start `litd` manually with a simple command like `litd --uipassword=YourPassword`, but that approach lacks resilience. If the machine reboots at 2 AM, your Terminal connection disappears. A systemd service solves this problem elegantly. - -Create the service file: - -```bash -sudo nano /etc/systemd/system/litd.service -``` - -Paste the following configuration: - -```ini -[Unit] -Description=LitD Lightning Terminal Daemon -Requires=lnd.service -After=lnd.service - -[Service] -ExecStart=/home//go/bin/litd -User= -Group= -Type=simple -Restart=always -RestartSec=120 - -[Install] -WantedBy=multi-user.target -``` +![LNP404](assets/en/004.webp) -Replace `` with your actual Linux username. A few points worth noting: +#### Key Takeaways +- LitD remote mode lets you enhance an existing LND node with Loop, Pool, Faraday, and more **without modifying your LND installation**. +- Source installation ensures transparency and customization. +- Proper `lit.conf` and systemd integration make LitD production‑ready. +- Terminal + LNC provide secure, flexible local and remote node management. -- **`Requires=lnd.service`** and **`After=lnd.service`** ensure that `litd` starts only after LND is up and running. Since `litd` depends on LND's RPC interface, starting it before LND would cause connection failures. -- **`Restart=always`** with a **`RestartSec=120`** delay means that if `litd` crashes, systemd will wait two minutes and then restart it automatically. -- The `ExecStart` path should point to wherever `make install` placed the `litd` binary (typically `$GOPATH/bin/litd`). - -Now enable and start the service: - -```bash -sudo systemctl enable litd -sudo systemctl start litd -``` - -Verify that `litd` is running and listening on the expected port: - -```bash -ss -tlnp | grep 8443 -``` - -If you see `litd` listening on port 8443, the daemon is operational. You can also check its status at any time with: - -```bash -sudo systemctl status litd -``` - -### Accessing the Terminal UI - -With `litd` running, open a browser and navigate to: - -``` -https://:8443 -``` - -If you have not configured a domain name or SSL certificate (which is typical on testnet), your browser will display a security warning about the self-signed certificate. This is expected; proceed past the warning for testing purposes. On a production node, you would configure a proper TLS certificate. - -Enter the UI password you defined in `lit.conf`, and you will see the Terminal interface. From here, you have access to all the management tools we will explore throughout this course: health checks, channel management, Loop, Pool, Autofees, and more. - -### Connecting to Terminal on the Web - -The local UI is useful, but Lightning Terminal truly shines when accessed through **Terminal on the web** at `terminal.lightning.engineering`. This hosted interface connects to your node remotely using **Lightning Node Connect (LNC)**, an encrypted communication protocol that works even when your node sits behind Tor or NAT. - -Here is how LNC works at a high level: your `litd` daemon makes an outgoing connection to a web proxy (the "mailbox"). Because the connection is outgoing, you do not need to open any ports on your firewall. The proxy server sees only encrypted blobs; Lightning Labs cannot inspect your private channel balances, HTLCs, or on-chain data. The connection is authenticated using a **one-time pairing phrase**, a set of 10 words that you should treat with the same care as a password. - -#### Connecting via the UI - -From the local Terminal interface, click the connection button to initiate an LNC session. The interface will generate a 10-word pairing phrase. Copy this phrase, then navigate to `terminal.lightning.engineering` in your browser. Paste the phrase, set a session password, and you are connected. - -#### Connecting via the Command Line - -For automation or headless setups, you can generate the connection string directly from the command line using `litcli`: - -```bash -litcli --network=testnet sessions add --label default --type admin -``` - -This command creates a new administrative session and outputs a connection string. You can then paste this string into the Terminal web interface to establish the connection. Note that `litcli` supports several session types beyond `admin`, including read-only sessions for monitoring dashboards. - -**Important:** The connection string is equivalent to an administrative private key for your node. Never broadcast it publicly, and never reuse a pairing phrase after it has been consumed. - -### Summary - -Let's recap what we have accomplished in this chapter. We installed `litd` from source by cloning the Lightning Labs repository and running `make install`. We verified that `rpcmiddleware.enable=true` is set in our LND configuration. We created a dedicated `lit.conf` file with all the parameters needed for remote mode operation. We set up a systemd service so that `litd` starts automatically and survives reboots. Finally, we connected to Terminal on the web using Lightning Node Connect. - -In the next chapter, we will explore what Terminal reveals about our node's health and discover how the health check system evaluates routing performance across six key metrics. ## Health Checks and Recommendations ceb149b0-473b-4264-8bc3-b64ec8717aac ![video](https://www.youtube.com/watch?v=ZyZKFmKW_dU) -Now that we have Lightning Terminal installed and connected, let's explore the first thing it shows us: the health of our node. In this chapter, we will examine how Terminal evaluates your node across six diagnostic metrics, what each metric actually measures, and how the **Recommended Channels** feature suggests new peers that benefit both your node and the broader Lightning Network. - -### Why Health Checks Matter +### Understanding Lightning Terminal's Optimization Tools -Running a Lightning node is not simply a matter of keeping software online. A routing node must maintain sufficient channels, balanced liquidity, stable connections, and quality peers in order to forward payments reliably. Without a systematic way to evaluate these factors, operators are left guessing about their node's effectiveness. +Lightning Terminal provides comprehensive tools for monitoring and optimizing your Lightning Network node's performance. This chapter explores the Health Checks feature and the Recommended Channels system, two essential components for maintaining a well-functioning routing node. While these features are currently available for mainnet nodes, understanding their principles and metrics will help you make informed decisions about your node's configuration and network participation. -Terminal's **Health Checks** provide exactly this systematic evaluation. Think of them as a diagnostic report for your node, covering six dimensions of routing performance. However, and this is an important nuance, these checks are designed specifically for routing nodes. If your node specializes in sending payments (a consumer wallet) or receiving payments (a merchant endpoint), it may not score well on all six checks, and that is perfectly fine. The checks measure routing capability, not general usefulness. +#### The Health Checks Framework -### Exploring Your Node's Health +The Health Checks feature offers a systematic evaluation of your node's performance across six key metrics. When you access your node through Terminal's web interface, you'll find a summary at the top indicating whether your node passes all checks. For detailed analysis, navigate to the Explore tab and search for your node using its alias or public key. This displays your node's score along with comprehensive information including current capacity, node age, peer quality, and centrality measures. -When you connect to Terminal on the web, the homepage displays a summary of your node's health status at the top. To get a more detailed view, navigate to the **Explore** tab and search for your node by alias or public key: +![LNP404](assets/en/005.webp) -1. Copy your node's public key from the homepage -2. Click the **Explore** tab -3. Paste your public key into the search field +It's crucial to understand that Health Checks are designed primarily for routing nodes. These metrics evaluate how well your node can facilitate payments across the network, requiring consistent uptime, adequate channel capacity, and reliable peer connections. However, if your node specializes in sending or receiving payments rather than routing, you may not score highly on these checks, and that's perfectly acceptable. The key is aligning your node's configuration with its intended purpose. -This brings up a detailed profile of your node, including its overall score, current capacity, age, number of good peers, and centrality measure. Below these summary statistics, you will find the six individual health checks. +### Core Health Check Metrics -### The Six Health Checks +The six metrics evaluate different aspects of node performance: -Let's walk through each check and understand what it measures: +**Online Status**: The most fundamental check verifying your node is online. For routing nodes, consistent uptime is non-negotiable since you cannot facilitate payments when offline. -**1. Node Is Online** +**Channel Count**: Evaluates whether your node maintains sufficient active channels for effective routing. Approximately fourteen active channels demonstrates adequate connectivity for routing operations. -This is the most fundamental check. A routing node must be reachable on the network to forward payments. If your node experiences frequent downtime, it cannot route payments, and peers will eventually close their channels with you. For routing nodes, consistent uptime is not optional; it is the foundation upon which everything else depends. +**Routing Capacity**: Examines whether channels have sufficient capacity in both directions to route payments successfully. A channel might exist but becomes less useful if balance is heavily skewed to one side. -**2. Plenty of Channels** +**Channel Health and Stability**: These metrics assess whether channels remain active with regular activity and maintain consistent uptime. The system specifically evaluates public channels, so private channels with lower activity won't negatively impact scores. -A routing node needs a sufficient number of active channels to create viable payment paths. A node with only one or two channels cannot meaningfully participate in routing because there are too few paths through it. Terminal evaluates whether your node has enough active channels to function as a useful routing intermediary. Around 14 active channels is generally considered adequate connectivity for routing operations. +**Peer Quality**: Evaluates whether your public channels connect to other well-performing routing nodes. This recognizes that node effectiveness depends on both your performance and the quality of network connections. -**3. Good Routing Capacity** +### Leveraging Recommended Channels -Having many channels is necessary but not sufficient. Each channel must also have **adequate capacity in both directions** to route payments of reasonable size. In other words, a channel where all the balance sits on one side cannot forward payments in the depleted direction. This check evaluates whether your channels collectively provide enough bidirectional capacity to handle typical routing requests. +The Recommended Channels feature provides curated suggestions for new channel partners that benefit both your node and the broader Lightning Network. Access this feature from the channels tab to see potential peers with information including network rank, alias, centrality measures, and total capacity. -**4. Many Healthy Channels** +![LNP404](assets/en/006.webp) -Beyond capacity, Terminal evaluates whether your channels are actually healthy. A **healthy channel** is one that remains active, has reasonable capacity, and sees some activity over time. This check focuses specifically on public channels (channels that are announced to the network graph). Private channels, which are typically used for mobile wallets or merchant endpoints, are not factored into this metric. +These recommendations serve dual purposes: identifying stable peers that would benefit from additional well-connected partners, and promoting network health by encouraging connections that decentralize routing paths and allocate capital where most needed. When you open a channel to a recommended node, you contribute to overall Lightning Network resilience and efficiency. -**5. Channel Stability** +The recommended nodes represent carefully selected candidates based on performance history and network position. Click on any recommendation to view detailed information including activity duration, peer count, and specific Health Checks passed. This transparency allows informed decisions about channel partnerships that align with your node's strategy and capacity allocation goals. -Do your channels stay open and active, or do they frequently go offline? This check penalizes nodes whose channels are unstable, where peers disconnect often or where channels are opened and closed in rapid succession. Stability signals to the network that your node is a reliable routing partner. +### Optimizing Your Node's Performance -**6. Many Good Peers** +Regular monitoring of Health Check performance and thoughtful selection of new channel partners from the recommended list optimizes your node's effectiveness while supporting network growth. Understanding these tools empowers active management of your node's health and contribution to the Lightning Network's continued expansion and decentralization. -This is the most demanding check. It evaluates not just your own node's performance, but the quality of the nodes you connect to. Your public channels should reach out to **other well-performing routing nodes**. A node that connects only to poorly maintained or unreliable peers inherits some of that unreliability, because payments that route through your node depend on your peers being available and well-connected too. - -In Terminal's terminology, a **"stable peer"** is a node that passes five of the six health checks, typically all checks except this last one ("many good peers"). This definition becomes important for the Recommended Channels feature, which we will explore next. - -### Understanding Your Scores - -Each health check includes a link to more detailed documentation. If you pass some checks but fail others, these links provide actionable guidance on how to improve. Here is a general diagnostic approach: - -| Failed Check | Likely Cause | Action | -|-------------|-------------|--------| -| Node is online | Uptime issues | Investigate network stability, configure systemd for auto-restart | -| Plenty of channels | Too few connections | Open additional channels to well-connected peers | -| Good routing capacity | Channels depleted on one side | Rebalance using Loop (covered in a later chapter) | -| Many healthy channels | Inactive or undersized channels | Close inactive channels, open larger ones | -| Channel stability | Frequent opens/closes or peer disconnections | Choose more stable peers, investigate network issues | -| Many good peers | Connected to poorly performing nodes | Open channels to recommended peers (see below) | - -### Recommended Channels - -Scroll down on the Channels tab of the homepage, and you will find the **Recommended Channels** section. This feature identifies nodes on the network that would benefit from a well-connected peer, and it suggests that you be that peer. - -The recommendation logic works as follows: Terminal identifies "stable peers," nodes that pass five of six health checks (everything except "many good peers"). These are reliable, well-maintained nodes that simply need better-connected partners to reach their full routing potential. When you open a channel to one of these recommended nodes, the benefit operates on three levels: - -1. **Your node** gains a new, reliable routing partner -2. **The recommended peer** may pass its final health check, becoming a fully healthy routing node -3. **The network as a whole** benefits from more decentralized routing paths and better capital allocation - -For each recommended node, Terminal displays its rank, alias, centrality score, and total capacity. You can click on any recommendation to view detailed information, including how long the node has been active, how many peers it has, and which health checks it passes. - -It is worth noting that opening a channel to a recommended peer does not guarantee that the peer will pass its final health check. Success also depends on the capacity you allocate to the channel and ongoing maintenance of that channel's liquidity balance. - -### Summary - -In this chapter, we explored Terminal's Health Checks framework and the Recommended Channels feature. We learned that the six health checks evaluate routing-specific performance: uptime, channel count, bidirectional capacity, channel health, stability, and peer quality. We also discovered how the recommendation system identifies stable peers that would benefit from new connections, creating a virtuous cycle of network improvement. - -In the next chapter, we will dive into the data that Terminal provides about your node's financial performance, routing activity, and channel-level analytics. +By leveraging both Health Checks for performance assessment and Recommended Channels for strategic growth, you can maintain a well-functioning node that serves both your operational goals and the broader network's needs. ## Insights, Forwards, and Channels 37799ff2-ca5a-4db4-aa21-fed5a5420be4 ![video](https://www.youtube.com/watch?v=Mv7wMwnr-Sw) -Now that we understand how Terminal evaluates our node's health, let's explore the financial and operational data it provides. The Terminal Web homepage is effectively your node's command center, consolidating routing data, profitability metrics, and channel analytics into a single interface. In this chapter, we will examine the four key performance indicators, the forwarding log, the top routes analysis, and the channel management tools that make Terminal such a powerful operational dashboard. - -### The Four Key Performance Indicators - -At the top of the Terminal homepage, you will find four metrics that provide an instant snapshot of your node's financial performance: - -| Metric | What It Measures | -|--------|-----------------| -| **Spent Satoshis** | Total operational costs: on-chain fees for opening and closing channels, routing fees paid when sending payments, rebalancing costs | -| **Earned Satoshis** | Revenue generated from forwarding payments through your node | -| **Net Profit** | Earned Satoshis minus Spent Satoshis | -| **ROI (Return on Investment)** | Net Profit relative to the total capital locked in your channels | - -These four numbers tell you, at a glance, whether your node is operating at a profit or a loss. If you are running a routing node with the goal of earning fees, this is where you assess whether your strategy is working. If your node is not optimized for routing (perhaps it exists primarily to support a specific application or service), a negative ROI is not necessarily a problem; it simply reflects a different use case. - -You can adjust the **time period** for these metrics using the controls at the top of the dashboard. This allows you to isolate specific periods, which is particularly useful when evaluating the impact of a fee policy change or a new channel opening. - -### Profit and Loss Breakdown - -For deeper financial analysis, click through to the **Profit and Loss breakdown**. This view itemizes your revenue sources and expense categories, providing granular visibility into where your satoshis are flowing. The breakdown shows: - -- How you have been **earning fees** (which channels and routes generate the most revenue) -- How you have been **spending satoshis** (channel opening costs, routing fees, rebalancing expenses) - -One of the most practical features here is the **CSV export** button. You can download your complete profit and loss data and import it into a spreadsheet for external accounting, tax reporting, or more sophisticated financial modeling. For operators who manage multiple nodes or need to report to stakeholders, this bridges the gap between node management and traditional bookkeeping. - -### Top Routes - -Below the KPI summary, you will find the **Top Routes** section. This is where Terminal reveals the specific payment pathways that drive the majority of your forwarding volume and fee revenue. - -Understanding your top routes is strategically important. If a particular channel combination consistently generates the highest fees, that tells you several things: those channels have adequate liquidity, the fee rates are attracting traffic, and the peers on either end are active routing participants. These are the channels you want to pay the most attention to when it comes to liquidity management. - -The analysis breaks down further into **Top Outbound** and **Top Inbound** categories. This distinction helps you understand the directionality of your traffic: - -- **Top Outbound** channels are the ones through which payments most frequently leave your node. These channels tend to drain your local (outbound) balance over time. -- **Top Inbound** channels are the ones through which payments most frequently arrive at your node. These channels accumulate local balance over time. - -Understanding these flow patterns is crucial for anticipating liquidity needs. If a high-earning outbound channel is steadily draining, you know you will eventually need to replenish its local balance (using Loop In, for example) to keep the revenue flowing. - -### The Forwards Log - -Scrolling down further, you reach the **Forwards** section. This is a comprehensive log of every payment your node has forwarded, displayed both as a time-series graph and as a detailed event list. - -The graph provides a visual overview of routing activity over time. You can adjust the time window to zoom in on specific periods of interest. Below the graph, each forwarding event is logged individually, showing: - -- The timestamp of the forward -- The amount forwarded -- The fee earned for facilitating that payment +### Financial Performance and Node Analytics -This level of detail creates an audit trail that is invaluable for troubleshooting. If you notice a drop in forwarding activity, you can correlate it with specific events: a channel going offline, a fee policy change, or a liquidity imbalance that developed on a key route. +Terminal Web serves as the primary command center for Lightning Network node operators, consolidating complex routing data into a streamlined financial interface. The dashboard’s homepage is anchored by four key performance indicators (KPIs) that provide an instant health check of the node's operations: **Return on Investment (ROI)**, **Net Profit**, **Earned Satoshis**, and **Spent Satoshis**. -### The Channels Tab +These metrics are dynamically calculated to offer a transparent view of profitability. "Spent Satoshis" aggregates all operational costs, such as on-chain transaction fees for opening and closing channels, as well as costs associated with rebalancing liquidity. Conversely, "Earned Satoshis" tracks the revenue generated from forwarding payments for other network participants. The platform automatically synthesizes these figures into a Net Profit value, while the ROI metric contextualizes this profit against the total capital locked in channels. -Let's now turn to the **Channels** tab, which represents the operational core of Terminal Web. At the top level, you will see aggregate statistics: +To support deeper analysis, the dashboard allows operators to adjust the timeframe of these metrics, enabling the isolation of specific periods to evaluate the impact of fee policy changes or market volatility. A dedicated Profit and Loss (P&L) breakdown feature itemizes revenue sources and expense categories, offering granular visibility into financial flows. For operators integrating with external accounting software or performing complex modeling, this data can be exported directly to CSV formats, bridging the gap between node management and traditional bookkeeping. -- **Total channels** (active and inactive) -- **Total outbound capacity** (your ability to send or route outward) -- **Total inbound capacity** (your ability to receive or route inward) +### Routing Intelligence and Traffic Analysis -But the real power of this tab lies in the **per-channel liquidity visualization**. For each channel, Terminal displays a visual bar showing the balance distribution between local (outbound) and inbound liquidity. At a glance, you can see: +Beyond high-level financials, Terminal Web provides critical insights into the actual movement of funds through the node via its routing analysis tools. The **Top Routes** feature is essential for strategic optimization; it identifies the specific pathways and channel combinations that drive the majority of the node's forwarding volume. Recognizing these high-value routes allows operators to prioritize liquidity maintenance where it generates the most significant return. -- Channels that are **local-heavy** (full of outbound liquidity, depicted on the left side of the bar) -- Channels that are **remote-heavy** (full of inbound liquidity, depicted on the right side of the bar) -- Channels that are **well-balanced** (liquidity distributed roughly evenly) +This analysis is segmented into "Top Outbound" and "Top Inbound" categories. This distinction helps operators understand the directionality of their traffic—identifying which peers are primarily sources of liquidity versus those that act as sinks. Understanding these flow patterns is crucial for preempting liquidity exhaustion on critical paths. Additionally, the dashboard maintains a comprehensive **Forwards Log**, which visualizes routing activity over time and provides a detailed history of individual forwarding events. Each entry logs the amount forwarded and the specific fee earned, creating an audit trail that is invaluable for troubleshooting failed routes or validating the effectiveness of fee adjustments. -This visual representation is far more efficient than reading through numerical tables. In a few seconds, you can scan all your channels and identify which ones need attention. +### Channel Management and Liquidity Visualization -### Per-Channel Analytics +The Channels tab represents the operational core of Terminal Web, offering a detailed inventory of every peer connection. At the top level, it presents aggregate statistics, including the total count of active versus inactive channels and the node's overall inbound and outbound capacity. However, the most practical tool for daily operations is the **Liquidity Visualization**. -Click on any individual channel, and Terminal reveals detailed metrics: +![LNP404](assets/en/007.webp) -- **Satoshis earned** through that specific channel -- **ROI** for channels you opened (comparing earned fees against the on-chain cost of opening the channel) -- **Peer information** including the node alias and public key -- **Channel status** (active or inactive) -- **Total capacity** of the channel +Rather than displaying raw numbers, Terminal Web utilizes visual bars to represent the balance distribution of each channel. This makes it immediately apparent which channels are "local-heavy" (full of outbound liquidity) or "remote-heavy" (full of inbound liquidity). This visual scan is far more efficient than parsing numerical tables, allowing operators to quickly identify channels that require rebalancing to maintain routing efficiency. -The ROI calculation is particularly valuable for evaluating past decisions. If you opened a channel and the fees it has generated exceed the on-chain cost of creating it, that channel is profitable. If not, you may want to consider whether to keep it open or reallocate that capital elsewhere. - -### Channel Actions - -From the channel detail view, you can take direct action: - -- **Update the fee policy** for that specific channel. If a channel is underperforming, adjusting its fee rate may attract more routing traffic. If it is being depleted too quickly, raising the fee can slow the drain. -- **Close the channel** if it is consistently inactive or unprofitable. Closing an underperforming channel frees up capital that can be redeployed to a more productive peer. - -Terminal also logs all **channel lifecycle events**, including opens, cooperative closes, and force closes. This history appears in the **Channel Actions** section and provides context for understanding changes in your channel count over time. If you notice your channel count dropped unexpectedly, check this log to see whether a peer force-closed on you, or whether an old inactive channel was cleaned up. - -### Summary - -In this chapter, we explored Terminal's financial dashboard and channel management tools. We examined the four KPIs that summarize node profitability (Spent Sats, Earned Sats, Net Profit, ROI), the Top Routes analysis for identifying high-value payment paths, the Forwards log for auditing individual routing events, and the Channels tab for visual liquidity management and per-channel analytics. - -In the next chapter, we will discover how to automate one of the most time-consuming aspects of node management: fee adjustment. The Autofees feature can significantly reduce your operational overhead while improving both fee earnings and liquidity balance. +#### Advanced Channel Actions +Terminal Web goes beyond passive monitoring by integrating actionable controls directly into the analytics interface. Each channel displays a calculated ROI—specifically for channels initiated by the local operator—comparing earned fees against the on-chain cost of opening the channel. This per-channel profitability metric is decisive when determining whether to keep a connection alive. From this same interface, operators can execute critical lifecycle actions: they can adjust fee policies to influence traffic flow or initiate channel closures for underperforming peers. The system also logs all channel lifecycle events—opens, cooperative closes, and force closes—providing a historical context that helps operators refine their peer selection strategy over time. ## Autofees c6264c0b-10f6-4261-8d1e-47593168d8ca ![video](https://www.youtube.com/watch?v=wglBEUtXgTo) -If you have been managing a Lightning routing node for any length of time, you know that fee management is one of the most persistent operational challenges. Set your fees too high, and traffic stops flowing through your channels. Set them too low, and you underprice your liquidity, draining your outbound capacity without earning adequate compensation. In this chapter, we will explore **Autofees**, a Terminal feature that automates fee adjustments on a per-peer basis, adapting dynamically to changes in demand and routing flows. - -### Why Automate Fees? - -Manual fee management requires constant attention. Each channel has its own traffic patterns, each peer behaves differently, and market conditions shift over time. An operator managing dozens of channels would need to monitor each one individually, compare forwarding volumes, evaluate whether current fees are capturing enough value, and adjust accordingly. This is time-consuming and error-prone. - -Autofees addresses this by applying an intelligent algorithm that observes your node's routing history and adjusts fees incrementally. The goal is twofold: **stabilize traffic** to prevent the feast-or-famine pattern that many routing nodes experience, and **prevent underpricing of liquidity** so that your outbound capacity is not drained without fair compensation. - -### How the Algorithm Works - -The Autofees engine does not apply random or uniform adjustments. It operates on a comparative analysis of historical performance, and it works on a **per-peer basis**, not as a blanket policy across your entire node. - -Here is the core mechanism: - -1. **Establish a baseline.** The algorithm examines the forwarding traffic of your **top five earning peers over the past 60 days**. This establishes a reference throughput: how much volume, under what conditions, generated the best returns. - -2. **Compare recent activity.** The algorithm then looks at forwarding traffic from the **past few days** and compares it against this 60-day baseline. - -3. **Adjust accordingly.** - - If recent traffic **exceeds** the baseline, the algorithm interprets this as a demand surge and may incrementally **increase fees** to capture more revenue. - - If recent traffic **falls below** the baseline, the algorithm interprets this as a demand slump and may **decrease fees** to attract more routing volume. - -4. **Liquidity protection.** When a channel reaches approximately **7/8ths depletion** (only 1/8 of its capacity remaining on one side), fees increase mildly to signal scarcity and discourage further draining. - -Updates occur in **small increments every three days**. This conservative pacing minimizes network gossip overhead (since fee policy changes must be broadcast to the network) and prevents the algorithm from overreacting to short-term fluctuations. - -In other words, Autofees behaves like a patient, data-driven operator who checks each channel's performance every few days and makes small, targeted adjustments based on what the numbers say. - -### Privacy Architecture - -A natural concern when enabling any automated tool is: what data does it access, and who can see it? Autofees is designed with the **principle of least privilege** in mind. - -When you enable Autofees, Terminal establishes a dedicated **Lightning Node Connect (LNC)** session with strictly limited permissions: - -| Access Type | Scope | -|------------|-------| -| **Read** | Forwarding history, channel balances, current fee policies | -| **Write** | Fee policy updates only (cannot spend funds, close channels, or alter other node settings) | - -This means the Autofees session cannot move your money, cannot close your channels, and cannot modify anything beyond fee rates. The session is visible in `litd` and can be revoked at any time. - -To further protect your privacy, `litd` employs a **Privacy Mapper** that obfuscates sensitive data before it leaves your node. Specifically: - -- **Channel IDs** are mapped to random values -- **Channel points** are obfuscated -- **Node public keys** are obfuscated -- **Amounts in forwarding data** are randomly altered to break amount correlation -- **Timestamps in forwarding data** are randomly altered to break time correlation - -The Privacy Mapper ensures that the external algorithm can optimize fee calculations without knowing your node's specific identity or topology. You can inspect these mappings at any time using the command line: - -```bash -litcli privacy -``` - -This command lets you manually convert between real and privacy-mapped values for debugging purposes. - -### Configuration Prerequisites +### Automating Channel Fees with Lightning Terminal -Before enabling Autofees, you need to verify two configuration items. +Managing a Lightning Network node involves a constant trade-off between liquidity and revenue. If fees are too high, traffic stops; if fees are too low, the node operator underprices their liquidity and drains their outbound capacity without sufficient compensation. Lightning Terminal’s **Auto-Fees** feature addresses this by automating fee adjustments. -**Required: Enable RPC Middleware** +Instead of requiring the operator to manually tune channel policies daily, Auto-Fees employs an intelligent algorithm designed to stabilize routing traffic. The system dynamically adapts to changing market conditions, aiming to maximize fee revenue while maintaining a healthy flow of payments. This automation allows operators to move away from micromanagement and focus on high-level strategy, preventing the common issue of underpricing liquidity during periods of high demand. -Open your LND configuration file: +### Algorithmic Logic and Traffic Analysis -```bash -nano ~/.lnd/lnd.conf -``` - -Ensure this line is present: - -```ini -rpcmiddleware.enable=true -``` - -Without this setting, Autofees cannot intercept and modify fee policies. If you followed the installation in Chapter 1.1, you already have this configured. - -**Recommended: Set a High Initial Fee Rate** - -Lightning Labs recommends setting a relatively high default fee rate before enabling Autofees: - -```ini -bitcoin.feerate=2500 -``` - -The reasoning is strategic: the algorithm can safely **lower** fees from a high starting point to find the optimal rate. If you start with a low fee rate, the algorithm has limited upward room and your channels may be drained before fees adjust sufficiently. Starting high is the conservative approach; the algorithm will find the right level by adjusting downward. - -**Important side effect:** Enabling Autofees automatically sets the channel **CLTV delta to 100 blocks**. The CLTV delta (CheckLockTimeVerify) is the number of blocks your node requires for HTLC timeout. A value of 100 is reasonable for most routing nodes, but you should be aware of this automatic change. - -### Enabling Autofees - -With the prerequisites in place, enabling Autofees takes just a few clicks in the Terminal interface: - -1. Navigate to the **Loop** tab in Terminal -2. Click **Autopilot** -3. Click **Enable** -4. Review the per-channel toggles and adjust as needed -5. Click **Save** - -That is it. The algorithm begins working immediately, establishing its baseline from your historical forwarding data. - -### Per-Peer Granularity +The Auto-Fees engine does not apply random adjustments; it operates on a comparative analysis of historical performance. When enabled, the system establishes a performance baseline by analyzing the forwarding traffic of the node’s **top five earning peers** over a roughly 60-day period. -One of the most practical aspects of Autofees is that you can **enable or disable it on a per-channel basis**. After enabling the feature globally, scroll down to see the list of your channels with individual toggles. +Once this baseline is established, the algorithm monitors forwarding activity from the immediate past (the last few days) and compares it against the historical trend. +* **Demand Surges:** If recent traffic exceeds the baseline, the algorithm may incrementally increase fees to capture more revenue from the high demand. +* **Demand Slumps:** If traffic drops below the baseline, the algorithm may lower fees to attract routing volume and re-establish flow. -This allows a hybrid management approach: +Crucially, this logic is applied on a **per-peer basis**. The system does not enforce a blanket policy across the entire node but rather tailors adjustments to the specific routing dynamics of each channel relationship. Despite this automation, the operator retains ultimate sovereignty; manual overrides are always possible, allowing the user to lock specific fees for strategic peers regardless of the algorithm’s suggestions. -- **Automated channels**: Enable Autofees for channels where you are unsure of the optimal fee rate or where manual management is too time-consuming -- **Manual channels**: Keep Autofees disabled for strategic peers where you have a specific fee policy in mind (for example, a channel to Loop's node where you want a fixed rate) +### Privacy Architecture and Security -Even with Autofees enabled, you retain the ability to **manually override any fee rate at any time**. The algorithm will respect your manual changes and factor them into subsequent adjustments. +A primary concern for node operators using automated tools is the security of their node credentials and the privacy of their routing data. Auto-Fees is architected to operate with the principle of least privilege using **Lightning Node Connect (LNC)**. -### Operational Best Practices +When Auto-Fees is activated, Terminal establishes a dedicated, isolated LNC session. This session is restricted by strict permissions: +* **Read Access:** Limited to forwarding history, channel balances, and current fee policies. +* **Write Access:** Strictly limited to updating fee policies. It cannot spend funds, close channels, or alter other node settings. -A few guidelines to get the most out of Autofees: +To further protect operator data, LitD employs a **Privacy Mapper**. Before any data leaves the local node environment to be processed by the Auto-Fees logic, the Privacy Mapper obfuscates sensitive identifiers such as Channel IDs, Channel Points, and Node Public Keys. This ensures that the external logic can optimize the math without exposing the node’s specific identity or topology map to the central server. Operators can verify this obfuscation via the LitD command-line interface and revoke the session at any time. -- **Do not restart Autofees unnecessarily.** Restarting the feature causes the algorithm to re-establish its baseline, which can lead to false double-counting of forwarding data across overlapping periods. -- **Be patient.** The algorithm updates every three days. Give it at least two to three weeks to establish meaningful patterns before evaluating its performance. -- **Algorithm improvements are deployed server-side.** You do not need to upgrade `litd` to receive the latest version of the Autofees algorithm. Improvements are delivered through Terminal automatically. -- **Monitor the results.** Use the Insights and Forwards data we explored in the previous chapter to evaluate whether Autofees is improving your fee revenue and liquidity balance over time. +### Configuration and Activation -### Summary +Implementing Auto-Fees requires specific node configurations to function correctly. The most critical prerequisite is enabling the RPC middleware in the `lnd.conf` file. Without setting `rpcmiddleware.enable=true`, the Terminal cannot intercept and modify the fee policies. -In this chapter, we explored Autofees, Terminal's automated fee management feature. We learned that the algorithm establishes a 60-day baseline from your top-earning peers, compares recent traffic against that baseline, and makes small per-peer adjustments every three days. We examined the privacy architecture, including the dedicated LNC session with restricted permissions and the Privacy Mapper that obfuscates your node's identity. We configured the prerequisites (`rpcmiddleware.enable=true` and a high initial fee rate) and walked through the activation process in the Terminal UI. +**Recommended Baseline:** +Lightning Labs recommends setting a default `base_fee_msat` of approximately **2,500 millisatoshis** in the configuration. This specific value provides the algorithm with necessary "headroom"—a middle ground that allows the system flexibility to adjust fees both upward and downward as needed without hitting floor or ceiling constraints immediately. -With Autofees running, your node can adapt to changing market conditions without constant manual intervention, freeing you to focus on higher-level strategy: choosing peers, managing liquidity through Loop, and expanding your routing capacity through Pool. These are exactly the topics we will cover in the chapters ahead. +**Enabling the Feature:** +Once the configuration is set, activation is handled via the Terminal UI: +1. Navigate to the **Loop** tab. +2. Select **Autopilot**. +3. Click **Enable**. -# Managing Your Node's Network -b6bc2556-170a-4992-8046-a8756d91a6b6 +The interface provides granular control, allowing operators to toggle Auto-Fees on or off for individual channels. This allows for a hybrid management style, where stable, high-volume channels are managed automatically, while experimental or strategic private channels remain under manual control. ## Multi-Node Connections 9f6f9bf3-999e-4dad-9d2d-0b725178d754 ![video](https://www.youtube.com/watch?v=SGY9h8JW4go) -As your Lightning infrastructure grows, a natural question arises: how do we manage multiple nodes without juggling separate browser sessions, bookmarks, and login credentials for each one? Whether you are running a mainnet routing node alongside a testnet playground, maintaining redundant backups, or overseeing nodes for different organizations, the overhead of context-switching between isolated dashboards quickly becomes a bottleneck. +### Unified Infrastructure Management -Lightning Terminal solves this with its **multi-node connection system**. In this chapter, we will explore how to generate connection strings for multiple nodes, onboard them into a single Terminal workspace, and switch between them instantly. The process is remarkably straightforward, but the security implications deserve careful attention. +Lightning Terminal has evolved from a single-node utility into a comprehensive infrastructure management platform. The **Multi-Node Interface** enables operators to oversee distinct Lightning Network nodes—whether they are redundant backups, separate routing nodes, or nodes operating on different networks (e.g., Mainnet vs. Testnet)—from a single, unified dashboard. -### Generating a Connection String - -The foundation of every Terminal connection is the **connection string**, a cryptographic pairing phrase generated by Lightning Node Connect (LNC). Because LNC works through outgoing connections to a web proxy, you do not need to open any ports on your firewall or modify your Tor configuration. The node reaches out to the proxy; the proxy never reaches in. - -You can generate connection strings through the LitD web interface, but the command line gives us more explicit control over the session parameters. Let's examine the `litcli` command that creates a new administrative session: - -```bash -litcli --network=testnet sessions add --label="Routing-Node-East" --type=admin -``` - -Let's break down each parameter: - -- `--network=testnet` specifies the network this node operates on (use `mainnet` for production nodes). -- `sessions add` tells `litcli` to create a new LNC session. -- `--label="Routing-Node-East"` assigns a human-readable name that will appear in the Terminal dropdown, helping you distinguish nodes at a glance. -- `--type=admin` grants full administrative privileges over the node. For read-only monitoring, you could use `--type=readonly` instead. - -When you execute this command, `litcli` outputs a connection string. In other words, this string is the cryptographic key that authorizes Terminal to communicate with your node. It looks something like a long encoded phrase, and it is the only thing standing between an attacker and full administrative access to your channels and funds. - -**This point is critical**: treat every connection string with the same care you would give a private key. Never paste it into a public chat, never transmit it over an unencrypted channel, and never store it in plaintext alongside other credentials. Once you have used it to pair with Terminal, the string is consumed and cannot be reused, but until that moment, anyone who possesses it can connect. - -### Connecting Your First Node - -With the connection string in hand, we navigate to the Terminal web interface and click the **Connect My Node** button. After pasting the string, Terminal prompts us to create a **session password**. This is a critical secondary security layer: even if someone gains access to the browser or device running Terminal, they cannot interact with your node without entering this password. - -In other words, the connection string authenticates the node-to-proxy link, while the session password protects the local browser session. Together, they form a two-factor model that keeps your node secure. - -Once the password is confirmed, Terminal establishes the encrypted connection. You will see your node's dashboard populate with its channels, balances, health checks, and routing data. At this point, the first node is fully onboarded. - -### Adding Additional Nodes - -To add a second (or third, or tenth) node, we follow the exact same procedure on the other machine. Let's say we have a second testnet node. We SSH into it and generate another connection string: - -```bash -litcli --network=testnet sessions add --label="L402-Fun-Node" --type=admin -``` +This architecture eliminates the friction of logging in and out of different browser sessions or managing multiple disparate URLs. The integration is designed to be lightweight yet robust; adding a new node does not dilute the functionality available. Whether an operator manages two nodes or a dozen, the full suite of Terminal tools—Loop for liquidity, Pool for leasing, and health monitoring—remains fully accessible for every specific instance connected to the workspace. -Back in the Terminal interface, we click **Add Node** in the header area, paste the new connection string, and set a password for this session. Terminal treats each connection independently, maintaining separate authentication tokens and session states. +### Generating Connection Credentials -After confirmation, both nodes are now available in your workspace. +The foundation of the multi-node setup is the **Connection String**. Because Terminal operates securely over Lightning Node Connect (LNC), it does not require opening ports on your firewall. Instead, each node must generate a unique, cryptographic pairing phrase that authorizes the Terminal interface to communicate with the Lightning Terminal Daemon (LitD). -### Context Switching Between Nodes +Operators can generate these strings via the LitD UI, but the Command Line Interface (CLI) offers granular control for power users. Using the `litcli` tool, an operator creates a session by defining specific parameters: +* **Network:** Specifies if the node is on `mainnet` or `testnet`. +* **Label:** Assigns a human-readable alias (e.g., "Routing-Node-East") to distinguish the node in the UI. +* **Type:** Defines the permission scope, typically set to "admin" for full management capabilities. -Once multiple nodes are onboarded, the **node selector dropdown** in the Terminal header becomes your primary navigation tool. Clicking it reveals a list of all connected nodes, identified by the labels you assigned during session creation. +#### Security Implications +The generated connection string contains the authentication data necessary to administer the node. It functions effectively as a private key for administrative access. Consequently, these strings must be handled with extreme care—never shared in public forums or transmitted over unencrypted channels. Possession of the string grants the holder the ability to manipulate the node's channels and funds through the Terminal interface. -When you select a different node, the entire dashboard context refreshes instantly: +### The Connection Workflow and Context Switching -- **Metrics update**: ROI, net profit, earned sats, and spent sats reflect the selected node's data. -- **Channel list refreshes**: you see only the peers and channels associated with the active node. -- **Tool state changes**: the Loop, Pool, and Autopilot interfaces update to show swaps, auctions, and fee configurations relevant to the currently selected node. +Connecting the first node establishes the baseline workspace. The operator selects "Connect My Node" and pastes the generated connection string. Crucially, Terminal enforces a secondary security layer: **The Session Password**. Upon pasting the string, the user must define a local password. This ensures that even if the physical device running the browser is compromised, the active Terminal session cannot be used to interact with the node without this second factor of authentication. -This efficient switching mechanism allows operators to maintain situational awareness across their entire fleet. If you notice a liquidity imbalance on one node, you can address it immediately, then switch to another node to check on a pending channel opening, all without leaving the Terminal workspace. +Adding subsequent nodes follows an identical pattern via the "Add Node" option in the interface's header. Terminal treats each connection independently, maintaining separate authentication tokens and session states for each node. -### Summary - -In this chapter, we saw how to generate LNC connection strings via `litcli`, onboard multiple nodes into a single Terminal session, and switch between them using the node selector dropdown. The key takeaway is that **multi-node management requires no additional infrastructure**: the same LNC protocol that secures a single connection scales seamlessly to many. In the next chapter, we will put these connected nodes to work by opening channels efficiently using batch transactions. +**Operational Context Switching:** +Once multiple nodes are onboarded, the **Node Selector** dropdown becomes the primary navigation tool. Switching between nodes is instantaneous. When a new node is selected, the entire dashboard context shifts. +* **Metrics Update:** ROI, net profit, and routing history immediately reflect the selected node's data. +* **Channel Management:** The channel list refreshes to show peers associated only with the active node. +* **Tool State:** Loop and Pool interfaces update to show swaps and auctions relevant to the currently selected entity. +This efficient switching mechanism allows operators to maintain high-level situational awareness across their entire fleet, rapidly responding to liquidity imbalances or alerts on any specific node without leaving the command center. ## Opening Channels & Batching c7e83bd9-df1c-4763-8401-488b733d835c ![video](https://www.youtube.com/watch?v=VmvwM-zv2i0) -Now that we can manage our nodes from a single interface, let's examine one of the most important operations any node operator performs: opening payment channels. More specifically, we will learn how to open multiple channels simultaneously using a single on-chain transaction, a feature called **batch opens**. - -To understand why this matters, we first need to appreciate the cost structure of channel creation. - -### Why Batching Matters - -Every Lightning payment channel is anchored by an on-chain Bitcoin transaction. This transaction creates a **2-of-2 multisignature output** that locks funds cooperatively between you and your peer. Traditionally, if you wanted to open five channels, you would broadcast five separate transactions to the Bitcoin network, each one consuming its own inputs, paying its own mining fees, and occupying its own block space. - -This approach is wasteful for two reasons. First, each transaction carries overhead bytes for its inputs, signatures, and metadata, so you pay miner fees five times for work that could largely be consolidated. Second, if you are spending from a single large UTXO, each individual transaction produces a change output, fragmenting your wallet into progressively smaller pieces. Over time, this **UTXO fragmentation** leads to higher fees on future transactions because spending many small UTXOs requires more input data than spending one large one. - -**Batch opens solve both problems at once.** By aggregating multiple channel openings into a single transaction, you consume one set of inputs, pay one mining fee (amortized across all channels), and produce a clean set of outputs: one per channel, plus a single change output returning the remainder to your wallet. - -In other words, if opening five channels individually might cost you 5,000 satoshis in total fees, batching them together might cost only 1,500 satoshis for the same result. The savings scale with the number of channels and the prevailing fee environment. - -### Preparing for a Batch Open +### The Economics of Batch Opens -Before you begin, you need two things: +In the Lightning Network, every payment channel is anchored by an on-chain Bitcoin transaction. Traditionally, establishing a robust node with multiple peers required a separate transaction for each channel. This approach is inefficient, consuming significant block space and incurring separate mining fees for every single connection. -1. **Sufficient on-chain funds** in your LND wallet to cover the total capacity of all channels plus the mining fee. -2. **The public keys** of the peers you want to connect with. You can find these through the Terminal Explorer tab, through Lightning network explorers like [1ML](https://1ml.com/) or [Amboss](https://amboss.space/), or by asking the node operator directly. +Lightning Terminal solves this with **Batch Opens**. This feature allows node operators to aggregate multiple channel openings into a single on-chain transaction. -A public key (also called a **node identity key**) is a 66-character hexadecimal string that uniquely identifies a node on the Lightning Network. It looks something like this: +The technical advantage is substantial. Instead of broadcasting five separate transactions to open five channels (paying overhead bytes for inputs and signatures five times), a batch open consumes a single UTXO (or set of UTXOs) and creates multiple outputs—one for each channel—within the same transaction envelope. This consolidation drastically reduces the cost per channel, making it a critical strategy for liquidity management during periods of high on-chain fee pressure. It also optimizes the node's UTXO set, preventing the fragmentation of wallet funds into "dust" outputs. -``` -02e7a7d3c1e6055b7b7457d95e04d9bbd24f200fd4a58daca7beee7bc776e17440 -``` - -### Walking Through the Batch Workflow - -Let's open two channels simultaneously using the Terminal interface. Here is the step-by-step process: +### Configuring the Batch Workflow -**Step 1: Initiate the first channel.** -Click the **Open Channel** button on the Terminal homepage. Paste the public key of your first target peer into the search field. Terminal validates that this node exists on the network and is reachable. - -**Step 2: Set the channel capacity.** -Define how many satoshis you want to commit to this channel. For example, we might allocate 1,000,000 satoshis (0.01 BTC): - -``` -Channel capacity: 1,000,000 sats -``` +The process begins in the Terminal dashboard via the **Open Channel** interface. To initiate a batch, the operator requires the public identity keys of the target peers. -This amount becomes the total capacity of the channel, initially sitting entirely on your side as outbound liquidity. +The workflow is iterative: +1. **Peer Identification:** Enter the Public Key of the first peer. Terminal validates the node's existence on the network. +2. **Capacity Allocation:** Define the channel size in satoshis. This determines the liquidity locked into that specific connection. +3. **Parameter Setup:** Configure initial routing fees (Base Fee and Fee Rate) and visibility settings (Public vs. Private). -**Step 3: Configure fees and visibility.** -Terminal presents two important configuration options: +#### Channel Visibility and Fees +A critical decision point during configuration is the channel's visibility. **Public Channels** are broadcast to the network graph, enabling random nodes to route payments through them, generating fee revenue. **Private Channels** remain unannounced, visible only to the two direct peers. These are ideal for mobile wallets or merchant terminals that do not intend to route third-party traffic. Similarly, initial fee settings dictate the channel's competitiveness; while defaults are provided, experienced operators tune these metrics based on the specific peer's reliability and location in the network topology. -- **Fee settings**: the base fee and fee rate that your node will charge for routing payments through this channel. You can accept the defaults or tune them based on your routing strategy. -- **Channel visibility**: choose between a public or a private channel. +### Execution and On-Chain Verification -**Public channels are broadcast** to the network graph, meaning any node can discover them and attempt to route payments through them. This is the standard choice for routing nodes that want to earn forwarding fees. +The true utility of the batch feature is the **"Add Channel"** function. Rather than finalizing the transaction after configuring one peer, the operator stacks additional peers into the same session. As new channels are added, the marginal cost of each addition is negligible compared to the base cost of the transaction. -**Private channels remain unannounced.** Only you and your direct peer know the channel exists. This is appropriate for mobile wallets, merchant terminals, or any situation where you want to send and receive without advertising your channel to the wider network. +Once the batch is fully assembled, the operator sets the **Mining Fee**. This fee pays the Bitcoin miners to confirm the aggregate transaction. Because this single fee is amortized across all new channels, the effective cost per channel drops significantly. -**Step 4: Add another channel to the batch.** -Here is where the magic happens. Instead of clicking "Submit," click **Add Channel**. This stacks a second channel into the same pending transaction. Paste the public key of your second peer, configure the capacity, fees, and visibility just as before. +**Verification:** +After the transaction is broadcast, the channels enter a "pending" state until confirmed. Verification can be performed via any block explorer. A properly executed batch transaction will display a distinct structure: +* **Inputs:** One or more UTXOs from the node's wallet. +* **Outputs:** Multiple outputs of equal or varying values (representing the funded channels). +* **Change Output:** A single output returning any remaining funds to the node's internal wallet. -You can repeat this step as many times as you need. Each additional channel adds minimal marginal cost to the transaction. - -**Step 5: Set the mining fee and broadcast.** -Once all channels are queued, Terminal presents a final screen where you select the **mining fee rate** for the entire batch transaction. A higher fee rate means faster confirmation; a lower fee rate saves money but may take longer to confirm. Choose based on your urgency. - -Click the **Batch Open Channels** button to broadcast the transaction. - -### Verifying on a Block Explorer - -After broadcasting, the channels enter a **pending confirmation** state while the transaction awaits confirmation. You can verify the batch structure by looking up the transaction on any block explorer. A properly executed batch transaction will show: - -- **Transaction inputs**: one or more UTXOs from your LND wallet. -- **Channel outputs**: multiple outputs of varying sizes (one per channel, each matching the capacity you specified). -- **Change output returned**: a single output returning the remaining funds to your wallet. - -For example, if you opened two channels of 1,000,000 sats each from a 5,000,000 sat UTXO, the transaction would show: - -``` -Input: 5,000,000 sats (your UTXO) -Output: 1,000,000 sats (Channel 1 - 2-of-2 multisig) -Output: 1,000,000 sats (Channel 2 - 2-of-2 multisig) -Output: 2,999,500 sats (change back to your wallet, minus fees) -``` - -This confirms that both channels were funded from a single transaction, exactly as intended. - -### Summary - -In this chapter, we learned that batch opens aggregate multiple channel openings into a single on-chain transaction, reducing fees and preventing UTXO fragmentation. We walked through the Terminal workflow for configuring each channel's capacity, fees, and visibility, then stacking them into one batch. In the next chapter, we will explore what happens after channels are open: how to manage their liquidity over time using Lightning Loop. +This on-chain footprint confirms that the batch logic was executed correctly, locking funds into the 2-of-2 multisignature addresses required for the Lightning channels while maximizing capital efficiency. ## Lightning Loop f2642efb-a485-4bc9-b571-d8e901e3e8b1 ![video](https://www.youtube.com/watch?v=kYlfHqQnpVM) -Now that we know how to open channels efficiently, we face the ongoing challenge that defines Lightning node operation: **liquidity management**. A channel does not stay balanced on its own. Every payment that flows through it shifts the balance, and over time, channels inevitably become lopsided. When all the funds sit on your side, you can send but cannot receive. When all the funds sit on your peer's side, you can receive but cannot send. Either way, the channel's utility drops significantly. - -The traditional solution was to close the unbalanced channel and open a new one, which is expensive and slow. **Lightning Loop** provides a far better alternative: it lets you rebalance channels without closing them, using a cryptographic technique called **submarine swaps**. - -In this chapter, we will explore Loop Out, Loop In, and the powerful Auto Loop automation system. - -### Understanding Submarine Swaps +### Liquidity Management with Loop Out -Before we dive into the interface, let's take a moment to understand the mechanism that makes Loop possible. A **submarine swap** is an atomic exchange between on-chain Bitcoin and off-chain Lightning Bitcoin. "Atomic" means that either both sides of the swap complete, or neither does. There is no scenario where one party takes the money and disappears. +Terminal’s Loop feature is a specialized tool for managing Lightning Network liquidity, specifically designed to rebalance channels without the costly and time-consuming process of closing and reopening them. A healthy routing node requires balanced channels to facilitate traffic in both directions. When a channel becomes "lopsided"—holding all funds on one side—its utility drops significantly. -The swap uses Hash Time-Locked Contracts (HTLCs) on both layers: +**Loop Out** is the primary mechanism for acquiring **inbound liquidity**. This is necessary when a channel’s local balance is full, meaning the node can send payments but cannot receive them. -1. One party creates a secret value (called the **preimage, or secret**) and shares only its hash. -2. An on-chain HTLC locks funds that can be claimed by revealing the preimage, or refunded after a timeout. -3. A Lightning HTLC locks funds on the other side, gated by the same hash. -4. When one party reveals the preimage to claim one side, the other party can use that same preimage to claim the other side. +By executing a Loop Out, the operator sends funds via Lightning to the Loop server, which then returns an equivalent amount of Bitcoin to the operator's on-chain wallet. This effectively "empties" the local side of the channel, creating space to receive new payments. Terminal simplifies this with a visual slider interface; operators drag the slider to the desired target balance (e.g., 50%), and the system calculates the required swap amount. -In other words, the swap is cryptographically bound so that both legs must settle together. This is what makes Loop **non-custodial and trustless**: the Loop server never takes custody of your funds. +**Cost Considerations:** +Operators must account for three distinct fee components: +1. **Service Fee:** Paid to the Loop provider. +2. **Routing Fees:** Paid to the network to route the payment to the Loop server. +3. **Miner Fees:** Paid to confirm the on-chain settlement transaction. -### Loop Out: Creating Inbound Liquidity +### Refilling Capacity with Loop In -**Loop Out** is the operation you use when a channel is full on your side (high local balance, low remote balance). You can send payments through this channel, but you cannot receive them. To fix this, Loop Out moves funds from your Lightning channel to an on-chain address, freeing up space on the remote side. +**Loop In** serves the inverse function. It is utilized when a channel has been depleted of local funds (high remote balance), leaving the node unable to route outgoing payments. To fix this, the operator pushes on-chain Bitcoin into the channel, converting it into off-chain Lightning liquidity. -Here is what happens step by step: +**Prerequisites and Timing:** +Unlike Loop Out, a Loop In operation requires the operator to hold sufficient *on-chain* Bitcoin reserves. The Terminal interface validates wallet balances in real-time before authorizing the swap. -1. You initiate a Loop Out for a specified amount. -2. The Loop server creates an on-chain HTLC locked to a hash. -3. Your node routes a Lightning payment (locked to the same hash) to the Loop server through the target channel. -4. The Loop server reveals the preimage to claim the Lightning payment. -5. You use that preimage to sweep the on-chain HTLC to your Bitcoin address. +A critical variable in Loop In operations is the **Confirmation Target**. Since the operation relies on an initial on-chain transaction, the operator can choose between speed and cost. +* **Low Confirmation Target:** Higher miner fees, faster liquidity availability. +* **High Confirmation Target:** Lower miner fees, slower settlement. -The net result: your Lightning channel now has more room on the remote side (inbound liquidity), and you received the equivalent amount on-chain. +This flexibility allows operators to prioritize urgent liquidity needs or optimize for cost savings during periods of low network congestion. -**Using Loop Out in Terminal:** +### Automated Liquidity via Auto Loop -In the Terminal interface, navigate to the **Loop tab** in the header. You will see a list of your channels, and you can filter by those with **low inbound** balance. Select the channel you want to rebalance, then drag the slider to your desired target balance (for example, 50% for a roughly balanced channel). +While manual loops are useful for spot-adjustments, high-volume nodes require constant maintenance. **Auto Loop** transforms this manual process into a set-and-forget background service. It utilizes the "Autopilot" engine to monitor channel balances and execute swaps automatically when specific thresholds are breached. -Click the **Next button**, and Terminal presents the fee breakdown: +Auto Loop operates at three hierarchical levels: +* **Node Level:** Balances the aggregate liquidity of the entire node. +* **Peer Level:** Manages the total balance across all channels shared with a specific peer. +* **Channel Level:** Micro-manages the liquidity of a single, high-priority channel. -- **Loop service fee**: paid to the Loop server for facilitating the swap. -- **On-chain fees**: paid to miners for confirming the settlement transaction. -- **Lightning routing fees**: paid to intermediate nodes for routing the payment to the Loop server. +#### The Budget System +To prevent runaway costs, Auto Loop is governed by a strict **Budget System**. Operators define a `Total Budget` that caps the amount of fees the system can spend within a specific cycle (e.g., Daily, Weekly, or Monthly). -You also have access to **advanced options**, including the ability to specify a custom on-chain address where you want the funds delivered (instead of your LND wallet's default address). +Additionally, specific constraints ensure efficiency: +* **Minimum Loop Size:** Prevents the system from executing "dust" loops that are eaten up by fees. +* **Maximum Fee:** Establishes a hard ceiling on the cost of any individual swap. -If the fees look acceptable, click the **Submit button** to execute the swap. - -**Via CLI:** - -For operators who prefer the command line, you can also execute Loop Out directly: - -```bash -loop out --channel 735057608151793668 --conf_target 250 \ - --label "rebalance-east-node" --max_swap_routing_fee 2500 \ - --addr bc1qvnfuf2zvg6mrfyjhc8h4c7ge9a7ywfrav52qru \ - --amt 1000000 -``` - -Key parameters: - -| Flag | Purpose | -|------|---------| -| `--channel` | Force the swap through a specific channel (by short channel ID) | -| `--conf_target` | Desired confirmation speed in blocks (higher = lower fee) | -| `--label` | Human-readable tag for identifying the swap later | -| `--max_swap_routing_fee` | Cap on Lightning routing fees in satoshis | -| `--addr` | Custom destination for the on-chain funds | -| `--amt` | The swap amount in satoshis | - -You can check current minimum/maximum amounts and fee estimates before committing: - -```bash -loop terms -loop quote out 1000000 -``` - -### Loop In: Restoring Outbound Liquidity - -**Loop In** serves the inverse function. Use it when a channel has been depleted on your side (low local balance, high remote balance), leaving you unable to send or route outgoing payments. - -In a Loop In, you send on-chain Bitcoin to the Loop server, and it sends you the equivalent amount over Lightning, pushing funds back to your side of the channel. - -**Before you begin**: unlike Loop Out, a Loop In requires that you hold sufficient **on-chain Bitcoin reserves**. If your LND wallet does not have enough funds, Terminal will alert you before proceeding. You may need to reduce the swap amount or deposit more on-chain Bitcoin first. - -**Using Loop In in Terminal:** - -Filter your channels by **low outbound** balance, select the target channel, and drag the slider to your desired balance. Click the **Next button** and choose the **One-time manual** loop option. - -An important setting here is the **confirmation target**. Since Loop In begins with an on-chain transaction, you can trade speed for cost: - -- A **low confirmation target** (e.g., 3 blocks) means higher miner fees but faster liquidity availability. -- A **high confirmation target** (e.g., 100 blocks) means lower miner fees but a longer wait before the swap completes. - -Choose based on how urgently you need the outbound capacity. - -**Via CLI:** - -```bash -loop in --last_hop 02e7a7d3c1e6055b7b7457d95e04d9bbd24f200fd4a58daca7beee7bc776e17440 \ - --amt 500000 -``` - -The `--last_hop` flag is particularly useful: it specifies which peer should deliver the final Lightning payment, giving you precise control over which channel receives the new outbound capacity. - -### Auto Loop: Automated Liquidity Management - -Manual loops are effective for spot adjustments, but high-volume routing nodes need continuous rebalancing. Executing loops by hand every time a channel drifts out of balance is neither scalable nor practical. This is where **Auto Loop** transforms liquidity management into a background service. - -Auto Loop monitors your channel balances and **automatically dispatches swaps** when they breach configured thresholds. It operates at three hierarchical levels: - -1. **Node level**: balances the aggregate liquidity across your entire node. -2. **Peer level**: manages the total balance across all channels shared with a specific peer (useful when you have multiple channels with the same counterparty). -3. **Channel level**: micro-manages the liquidity of a single, high-priority channel. - -**Enabling Auto Loop in Terminal:** - -In the Loop tab, select a channel and click the **Next button**. Instead of choosing "One-time manual," select the **Auto Loop** option. Terminal then presents the budget configuration: - -**The budget system** is the safety mechanism that prevents Auto Loop from spending unlimited fees on your behalf. You configure: - -- **Minimum loop size**: the threshold below which Auto Loop will not execute a swap (prevents tiny, fee-inefficient "dust" loops). -- **Maximum fee per swap**: a hard ceiling on what any individual swap can cost. -- **Total budget amount**: the maximum satoshis Auto Loop can spend on fees (service fees + on-chain fees + routing fees combined) within a given period. -- **Budget period**: how often the budget refreshes. Options include 1 day, 3 days, 7 days, 14 days, or 28 days. - -For example, you might configure: "I am willing to spend up to 50,000 satoshis in total fees every 7 days to keep this channel balanced." - -**Via CLI, the equivalent configuration looks like this:** - -```bash -# Enable Autoloop -loop setparams --autoloop=true - -# Set a liquidity rule for a specific channel -loop setrule 735057608151793668 --incoming_threshold=25 --outgoing_threshold=25 - -# Configure the budget: 100,000 sats refreshing every 7 days -loop setparams --autobudget=100000 --autobudgetrefreshperiod=604800s - -# Set fee limits -loop setparams --sweepconf=250 --maxswapfee=1 --maxroutingfee=1 -``` - -The `--incoming_threshold` and `--outgoing_threshold` parameters define the minimum percentage of channel capacity that must remain as inbound and outbound liquidity, respectively. When either side falls below its threshold, Auto Loop triggers a swap to restore the balance. - -**Monitoring Auto Loop:** - -Once active, the Autopilot dashboard (accessible via the **Autopilot toggle** button at the top of the Loop tab) shows you: - -- Whether Auto Loop is currently active or paused. -- How many loops have been performed recently. -- The current budget consumption. -- A history of all automated swaps. - -You can **pause Auto Loop at any time** without losing your configuration. You can also adjust the budget, fee limits, or thresholds on the fly. Just remember to click the **Save button** after making changes. - -A useful CLI command for debugging is `loop suggestswaps`, which shows what Auto Loop *would* dispatch without actually executing anything: - -```bash -loop suggestswaps -``` - -This is essentially a dry run that lets you verify your rules and budgets are configured correctly before enabling automation. - -**Please note**: Autoloop parameters are **not persisted across restarts** of the `loopd` daemon. If you restart your node, you will need to reconfigure your Autoloop settings. - -### Summary - -In this chapter, we explored the three modes of Lightning Loop: manual Loop Out (to create inbound liquidity), manual Loop In (to restore outbound liquidity), and Auto Loop (to automate the entire process). The underlying mechanism, submarine swaps, ensures that all operations are trustless and non-custodial. The budget system gives you precise control over costs, and the three-tier hierarchy (node, peer, channel) lets you tailor your liquidity strategy to your specific needs. In the next chapter, we will look at how to evaluate the peers you are connected to using Terminal's Peer Insights feature. +The Autopilot dashboard provides a live view of these operations, allowing operators to pause the service during volatile market conditions or adjust budgets as their node's revenue grows. ## Peer Insights 27d09714-6496-4451-bb08-1927e0148d1e ![video](https://www.youtube.com/watch?v=4x1V_G_DlKo) -Up to this point, we have learned how to connect nodes, open channels efficiently, and manage liquidity. But there is a question we have not yet addressed: how do we evaluate whether a particular peer is worth connecting to, and how do we measure the value of our existing relationships? Making good peering decisions is one of the most consequential aspects of running a routing node, because **the quality of your peers directly determines the quality of your routing**. - -Lightning Terminal's **Peer Insights** feature, available in the Explorer tab, provides the intelligence layer we need to make these decisions. It operates on two tiers: general reconnaissance data available for any public node on the network, and detailed performance analytics available only for nodes with whom you already share a channel. - -### The Explorer Tab - -When you navigate to the **Explorer tab** with a node connected to Terminal, you see a ranked list of top-performing nodes on the network. This list goes beyond simple capacity rankings. Terminal augments each entry with contextual badges, small visual indicators that surface useful information at a glance. +### Peer Insights: Network Intelligence -For example, you might see a badge indicating that a node has **open liquidity orders** in the Pool marketplace (we will explore Pool in a later chapter). Another badge might tell you that a particular node is already **your peer**, meaning you have at least one channel open with them. +Lightning Terminal’s **Peer Insights** is a robust intelligence layer integrated directly into the Explorer tab. It is designed to move node operators beyond basic connectivity metrics (like capacity and channel count) toward a deeper understanding of network behavior and peer value. -Each node entry also displays key metrics: +The feature operates on a tiered information architecture. At the base level, it provides general reconnaissance data for any node on the public network, useful for scouting potential partners. At the advanced level, it unlocks detailed performance analytics for nodes with whom you already maintain open channels. This dual capability allows operators to assess the "reputation" and strategic value of a peer before opening a channel, and then monitor the actual ROI of that relationship over time. -- **Total channel capacity**: the total Bitcoin locked in the node's channels. -- **Node age on network**: how long the node has been active on the network. -- **Number of peers**: how many other nodes it is connected to. -- **Centrality score**: a measure of how critical this node is to the overall network topology. A high centrality score means many shortest paths between other nodes pass through this one, making it an important routing hub. -- **Health check status**: whether the node passes Terminal's six health checks. +### Visual Indicators and Network Scouting -These metrics allow you to quickly scan for stable, well-connected candidates before committing capital to a new channel. +The primary interface for Peer Insights is the **Explorer Tab**. This dashboard presents a ranked list of top-performing nodes, but augments this list with contextual "badges" or visual indicators overlaid on the node entries. -### Searching for a Specific Node - -Beyond browsing the ranked list, you can search for any node on the network by pasting its public key into the search field: - -``` -02e7a7d3c1e6055b7b7457d95e04d9bbd24f200fd4a58daca7beee7bc776e17440 -``` +These indicators allow for rapid scanning of the network landscape. For example, specific badges highlight whether a node has open liquidity orders in the Pool marketplace or if it is currently connected to your node. +* **Health Check:** Instantly communicates operational uptime and reliability. +* **Centrality Score:** Indicates how critical that node is to the overall network topology. +* **Capacity & Age:** Establishes the scale and longevity of the node’s operations. -Terminal will pull up a detailed profile for that node, displaying its capacity, age, peer count, centrality, and health check results. This is useful when someone recommends a peer or when you want to evaluate a node before opening a channel with it. +By filtering through these metrics, an operator can quickly identify stable, high-capacity nodes that are actively seeking liquidity, making them ideal candidates for new channel openings. -### The Fee Distribution Graph +### Analyzing Fee Strategies -One of the most powerful analytical tools in Peer Insights is the **fee distribution graph**. This visualization shows you how a node has priced its channels, giving you a window into its routing philosophy. +One of the most sophisticated tools within Peer Insights is the **Fee Distribution Graph**. This visualization decompresses the complex fee policies of a target node across its entire channel portfolio. The graph uses a dual-axis design: +* **Horizontal Axis:** Represents fee rates (parts per million or ppm). +* **Vertical Axis:** Represents the number of channels. +* **Split View:** Inbound fees are plotted above the axis; outbound fees are plotted below. -- **Horizontal axis (x)**: fee rates, from low on the left to high on the right. -- **Vertical axis (y)**: the number of channels. -- **Split view**: the upper portion shows **inbound fee distribution**, and the lower portion shows **outbound fee distribution**. - -Each bar on the graph represents a group of channels clustered at a similar fee rate. By hovering over a bar, you can see exactly how many channels fall within that fee range. - -Let's say you are examining a node with 16 channels. The graph might show: - -- 15 channels with outbound fee rates clustered between 660 and 1,000 ppm (parts per million). -- 1 channel with a significantly lower outbound fee. -- 5 channels with low inbound fees, 6 with moderate inbound fees, 2 with higher inbound fees, and 3 outliers with very high inbound fees. - -What does this tell us? The tight clustering of outbound fees suggests this operator actively manages their fee policy and has settled on a consistent strategy for most channels. The single low-fee outlier might be a strategic channel to a high-volume peer where the operator is willing to accept lower margins for reliable throughput. The spread in inbound fees suggests different peers have set different inbound rates on their end of the channels. - -**Why this matters for you**: if you are about to open a channel with this node, the fee distribution graph helps you set competitive fees. If most of their outbound channels are priced at 800 ppm, and you set yours at 2,000 ppm, routing algorithms will likely prefer cheaper paths and your channel may see little traffic. Conversely, if you set your fees too low, you might attract more traffic than you can sustain, depleting your channel quickly. - -This data is available for **any public node on the network**, not just your peers. It is all derived from the public network graph. +This visual clustering reveals the peer's routing philosophy. For example, if a node has a tight cluster of channels priced at 100ppm but a few outliers at 1000ppm, it suggests a tiered strategy where scarce liquidity is priced at a premium. Conversely, a flat distribution suggests a "set-and-forget" passive management style. Understanding these patterns is crucial when setting your own fees; pricing your channel competitively against a peer's existing connections ensures your node remains an attractive hop for routing. ### Peer-Specific Performance Analytics -For nodes with whom you already share a channel, Peer Insights unlocks an additional layer of data: your actual interaction history. While the fee distribution graph shows public information anyone can see, **performance analytics draw from your node's private forwarding data** to show the real value of the relationship. +For existing partners, Peer Insights unlocks a granular history of the relationship. While general network explorers can only guess at routing volume, Terminal leverages your node's local data to display exact interaction metrics. Key metrics include: +* **Forwarding Events:** The total count of payments routed through this specific peer. +* **Volume Routed:** The cumulative amount of satoshis moved. +* **Fees Earned:** The direct revenue generated by this relationship. -- **Number of channels**: how many channels you share with this peer. -- **Total forwards**: the count of payments that have been routed through your shared channels. -- **Volume routed**: the cumulative amount of satoshis that have flowed through the connection. -- **Fees earned**: the direct revenue this peer relationship has generated for your node. - -For instance, you might discover that a peer with whom you have a single channel has routed 1,400,000 satoshis across just 3 forwarding events, earning you 136.5 satoshis in fees. That is useful context: a small number of forwards, but each one carrying significant volume. - -This data transforms abstract channel management into **evidence-based decision making**. Consider these scenarios: - -- A channel has high capacity but zero forwarding events over the past month. The analytics make this inefficiency obvious, signaling that you should either adjust fees, close the channel, or investigate why traffic is avoiding this route. -- A channel shows consistently high volume and steady fee earnings. This peer is valuable, and you might consider opening an additional channel to increase capacity, or you might raise fees slightly to capture more revenue without discouraging traffic. -- A peer generates high volume but at very low fees. You can evaluate whether the revenue justifies the capital locked in the channel, or whether that capital would earn more deployed elsewhere. - -### Putting It All Together - -Peer Insights brings together three layers of intelligence: - -1. **Network-wide scouting** (Explorer tab rankings, badges, health checks) for discovering potential new peers. -2. **Fee analysis** (the fee distribution graph) for understanding a node's pricing strategy before and after you connect. -3. **Relationship analytics** (forwarding events, volume, earnings) for measuring the real return on each channel. - -Together, these tools allow you to treat your node not just as a piece of software, but as a portfolio of financial relationships that require active monitoring and optimization. The best routing nodes are not simply the ones with the most channels or the most capacity; they are the ones whose operators make informed decisions about where to deploy their capital, informed by exactly the kind of data that Peer Insights provides. - -### Summary - -In this chapter, we explored the Peer Insights feature in Terminal's Explorer tab. We learned how to scout potential peers using capacity, centrality, and health check data; how to analyze a node's fee strategy using the fee distribution graph; and how to evaluate existing peer relationships using forwarding metrics. These tools give you the intelligence foundation for making sound channel management decisions. In the next part of the course, we will continue building on these skills by examining liquidity reports and advanced node accounting. +This data transforms abstract channel management into evidence-based strategy. If a channel has high capacity but zero forwarding events over a month, the analytics will make this inefficiency obvious, signaling a need for fee adjustment or channel closure. Conversely, high-volume, low-fee peers can be identified as candidates for fee increases. By centralizing this data, Peer Insights allows operators to treat their node not just as a piece of software, but as a portfolio of financial assets that requires active optimization. # Last Steps 2e886890-62f7-4453-9c6f-9b397a280b75 @@ -1120,534 +400,133 @@ In this chapter, we explored the Peer Insights feature in Terminal's Explorer ta ![video](https://www.youtube.com/watch?v=7ga-8AhCNK4) -### Why Liquidity Visibility Matters - -Throughout this course, we have explored many facets of Lightning node management: health checks, fee automation, channel opening strategies, and submarine swaps. All of these tools share one underlying concern, the management of liquidity. Now, let us turn to a feature that synthesizes this concern into a single diagnostic view. - -The fundamental challenge of **liquidity management on the Lightning Network** is that failure is silent. When your node lacks sufficient capacity in the right direction, payments do not fail with a loud error on your side. They simply route around you. The senders find alternative paths, and you, the operator, never see the revenue that could have been yours. In other words, the most costly liquidity problems are the ones you do not know you have. - -Lightning Terminal addresses this with the **Liquidity Report**, accessible from the main dashboard. This tool provides a comprehensive visualization of your node's ability to receive, send, and route payments of various sizes. If you are not already very familiar with the concepts of inbound and outbound liquidity, I recommend reviewing the [Lightning Labs documentation on understanding liquidity](https://docs.lightning.engineering) before continuing, as this chapter builds directly on those fundamentals. - -### The Routable Liquidity Chart - -The primary instrument in the Liquidity Report is the **Routable Liquidity Chart**. This chart breaks your node's total capacity into its two critical components: - -- **Inbound liquidity**: the funds sitting on the remote side of your channels, representing your ability to receive payments. -- **Outbound liquidity**: the funds sitting on your local side, representing your ability to send payments or initiate the first hop of a routed payment. - -The chart offers two viewing modes. The **Cumulative View** aggregates all your channels into a single ratio, letting you assess the overall balance at a glance. For instance, you might immediately see that your node is heavily skewed toward inbound capacity, with relatively little outbound. Whether this distribution is desirable depends entirely on your use case: a merchant receiving payments benefits from strong inbound liquidity, while a routing node needs a healthy balance of both. - -The **Detailed View** breaks the same data down by individual channels. This is where you begin to identify specific channels that may need rebalancing, either through manual intervention or through the Loop operations we covered earlier in the course. +### Visualizing Liquidity Health -I recommend visiting the Liquidity Report regularly. Because silent liquidity problems accumulate gradually (a channel slowly depleting over weeks, for example), periodic review is the most reliable way to catch issues before they become costly. +Managing liquidity is arguably the most complex aspect of running a Lightning node because failure is often silent. Unlike a crashed server or a rejected transaction, poor liquidity manifests as "invisible" problems—payments that simply route around your node because they cannot find a path, leaving you unaware of the lost revenue. -### The Simulation Engine +Lightning Terminal addresses this with the **Liquidity Report**, accessible via the **Loop** tab. This tool provides a diagnostic visualization of your node's ability to route payments and receive funds. -Liquidity is not a static property. A node that routes a 500,000 satoshi payment with ease might completely fail when confronted with a 15,000,000 satoshi transaction. The capacity exists in aggregate, but no single channel may be large enough to carry the larger payment. +The primary tool here is the **Routable Liquidity Chart**. It breaks down capacity into its two critical components: +* **Inbound Liquidity:** The ability to receive funds (remote balance). +* **Outbound Liquidity:** The ability to send funds (local balance). -To help operators reason about this, the Liquidity Report includes a **simulation engine** with three preset payment sizes: +The chart offers two viewing modes to help operators assess their standing. The **Cumulative View** provides a high-level ratio assessment, useful for quickly spotting gross imbalances (e.g., a node that is 90% outbound and only 10% inbound). The **Detailed View** breaks this data down by individual channels, allowing for specific troubleshooting. -- `500,000 sats` -- `5,000,000 sats` -- `15,000,000 sats` +### Simulating Payment Scenarios -As you toggle between these settings, two elements of the dashboard update dynamically: +Liquidity is not static; it behaves differently depending on the size of the payment being routed. A node might be perfectly capable of routing a 1,000 satoshi micropayment but completely fail to route a 5,000,000 satoshi transaction. The Liquidity Report includes a **Simulation Engine** to test these variances. -1. **The Routable Liquidity Chart** adjusts to show which channels remain viable at each payment size. Channels that lack sufficient depth simply disappear from the visualization, making bottlenecks immediately visible. -2. **The Estimated Last Hop Fee** recalculates to project what it would cost an external sender to route a payment of that size through your node. +Operators can toggle between three preset payment sizes: **500k sats**, **5M sats**, and **15M sats**. +As you adjust these settings, the dashboard dynamically updates two key metrics: +1. **Routable Liquidity Chart:** Visually demonstrates which channels "drop off" and become unusable as the payment size increases. +2. **Estimated Last Hop Fee:** Projects the cost for an external user to route a payment of that specific size to your node. -This simulation capability is essential for capacity planning. If you expect your node to handle large-value payments (perhaps because you serve as a routing hub for business clients), you can verify that you actually have channels deep enough to support those transactions. If the chart goes blank at `5,000,000 sats`, you know exactly where to focus your next channel opening or Loop operation. +This feature is critical for capacity planning. It helps operators identify "bottleneck" channels that appear healthy on the surface but lack the depth required to handle larger, higher-fee transactions. -### Analyzing Routing Quality by Fee Rate +### Analyzing Performance by Fee Rate -Beyond raw capacity, the Liquidity Report analyzes your channels through the lens of fee rates. The **Routable Inbound Chart**, located below the main liquidity visualization, plots your channels along two axes: +Beyond raw capacity, the report analyzes liquidity through the lens of **Fee Rates**. The **Routable Inbound Chart** plots your channels along an X-axis representing fee rates (parts per million), while the Y-axis displays channel density. -- **X-axis**: the fee rate (in parts per million) associated with each channel. -- **Y-axis**: two perspectives are available. The **Channel Count** view shows how many channels fall into each fee range, while the **Channel Percentage** view shows the proportion of your total routing capacity available at each fee rate. +This dual-perspective chart (Channel Count vs. Percentage) reveals the "quality" of your routing options. It helps answer specific strategic questions: +* **Availability:** Do I have inbound liquidity available at low fee rates, or is my capacity expensive to access? +* **Dead Zones:** Are there fee ranges where I have zero routable capacity? -This dual-perspective chart reveals the quality of your routing options, not just the quantity. It helps you answer specific strategic questions: +#### Identifying Hidden Issues +The ultimate goal of these reports is to detect **Systematic Inefficiencies**. For example, the chart might reveal that while you have ample total liquidity, it is all concentrated in high-fee channels that the network routing algorithms ignore for standard payments. Alternatively, it might show that your low-fee channels are constantly depleted. -- **Do I have inbound liquidity at competitive fee rates?** If all your capacity is concentrated in high-fee channels, the network's routing algorithms may consistently bypass you in favor of cheaper paths. -- **Are there dead zones in my fee distribution?** The chart may highlight fee ranges where you have zero routable capacity, marked with an attention indicator for channels that need intervention. - -Watch how this chart changes as you adjust the simulated payment size. You may discover that your node handles small payments across many fee ranges, but only a handful of channels can support medium or large payments. This insight allows you to rebalance or open new channels specifically to fill the gaps in your routing profile. - -### Summary - -The Liquidity Report transforms node management from a reactive process (fixing problems after they manifest) into a proactive strategy. By combining the routable liquidity visualization, the payment size simulation engine, and the fee rate analysis chart, you gain the ability to detect silent inefficiencies and address them before they cost you revenue. As we will see in the next chapter, this kind of granular control extends even further when we introduce virtual accounts on top of your node. +By correlating payment sizes with fee rates, the Liquidity Report transforms node management from a reactive process (fixing stuck channels) to a proactive strategy. It allows the operator to rebalance channels specifically to fill the gaps in their routing profile, capturing the fee revenue that was previously bypassing their node entirely. ## LND Accounts 0d31ef81-4e77-4c5e-adc5-081df64c27ec ![video](https://www.youtube.com/watch?v=G1rv9dZQO5o) -### The Problem of Shared Access - -Now that we understand how to monitor and optimize a node's liquidity, let us examine a different operational challenge: sharing that node's capabilities with multiple users or applications. - -In a typical LND deployment, any application that connects to the node receives broad access to its full balance and channel infrastructure. A mobile wallet, a tipping bot, and a merchant point-of-sale system might all authenticate with the same administrative macaroon. If any one of these applications is compromised, the attacker gains access to everything. This is a fragile security model, and it becomes increasingly dangerous as more services depend on a single node. - -Lightning Terminal solves this with a feature called **LND Accounts**. These are **virtual off-chain accounts** layered on top of a single LND node, each with its own authentication token, spending limits, and permission scope. Let us explore how they work and why they matter. - -### Understanding the Architecture - -It is crucial to understand what an LND Account is and, equally important, what it is not. An LND Account does not possess its own on-chain wallet, its own Lightning channels, or its own private keys. All cryptographic key management and liquidity remain under the control of the host LND node. The "account" is a logic layer: a virtual partition that tracks a balance and enforces access rules. +### LND Accounts: Virtual Off-Chain Infrastructure -In other words, the host node operator retains full custody of the underlying funds. The account holder enters a trust relationship with the node operator regarding the availability of those funds. This is, by design, a custodial arrangement at the account level. The operator manages the real channels and liquidity; the account holder operates within a sandboxed environment defined by the operator. +Lightning Terminal (LitD) introduces a powerful primitive known as **LND Accounts**. These are virtual, off-chain accounts layered on top of a single Lightning Network Daemon (LND) node. Unlike independent nodes that manage their own channels and private keys, LND Accounts function as partitioned entities within the host node's existing infrastructure. -This architecture is powered by the **RPC Middleware Interceptor**, which intercepts every API call made with an account macaroon and filters the responses accordingly. When an account holder queries their balance, for example, they see only their virtual allocation, not the node's full channel balance. On-chain balance always returns `0`. The channel list returns empty. Payment and invoice histories are filtered to show only transactions belonging to that specific account. +It is crucial to understand the architectural distinction: an LND Account does not possess its own on-chain wallet or Lightning channels. Instead, the primary LND node retains custody of all cryptographic keys and manages the underlying liquidity. The "account" is essentially a logic layer that tracks a virtual balance and enforces specific access rules managed by the host. This design allows operators to share their node's liquidity and connectivity with multiple users or applications without fragmenting the node’s capital or spinning up redundant infrastructure. -### Security Through Segregation +### Security Architecture and Resource Segregation -The primary value of LND Accounts is **risk containment through resource segregation**. Each account operates as a distinct, sandboxed environment with three layers of constraint: +The primary value proposition of LND Accounts is **Risk Containment** via segregation. In a standard deployment, connecting multiple applications (e.g., a mobile wallet, a tipping bot, and a merchant store) to a single LND node often grants them broad access to the node’s full balance. If one application is compromised, the entire node's funds are at risk. -- **Granular permissions**: each account operates under a specific **macaroon authentication token** (native to LND) with restricted permission scopes. The standard account macaroon includes permissions like `info:read`, `invoices:read`, `invoices:write`, `offchain:read`, `offchain:write`, and `onchain:read`. -- **Budget allocations**: operators assign a strict spending limit in satoshis. Even if the connected application attempts to spend more, LND rejects the request at the protocol level. -- **Expiration enforcement**: accounts can be configured with time-limited validity (for example, 90 days). Once the expiration passes, the account's connection string ceases to function, preventing "zombie" permissions from becoming long-term vulnerabilities. +LND Accounts solve this by creating distinct, sandboxed environments for each application. +* **Granular Permissions:** Each account operates under a specific macaroon (authentication token) with restricted scopes. +* **Budget Allocations:** Operators can assign strict spending limits (e.g., 100,000 sats). Even if the application tries to spend more, the LND node will reject the request at the protocol level. +* **Expiration Enforcement:** Accounts can be configured with time-locks (e.g., 90 days), ensuring that temporary access grants automatically expire, preventing "zombie" permissions from becoming long-term vulnerabilities. -This layered model reduces what security professionals call the "blast radius" of a breach. If a specific account credential is stolen, the attacker is limited strictly to that account's remaining budget and permissions. The core node, other accounts, and the underlying channel infrastructure remain untouched. +This layered security model reduces the "blast radius" of a security breach. If a specific account credential is stolen, the attacker is limited strictly to that account's remaining budget and permissions, leaving the core node and other accounts untouched. -### Creating an Account via the Terminal UI +### Configuration and Connection Workflow -Let us walk through the practical workflow for creating an LND Account using the Lightning Terminal web interface. We will use the **Lightning Node Connect** tab, which handles both standard connections and custodial account creation. +Creating and managing these accounts is handled directly through the Lightning Terminal interface, specifically under the **Lightning Node Connect (LNC)** tab. -1. Navigate to the **Lightning Node Connect** tab in the LitD UI. -2. Click **Create a new session** and assign it a descriptive name (for example, `AccountsDemo`). -3. Under **Permission Types**, select **Custom Type** rather than a standard admin or read-only preset. -4. In the permissions panel, select **Custodial Account**. Notice that this selection reveals additional fields: a **balance allocation** (the spending limit in satoshis) and an **expiration date**. -5. Define the budget and expiration (for example, 100,000 sats with a 90-day expiry). -6. Click the **Submit button**. +The workflow moves beyond simple connection strings into **Custodial Account** configuration: +1. **Session Initialization:** The operator starts by creating a new session and selecting "Custom" permissions rather than a standard admin access level. +2. **Parameter Definition:** The interface prompts for critical constraints. The operator defines the **Balance Allocation** (the spending limit in satoshis) and the **Expiration Date**. +3. **Generation:** The system generates a proprietary connection string (pairing phrase) or QR code. -The system generates a **Lightning Node Connect pairing phrase** (and optionally a QR code) that encapsulates the account's connection credentials. This pairing phrase can be shared with the intended user or application. - -**Important to note**: custodial accounts created this way connect exclusively through Lightning Node Connect. They cannot be used with the Terminal web interface directly; they are designed for wallet applications, browser extensions, or custom integrations. - -### Creating an Account via the CLI - -For operators who prefer command-line workflows, accounts can also be created using `litcli`: - -```bash -litcli accounts create 50000 --save_to /tmp/user.macaroon -``` - -This command creates an account with a 50,000 satoshi budget and saves the corresponding macaroon to the specified path. You can then inspect the macaroon to verify its permissions: - -```bash -lncli printmacaroon --macaroon_file /tmp/user.macaroon -``` +**Connectivity:** +These accounts connect via **Lightning Node Connect (LNC)**. This protocol establishes an encrypted, end-to-end connection between the user (or application) and the node without requiring the operator to open ports on their router or expose their IP address. -To list all existing accounts and their IDs: - -```bash -litcli accounts list -``` - -If you need to create an LNC session specifically tied to an account: - -```bash -litcli sessions add --label pointofsale --type account --account_id d64dbc31b28edf66 -``` - -And to test the account by querying the channel balance through its restricted macaroon: - -```bash -lncli --macaroonpath=/tmp/user.macaroon channelbalance -``` - -If a macaroon is lost but the account still exists, it can be reconstructed by baking a new base macaroon and adding the account-specific caveat: - -```bash -lncli bakemacaroon info:read invoices:read invoices:write offchain:read offchain:write onchain:read peers:read --save_to tmp.macaroon -lncli constrainmacaroon --custom_caveat_name account --custom_caveat_condition tmp.macaroon accounts.macaroon -rm tmp.macaroon -``` - -### Practical Use Cases - -This functionality opens several practical scenarios: - -- **Onboarding friends or family**: a node operator creates an account with a modest budget and shares the QR code. The recipient downloads a compatible wallet (such as Zeus), scans the code, and immediately has access to the Lightning Network using the operator's liquidity, without needing to manage channels or understand the underlying infrastructure. -- **Application isolation**: a developer running multiple microservices against a single node can create separate accounts for each service. A bug in one service cannot drain the wallet of another. -- **Enhanced security model**: when multiple applications connect to a single LND node, each receives its own constrained account rather than sharing a single administrative macaroon. Application A has its own permissions and budget; Application B has its own permissions and budget. A compromise of one does not affect the other. - -### Summary - -LND Accounts extend the capabilities of a single Lightning node by introducing **virtual off-chain partitions** with isolated budgets, permissions, and expiration policies. Whether configured through the Terminal UI or the command line, they provide a practical security layer for operators who share their node's infrastructure with multiple users or applications. In the next and final chapter, we will bring everything together by building a complete LitD node from scratch. +**Practical Use Cases:** +This functionality is ideal for onboarding trusted peers or testing environments. For example, a node operator can create an account for a friend to experiment with Lightning payments. The friend downloads a compatible wallet, scans the QR code, and immediately has access to the Lightning Network using the operator's liquidity, but is strictly limited to the funds allocated in the virtual account. Similarly, developers can spin up separate accounts for different microservices, ensuring that a bug in one service cannot drain the wallet of another. ## RUN LITD: Building a Node from Scratch 710c2090-e905-4141-8b12-7a81d7c276a1 ![video](https://www.youtube.com/watch?v=lopHP_nF0tE) -### Why Build a Node from Scratch? +### LITD Architecture and Repository Structure -Throughout this course, we have worked with an already-running Lightning Terminal instance, exploring its features one by one. Now, in this final technical chapter, we will go through the entire process of building a LitD node from a bare server. This is where all the concepts we have studied converge into a single, hands-on deployment. +The Lightning Terminal Daemon (LITD) is a unified binary that bundles the core Lightning Network Daemon (LND) with essential operational tools: **Loop** (liquidity swaps), **Pool** (liquidity marketplace), **Faraday** (accounting/analytics), and **Taproot Assets**. By running these components as a single integrated system, developers and node operators avoid the complexity of managing five distinct daemons and their inter-process communications. -As we discussed in the very first chapter, **Lightning Terminal Daemon (LitD)** is a unified binary that bundles LND with Loop, Pool, Faraday, and Taproot Assets into a single integrated system. By running LitD rather than managing five separate daemons, we dramatically simplify the operational complexity of a full Lightning Labs stack. +To streamline deployment, the community utilizes the **Run LITD** repository. Inspired by Alex Bosworth’s "Run LND," this repository is optimized for speed and standardized configuration. It offers three distinct implementation pathways depending on the operator's need for control: +1. **Automated Scripts:** Bash scripts that handle the end-to-end installation (ideal for rapid testing). +2. **Manual Checklists:** Step-by-step guides for operators who need to audit every command. +3. **Example Configurations:** Reference files for `bitcoin.conf`, `lit.conf`, and systemd services. -To streamline this deployment, we will use the **Run LitD** repository, a community resource inspired by Alex Bosworth's well-known "Run LND" guide. The Run LitD repository provides three complementary pathways: +### Hardware Prerequisites and Installation Stages -1. **Automated bash scripts**: handle the end-to-end installation (ideal for rapid testing and development environments). -2. **Manual checklists**: step-by-step notes for operators who want to audit every command before executing it. -3. **Example configuration files**: reference `bitcoin.conf`, `lit.conf`, and `systemd` service files that can be adapted to any environment. +Before deployment, operators must provision a server meeting minimum specifications. The scripts are tested specifically on **Ubuntu 24.04**. A baseline configuration requires at least **4GB of RAM** and sufficient storage. +* **Pruned Node:** ~80GB storage (sufficient for most Lightning operations). +* **Archival Node:** ~1TB+ storage (required only if you need a full historical copy of the blockchain). -**Important disclaimer**: as noted in the repository itself, these scripts are designed for developers who want to spin up a node quickly for testing purposes. If you are building a production node with real funds, take the time to read through every script, audit every configuration line, and follow your own security best practices. Do not blindly trust any automation when real money is at stake. +The installation workflow is divided into three sequential stages: +1. **Server Preparation:** Secures the environment by creating a dedicated user, configuring SSH keys, and disabling root login/password authentication. +2. **Bitcoin Core Setup:** Installs the Bitcoin backend. The repository supports both **Binary** (faster, pre-compiled) and **Source** (auditable, slower) installation methods. +3. **LITD Deployment:** Compiles or downloads the LITD binary. For source installations, this step automatically handles dependencies like Go, Node.js, and Yarn. -### Server Requirements and Prerequisites +### Configuration, Wallet Ops, and Service Management -These scripts have been tested on **Ubuntu 24.04**. If you are running a different distribution, the process will likely work with minor adjustments, but be prepared for occasional differences in package names or paths. +Unlike a standalone LND setup, LITD uses a unified configuration file located in the `.lit` directory. This introduces a specific syntax requirement: standard LND parameters must be prefixed with `lnd.`. For example, a setting that is `alias=MyNode` in LND becomes `lnd.alias=MyNode` in `lit.conf`. This separation allows the daemon to route configurations to the correct internal sub-server (e.g., specific settings for Loop or Faraday). -Here are the baseline hardware requirements: +**Wallet Initialization:** +Once the software is installed, the operator must manually start LITD to generate the wallet seed. The setup scripts include a secure password management mechanism that enables **Auto-Unlock**. This allows LITD to automatically decrypt the wallet upon system reboot, ensuring the node comes back online immediately after power failures or maintenance without manual intervention. -| Resource | Minimum | Notes | -|----------|---------|-------| -| **RAM (minimum)** | 4 GB | Sufficient for a pruned node with LitD | -| **Storage (pruned)** | ~80 GB | Default configuration in the scripts | -| **Storage (archival)** | ~1 TB+ | Only if you need full blockchain history | -| **Operating system** | Ubuntu 24.04 | Tested target; other Debian-based systems may work | +**Systemd Integration:** +The final setup script wraps both Bitcoin Core and LITD in `systemd` service files. This transforms them into background services that start on boot (`systemctl enable litd`). Verification involves checking the service status logs to ensure the node is successfully syncing with the blockchain and that all bundled sub-servers (Loop, Pool) are active and communicating. -Note that the scripts configure a **pruned Bitcoin node** by default. If you want to run a full archival node, look for the pruning configuration line in the Bitcoin setup script and adjust it accordingly. For full archival nodes, you may also want to configure an external data store for the blockchain data; the Run LitD repository includes notes on how to do this. - -The installation proceeds in three stages, each handled by a separate script: - -1. **Server Preparation** (`server_setup.sh`): creates a dedicated user, configures SSH keys, disables root login and password authentication. -2. **Bitcoin Core Setup** (binary or source script): installs Bitcoin Core with signature verification. -3. **LitD Deployment** (two or three scripts depending on method): installs dependencies, compiles LitD from source, configures `lit.conf`, initializes the wallet, and sets up `systemd` services. - -### Stage 1: Server Preparation - -We begin by logging into our fresh Ubuntu server as root. The first task is to clone the Run LitD repository: - -```bash -git clone https://github.com/lightninglabs/run-litd.git -``` - -Navigate into the repository and examine the scripts: - -```bash -cd run-litd -ls scripts/ -``` - -The server setup script handles basic security hardening. Before running it, ensure it is executable: - -```bash -chmod +x scripts/server_setup.sh -``` - -Since we are logged in as root, we run it directly: - -```bash -./scripts/server_setup.sh -``` - -The script will prompt you for several pieces of information: - -1. **Sudo password for the new `ubuntu` user**: this creates a non-root user that will own all subsequent operations. -2. **SSH public keys**: paste the public keys you want to authorize for this user. Each key should be on its own line. Press Enter after the last key, then Ctrl+D to confirm. - -Once the script completes, it will have: -- Created a new `ubuntu` user with sudo privileges -- Configured SSH key-based authentication for that user -- Disabled root login over SSH -- Disabled password-based authentication - -At this point, log out of the root session and reconnect as the new `ubuntu` user: - -```bash -ssh ubuntu@ -``` - -After logging back in, move the repository to the new user's home directory and fix ownership: - -```bash -sudo mv /root/run-litd /home/ubuntu/ -sudo chown -R ubuntu:ubuntu /home/ubuntu/run-litd -``` - -### Stage 2: Installing Bitcoin Core - -With the server secured, we install the Bitcoin backend. The repository offers two methods: - -- **Binary installation**: downloads the pre-compiled Bitcoin Core binary and verifies signatures. Faster, suitable when the focus is on LitD rather than Bitcoin Core itself. -- **Source installation**: compiles Bitcoin Core from source. More thorough and auditable, but slower. - -For this walkthrough, we will use the binary method. Make the script executable and run it with `sudo`: - -```bash -chmod +x scripts/bitcoin_setup_binary.sh -sudo ./scripts/bitcoin_setup_binary.sh -``` - -The script performs the following operations automatically: -- Downloads the specified version of Bitcoin Core -- Verifies cryptographic signatures for security -- Installs the binary to the appropriate system path -- Creates the Bitcoin data directory with correct permissions -- Generates a `bitcoin.conf` configuration file -- Creates and enables a `systemd` service for `bitcoind` - -During execution, the script will output an **RPC connection string** (containing the `rpcuser` and `rpcpassword`). This is critical: - -``` -rpcuser=yourgenerateduser -rpcpassword=yourgeneratedpassword -``` - -**Copy this connection string immediately and store it safely.** You will need it when configuring LitD in the next stage. If you lose it or encounter connection errors between Bitcoin Core and LitD later, you can regenerate it by following the instructions in the repository's checklist. - -The script will also ask you to select a network: - -- **mainnet (production)**: for use with real bitcoin -- **signet (testing)**: recommended when learning - -For our demonstration, we select **signet for testing**. After the script completes, verify that Bitcoin Core is running: - -```bash -sudo systemctl status bitcoind -``` - -You should see the service active and running. Bitcoin Core will begin synchronizing with the blockchain in the background. - -### Stage 3: Installing LitD from Source - -Now we arrive at the core of this chapter: installing Lightning Terminal Daemon. We will compile from source, which provides a complete understanding of what is happening on the server. The repository also offers a binary download script if you prefer speed over transparency. - -The LitD source installation is divided into two (or three) scripts that run sequentially. - -#### Script 1: Install Dependencies - -The first script installs the build dependencies: **Go, Node.js, and Yarn**. - -```bash -chmod +x scripts/litd_setup_1.sh -sudo ./scripts/litd_setup_1.sh -``` - -This script: -- Installs the Go programming language (required to compile LitD and LND) -- Configures the `GOPATH` environment variable -- Installs Node.js (required for building the web UI) -- Installs Yarn (the package manager used by the Terminal frontend) - -Because the Go path configuration modifies the shell environment, log out and log back in after this script completes: - -```bash -exit -ssh ubuntu@ -``` - -Then verify that all dependencies were installed correctly: - -```bash -go version -``` - -You should see the installed Go version. Then check Node.js and Yarn: - -```bash -node --version -yarn --version -``` - -If all three commands return version numbers, the dependencies are properly installed and we can proceed. - -#### Script 2: Compile and Configure LitD - -The second script is the most substantial. It clones the Lightning Terminal repository, compiles the binary from source, and generates the configuration file. - -```bash -chmod +x scripts/litd_setup_2.sh -sudo ./scripts/litd_setup_2.sh -``` - -The compilation process takes approximately 5 to 10 minutes depending on your server's resources. Once complete, the script prompts you for configuration parameters: - -1. **Network selection**: enter `signet` (or `mainnet`, matching your Bitcoin Core configuration). -2. **RPC connection string**: paste the `rpcuser` and `rpcpassword` that you saved during the Bitcoin Core setup. Be careful with copy-paste errors here; a mismatched credential is the most common cause of connection failures between Bitcoin Core and LitD. -3. **UI password**: choose a password for the Lightning Terminal web interface. -4. **Node alias**: a human-readable name for your node (for example, `my-litd-node`). - -The script creates the configuration file at `~/.lit/lit.conf`. Let us examine what a typical configuration looks like: - -```ini -# Lightning Terminal configuration -lnd-mode=integrated - -# UI -uipassword=YOUR_SECURE_PASSWORD - -# LND settings (note the lnd. prefix) -lnd.bitcoin.active=1 -lnd.bitcoin.signetseednode=x.x.x.x -lnd.bitcoin.node=bitcoind -lnd.bitcoind.rpchost=127.0.0.1 -lnd.bitcoind.rpcuser=yourgenerateduser -lnd.bitcoind.rpcpass=yourgeneratedpassword -lnd.bitcoind.zmqpubrawblock=tcp://127.0.0.1:28332 -lnd.bitcoind.zmqpubrawtx=tcp://127.0.0.1:28333 -lnd.alias=my-litd-node - -# Taproot Assets settings can be added here -``` - -Notice the critical syntax: when running in **integrated mode**, all LND parameters must be prefixed with `lnd.`. A setting that would be `alias=my-litd-node` in a standalone `lnd.conf` becomes `lnd.alias=my-litd-node` in `lit.conf`. This prefix system allows the daemon to route each setting to the correct internal sub-server (LND, Loop, Pool, Faraday, or Taproot Assets). - -#### Wallet Initialization - -Before running the final setup script, we must initialize the LND wallet. This is a manual step that generates the cryptographic seed for your node. - -Open two terminal windows connected to your server. In the first window, start LitD manually: - -```bash -litd -``` - -LitD will start up but pause, indicating that it needs a wallet to be created or unlocked. In the second terminal window, create the wallet: - -```bash -lncli --network=signet create -``` - -**Note on network mismatch**: the `--network` flag must match your configured network. If there is a mismatch (for example, using `--network=mainnet` when LitD is configured for signet), you may encounter a macaroon error. - -The wallet creation process will prompt you for: - -1. **Wallet password**: enter the password (twice for confirmation). This is the password LitD will use to unlock the wallet on startup. -2. **New seed or existing seed**: select the option to create a new seed. -3. **Optional passphrase encryption**: you can skip this for testing environments. - -The system then displays your **24-word recovery seed**: - -``` -abandon ability able about above absent absorb abstract absurd abuse access accident ... -``` - -**Back up this seed immediately using your preferred secure backup method.** This seed is the master key to all funds on this node. If you lose it and your server fails, your funds are unrecoverable. - -#### Auto-Unlock Configuration - -The setup scripts include a mechanism for **automatic wallet unlocking**. During installation, a file is created containing the wallet password. This allows LitD to decrypt the wallet automatically on system reboot, ensuring your node comes back online after power failures or maintenance without manual intervention. - -The password file is stored securely with restricted permissions. You can verify its location and contents (on a test node) with: - -```bash -cat ~/.lit/wallet_password -``` - -In a production environment, you should carefully evaluate the security trade-offs of auto-unlock. Storing the password on disk means that anyone with root access to the server can unlock the wallet. For high-value nodes, you may prefer manual unlock after each reboot. - -After the wallet is initialized, stop LitD gracefully in the first terminal (Ctrl+C) and proceed to the final script. - -#### Script 3: Systemd Services and Final Configuration - -The third and final script wraps everything into `systemd` services and applies final configuration updates: - -```bash -chmod +x scripts/litd_setup_3.sh -sudo ./scripts/litd_setup_3.sh -``` - -This script: -- Updates the `lit.conf` with any remaining settings -- Creates a `systemd` service file for LitD at `/etc/systemd/system/litd.service` -- Enables and starts the LitD service - -Upon completion, the script displays a confirmation message. Verify that both services are running: - -```bash -sudo systemctl status bitcoind -sudo systemctl status litd -``` - -Both should show as active. You can also check the LitD logs for any errors: - -```bash -sudo journalctl -u litd -f -``` - -### Exploring the Installed System - -Now that our node is fully operational, let us take a moment to examine the file system structure that the scripts have created. - -The key directories are: - -| Path | Contents | -|------|----------| -| `~/.bitcoin/` | Bitcoin Core data directory and `bitcoin.conf` | -| `~/.lnd/` | LND data (channels, macaroons, wallet) | -| `~/.lit/` | LitD configuration (`lit.conf`) and TLS certificate | -| `~/.tapd/` | Taproot Assets daemon data | - -To inspect the Bitcoin Core configuration: - -```bash -cat ~/.bitcoin/bitcoin.conf -``` - -To inspect the LitD configuration: - -```bash -cat ~/.lit/lit.conf -``` - -The `systemd` service files are located at: - -```bash -ls /etc/systemd/system/bitcoind.service /etc/systemd/system/litd.service -``` - -These services are configured to start automatically on boot and restart on failure. This is essential for node reliability: you do not want to be manually restarting services at 3 AM because of a brief power interruption. - -To manage the services: - -```bash -# Stop LitD -sudo systemctl stop litd - -# Start LitD -sudo systemctl start litd - -# Restart LitD (after config changes) -sudo systemctl restart litd - -# View recent logs -sudo journalctl -u litd --since "10 minutes ago" -``` - -### Summary - -In this chapter, we have walked through the complete process of building a Lightning Terminal node from a bare Ubuntu server. We progressed through three stages: server hardening (SSH, dedicated user, disabled root access), Bitcoin Core installation (binary download with signature verification), and LitD compilation from source (Go, Node.js, Yarn dependencies, followed by the build and configuration). We initialized the wallet, configured auto-unlock for resilience, and wrapped everything in `systemd` services for production-grade process management. +# Conclusion +90cfdd76-7deb-4162-87a5-24bb845ba786 -This is the culmination of everything we have covered in this course. You now have a fully operational LitD node with access to LND, Loop, Pool, Faraday, and Taproot Assets, all manageable from the Lightning Terminal web interface or via the command line. The health checks, autofees, liquidity reports, and account management features we explored in earlier chapters are all available on this node, ready to be configured according to your operational needs. -# Conclusion -90cfdd76-7deb-4162-87a5-24bb845ba786 ## Ratings & Reviews dd13ca51-9c2c-4cb8-bdfc-c452f205229a + true + ## Final Exam + 2a19c10e-ced6-11f0-8ab2-cf79e817a351 true ## Conclusion 8cf6f7c4-a520-40e6-a198-42fdd0d78f3b -Over the course of LNP 404, we have progressively explored the full Lightning Terminal stack, moving from initial installation and connection all the way through to building a complete node from scratch. - -In **Part 1**, we established the foundations: installing LitD, connecting via Lightning Node Connect, understanding health checks, navigating the dashboard's insights and forwarding data, and configuring Autofees for dynamic fee management. - -In **Part 2**, we expanded our operational toolkit: managing multiple nodes from a single interface, opening channels efficiently through batch transactions, using Lightning Loop for non-custodial liquidity swaps, and leveraging Peer Insights to make informed decisions about channel partners. - -In **Part 3**, we completed the picture with the Liquidity Report (a diagnostic tool for silent liquidity problems), LND Accounts (virtual off-chain partitions for sharing node access securely), and the full Run LitD deployment walkthrough that tied every concept together in practice. - -The Lightning Network is still a rapidly evolving system. The tools we have covered in this course, particularly Lightning Terminal, Loop, Pool, Faraday, and Taproot Assets, continue to receive updates and new features. I encourage you to consult the official documentation at [docs.lightning.engineering](https://docs.lightning.engineering) regularly, and to experiment with the features on signet or testnet before deploying changes to a production node. - -If you found this course helpful, I would be very grateful if you could take a few moments to rate it and share your feedback. Your input helps improve the material for future students and supports the Plan B Network's mission to make Bitcoin education accessible to everyone. - -Thank you for following this course, and congratulations on reaching the end. You now have both the conceptual understanding and the practical skills to operate a Lightning node with confidence. Let's keep building. true From 9c0d4fec5053a516d9f43bc5cb9d6f140c463b13 Mon Sep 17 00:00:00 2001 From: Rogzy Date: Sun, 22 Mar 2026 01:32:40 +0100 Subject: [PATCH 06/10] fix: restore full en.md and re-add 7 screenshots Previous commit accidentally overwrote the harmonized en.md (1653 lines) with a stale copy (532 lines), losing the introduction, prerequisites, course structure, and all harmonization work. Restored from 0206e26621 and re-inserted the 7 image references at correct positions. Co-Authored-By: Claude Opus 4.6 (1M context) --- courses/lnp404/en.md | 1747 ++++++++++++++++++++++++++++++++++-------- 1 file changed, 1443 insertions(+), 304 deletions(-) diff --git a/courses/lnp404/en.md b/courses/lnp404/en.md index 364fc8ccc22..12f1a6008db 100644 --- a/courses/lnp404/en.md +++ b/courses/lnp404/en.md @@ -1,396 +1,1134 @@ --- name: Navigating Your Node with Terminal -goal: Take a deep dive into your lightning node with Terminal +goal: Master the management and optimization of your Lightning node using Lightning Terminal (LitD) objectives: - - Install and connect your Lightning node using Terminal tools and commands. - - Monitor your node’s health and receive actionable recommendations for optimization. - - Analyze channels, forwards, and peer insights to improve node efficiency and reliability. - - Interpret liquidity and accounting reports for better decision-making. + - Install Lightning Terminal and connect to your existing LND node in remote mode + - Monitor your node's health with the six-metric diagnostic framework + - Analyze routing performance through forwards, channel insights, and peer analytics + - Automate fee management with the Autofees algorithm and understand its privacy architecture + - Manage liquidity through Loop In, Loop Out, and Auto Loop with budget controls + - Open multiple channels efficiently using batch transactions + - Operate a multi-node infrastructure from a single Terminal dashboard + - Set up virtual LND accounts with granular permissions and spending limits + - Build a complete Lightning node from scratch using the Run LITD repository --- -# A Journey into your Lightning Node +# A Journey into Your Lightning Node -Navigating Your Node with Terminal is a comprehensive journey into managing, optimizing, and understanding your Bitcoin Lightning node through the power of the command line. -From installation to advanced multi-node management, this course equips you with the practical skills and theoretical knowledge needed to operate your Lightning setup like a pro. You’ll explore key tools such as Lightning Terminal (LND, Loop, Pool, and Faraday) and learn to analyze your node’s health, liquidity, fees, and network interactions directly from the terminal. +Running a Lightning node is one thing. Managing it effectively is another challenge entirely. Whether you are routing payments across the network, running a merchant setup, or simply experimenting on testnet, the operational demands of a Lightning node go far beyond the initial installation: monitoring channel health, balancing liquidity, optimizing fee policies, and keeping your infrastructure secure and resilient. -By the end, you’ll not only understand how to maintain and scale your Lightning operation. +This is where **Lightning Terminal** comes in. Developed by Lightning Labs, Lightning Terminal (also known as **LitD**, for Lightning Terminal Daemon) is an all-in-one management stack that bundles several essential tools into a single binary: **Loop** for liquidity swaps, **Pool** for the channel marketplace, **Faraday** for accounting and analytics, **Taproot Assets**, and optionally **LND** itself. In other words, rather than managing five separate daemons and their inter-process communications, you run one program that ties everything together through a unified web interface. + +This course is built around the demo series by **Hannah Rosenberg** from Lightning Labs. Each chapter pairs a video walkthrough with detailed written content, including the actual CLI commands, configuration files, and procedures you will need. This is a hands-on, practice-focused course: you will spend most of your time in the terminal and in the Terminal web interface, working with real tools on real (or testnet) infrastructure. + +### Prerequisites + +To follow this course comfortably, you should have: + +- A basic understanding of how the Lightning Network works (channels, routing, invoices) +- Familiarity with the Linux command line (`ssh`, `nano`, `systemctl`, `git`) +- An existing LND node running on testnet or mainnet (for the first 10 chapters), or a fresh Ubuntu server (for the final chapter, which builds everything from scratch) +- Go 1.21+ and Node.js installed on your machine (for compiling LitD from source) + +If you have never set up a Lightning node before, we recommend starting with the [LNP 202 course](https://planb.academy/courses/lnp202), which walks you through the initial setup of your first Lightning node. + +### Course structure + +The course is organized in three parts: + +**Part 1: Getting Started with Terminal** + +We begin by installing LitD and connecting to the Terminal web interface. From there, we explore the Health Checks framework to evaluate your node's performance across six key metrics, then dive into the financial analytics dashboard to understand your routing revenue, channel efficiency, and network position. The part concludes with Autofees, an automated fee management system that adjusts your channel policies based on historical traffic patterns. + +**Part 2: Managing Your Node's Network** + +In this part, we move into active node management. You will learn how to operate multiple Lightning nodes from a single Terminal dashboard, open channels efficiently using batch transactions, manage your liquidity through Loop swaps (both manual and automated), and leverage Peer Insights to make data-driven decisions about your channel partnerships. + +**Part 3: Advanced Features and Full Node Setup** + +The final part covers advanced topics: the Liquidity Report for diagnosing silent routing problems, LND Accounts for creating sandboxed virtual wallets with granular permissions, and a comprehensive from-scratch installation walkthrough using the Run LITD repository. This last chapter is the most code-intensive in the course, covering server hardening, Bitcoin Core installation, LitD compilation, wallet initialization, and systemd service management. + +### Documentation and resources + +Throughout this course, we reference the official Lightning Labs documentation extensively. Here are the key resources you may want to bookmark: + +- [Lightning Terminal docs](https://docs.lightning.engineering/lightning-network-tools/lightning-terminal) +- [Loop docs](https://docs.lightning.engineering/lightning-network-tools/loop) +- [Pool docs](https://docs.lightning.engineering/lightning-network-tools/pool) +- [LND docs](https://docs.lightning.engineering/lightning-network-tools/lnd) +- [Run LITD repository](https://github.com/lightninglabs/lightning-terminal) +- [Lightning Node Connect](https://docs.lightning.engineering/lightning-network-tools/lightning-terminal/lightning-node-connect) + +Ready to take full control of your Lightning node? Let's get started. +++ -# First steps of installing your Lightning Node -d74ec352-1a5d-466d-a06d-571fc9f99937 +# Introduction +a1f3d9c2-7b4e-4c8a-9d5f-2e6b8c0d4a7e + +## Course overview +f4e2a1b3-5c6d-4e8f-9a0b-1d3c5e7f2a4b + +Welcome to the LNP 404 course! Together, we will explore how to manage, optimize, and understand your Bitcoin Lightning node through the power of **Lightning Terminal** (LitD), an all-in-one management stack developed by Lightning Labs. + +This course is built around the demo series by [Hannah Rosenberg](https://planb.academy/professors/hannah-rosenberg) from Lightning Labs. Each chapter pairs a video walkthrough with detailed written content, including the actual CLI commands, configuration files, and procedures you will need. + +### Why this course matters + +Running a Lightning node means you are part of the payment infrastructure of Bitcoin. But without proper tooling, operating a node is like flying blind: you cannot see which channels are profitable, where liquidity is stuck, or whether your fee policies are competitive. Most node operators leave money on the table simply because they lack visibility into their own operations. + +This course gives you that visibility and the tools to act on it. + +### What you will learn + +By the end of this course, you will be able to: + +- Install, configure, and run Lightning Terminal on your own infrastructure +- Diagnose node performance issues using health checks and liquidity reports +- Automate fee management so your channels stay competitive without manual tuning +- Rebalance liquidity through Loop swaps (manual and automated) with budget controls +- Open multiple channels in a single on-chain transaction to save fees +- Manage a fleet of Lightning nodes from one unified dashboard +- Create sandboxed virtual accounts with spending limits for apps and users +- Build a complete Lightning node from scratch on a fresh Ubuntu server + +These are the operational skills that separate a passive node operator from someone who runs a professional, revenue-generating Lightning infrastructure. + +### Curriculum + +**Part 1: Getting Started with Terminal** covers installation, the Health Checks diagnostic framework, financial analytics (ROI, forwards, channel insights), and the Autofees algorithm for automated fee management. + +**Part 2: Managing Your Node's Network** covers multi-node management from a single dashboard, batch channel openings, Lightning Loop for liquidity management (Loop In, Loop Out, Auto Loop), and Peer Insights for data-driven channel decisions. + +**Part 3: Advanced Features and Full Node Setup** covers the Liquidity Report for diagnosing silent routing problems, LND Accounts for sandboxed virtual wallets, and a comprehensive from-scratch node build using the Run LITD repository. + +### Prerequisites and tools + +This course assumes familiarity with the Linux command line (`bash`, `ssh`, `nano`, `systemctl`, `git`) and a basic understanding of how the Lightning Network works (channels, routing, invoices). You will work primarily with **Go**, **Node.js**, and **systemd** configuration files. All commands shown use `bash` on Ubuntu. + +You will need either an existing LND node (testnet or mainnet) for the first 10 chapters, or a fresh Ubuntu server for the final chapter. If you have never set up a Lightning node before, I recommend starting with the [LNP 202 course](https://planb.academy/courses/lnp202). + +### Documentation and resources + +Throughout this course, we reference the official Lightning Labs documentation: + +- [Lightning Terminal docs](https://docs.lightning.engineering/lightning-network-tools/lightning-terminal) +- [Loop docs](https://docs.lightning.engineering/lightning-network-tools/loop) +- [Pool docs](https://docs.lightning.engineering/lightning-network-tools/pool) +- [LND docs](https://docs.lightning.engineering/lightning-network-tools/lnd) +- [Run LITD repository](https://github.com/lightninglabs/lightning-terminal) +- [Lightning Node Connect](https://docs.lightning.engineering/lightning-network-tools/lightning-terminal/lightning-node-connect) + +Ready to take full control of your Lightning node? Let's get started. + +# First steps of installing your Lightning Node +d74ec352-1a5d-466d-a06d-571fc9f99937 + +## Install & Connect +0fa71ff6-9b15-4e8b-8270-2ff7df465c11 + +![video](https://www.youtube.com/watch?v=XibPhZtNQak) + +Running a Lightning node is one thing. Managing it with confidence is something else entirely. In this first chapter, we will install **Lightning Terminal**, the all-in-one management interface developed by Lightning Labs, and we will connect it to an existing LND node. By the end of this chapter, you will have a running `litd` daemon, a proper configuration file, a systemd service that survives reboots, and a secure browser connection to Terminal on the web. + +Let's go! + +### What is Lightning Terminal? + +Before we touch the command line, let's understand what we are about to install. **Lightning Terminal (LitD)** is a unified management stack that bundles several powerful tools into a single binary: + +- **LND** (optionally, if you do not already have it running) +- **Lightning Loop** for submarine swaps between on-chain and off-chain Bitcoin +- **Lightning Pool** for buying and selling inbound channel liquidity +- **Faraday** for financial reporting and channel analytics +- **Taproot Assets Protocol** for asset issuance over Lightning + +In other words, `litd` is the gateway between a browser-based management interface and your Lightning node's gRPC API. Anyone who has access to `litd` can monitor and manage the node, which is why we will pay careful attention to authentication and security throughout this chapter. + +### Two Deployment Modes + +LitD supports two ways of running alongside LND: + +| Mode | Description | When to use | +|------|-------------|-------------| +| **Integrated mode** | LitD ships with its own embedded LND instance | Fresh installations where you want everything in a single process | +| **Remote mode** | LitD connects to an already-running LND instance | Existing nodes where you want to add Terminal without reconfiguring LND | + +In this course, we will use **remote mode**, which is the ideal approach when you already have a production or testnet LND node running. Remote mode lets you enhance your existing setup with Loop, Pool, Faraday, and the Terminal web interface without touching your LND installation. + +### Prerequisites + +Installing `litd` from source requires up-to-date development tools. Before proceeding, verify that you have recent versions of both Go and Node.js on your machine: + +```bash +go version +``` + +You should see something like `go1.21.3` or newer. + +```bash +node --version +``` + +You should see `v20.x` or newer (the exact version matters less than being reasonably current). + +You will also need a running Bitcoin backend (typically `bitcoind`) and a functioning LND node. Let's confirm that both processes are active: + +```bash +ss -tlnp | grep -E 'bitcoind|lnd|litd' +``` + +You should see `bitcoind` and `lnd` listening on their respective ports. If `litd` already appears, you may have a previous installation; stop it before continuing. + +### Cloning and Compiling LitD + +Now that our environment is ready, let's install LitD from source. We begin by cloning the official Lightning Labs repository: + +```bash +git clone https://github.com/lightninglabs/lightning-terminal.git +cd lightning-terminal +``` + +Next, we check out the latest stable release. As of this writing, that is version `v0.12.2-alpha`: + +```bash +git checkout v0.12.2-alpha +``` + +Then we compile and install the binary with a single command: + +```bash +make install +``` + +This step compiles the Go backend, builds the UI assets, and places the `litd` binary in your `$GOPATH/bin` directory. It typically takes a few minutes. Once it completes, confirm that `litd` is accessible system-wide: + +```bash +litd --version +``` + +If the version string prints correctly, the installation is complete. + +![LNP404](assets/en/001.webp) + +Let's move on to configuration. + +### Preparing the LND Configuration + +Before `litd` can communicate with your existing LND node, we need to verify one critical setting in your LND configuration file. Open it: + +```bash +nano ~/.lnd/lnd.conf +``` + +Look for the following line (or add it if it is missing): + +```ini +rpcmiddleware.enable=true +``` + +This setting enables the **RPC Middleware Interceptor**, which allows `litd` to authenticate and communicate with LND. Without it, `litd` will fail to connect in remote mode, and you may encounter cryptic macaroon errors. Save and close the file, then restart LND if you had to modify this setting. + +### Creating the LitD Configuration File + +Rather than passing dozens of flags on the command line each time we start `litd`, we will create a dedicated configuration file. First, let's create the data directory: + +```bash +mkdir -p ~/.lit +``` + +Now create the configuration file: + +```bash +nano ~/.lit/lit.conf +``` + +Here is a complete configuration for remote mode. We will walk through each section: + +```ini +# LitD operation mode +lnd-mode=remote + +# Network (change to mainnet for production) +network=testnet + +# UI password (use a strong, unique password on production nodes) +uipassword=YourSecurePasswordHere + +# Remote LND connection settings +remote.lnd.rpcserver=localhost:10009 +remote.lnd.macaroonpath=~/.lnd/data/chain/bitcoin/testnet/admin.macaroon +remote.lnd.tlscertpath=~/.lnd/tls.cert + +# HTTPS listen address for the Terminal UI +httpslisten=0.0.0.0:8443 +``` + +Let's examine what each block does: + +1. **`lnd-mode=remote`** tells `litd` that we already have an LND node running. From `litd`'s perspective, LND is a remote service it connects to, even when both run on the same machine. + +2. **`network=testnet`** ensures `litd` operates on the correct network. If you are running mainnet, change this accordingly. A network mismatch will produce macaroon authentication errors that can be difficult to diagnose. + +3. **`uipassword`** sets the password for the browser-based Terminal UI. On a production machine, use a password generated by a password manager. + +4. **The three `remote.lnd.*` lines** tell `litd` how to talk to LND: the RPC server address, the path to the admin macaroon for authentication, and the path to the TLS certificate. Note that the macaroon path includes the network name (`testnet` in our case). + +5. **`httpslisten=0.0.0.0:8443`** instructs `litd` to listen for HTTPS connections on port 8443 from any network interface. This is the port we will use to access the Terminal UI in a browser. + +### Setting Up a Systemd Service + +We could start `litd` manually with a simple command like `litd --uipassword=YourPassword`, but that approach lacks resilience. If the machine reboots at 2 AM, your Terminal connection disappears. A systemd service solves this problem elegantly. + +Create the service file: + +```bash +sudo nano /etc/systemd/system/litd.service +``` + +Paste the following configuration: + +```ini +[Unit] +Description=LitD Lightning Terminal Daemon +Requires=lnd.service +After=lnd.service + +[Service] +ExecStart=/home//go/bin/litd +User= +Group= +Type=simple +Restart=always +RestartSec=120 + +[Install] +WantedBy=multi-user.target +``` + +Replace `` with your actual Linux username. A few points worth noting: + +- **`Requires=lnd.service`** and **`After=lnd.service`** ensure that `litd` starts only after LND is up and running. Since `litd` depends on LND's RPC interface, starting it before LND would cause connection failures. +- **`Restart=always`** with a **`RestartSec=120`** delay means that if `litd` crashes, systemd will wait two minutes and then restart it automatically. +- The `ExecStart` path should point to wherever `make install` placed the `litd` binary (typically `$GOPATH/bin/litd`). + +Now enable and start the service: + +```bash +sudo systemctl enable litd +sudo systemctl start litd +``` + +Verify that `litd` is running and listening on the expected port: + +```bash +ss -tlnp | grep 8443 +``` + +If you see `litd` listening on port 8443, the daemon is operational. You can also check its status at any time with: + +```bash +sudo systemctl status litd +``` + +### Accessing the Terminal UI + +With `litd` running, open a browser and navigate to: + +``` +https://:8443 +``` + +If you have not configured a domain name or SSL certificate (which is typical on testnet), your browser will display a security warning about the self-signed certificate. This is expected; proceed past the warning for testing purposes. On a production node, you would configure a proper TLS certificate. + +Enter the UI password you defined in `lit.conf`, and you will see the Terminal interface. + +![LNP404](assets/en/002.webp) + +From here, you have access to all the management tools we will explore throughout this course: health checks, channel management, Loop, Pool, Autofees, and more. + +### Connecting to Terminal on the Web + +The local UI is useful, but Lightning Terminal truly shines when accessed through **Terminal on the web** at `terminal.lightning.engineering`. This hosted interface connects to your node remotely using **Lightning Node Connect (LNC)**, an encrypted communication protocol that works even when your node sits behind Tor or NAT. + +Here is how LNC works at a high level: your `litd` daemon makes an outgoing connection to a web proxy (the "mailbox"). Because the connection is outgoing, you do not need to open any ports on your firewall. The proxy server sees only encrypted blobs; Lightning Labs cannot inspect your private channel balances, HTLCs, or on-chain data. The connection is authenticated using a **one-time pairing phrase**, a set of 10 words that you should treat with the same care as a password. + +#### Connecting via the UI + +From the local Terminal interface, click the connection button to initiate an LNC session. The interface will generate a 10-word pairing phrase. Copy this phrase, then navigate to `terminal.lightning.engineering` in your browser. Paste the phrase, set a session password, and you are connected. + +![LNP404](assets/en/003.webp) + +#### Connecting via the Command Line + +For automation or headless setups, you can generate the connection string directly from the command line using `litcli`: + +```bash +litcli --network=testnet sessions add --label default --type admin +``` + +This command creates a new administrative session and outputs a connection string. You can then paste this string into the Terminal web interface to establish the connection. Note that `litcli` supports several session types beyond `admin`, including read-only sessions for monitoring dashboards. + +**Important:** The connection string is equivalent to an administrative private key for your node. Never broadcast it publicly, and never reuse a pairing phrase after it has been consumed. + +### Summary + +Let's recap what we have accomplished in this chapter. We installed `litd` from source by cloning the Lightning Labs repository and running `make install`. We verified that `rpcmiddleware.enable=true` is set in our LND configuration. We created a dedicated `lit.conf` file with all the parameters needed for remote mode operation. We set up a systemd service so that `litd` starts automatically and survives reboots. Finally, we connected to Terminal on the web using Lightning Node Connect. + +![LNP404](assets/en/004.webp) + +In the next chapter, we will explore what Terminal reveals about our node's health and discover how the health check system evaluates routing performance across six key metrics. + +## Health Checks and Recommendations +ceb149b0-473b-4264-8bc3-b64ec8717aac + +![video](https://www.youtube.com/watch?v=ZyZKFmKW_dU) + +Now that we have Lightning Terminal installed and connected, let's explore the first thing it shows us: the health of our node. In this chapter, we will examine how Terminal evaluates your node across six diagnostic metrics, what each metric actually measures, and how the **Recommended Channels** feature suggests new peers that benefit both your node and the broader Lightning Network. + +### Why Health Checks Matter + +Running a Lightning node is not simply a matter of keeping software online. A routing node must maintain sufficient channels, balanced liquidity, stable connections, and quality peers in order to forward payments reliably. Without a systematic way to evaluate these factors, operators are left guessing about their node's effectiveness. + +Terminal's **Health Checks** provide exactly this systematic evaluation. Think of them as a diagnostic report for your node, covering six dimensions of routing performance. However, and this is an important nuance, these checks are designed specifically for routing nodes. If your node specializes in sending payments (a consumer wallet) or receiving payments (a merchant endpoint), it may not score well on all six checks, and that is perfectly fine. The checks measure routing capability, not general usefulness. + +### Exploring Your Node's Health + +When you connect to Terminal on the web, the homepage displays a summary of your node's health status at the top. To get a more detailed view, navigate to the **Explore** tab and search for your node by alias or public key: + +1. Copy your node's public key from the homepage +2. Click the **Explore** tab +3. Paste your public key into the search field + +![LNP404](assets/en/005.webp) + +This brings up a detailed profile of your node, including its overall score, current capacity, age, number of good peers, and centrality measure. Below these summary statistics, you will find the six individual health checks. + +### The Six Health Checks + +Let's walk through each check and understand what it measures: + +**1. Node Is Online** + +This is the most fundamental check. A routing node must be reachable on the network to forward payments. If your node experiences frequent downtime, it cannot route payments, and peers will eventually close their channels with you. For routing nodes, consistent uptime is not optional; it is the foundation upon which everything else depends. + +**2. Plenty of Channels** + +A routing node needs a sufficient number of active channels to create viable payment paths. A node with only one or two channels cannot meaningfully participate in routing because there are too few paths through it. Terminal evaluates whether your node has enough active channels to function as a useful routing intermediary. Around 14 active channels is generally considered adequate connectivity for routing operations. + +**3. Good Routing Capacity** + +Having many channels is necessary but not sufficient. Each channel must also have **adequate capacity in both directions** to route payments of reasonable size. In other words, a channel where all the balance sits on one side cannot forward payments in the depleted direction. This check evaluates whether your channels collectively provide enough bidirectional capacity to handle typical routing requests. + +**4. Many Healthy Channels** + +Beyond capacity, Terminal evaluates whether your channels are actually healthy. A **healthy channel** is one that remains active, has reasonable capacity, and sees some activity over time. This check focuses specifically on public channels (channels that are announced to the network graph). Private channels, which are typically used for mobile wallets or merchant endpoints, are not factored into this metric. + +**5. Channel Stability** + +Do your channels stay open and active, or do they frequently go offline? This check penalizes nodes whose channels are unstable, where peers disconnect often or where channels are opened and closed in rapid succession. Stability signals to the network that your node is a reliable routing partner. + +**6. Many Good Peers** + +This is the most demanding check. It evaluates not just your own node's performance, but the quality of the nodes you connect to. Your public channels should reach out to **other well-performing routing nodes**. A node that connects only to poorly maintained or unreliable peers inherits some of that unreliability, because payments that route through your node depend on your peers being available and well-connected too. + +In Terminal's terminology, a **"stable peer"** is a node that passes five of the six health checks, typically all checks except this last one ("many good peers"). This definition becomes important for the Recommended Channels feature, which we will explore next. + +### Understanding Your Scores + +Each health check includes a link to more detailed documentation. If you pass some checks but fail others, these links provide actionable guidance on how to improve. Here is a general diagnostic approach: + +| Failed Check | Likely Cause | Action | +|-------------|-------------|--------| +| Node is online | Uptime issues | Investigate network stability, configure systemd for auto-restart | +| Plenty of channels | Too few connections | Open additional channels to well-connected peers | +| Good routing capacity | Channels depleted on one side | Rebalance using Loop (covered in a later chapter) | +| Many healthy channels | Inactive or undersized channels | Close inactive channels, open larger ones | +| Channel stability | Frequent opens/closes or peer disconnections | Choose more stable peers, investigate network issues | +| Many good peers | Connected to poorly performing nodes | Open channels to recommended peers (see below) | + +### Recommended Channels + +![LNP404](assets/en/006.webp) + +Scroll down on the Channels tab of the homepage, and you will find the **Recommended Channels** section. This feature identifies nodes on the network that would benefit from a well-connected peer, and it suggests that you be that peer. + +The recommendation logic works as follows: Terminal identifies "stable peers," nodes that pass five of six health checks (everything except "many good peers"). These are reliable, well-maintained nodes that simply need better-connected partners to reach their full routing potential. When you open a channel to one of these recommended nodes, the benefit operates on three levels: + +1. **Your node** gains a new, reliable routing partner +2. **The recommended peer** may pass its final health check, becoming a fully healthy routing node +3. **The network as a whole** benefits from more decentralized routing paths and better capital allocation + +For each recommended node, Terminal displays its rank, alias, centrality score, and total capacity. You can click on any recommendation to view detailed information, including how long the node has been active, how many peers it has, and which health checks it passes. + +It is worth noting that opening a channel to a recommended peer does not guarantee that the peer will pass its final health check. Success also depends on the capacity you allocate to the channel and ongoing maintenance of that channel's liquidity balance. + +### Summary + +In this chapter, we explored Terminal's Health Checks framework and the Recommended Channels feature. We learned that the six health checks evaluate routing-specific performance: uptime, channel count, bidirectional capacity, channel health, stability, and peer quality. We also discovered how the recommendation system identifies stable peers that would benefit from new connections, creating a virtuous cycle of network improvement. + +In the next chapter, we will dive into the data that Terminal provides about your node's financial performance, routing activity, and channel-level analytics. + +## Insights, Forwards, and Channels +37799ff2-ca5a-4db4-aa21-fed5a5420be4 + +![video](https://www.youtube.com/watch?v=Mv7wMwnr-Sw) + +Now that we understand how Terminal evaluates our node's health, let's explore the financial and operational data it provides. The Terminal Web homepage is effectively your node's command center, consolidating routing data, profitability metrics, and channel analytics into a single interface. In this chapter, we will examine the four key performance indicators, the forwarding log, the top routes analysis, and the channel management tools that make Terminal such a powerful operational dashboard. + +### The Four Key Performance Indicators + +At the top of the Terminal homepage, you will find four metrics that provide an instant snapshot of your node's financial performance: + +| Metric | What It Measures | +|--------|-----------------| +| **Spent Satoshis** | Total operational costs: on-chain fees for opening and closing channels, routing fees paid when sending payments, rebalancing costs | +| **Earned Satoshis** | Revenue generated from forwarding payments through your node | +| **Net Profit** | Earned Satoshis minus Spent Satoshis | +| **ROI (Return on Investment)** | Net Profit relative to the total capital locked in your channels | + +These four numbers tell you, at a glance, whether your node is operating at a profit or a loss. If you are running a routing node with the goal of earning fees, this is where you assess whether your strategy is working. If your node is not optimized for routing (perhaps it exists primarily to support a specific application or service), a negative ROI is not necessarily a problem; it simply reflects a different use case. + +You can adjust the **time period** for these metrics using the controls at the top of the dashboard. This allows you to isolate specific periods, which is particularly useful when evaluating the impact of a fee policy change or a new channel opening. + +### Profit and Loss Breakdown + +For deeper financial analysis, click through to the **Profit and Loss breakdown**. This view itemizes your revenue sources and expense categories, providing granular visibility into where your satoshis are flowing. The breakdown shows: + +- How you have been **earning fees** (which channels and routes generate the most revenue) +- How you have been **spending satoshis** (channel opening costs, routing fees, rebalancing expenses) + +One of the most practical features here is the **CSV export** button. You can download your complete profit and loss data and import it into a spreadsheet for external accounting, tax reporting, or more sophisticated financial modeling. For operators who manage multiple nodes or need to report to stakeholders, this bridges the gap between node management and traditional bookkeeping. + +### Top Routes + +Below the KPI summary, you will find the **Top Routes** section. This is where Terminal reveals the specific payment pathways that drive the majority of your forwarding volume and fee revenue. + +Understanding your top routes is strategically important. If a particular channel combination consistently generates the highest fees, that tells you several things: those channels have adequate liquidity, the fee rates are attracting traffic, and the peers on either end are active routing participants. These are the channels you want to pay the most attention to when it comes to liquidity management. + +The analysis breaks down further into **Top Outbound** and **Top Inbound** categories. This distinction helps you understand the directionality of your traffic: + +- **Top Outbound** channels are the ones through which payments most frequently leave your node. These channels tend to drain your local (outbound) balance over time. +- **Top Inbound** channels are the ones through which payments most frequently arrive at your node. These channels accumulate local balance over time. + +Understanding these flow patterns is crucial for anticipating liquidity needs. If a high-earning outbound channel is steadily draining, you know you will eventually need to replenish its local balance (using Loop In, for example) to keep the revenue flowing. + +### The Forwards Log + +Scrolling down further, you reach the **Forwards** section. This is a comprehensive log of every payment your node has forwarded, displayed both as a time-series graph and as a detailed event list. + +The graph provides a visual overview of routing activity over time. You can adjust the time window to zoom in on specific periods of interest. Below the graph, each forwarding event is logged individually, showing: + +- The timestamp of the forward +- The amount forwarded +- The fee earned for facilitating that payment + +This level of detail creates an audit trail that is invaluable for troubleshooting. If you notice a drop in forwarding activity, you can correlate it with specific events: a channel going offline, a fee policy change, or a liquidity imbalance that developed on a key route. + +### The Channels Tab + +Let's now turn to the **Channels** tab, which represents the operational core of Terminal Web. At the top level, you will see aggregate statistics: + +- **Total channels** (active and inactive) +- **Total outbound capacity** (your ability to send or route outward) +- **Total inbound capacity** (your ability to receive or route inward) + +![LNP404](assets/en/007.webp) + +But the real power of this tab lies in the **per-channel liquidity visualization**. For each channel, Terminal displays a visual bar showing the balance distribution between local (outbound) and inbound liquidity. At a glance, you can see: + +- Channels that are **local-heavy** (full of outbound liquidity, depicted on the left side of the bar) +- Channels that are **remote-heavy** (full of inbound liquidity, depicted on the right side of the bar) +- Channels that are **well-balanced** (liquidity distributed roughly evenly) + +This visual representation is far more efficient than reading through numerical tables. In a few seconds, you can scan all your channels and identify which ones need attention. + +### Per-Channel Analytics + +Click on any individual channel, and Terminal reveals detailed metrics: + +- **Satoshis earned** through that specific channel +- **ROI** for channels you opened (comparing earned fees against the on-chain cost of opening the channel) +- **Peer information** including the node alias and public key +- **Channel status** (active or inactive) +- **Total capacity** of the channel + +The ROI calculation is particularly valuable for evaluating past decisions. If you opened a channel and the fees it has generated exceed the on-chain cost of creating it, that channel is profitable. If not, you may want to consider whether to keep it open or reallocate that capital elsewhere. + +### Channel Actions + +From the channel detail view, you can take direct action: + +- **Update the fee policy** for that specific channel. If a channel is underperforming, adjusting its fee rate may attract more routing traffic. If it is being depleted too quickly, raising the fee can slow the drain. +- **Close the channel** if it is consistently inactive or unprofitable. Closing an underperforming channel frees up capital that can be redeployed to a more productive peer. + +Terminal also logs all **channel lifecycle events**, including opens, cooperative closes, and force closes. This history appears in the **Channel Actions** section and provides context for understanding changes in your channel count over time. If you notice your channel count dropped unexpectedly, check this log to see whether a peer force-closed on you, or whether an old inactive channel was cleaned up. + +### Summary + +In this chapter, we explored Terminal's financial dashboard and channel management tools. We examined the four KPIs that summarize node profitability (Spent Sats, Earned Sats, Net Profit, ROI), the Top Routes analysis for identifying high-value payment paths, the Forwards log for auditing individual routing events, and the Channels tab for visual liquidity management and per-channel analytics. + +In the next chapter, we will discover how to automate one of the most time-consuming aspects of node management: fee adjustment. The Autofees feature can significantly reduce your operational overhead while improving both fee earnings and liquidity balance. + +## Autofees +c6264c0b-10f6-4261-8d1e-47593168d8ca + +![video](https://www.youtube.com/watch?v=wglBEUtXgTo) + +If you have been managing a Lightning routing node for any length of time, you know that fee management is one of the most persistent operational challenges. Set your fees too high, and traffic stops flowing through your channels. Set them too low, and you underprice your liquidity, draining your outbound capacity without earning adequate compensation. In this chapter, we will explore **Autofees**, a Terminal feature that automates fee adjustments on a per-peer basis, adapting dynamically to changes in demand and routing flows. + +### Why Automate Fees? + +Manual fee management requires constant attention. Each channel has its own traffic patterns, each peer behaves differently, and market conditions shift over time. An operator managing dozens of channels would need to monitor each one individually, compare forwarding volumes, evaluate whether current fees are capturing enough value, and adjust accordingly. This is time-consuming and error-prone. + +Autofees addresses this by applying an intelligent algorithm that observes your node's routing history and adjusts fees incrementally. The goal is twofold: **stabilize traffic** to prevent the feast-or-famine pattern that many routing nodes experience, and **prevent underpricing of liquidity** so that your outbound capacity is not drained without fair compensation. + +### How the Algorithm Works + +The Autofees engine does not apply random or uniform adjustments. It operates on a comparative analysis of historical performance, and it works on a **per-peer basis**, not as a blanket policy across your entire node. + +Here is the core mechanism: + +1. **Establish a baseline.** The algorithm examines the forwarding traffic of your **top five earning peers over the past 60 days**. This establishes a reference throughput: how much volume, under what conditions, generated the best returns. + +2. **Compare recent activity.** The algorithm then looks at forwarding traffic from the **past few days** and compares it against this 60-day baseline. + +3. **Adjust accordingly.** + - If recent traffic **exceeds** the baseline, the algorithm interprets this as a demand surge and may incrementally **increase fees** to capture more revenue. + - If recent traffic **falls below** the baseline, the algorithm interprets this as a demand slump and may **decrease fees** to attract more routing volume. + +4. **Liquidity protection.** When a channel reaches approximately **7/8ths depletion** (only 1/8 of its capacity remaining on one side), fees increase mildly to signal scarcity and discourage further draining. + +Updates occur in **small increments every three days**. This conservative pacing minimizes network gossip overhead (since fee policy changes must be broadcast to the network) and prevents the algorithm from overreacting to short-term fluctuations. + +In other words, Autofees behaves like a patient, data-driven operator who checks each channel's performance every few days and makes small, targeted adjustments based on what the numbers say. + +### Privacy Architecture + +A natural concern when enabling any automated tool is: what data does it access, and who can see it? Autofees is designed with the **principle of least privilege** in mind. + +When you enable Autofees, Terminal establishes a dedicated **Lightning Node Connect (LNC)** session with strictly limited permissions: + +| Access Type | Scope | +|------------|-------| +| **Read** | Forwarding history, channel balances, current fee policies | +| **Write** | Fee policy updates only (cannot spend funds, close channels, or alter other node settings) | + +This means the Autofees session cannot move your money, cannot close your channels, and cannot modify anything beyond fee rates. The session is visible in `litd` and can be revoked at any time. + +To further protect your privacy, `litd` employs a **Privacy Mapper** that obfuscates sensitive data before it leaves your node. Specifically: + +- **Channel IDs** are mapped to random values +- **Channel points** are obfuscated +- **Node public keys** are obfuscated +- **Amounts in forwarding data** are randomly altered to break amount correlation +- **Timestamps in forwarding data** are randomly altered to break time correlation + +The Privacy Mapper ensures that the external algorithm can optimize fee calculations without knowing your node's specific identity or topology. You can inspect these mappings at any time using the command line: + +```bash +litcli privacy +``` + +This command lets you manually convert between real and privacy-mapped values for debugging purposes. + +### Configuration Prerequisites + +Before enabling Autofees, you need to verify two configuration items. + +**Required: Enable RPC Middleware** + +Open your LND configuration file: + +```bash +nano ~/.lnd/lnd.conf +``` + +Ensure this line is present: + +```ini +rpcmiddleware.enable=true +``` + +Without this setting, Autofees cannot intercept and modify fee policies. If you followed the installation in Chapter 1.1, you already have this configured. + +**Recommended: Set a High Initial Fee Rate** + +Lightning Labs recommends setting a relatively high default fee rate before enabling Autofees: + +```ini +bitcoin.feerate=2500 +``` + +The reasoning is strategic: the algorithm can safely **lower** fees from a high starting point to find the optimal rate. If you start with a low fee rate, the algorithm has limited upward room and your channels may be drained before fees adjust sufficiently. Starting high is the conservative approach; the algorithm will find the right level by adjusting downward. + +**Important side effect:** Enabling Autofees automatically sets the channel **CLTV delta to 100 blocks**. The CLTV delta (CheckLockTimeVerify) is the number of blocks your node requires for HTLC timeout. A value of 100 is reasonable for most routing nodes, but you should be aware of this automatic change. + +### Enabling Autofees + +With the prerequisites in place, enabling Autofees takes just a few clicks in the Terminal interface: + +1. Navigate to the **Loop** tab in Terminal +2. Click **Autopilot** +3. Click **Enable** +4. Review the per-channel toggles and adjust as needed +5. Click **Save** + +That is it. The algorithm begins working immediately, establishing its baseline from your historical forwarding data. + +### Per-Peer Granularity + +One of the most practical aspects of Autofees is that you can **enable or disable it on a per-channel basis**. After enabling the feature globally, scroll down to see the list of your channels with individual toggles. + +This allows a hybrid management approach: + +- **Automated channels**: Enable Autofees for channels where you are unsure of the optimal fee rate or where manual management is too time-consuming +- **Manual channels**: Keep Autofees disabled for strategic peers where you have a specific fee policy in mind (for example, a channel to Loop's node where you want a fixed rate) + +Even with Autofees enabled, you retain the ability to **manually override any fee rate at any time**. The algorithm will respect your manual changes and factor them into subsequent adjustments. + +### Operational Best Practices + +A few guidelines to get the most out of Autofees: + +- **Do not restart Autofees unnecessarily.** Restarting the feature causes the algorithm to re-establish its baseline, which can lead to false double-counting of forwarding data across overlapping periods. +- **Be patient.** The algorithm updates every three days. Give it at least two to three weeks to establish meaningful patterns before evaluating its performance. +- **Algorithm improvements are deployed server-side.** You do not need to upgrade `litd` to receive the latest version of the Autofees algorithm. Improvements are delivered through Terminal automatically. +- **Monitor the results.** Use the Insights and Forwards data we explored in the previous chapter to evaluate whether Autofees is improving your fee revenue and liquidity balance over time. + +### Summary + +In this chapter, we explored Autofees, Terminal's automated fee management feature. We learned that the algorithm establishes a 60-day baseline from your top-earning peers, compares recent traffic against that baseline, and makes small per-peer adjustments every three days. We examined the privacy architecture, including the dedicated LNC session with restricted permissions and the Privacy Mapper that obfuscates your node's identity. We configured the prerequisites (`rpcmiddleware.enable=true` and a high initial fee rate) and walked through the activation process in the Terminal UI. + +With Autofees running, your node can adapt to changing market conditions without constant manual intervention, freeing you to focus on higher-level strategy: choosing peers, managing liquidity through Loop, and expanding your routing capacity through Pool. These are exactly the topics we will cover in the chapters ahead. + +# Managing Your Node's Network +b6bc2556-170a-4992-8046-a8756d91a6b6 + +## Multi-Node Connections +9f6f9bf3-999e-4dad-9d2d-0b725178d754 + +![video](https://www.youtube.com/watch?v=SGY9h8JW4go) + +As your Lightning infrastructure grows, a natural question arises: how do we manage multiple nodes without juggling separate browser sessions, bookmarks, and login credentials for each one? Whether you are running a mainnet routing node alongside a testnet playground, maintaining redundant backups, or overseeing nodes for different organizations, the overhead of context-switching between isolated dashboards quickly becomes a bottleneck. -## Install & Connect -0fa71ff6-9b15-4e8b-8270-2ff7df465c11 +Lightning Terminal solves this with its **multi-node connection system**. In this chapter, we will explore how to generate connection strings for multiple nodes, onboard them into a single Terminal workspace, and switch between them instantly. The process is remarkably straightforward, but the security implications deserve careful attention. -![video](https://www.youtube.com/watch?v=XibPhZtNQak) +### Generating a Connection String -### Lightning Terminal Remote Mode Overview -Lightning Terminal (LitD) is a unified management stack for Lightning nodes, bundling Loop, Pool, Faraday, Taproot Assets, and optionally LND. It can run in **integrated mode** (shipping with LND) or **remote mode**, where it connects to an already-running LND instance. This chapter focuses on **remote mode**, ideal for maintaining an established node without reconfiguring your infrastructure. +The foundation of every Terminal connection is the **connection string**, a cryptographic pairing phrase generated by Lightning Node Connect (LNC). Because LNC works through outgoing connections to a web proxy, you do not need to open any ports on your firewall or modify your Tor configuration. The node reaches out to the proxy; the proxy never reaches in. -#### System Requirements & Preparation -LitD requires up‑to‑date development tools: -- Go 1.21.3+ -- Node.js 2.1.5+ -Verifying running services ensures compatibility—typically `bitcoind` and `lnd` are active, while `litd` is not yet present. Remote mode requires `rpcmiddleware.enable=true` in the LND config, enabling LitD to authenticate and communicate with LND. +You can generate connection strings through the LitD web interface, but the command line gives us more explicit control over the session parameters. Let's examine the `litcli` command that creates a new administrative session: -#### Repository Setup & Compilation -To install LitD from source: -1. Clone `lightning-terminal` from GitHub. -2. Checkout the latest stable release (e.g., `v0.12.2-alpha`). -3. Run `make install` to compile Go code, build UI assets, and install the binary. -Running `litd` confirms the installation is accessible system‑wide. +```bash +litcli --network=testnet sessions add --label="Routing-Node-East" --type=admin +``` -![LNP404](assets/en/001.webp) +Let's break down each parameter: -#### Configuring lit.conf -A dedicated data folder (usually `~/.lit`) stores configuration and node metadata. Inside it, a `lit.conf` file defines operation parameters: -- `lnd-mode=remote` -- `network=testnet` -- `remote.lnd.rpcserver=` -- `remote.lnd.macaroonpath=` -- `remote.lnd.tlspath=` -- `uipassword=` -- `httpslisten=0.0.0.0:8443` +- `--network=testnet` specifies the network this node operates on (use `mainnet` for production nodes). +- `sessions add` tells `litcli` to create a new LNC session. +- `--label="Routing-Node-East"` assigns a human-readable name that will appear in the Terminal dropdown, helping you distinguish nodes at a glance. +- `--type=admin` grants full administrative privileges over the node. For read-only monitoring, you could use `--type=readonly` instead. -These settings securely bind LitD to your pre‑existing LND instance and expose the HTTPS UI interface. +When you execute this command, `litcli` outputs a connection string. In other words, this string is the cryptographic key that authorizes Terminal to communicate with your node. It looks something like a long encoded phrase, and it is the only thing standing between an attacker and full administrative access to your channels and funds. -### Running LitD with systemd -Creating `/etc/systemd/system/litd.service` turns LitD into a managed background service. -Key entries: -- Start only **after LND** (`After=lnd.service`). -- `Restart=always` for resilience. -- Proper user permissions for file access. +**This point is critical**: treat every connection string with the same care you would give a private key. Never paste it into a public chat, never transmit it over an unencrypted channel, and never store it in plaintext alongside other credentials. Once you have used it to pair with Terminal, the string is consumed and cannot be reused, but until that moment, anyone who possesses it can connect. -Enabling the service ensures LitD autostarts on reboot and stays active like any other core system component. +### Connecting Your First Node -### Accessing the Terminal Interface -Once active, browse to: -``` -https://:8443 +With the connection string in hand, we navigate to the Terminal web interface and click the **Connect My Node** button. After pasting the string, Terminal prompts us to create a **session password**. This is a critical secondary security layer: even if someone gains access to the browser or device running Terminal, they cannot interact with your node without entering this password. + +In other words, the connection string authenticates the node-to-proxy link, while the session password protects the local browser session. Together, they form a two-factor model that keeps your node secure. + +Once the password is confirmed, Terminal establishes the encrypted connection. You will see your node's dashboard populate with its channels, balances, health checks, and routing data. At this point, the first node is fully onboarded. + +### Adding Additional Nodes + +To add a second (or third, or tenth) node, we follow the exact same procedure on the other machine. Let's say we have a second testnet node. We SSH into it and generate another connection string: + +```bash +litcli --network=testnet sessions add --label="L402-Fun-Node" --type=admin ``` -Expect browser warnings on testnet unless proper SSL certificates are configured. The UI password defined in `lit.conf` grants access. -![LNP404](assets/en/002.webp) +Back in the Terminal interface, we click **Add Node** in the header area, paste the new connection string, and set a password for this session. Terminal treats each connection independently, maintaining separate authentication tokens and session states. -Terminal supports: -1. **Local browser access** (direct LitD UI) -2. **Remote access** through terminal.lightning.engineering using **Lightning Node Connect (LNC)**. +After confirmation, both nodes are now available in your workspace. -LNC acts as an encrypted, mailbox‑mediated communication layer for secure remote management without exposing LND ports. Pairing occurs using a one‑time phrase generated by the UI or CLI. +### Context Switching Between Nodes -![LNP404](assets/en/003.webp) +Once multiple nodes are onboarded, the **node selector dropdown** in the Terminal header becomes your primary navigation tool. Clicking it reveals a list of all connected nodes, identified by the labels you assigned during session creation. -#### Command-Line Session Control -`litcli` enables advanced session administration: -- Create sessions (`litcli sessions add`) -- Specify types (admin, readonly, etc.) -- Label sessions for tracking -- Produce pairing strings for automation or remote setups +When you select a different node, the entire dashboard context refreshes instantly: -This is essential for multi‑admin environments or tooling that integrates with Terminal’s APIs. +- **Metrics update**: ROI, net profit, earned sats, and spent sats reflect the selected node's data. +- **Channel list refreshes**: you see only the peers and channels associated with the active node. +- **Tool state changes**: the Loop, Pool, and Autopilot interfaces update to show swaps, auctions, and fee configurations relevant to the currently selected node. -![LNP404](assets/en/004.webp) +This efficient switching mechanism allows operators to maintain situational awareness across their entire fleet. If you notice a liquidity imbalance on one node, you can address it immediately, then switch to another node to check on a pending channel opening, all without leaving the Terminal workspace. -#### Key Takeaways -- LitD remote mode lets you enhance an existing LND node with Loop, Pool, Faraday, and more **without modifying your LND installation**. -- Source installation ensures transparency and customization. -- Proper `lit.conf` and systemd integration make LitD production‑ready. -- Terminal + LNC provide secure, flexible local and remote node management. +### Summary +In this chapter, we saw how to generate LNC connection strings via `litcli`, onboard multiple nodes into a single Terminal session, and switch between them using the node selector dropdown. The key takeaway is that **multi-node management requires no additional infrastructure**: the same LNC protocol that secures a single connection scales seamlessly to many. In the next chapter, we will put these connected nodes to work by opening channels efficiently using batch transactions. -## Health Checks and Recommendations -ceb149b0-473b-4264-8bc3-b64ec8717aac -![video](https://www.youtube.com/watch?v=ZyZKFmKW_dU) +## Opening Channels & Batching +c7e83bd9-df1c-4763-8401-488b733d835c -### Understanding Lightning Terminal's Optimization Tools +![video](https://www.youtube.com/watch?v=VmvwM-zv2i0) -Lightning Terminal provides comprehensive tools for monitoring and optimizing your Lightning Network node's performance. This chapter explores the Health Checks feature and the Recommended Channels system, two essential components for maintaining a well-functioning routing node. While these features are currently available for mainnet nodes, understanding their principles and metrics will help you make informed decisions about your node's configuration and network participation. +Now that we can manage our nodes from a single interface, let's examine one of the most important operations any node operator performs: opening payment channels. More specifically, we will learn how to open multiple channels simultaneously using a single on-chain transaction, a feature called **batch opens**. -#### The Health Checks Framework +To understand why this matters, we first need to appreciate the cost structure of channel creation. -The Health Checks feature offers a systematic evaluation of your node's performance across six key metrics. When you access your node through Terminal's web interface, you'll find a summary at the top indicating whether your node passes all checks. For detailed analysis, navigate to the Explore tab and search for your node using its alias or public key. This displays your node's score along with comprehensive information including current capacity, node age, peer quality, and centrality measures. +### Why Batching Matters -![LNP404](assets/en/005.webp) +Every Lightning payment channel is anchored by an on-chain Bitcoin transaction. This transaction creates a **2-of-2 multisignature output** that locks funds cooperatively between you and your peer. Traditionally, if you wanted to open five channels, you would broadcast five separate transactions to the Bitcoin network, each one consuming its own inputs, paying its own mining fees, and occupying its own block space. -It's crucial to understand that Health Checks are designed primarily for routing nodes. These metrics evaluate how well your node can facilitate payments across the network, requiring consistent uptime, adequate channel capacity, and reliable peer connections. However, if your node specializes in sending or receiving payments rather than routing, you may not score highly on these checks, and that's perfectly acceptable. The key is aligning your node's configuration with its intended purpose. +This approach is wasteful for two reasons. First, each transaction carries overhead bytes for its inputs, signatures, and metadata, so you pay miner fees five times for work that could largely be consolidated. Second, if you are spending from a single large UTXO, each individual transaction produces a change output, fragmenting your wallet into progressively smaller pieces. Over time, this **UTXO fragmentation** leads to higher fees on future transactions because spending many small UTXOs requires more input data than spending one large one. -### Core Health Check Metrics +**Batch opens solve both problems at once.** By aggregating multiple channel openings into a single transaction, you consume one set of inputs, pay one mining fee (amortized across all channels), and produce a clean set of outputs: one per channel, plus a single change output returning the remainder to your wallet. -The six metrics evaluate different aspects of node performance: +In other words, if opening five channels individually might cost you 5,000 satoshis in total fees, batching them together might cost only 1,500 satoshis for the same result. The savings scale with the number of channels and the prevailing fee environment. -**Online Status**: The most fundamental check verifying your node is online. For routing nodes, consistent uptime is non-negotiable since you cannot facilitate payments when offline. +### Preparing for a Batch Open -**Channel Count**: Evaluates whether your node maintains sufficient active channels for effective routing. Approximately fourteen active channels demonstrates adequate connectivity for routing operations. +Before you begin, you need two things: -**Routing Capacity**: Examines whether channels have sufficient capacity in both directions to route payments successfully. A channel might exist but becomes less useful if balance is heavily skewed to one side. +1. **Sufficient on-chain funds** in your LND wallet to cover the total capacity of all channels plus the mining fee. +2. **The public keys** of the peers you want to connect with. You can find these through the Terminal Explorer tab, through Lightning network explorers like [1ML](https://1ml.com/) or [Amboss](https://amboss.space/), or by asking the node operator directly. -**Channel Health and Stability**: These metrics assess whether channels remain active with regular activity and maintain consistent uptime. The system specifically evaluates public channels, so private channels with lower activity won't negatively impact scores. +A public key (also called a **node identity key**) is a 66-character hexadecimal string that uniquely identifies a node on the Lightning Network. It looks something like this: -**Peer Quality**: Evaluates whether your public channels connect to other well-performing routing nodes. This recognizes that node effectiveness depends on both your performance and the quality of network connections. +``` +02e7a7d3c1e6055b7b7457d95e04d9bbd24f200fd4a58daca7beee7bc776e17440 +``` -### Leveraging Recommended Channels +### Walking Through the Batch Workflow -The Recommended Channels feature provides curated suggestions for new channel partners that benefit both your node and the broader Lightning Network. Access this feature from the channels tab to see potential peers with information including network rank, alias, centrality measures, and total capacity. +Let's open two channels simultaneously using the Terminal interface. Here is the step-by-step process: -![LNP404](assets/en/006.webp) +**Step 1: Initiate the first channel.** +Click the **Open Channel** button on the Terminal homepage. Paste the public key of your first target peer into the search field. Terminal validates that this node exists on the network and is reachable. -These recommendations serve dual purposes: identifying stable peers that would benefit from additional well-connected partners, and promoting network health by encouraging connections that decentralize routing paths and allocate capital where most needed. When you open a channel to a recommended node, you contribute to overall Lightning Network resilience and efficiency. +**Step 2: Set the channel capacity.** +Define how many satoshis you want to commit to this channel. For example, we might allocate 1,000,000 satoshis (0.01 BTC): -The recommended nodes represent carefully selected candidates based on performance history and network position. Click on any recommendation to view detailed information including activity duration, peer count, and specific Health Checks passed. This transparency allows informed decisions about channel partnerships that align with your node's strategy and capacity allocation goals. +``` +Channel capacity: 1,000,000 sats +``` -### Optimizing Your Node's Performance +This amount becomes the total capacity of the channel, initially sitting entirely on your side as outbound liquidity. -Regular monitoring of Health Check performance and thoughtful selection of new channel partners from the recommended list optimizes your node's effectiveness while supporting network growth. Understanding these tools empowers active management of your node's health and contribution to the Lightning Network's continued expansion and decentralization. +**Step 3: Configure fees and visibility.** +Terminal presents two important configuration options: -By leveraging both Health Checks for performance assessment and Recommended Channels for strategic growth, you can maintain a well-functioning node that serves both your operational goals and the broader network's needs. +- **Fee settings**: the base fee and fee rate that your node will charge for routing payments through this channel. You can accept the defaults or tune them based on your routing strategy. +- **Channel visibility**: choose between a public or a private channel. -## Insights, Forwards, and Channels -37799ff2-ca5a-4db4-aa21-fed5a5420be4 +**Public channels are broadcast** to the network graph, meaning any node can discover them and attempt to route payments through them. This is the standard choice for routing nodes that want to earn forwarding fees. -![video](https://www.youtube.com/watch?v=Mv7wMwnr-Sw) +**Private channels remain unannounced.** Only you and your direct peer know the channel exists. This is appropriate for mobile wallets, merchant terminals, or any situation where you want to send and receive without advertising your channel to the wider network. -### Financial Performance and Node Analytics +**Step 4: Add another channel to the batch.** +Here is where the magic happens. Instead of clicking "Submit," click **Add Channel**. This stacks a second channel into the same pending transaction. Paste the public key of your second peer, configure the capacity, fees, and visibility just as before. -Terminal Web serves as the primary command center for Lightning Network node operators, consolidating complex routing data into a streamlined financial interface. The dashboard’s homepage is anchored by four key performance indicators (KPIs) that provide an instant health check of the node's operations: **Return on Investment (ROI)**, **Net Profit**, **Earned Satoshis**, and **Spent Satoshis**. +You can repeat this step as many times as you need. Each additional channel adds minimal marginal cost to the transaction. -These metrics are dynamically calculated to offer a transparent view of profitability. "Spent Satoshis" aggregates all operational costs, such as on-chain transaction fees for opening and closing channels, as well as costs associated with rebalancing liquidity. Conversely, "Earned Satoshis" tracks the revenue generated from forwarding payments for other network participants. The platform automatically synthesizes these figures into a Net Profit value, while the ROI metric contextualizes this profit against the total capital locked in channels. +**Step 5: Set the mining fee and broadcast.** +Once all channels are queued, Terminal presents a final screen where you select the **mining fee rate** for the entire batch transaction. A higher fee rate means faster confirmation; a lower fee rate saves money but may take longer to confirm. Choose based on your urgency. -To support deeper analysis, the dashboard allows operators to adjust the timeframe of these metrics, enabling the isolation of specific periods to evaluate the impact of fee policy changes or market volatility. A dedicated Profit and Loss (P&L) breakdown feature itemizes revenue sources and expense categories, offering granular visibility into financial flows. For operators integrating with external accounting software or performing complex modeling, this data can be exported directly to CSV formats, bridging the gap between node management and traditional bookkeeping. +Click the **Batch Open Channels** button to broadcast the transaction. -### Routing Intelligence and Traffic Analysis +### Verifying on a Block Explorer -Beyond high-level financials, Terminal Web provides critical insights into the actual movement of funds through the node via its routing analysis tools. The **Top Routes** feature is essential for strategic optimization; it identifies the specific pathways and channel combinations that drive the majority of the node's forwarding volume. Recognizing these high-value routes allows operators to prioritize liquidity maintenance where it generates the most significant return. +After broadcasting, the channels enter a **pending confirmation** state while the transaction awaits confirmation. You can verify the batch structure by looking up the transaction on any block explorer. A properly executed batch transaction will show: -This analysis is segmented into "Top Outbound" and "Top Inbound" categories. This distinction helps operators understand the directionality of their traffic—identifying which peers are primarily sources of liquidity versus those that act as sinks. Understanding these flow patterns is crucial for preempting liquidity exhaustion on critical paths. Additionally, the dashboard maintains a comprehensive **Forwards Log**, which visualizes routing activity over time and provides a detailed history of individual forwarding events. Each entry logs the amount forwarded and the specific fee earned, creating an audit trail that is invaluable for troubleshooting failed routes or validating the effectiveness of fee adjustments. +- **Transaction inputs**: one or more UTXOs from your LND wallet. +- **Channel outputs**: multiple outputs of varying sizes (one per channel, each matching the capacity you specified). +- **Change output returned**: a single output returning the remaining funds to your wallet. -### Channel Management and Liquidity Visualization +For example, if you opened two channels of 1,000,000 sats each from a 5,000,000 sat UTXO, the transaction would show: -The Channels tab represents the operational core of Terminal Web, offering a detailed inventory of every peer connection. At the top level, it presents aggregate statistics, including the total count of active versus inactive channels and the node's overall inbound and outbound capacity. However, the most practical tool for daily operations is the **Liquidity Visualization**. +``` +Input: 5,000,000 sats (your UTXO) +Output: 1,000,000 sats (Channel 1 - 2-of-2 multisig) +Output: 1,000,000 sats (Channel 2 - 2-of-2 multisig) +Output: 2,999,500 sats (change back to your wallet, minus fees) +``` -![LNP404](assets/en/007.webp) +This confirms that both channels were funded from a single transaction, exactly as intended. -Rather than displaying raw numbers, Terminal Web utilizes visual bars to represent the balance distribution of each channel. This makes it immediately apparent which channels are "local-heavy" (full of outbound liquidity) or "remote-heavy" (full of inbound liquidity). This visual scan is far more efficient than parsing numerical tables, allowing operators to quickly identify channels that require rebalancing to maintain routing efficiency. +### Summary -#### Advanced Channel Actions -Terminal Web goes beyond passive monitoring by integrating actionable controls directly into the analytics interface. Each channel displays a calculated ROI—specifically for channels initiated by the local operator—comparing earned fees against the on-chain cost of opening the channel. This per-channel profitability metric is decisive when determining whether to keep a connection alive. From this same interface, operators can execute critical lifecycle actions: they can adjust fee policies to influence traffic flow or initiate channel closures for underperforming peers. The system also logs all channel lifecycle events—opens, cooperative closes, and force closes—providing a historical context that helps operators refine their peer selection strategy over time. +In this chapter, we learned that batch opens aggregate multiple channel openings into a single on-chain transaction, reducing fees and preventing UTXO fragmentation. We walked through the Terminal workflow for configuring each channel's capacity, fees, and visibility, then stacking them into one batch. In the next chapter, we will explore what happens after channels are open: how to manage their liquidity over time using Lightning Loop. -## Autofees -c6264c0b-10f6-4261-8d1e-47593168d8ca +## Lightning Loop +f2642efb-a485-4bc9-b571-d8e901e3e8b1 -![video](https://www.youtube.com/watch?v=wglBEUtXgTo) +![video](https://www.youtube.com/watch?v=kYlfHqQnpVM) -### Automating Channel Fees with Lightning Terminal +Now that we know how to open channels efficiently, we face the ongoing challenge that defines Lightning node operation: **liquidity management**. A channel does not stay balanced on its own. Every payment that flows through it shifts the balance, and over time, channels inevitably become lopsided. When all the funds sit on your side, you can send but cannot receive. When all the funds sit on your peer's side, you can receive but cannot send. Either way, the channel's utility drops significantly. -Managing a Lightning Network node involves a constant trade-off between liquidity and revenue. If fees are too high, traffic stops; if fees are too low, the node operator underprices their liquidity and drains their outbound capacity without sufficient compensation. Lightning Terminal’s **Auto-Fees** feature addresses this by automating fee adjustments. +The traditional solution was to close the unbalanced channel and open a new one, which is expensive and slow. **Lightning Loop** provides a far better alternative: it lets you rebalance channels without closing them, using a cryptographic technique called **submarine swaps**. -Instead of requiring the operator to manually tune channel policies daily, Auto-Fees employs an intelligent algorithm designed to stabilize routing traffic. The system dynamically adapts to changing market conditions, aiming to maximize fee revenue while maintaining a healthy flow of payments. This automation allows operators to move away from micromanagement and focus on high-level strategy, preventing the common issue of underpricing liquidity during periods of high demand. +In this chapter, we will explore Loop Out, Loop In, and the powerful Auto Loop automation system. -### Algorithmic Logic and Traffic Analysis +### Understanding Submarine Swaps -The Auto-Fees engine does not apply random adjustments; it operates on a comparative analysis of historical performance. When enabled, the system establishes a performance baseline by analyzing the forwarding traffic of the node’s **top five earning peers** over a roughly 60-day period. +Before we dive into the interface, let's take a moment to understand the mechanism that makes Loop possible. A **submarine swap** is an atomic exchange between on-chain Bitcoin and off-chain Lightning Bitcoin. "Atomic" means that either both sides of the swap complete, or neither does. There is no scenario where one party takes the money and disappears. -Once this baseline is established, the algorithm monitors forwarding activity from the immediate past (the last few days) and compares it against the historical trend. -* **Demand Surges:** If recent traffic exceeds the baseline, the algorithm may incrementally increase fees to capture more revenue from the high demand. -* **Demand Slumps:** If traffic drops below the baseline, the algorithm may lower fees to attract routing volume and re-establish flow. +The swap uses Hash Time-Locked Contracts (HTLCs) on both layers: -Crucially, this logic is applied on a **per-peer basis**. The system does not enforce a blanket policy across the entire node but rather tailors adjustments to the specific routing dynamics of each channel relationship. Despite this automation, the operator retains ultimate sovereignty; manual overrides are always possible, allowing the user to lock specific fees for strategic peers regardless of the algorithm’s suggestions. +1. One party creates a secret value (called the **preimage, or secret**) and shares only its hash. +2. An on-chain HTLC locks funds that can be claimed by revealing the preimage, or refunded after a timeout. +3. A Lightning HTLC locks funds on the other side, gated by the same hash. +4. When one party reveals the preimage to claim one side, the other party can use that same preimage to claim the other side. -### Privacy Architecture and Security +In other words, the swap is cryptographically bound so that both legs must settle together. This is what makes Loop **non-custodial and trustless**: the Loop server never takes custody of your funds. -A primary concern for node operators using automated tools is the security of their node credentials and the privacy of their routing data. Auto-Fees is architected to operate with the principle of least privilege using **Lightning Node Connect (LNC)**. +### Loop Out: Creating Inbound Liquidity -When Auto-Fees is activated, Terminal establishes a dedicated, isolated LNC session. This session is restricted by strict permissions: -* **Read Access:** Limited to forwarding history, channel balances, and current fee policies. -* **Write Access:** Strictly limited to updating fee policies. It cannot spend funds, close channels, or alter other node settings. +**Loop Out** is the operation you use when a channel is full on your side (high local balance, low remote balance). You can send payments through this channel, but you cannot receive them. To fix this, Loop Out moves funds from your Lightning channel to an on-chain address, freeing up space on the remote side. -To further protect operator data, LitD employs a **Privacy Mapper**. Before any data leaves the local node environment to be processed by the Auto-Fees logic, the Privacy Mapper obfuscates sensitive identifiers such as Channel IDs, Channel Points, and Node Public Keys. This ensures that the external logic can optimize the math without exposing the node’s specific identity or topology map to the central server. Operators can verify this obfuscation via the LitD command-line interface and revoke the session at any time. +Here is what happens step by step: -### Configuration and Activation +1. You initiate a Loop Out for a specified amount. +2. The Loop server creates an on-chain HTLC locked to a hash. +3. Your node routes a Lightning payment (locked to the same hash) to the Loop server through the target channel. +4. The Loop server reveals the preimage to claim the Lightning payment. +5. You use that preimage to sweep the on-chain HTLC to your Bitcoin address. -Implementing Auto-Fees requires specific node configurations to function correctly. The most critical prerequisite is enabling the RPC middleware in the `lnd.conf` file. Without setting `rpcmiddleware.enable=true`, the Terminal cannot intercept and modify the fee policies. +The net result: your Lightning channel now has more room on the remote side (inbound liquidity), and you received the equivalent amount on-chain. -**Recommended Baseline:** -Lightning Labs recommends setting a default `base_fee_msat` of approximately **2,500 millisatoshis** in the configuration. This specific value provides the algorithm with necessary "headroom"—a middle ground that allows the system flexibility to adjust fees both upward and downward as needed without hitting floor or ceiling constraints immediately. +**Using Loop Out in Terminal:** -**Enabling the Feature:** -Once the configuration is set, activation is handled via the Terminal UI: -1. Navigate to the **Loop** tab. -2. Select **Autopilot**. -3. Click **Enable**. +In the Terminal interface, navigate to the **Loop tab** in the header. You will see a list of your channels, and you can filter by those with **low inbound** balance. Select the channel you want to rebalance, then drag the slider to your desired target balance (for example, 50% for a roughly balanced channel). -The interface provides granular control, allowing operators to toggle Auto-Fees on or off for individual channels. This allows for a hybrid management style, where stable, high-volume channels are managed automatically, while experimental or strategic private channels remain under manual control. +Click the **Next button**, and Terminal presents the fee breakdown: -## Multi-Node Connections -9f6f9bf3-999e-4dad-9d2d-0b725178d754 +- **Loop service fee**: paid to the Loop server for facilitating the swap. +- **On-chain fees**: paid to miners for confirming the settlement transaction. +- **Lightning routing fees**: paid to intermediate nodes for routing the payment to the Loop server. -![video](https://www.youtube.com/watch?v=SGY9h8JW4go) +You also have access to **advanced options**, including the ability to specify a custom on-chain address where you want the funds delivered (instead of your LND wallet's default address). -### Unified Infrastructure Management +If the fees look acceptable, click the **Submit button** to execute the swap. -Lightning Terminal has evolved from a single-node utility into a comprehensive infrastructure management platform. The **Multi-Node Interface** enables operators to oversee distinct Lightning Network nodes—whether they are redundant backups, separate routing nodes, or nodes operating on different networks (e.g., Mainnet vs. Testnet)—from a single, unified dashboard. +**Via CLI:** -This architecture eliminates the friction of logging in and out of different browser sessions or managing multiple disparate URLs. The integration is designed to be lightweight yet robust; adding a new node does not dilute the functionality available. Whether an operator manages two nodes or a dozen, the full suite of Terminal tools—Loop for liquidity, Pool for leasing, and health monitoring—remains fully accessible for every specific instance connected to the workspace. +For operators who prefer the command line, you can also execute Loop Out directly: -### Generating Connection Credentials +```bash +loop out --channel 735057608151793668 --conf_target 250 \ + --label "rebalance-east-node" --max_swap_routing_fee 2500 \ + --addr bc1qvnfuf2zvg6mrfyjhc8h4c7ge9a7ywfrav52qru \ + --amt 1000000 +``` -The foundation of the multi-node setup is the **Connection String**. Because Terminal operates securely over Lightning Node Connect (LNC), it does not require opening ports on your firewall. Instead, each node must generate a unique, cryptographic pairing phrase that authorizes the Terminal interface to communicate with the Lightning Terminal Daemon (LitD). +Key parameters: -Operators can generate these strings via the LitD UI, but the Command Line Interface (CLI) offers granular control for power users. Using the `litcli` tool, an operator creates a session by defining specific parameters: -* **Network:** Specifies if the node is on `mainnet` or `testnet`. -* **Label:** Assigns a human-readable alias (e.g., "Routing-Node-East") to distinguish the node in the UI. -* **Type:** Defines the permission scope, typically set to "admin" for full management capabilities. +| Flag | Purpose | +|------|---------| +| `--channel` | Force the swap through a specific channel (by short channel ID) | +| `--conf_target` | Desired confirmation speed in blocks (higher = lower fee) | +| `--label` | Human-readable tag for identifying the swap later | +| `--max_swap_routing_fee` | Cap on Lightning routing fees in satoshis | +| `--addr` | Custom destination for the on-chain funds | +| `--amt` | The swap amount in satoshis | -#### Security Implications -The generated connection string contains the authentication data necessary to administer the node. It functions effectively as a private key for administrative access. Consequently, these strings must be handled with extreme care—never shared in public forums or transmitted over unencrypted channels. Possession of the string grants the holder the ability to manipulate the node's channels and funds through the Terminal interface. +You can check current minimum/maximum amounts and fee estimates before committing: -### The Connection Workflow and Context Switching +```bash +loop terms +loop quote out 1000000 +``` -Connecting the first node establishes the baseline workspace. The operator selects "Connect My Node" and pastes the generated connection string. Crucially, Terminal enforces a secondary security layer: **The Session Password**. Upon pasting the string, the user must define a local password. This ensures that even if the physical device running the browser is compromised, the active Terminal session cannot be used to interact with the node without this second factor of authentication. +### Loop In: Restoring Outbound Liquidity -Adding subsequent nodes follows an identical pattern via the "Add Node" option in the interface's header. Terminal treats each connection independently, maintaining separate authentication tokens and session states for each node. +**Loop In** serves the inverse function. Use it when a channel has been depleted on your side (low local balance, high remote balance), leaving you unable to send or route outgoing payments. -**Operational Context Switching:** -Once multiple nodes are onboarded, the **Node Selector** dropdown becomes the primary navigation tool. Switching between nodes is instantaneous. When a new node is selected, the entire dashboard context shifts. -* **Metrics Update:** ROI, net profit, and routing history immediately reflect the selected node's data. -* **Channel Management:** The channel list refreshes to show peers associated only with the active node. -* **Tool State:** Loop and Pool interfaces update to show swaps and auctions relevant to the currently selected entity. +In a Loop In, you send on-chain Bitcoin to the Loop server, and it sends you the equivalent amount over Lightning, pushing funds back to your side of the channel. -This efficient switching mechanism allows operators to maintain high-level situational awareness across their entire fleet, rapidly responding to liquidity imbalances or alerts on any specific node without leaving the command center. +**Before you begin**: unlike Loop Out, a Loop In requires that you hold sufficient **on-chain Bitcoin reserves**. If your LND wallet does not have enough funds, Terminal will alert you before proceeding. You may need to reduce the swap amount or deposit more on-chain Bitcoin first. -## Opening Channels & Batching -c7e83bd9-df1c-4763-8401-488b733d835c +**Using Loop In in Terminal:** -![video](https://www.youtube.com/watch?v=VmvwM-zv2i0) +Filter your channels by **low outbound** balance, select the target channel, and drag the slider to your desired balance. Click the **Next button** and choose the **One-time manual** loop option. -### The Economics of Batch Opens +An important setting here is the **confirmation target**. Since Loop In begins with an on-chain transaction, you can trade speed for cost: -In the Lightning Network, every payment channel is anchored by an on-chain Bitcoin transaction. Traditionally, establishing a robust node with multiple peers required a separate transaction for each channel. This approach is inefficient, consuming significant block space and incurring separate mining fees for every single connection. +- A **low confirmation target** (e.g., 3 blocks) means higher miner fees but faster liquidity availability. +- A **high confirmation target** (e.g., 100 blocks) means lower miner fees but a longer wait before the swap completes. -Lightning Terminal solves this with **Batch Opens**. This feature allows node operators to aggregate multiple channel openings into a single on-chain transaction. +Choose based on how urgently you need the outbound capacity. -The technical advantage is substantial. Instead of broadcasting five separate transactions to open five channels (paying overhead bytes for inputs and signatures five times), a batch open consumes a single UTXO (or set of UTXOs) and creates multiple outputs—one for each channel—within the same transaction envelope. This consolidation drastically reduces the cost per channel, making it a critical strategy for liquidity management during periods of high on-chain fee pressure. It also optimizes the node's UTXO set, preventing the fragmentation of wallet funds into "dust" outputs. +**Via CLI:** -### Configuring the Batch Workflow +```bash +loop in --last_hop 02e7a7d3c1e6055b7b7457d95e04d9bbd24f200fd4a58daca7beee7bc776e17440 \ + --amt 500000 +``` -The process begins in the Terminal dashboard via the **Open Channel** interface. To initiate a batch, the operator requires the public identity keys of the target peers. +The `--last_hop` flag is particularly useful: it specifies which peer should deliver the final Lightning payment, giving you precise control over which channel receives the new outbound capacity. -The workflow is iterative: -1. **Peer Identification:** Enter the Public Key of the first peer. Terminal validates the node's existence on the network. -2. **Capacity Allocation:** Define the channel size in satoshis. This determines the liquidity locked into that specific connection. -3. **Parameter Setup:** Configure initial routing fees (Base Fee and Fee Rate) and visibility settings (Public vs. Private). +### Auto Loop: Automated Liquidity Management -#### Channel Visibility and Fees -A critical decision point during configuration is the channel's visibility. **Public Channels** are broadcast to the network graph, enabling random nodes to route payments through them, generating fee revenue. **Private Channels** remain unannounced, visible only to the two direct peers. These are ideal for mobile wallets or merchant terminals that do not intend to route third-party traffic. Similarly, initial fee settings dictate the channel's competitiveness; while defaults are provided, experienced operators tune these metrics based on the specific peer's reliability and location in the network topology. +Manual loops are effective for spot adjustments, but high-volume routing nodes need continuous rebalancing. Executing loops by hand every time a channel drifts out of balance is neither scalable nor practical. This is where **Auto Loop** transforms liquidity management into a background service. -### Execution and On-Chain Verification +Auto Loop monitors your channel balances and **automatically dispatches swaps** when they breach configured thresholds. It operates at three hierarchical levels: -The true utility of the batch feature is the **"Add Channel"** function. Rather than finalizing the transaction after configuring one peer, the operator stacks additional peers into the same session. As new channels are added, the marginal cost of each addition is negligible compared to the base cost of the transaction. +1. **Node level**: balances the aggregate liquidity across your entire node. +2. **Peer level**: manages the total balance across all channels shared with a specific peer (useful when you have multiple channels with the same counterparty). +3. **Channel level**: micro-manages the liquidity of a single, high-priority channel. -Once the batch is fully assembled, the operator sets the **Mining Fee**. This fee pays the Bitcoin miners to confirm the aggregate transaction. Because this single fee is amortized across all new channels, the effective cost per channel drops significantly. +**Enabling Auto Loop in Terminal:** -**Verification:** -After the transaction is broadcast, the channels enter a "pending" state until confirmed. Verification can be performed via any block explorer. A properly executed batch transaction will display a distinct structure: -* **Inputs:** One or more UTXOs from the node's wallet. -* **Outputs:** Multiple outputs of equal or varying values (representing the funded channels). -* **Change Output:** A single output returning any remaining funds to the node's internal wallet. +In the Loop tab, select a channel and click the **Next button**. Instead of choosing "One-time manual," select the **Auto Loop** option. Terminal then presents the budget configuration: -This on-chain footprint confirms that the batch logic was executed correctly, locking funds into the 2-of-2 multisignature addresses required for the Lightning channels while maximizing capital efficiency. +**The budget system** is the safety mechanism that prevents Auto Loop from spending unlimited fees on your behalf. You configure: -## Lightning Loop -f2642efb-a485-4bc9-b571-d8e901e3e8b1 +- **Minimum loop size**: the threshold below which Auto Loop will not execute a swap (prevents tiny, fee-inefficient "dust" loops). +- **Maximum fee per swap**: a hard ceiling on what any individual swap can cost. +- **Total budget amount**: the maximum satoshis Auto Loop can spend on fees (service fees + on-chain fees + routing fees combined) within a given period. +- **Budget period**: how often the budget refreshes. Options include 1 day, 3 days, 7 days, 14 days, or 28 days. -![video](https://www.youtube.com/watch?v=kYlfHqQnpVM) +For example, you might configure: "I am willing to spend up to 50,000 satoshis in total fees every 7 days to keep this channel balanced." -### Liquidity Management with Loop Out +**Via CLI, the equivalent configuration looks like this:** -Terminal’s Loop feature is a specialized tool for managing Lightning Network liquidity, specifically designed to rebalance channels without the costly and time-consuming process of closing and reopening them. A healthy routing node requires balanced channels to facilitate traffic in both directions. When a channel becomes "lopsided"—holding all funds on one side—its utility drops significantly. +```bash +# Enable Autoloop +loop setparams --autoloop=true -**Loop Out** is the primary mechanism for acquiring **inbound liquidity**. This is necessary when a channel’s local balance is full, meaning the node can send payments but cannot receive them. +# Set a liquidity rule for a specific channel +loop setrule 735057608151793668 --incoming_threshold=25 --outgoing_threshold=25 -By executing a Loop Out, the operator sends funds via Lightning to the Loop server, which then returns an equivalent amount of Bitcoin to the operator's on-chain wallet. This effectively "empties" the local side of the channel, creating space to receive new payments. Terminal simplifies this with a visual slider interface; operators drag the slider to the desired target balance (e.g., 50%), and the system calculates the required swap amount. +# Configure the budget: 100,000 sats refreshing every 7 days +loop setparams --autobudget=100000 --autobudgetrefreshperiod=604800s -**Cost Considerations:** -Operators must account for three distinct fee components: -1. **Service Fee:** Paid to the Loop provider. -2. **Routing Fees:** Paid to the network to route the payment to the Loop server. -3. **Miner Fees:** Paid to confirm the on-chain settlement transaction. +# Set fee limits +loop setparams --sweepconf=250 --maxswapfee=1 --maxroutingfee=1 +``` -### Refilling Capacity with Loop In +The `--incoming_threshold` and `--outgoing_threshold` parameters define the minimum percentage of channel capacity that must remain as inbound and outbound liquidity, respectively. When either side falls below its threshold, Auto Loop triggers a swap to restore the balance. -**Loop In** serves the inverse function. It is utilized when a channel has been depleted of local funds (high remote balance), leaving the node unable to route outgoing payments. To fix this, the operator pushes on-chain Bitcoin into the channel, converting it into off-chain Lightning liquidity. +**Monitoring Auto Loop:** -**Prerequisites and Timing:** -Unlike Loop Out, a Loop In operation requires the operator to hold sufficient *on-chain* Bitcoin reserves. The Terminal interface validates wallet balances in real-time before authorizing the swap. +Once active, the Autopilot dashboard (accessible via the **Autopilot toggle** button at the top of the Loop tab) shows you: -A critical variable in Loop In operations is the **Confirmation Target**. Since the operation relies on an initial on-chain transaction, the operator can choose between speed and cost. -* **Low Confirmation Target:** Higher miner fees, faster liquidity availability. -* **High Confirmation Target:** Lower miner fees, slower settlement. +- Whether Auto Loop is currently active or paused. +- How many loops have been performed recently. +- The current budget consumption. +- A history of all automated swaps. -This flexibility allows operators to prioritize urgent liquidity needs or optimize for cost savings during periods of low network congestion. +You can **pause Auto Loop at any time** without losing your configuration. You can also adjust the budget, fee limits, or thresholds on the fly. Just remember to click the **Save button** after making changes. -### Automated Liquidity via Auto Loop +A useful CLI command for debugging is `loop suggestswaps`, which shows what Auto Loop *would* dispatch without actually executing anything: -While manual loops are useful for spot-adjustments, high-volume nodes require constant maintenance. **Auto Loop** transforms this manual process into a set-and-forget background service. It utilizes the "Autopilot" engine to monitor channel balances and execute swaps automatically when specific thresholds are breached. +```bash +loop suggestswaps +``` -Auto Loop operates at three hierarchical levels: -* **Node Level:** Balances the aggregate liquidity of the entire node. -* **Peer Level:** Manages the total balance across all channels shared with a specific peer. -* **Channel Level:** Micro-manages the liquidity of a single, high-priority channel. +This is essentially a dry run that lets you verify your rules and budgets are configured correctly before enabling automation. -#### The Budget System -To prevent runaway costs, Auto Loop is governed by a strict **Budget System**. Operators define a `Total Budget` that caps the amount of fees the system can spend within a specific cycle (e.g., Daily, Weekly, or Monthly). +**Please note**: Autoloop parameters are **not persisted across restarts** of the `loopd` daemon. If you restart your node, you will need to reconfigure your Autoloop settings. -Additionally, specific constraints ensure efficiency: -* **Minimum Loop Size:** Prevents the system from executing "dust" loops that are eaten up by fees. -* **Maximum Fee:** Establishes a hard ceiling on the cost of any individual swap. +### Summary -The Autopilot dashboard provides a live view of these operations, allowing operators to pause the service during volatile market conditions or adjust budgets as their node's revenue grows. +In this chapter, we explored the three modes of Lightning Loop: manual Loop Out (to create inbound liquidity), manual Loop In (to restore outbound liquidity), and Auto Loop (to automate the entire process). The underlying mechanism, submarine swaps, ensures that all operations are trustless and non-custodial. The budget system gives you precise control over costs, and the three-tier hierarchy (node, peer, channel) lets you tailor your liquidity strategy to your specific needs. In the next chapter, we will look at how to evaluate the peers you are connected to using Terminal's Peer Insights feature. ## Peer Insights 27d09714-6496-4451-bb08-1927e0148d1e ![video](https://www.youtube.com/watch?v=4x1V_G_DlKo) -### Peer Insights: Network Intelligence +Up to this point, we have learned how to connect nodes, open channels efficiently, and manage liquidity. But there is a question we have not yet addressed: how do we evaluate whether a particular peer is worth connecting to, and how do we measure the value of our existing relationships? Making good peering decisions is one of the most consequential aspects of running a routing node, because **the quality of your peers directly determines the quality of your routing**. + +Lightning Terminal's **Peer Insights** feature, available in the Explorer tab, provides the intelligence layer we need to make these decisions. It operates on two tiers: general reconnaissance data available for any public node on the network, and detailed performance analytics available only for nodes with whom you already share a channel. + +### The Explorer Tab -Lightning Terminal’s **Peer Insights** is a robust intelligence layer integrated directly into the Explorer tab. It is designed to move node operators beyond basic connectivity metrics (like capacity and channel count) toward a deeper understanding of network behavior and peer value. +When you navigate to the **Explorer tab** with a node connected to Terminal, you see a ranked list of top-performing nodes on the network. This list goes beyond simple capacity rankings. Terminal augments each entry with contextual badges, small visual indicators that surface useful information at a glance. -The feature operates on a tiered information architecture. At the base level, it provides general reconnaissance data for any node on the public network, useful for scouting potential partners. At the advanced level, it unlocks detailed performance analytics for nodes with whom you already maintain open channels. This dual capability allows operators to assess the "reputation" and strategic value of a peer before opening a channel, and then monitor the actual ROI of that relationship over time. +For example, you might see a badge indicating that a node has **open liquidity orders** in the Pool marketplace (we will explore Pool in a later chapter). Another badge might tell you that a particular node is already **your peer**, meaning you have at least one channel open with them. -### Visual Indicators and Network Scouting +Each node entry also displays key metrics: -The primary interface for Peer Insights is the **Explorer Tab**. This dashboard presents a ranked list of top-performing nodes, but augments this list with contextual "badges" or visual indicators overlaid on the node entries. +- **Total channel capacity**: the total Bitcoin locked in the node's channels. +- **Node age on network**: how long the node has been active on the network. +- **Number of peers**: how many other nodes it is connected to. +- **Centrality score**: a measure of how critical this node is to the overall network topology. A high centrality score means many shortest paths between other nodes pass through this one, making it an important routing hub. +- **Health check status**: whether the node passes Terminal's six health checks. -These indicators allow for rapid scanning of the network landscape. For example, specific badges highlight whether a node has open liquidity orders in the Pool marketplace or if it is currently connected to your node. -* **Health Check:** Instantly communicates operational uptime and reliability. -* **Centrality Score:** Indicates how critical that node is to the overall network topology. -* **Capacity & Age:** Establishes the scale and longevity of the node’s operations. +These metrics allow you to quickly scan for stable, well-connected candidates before committing capital to a new channel. -By filtering through these metrics, an operator can quickly identify stable, high-capacity nodes that are actively seeking liquidity, making them ideal candidates for new channel openings. +### Searching for a Specific Node -### Analyzing Fee Strategies +Beyond browsing the ranked list, you can search for any node on the network by pasting its public key into the search field: -One of the most sophisticated tools within Peer Insights is the **Fee Distribution Graph**. This visualization decompresses the complex fee policies of a target node across its entire channel portfolio. +``` +02e7a7d3c1e6055b7b7457d95e04d9bbd24f200fd4a58daca7beee7bc776e17440 +``` + +Terminal will pull up a detailed profile for that node, displaying its capacity, age, peer count, centrality, and health check results. This is useful when someone recommends a peer or when you want to evaluate a node before opening a channel with it. + +### The Fee Distribution Graph + +One of the most powerful analytical tools in Peer Insights is the **fee distribution graph**. This visualization shows you how a node has priced its channels, giving you a window into its routing philosophy. The graph uses a dual-axis design: -* **Horizontal Axis:** Represents fee rates (parts per million or ppm). -* **Vertical Axis:** Represents the number of channels. -* **Split View:** Inbound fees are plotted above the axis; outbound fees are plotted below. -This visual clustering reveals the peer's routing philosophy. For example, if a node has a tight cluster of channels priced at 100ppm but a few outliers at 1000ppm, it suggests a tiered strategy where scarce liquidity is priced at a premium. Conversely, a flat distribution suggests a "set-and-forget" passive management style. Understanding these patterns is crucial when setting your own fees; pricing your channel competitively against a peer's existing connections ensures your node remains an attractive hop for routing. +- **Horizontal axis (x)**: fee rates, from low on the left to high on the right. +- **Vertical axis (y)**: the number of channels. +- **Split view**: the upper portion shows **inbound fee distribution**, and the lower portion shows **outbound fee distribution**. + +Each bar on the graph represents a group of channels clustered at a similar fee rate. By hovering over a bar, you can see exactly how many channels fall within that fee range. + +Let's say you are examining a node with 16 channels. The graph might show: + +- 15 channels with outbound fee rates clustered between 660 and 1,000 ppm (parts per million). +- 1 channel with a significantly lower outbound fee. +- 5 channels with low inbound fees, 6 with moderate inbound fees, 2 with higher inbound fees, and 3 outliers with very high inbound fees. + +What does this tell us? The tight clustering of outbound fees suggests this operator actively manages their fee policy and has settled on a consistent strategy for most channels. The single low-fee outlier might be a strategic channel to a high-volume peer where the operator is willing to accept lower margins for reliable throughput. The spread in inbound fees suggests different peers have set different inbound rates on their end of the channels. + +**Why this matters for you**: if you are about to open a channel with this node, the fee distribution graph helps you set competitive fees. If most of their outbound channels are priced at 800 ppm, and you set yours at 2,000 ppm, routing algorithms will likely prefer cheaper paths and your channel may see little traffic. Conversely, if you set your fees too low, you might attract more traffic than you can sustain, depleting your channel quickly. + +This data is available for **any public node on the network**, not just your peers. It is all derived from the public network graph. ### Peer-Specific Performance Analytics -For existing partners, Peer Insights unlocks a granular history of the relationship. While general network explorers can only guess at routing volume, Terminal leverages your node's local data to display exact interaction metrics. +For nodes with whom you already share a channel, Peer Insights unlocks an additional layer of data: your actual interaction history. While the fee distribution graph shows public information anyone can see, **performance analytics draw from your node's private forwarding data** to show the real value of the relationship. Key metrics include: -* **Forwarding Events:** The total count of payments routed through this specific peer. -* **Volume Routed:** The cumulative amount of satoshis moved. -* **Fees Earned:** The direct revenue generated by this relationship. -This data transforms abstract channel management into evidence-based strategy. If a channel has high capacity but zero forwarding events over a month, the analytics will make this inefficiency obvious, signaling a need for fee adjustment or channel closure. Conversely, high-volume, low-fee peers can be identified as candidates for fee increases. By centralizing this data, Peer Insights allows operators to treat their node not just as a piece of software, but as a portfolio of financial assets that requires active optimization. +- **Number of channels**: how many channels you share with this peer. +- **Total forwards**: the count of payments that have been routed through your shared channels. +- **Volume routed**: the cumulative amount of satoshis that have flowed through the connection. +- **Fees earned**: the direct revenue this peer relationship has generated for your node. + +For instance, you might discover that a peer with whom you have a single channel has routed 1,400,000 satoshis across just 3 forwarding events, earning you 136.5 satoshis in fees. That is useful context: a small number of forwards, but each one carrying significant volume. + +This data transforms abstract channel management into **evidence-based decision making**. Consider these scenarios: + +- A channel has high capacity but zero forwarding events over the past month. The analytics make this inefficiency obvious, signaling that you should either adjust fees, close the channel, or investigate why traffic is avoiding this route. +- A channel shows consistently high volume and steady fee earnings. This peer is valuable, and you might consider opening an additional channel to increase capacity, or you might raise fees slightly to capture more revenue without discouraging traffic. +- A peer generates high volume but at very low fees. You can evaluate whether the revenue justifies the capital locked in the channel, or whether that capital would earn more deployed elsewhere. + +### Putting It All Together + +Peer Insights brings together three layers of intelligence: + +1. **Network-wide scouting** (Explorer tab rankings, badges, health checks) for discovering potential new peers. +2. **Fee analysis** (the fee distribution graph) for understanding a node's pricing strategy before and after you connect. +3. **Relationship analytics** (forwarding events, volume, earnings) for measuring the real return on each channel. + +Together, these tools allow you to treat your node not just as a piece of software, but as a portfolio of financial relationships that require active monitoring and optimization. The best routing nodes are not simply the ones with the most channels or the most capacity; they are the ones whose operators make informed decisions about where to deploy their capital, informed by exactly the kind of data that Peer Insights provides. + +### Summary + +In this chapter, we explored the Peer Insights feature in Terminal's Explorer tab. We learned how to scout potential peers using capacity, centrality, and health check data; how to analyze a node's fee strategy using the fee distribution graph; and how to evaluate existing peer relationships using forwarding metrics. These tools give you the intelligence foundation for making sound channel management decisions. In the next part of the course, we will continue building on these skills by examining liquidity reports and advanced node accounting. # Last Steps 2e886890-62f7-4453-9c6f-9b397a280b75 @@ -400,133 +1138,534 @@ This data transforms abstract channel management into evidence-based strategy. I ![video](https://www.youtube.com/watch?v=7ga-8AhCNK4) -### Visualizing Liquidity Health +### Why Liquidity Visibility Matters + +Throughout this course, we have explored many facets of Lightning node management: health checks, fee automation, channel opening strategies, and submarine swaps. All of these tools share one underlying concern, the management of liquidity. Now, let us turn to a feature that synthesizes this concern into a single diagnostic view. + +The fundamental challenge of **liquidity management on the Lightning Network** is that failure is silent. When your node lacks sufficient capacity in the right direction, payments do not fail with a loud error on your side. They simply route around you. The senders find alternative paths, and you, the operator, never see the revenue that could have been yours. In other words, the most costly liquidity problems are the ones you do not know you have. + +Lightning Terminal addresses this with the **Liquidity Report**, accessible from the main dashboard. This tool provides a comprehensive visualization of your node's ability to receive, send, and route payments of various sizes. If you are not already very familiar with the concepts of inbound and outbound liquidity, I recommend reviewing the [Lightning Labs documentation on understanding liquidity](https://docs.lightning.engineering) before continuing, as this chapter builds directly on those fundamentals. + +### The Routable Liquidity Chart -Managing liquidity is arguably the most complex aspect of running a Lightning node because failure is often silent. Unlike a crashed server or a rejected transaction, poor liquidity manifests as "invisible" problems—payments that simply route around your node because they cannot find a path, leaving you unaware of the lost revenue. +The primary instrument in the Liquidity Report is the **Routable Liquidity Chart**. This chart breaks your node's total capacity into its two critical components: -Lightning Terminal addresses this with the **Liquidity Report**, accessible via the **Loop** tab. This tool provides a diagnostic visualization of your node's ability to route payments and receive funds. +- **Inbound liquidity**: the funds sitting on the remote side of your channels, representing your ability to receive payments. +- **Outbound liquidity**: the funds sitting on your local side, representing your ability to send payments or initiate the first hop of a routed payment. -The primary tool here is the **Routable Liquidity Chart**. It breaks down capacity into its two critical components: -* **Inbound Liquidity:** The ability to receive funds (remote balance). -* **Outbound Liquidity:** The ability to send funds (local balance). +The chart offers two viewing modes. The **Cumulative View** aggregates all your channels into a single ratio, letting you assess the overall balance at a glance. For instance, you might immediately see that your node is heavily skewed toward inbound capacity, with relatively little outbound. Whether this distribution is desirable depends entirely on your use case: a merchant receiving payments benefits from strong inbound liquidity, while a routing node needs a healthy balance of both. -The chart offers two viewing modes to help operators assess their standing. The **Cumulative View** provides a high-level ratio assessment, useful for quickly spotting gross imbalances (e.g., a node that is 90% outbound and only 10% inbound). The **Detailed View** breaks this data down by individual channels, allowing for specific troubleshooting. +The **Detailed View** breaks the same data down by individual channels. This is where you begin to identify specific channels that may need rebalancing, either through manual intervention or through the Loop operations we covered earlier in the course. -### Simulating Payment Scenarios +I recommend visiting the Liquidity Report regularly. Because silent liquidity problems accumulate gradually (a channel slowly depleting over weeks, for example), periodic review is the most reliable way to catch issues before they become costly. -Liquidity is not static; it behaves differently depending on the size of the payment being routed. A node might be perfectly capable of routing a 1,000 satoshi micropayment but completely fail to route a 5,000,000 satoshi transaction. The Liquidity Report includes a **Simulation Engine** to test these variances. +### The Simulation Engine -Operators can toggle between three preset payment sizes: **500k sats**, **5M sats**, and **15M sats**. -As you adjust these settings, the dashboard dynamically updates two key metrics: -1. **Routable Liquidity Chart:** Visually demonstrates which channels "drop off" and become unusable as the payment size increases. -2. **Estimated Last Hop Fee:** Projects the cost for an external user to route a payment of that specific size to your node. +Liquidity is not a static property. A node that routes a 500,000 satoshi payment with ease might completely fail when confronted with a 15,000,000 satoshi transaction. The capacity exists in aggregate, but no single channel may be large enough to carry the larger payment. -This feature is critical for capacity planning. It helps operators identify "bottleneck" channels that appear healthy on the surface but lack the depth required to handle larger, higher-fee transactions. +To help operators reason about this, the Liquidity Report includes a **simulation engine** with three preset payment sizes: -### Analyzing Performance by Fee Rate +- `500,000 sats` +- `5,000,000 sats` +- `15,000,000 sats` -Beyond raw capacity, the report analyzes liquidity through the lens of **Fee Rates**. The **Routable Inbound Chart** plots your channels along an X-axis representing fee rates (parts per million), while the Y-axis displays channel density. +As you toggle between these settings, two elements of the dashboard update dynamically: -This dual-perspective chart (Channel Count vs. Percentage) reveals the "quality" of your routing options. It helps answer specific strategic questions: -* **Availability:** Do I have inbound liquidity available at low fee rates, or is my capacity expensive to access? -* **Dead Zones:** Are there fee ranges where I have zero routable capacity? +1. **The Routable Liquidity Chart** adjusts to show which channels remain viable at each payment size. Channels that lack sufficient depth simply disappear from the visualization, making bottlenecks immediately visible. +2. **The Estimated Last Hop Fee** recalculates to project what it would cost an external sender to route a payment of that size through your node. -#### Identifying Hidden Issues -The ultimate goal of these reports is to detect **Systematic Inefficiencies**. For example, the chart might reveal that while you have ample total liquidity, it is all concentrated in high-fee channels that the network routing algorithms ignore for standard payments. Alternatively, it might show that your low-fee channels are constantly depleted. +This simulation capability is essential for capacity planning. If you expect your node to handle large-value payments (perhaps because you serve as a routing hub for business clients), you can verify that you actually have channels deep enough to support those transactions. If the chart goes blank at `5,000,000 sats`, you know exactly where to focus your next channel opening or Loop operation. -By correlating payment sizes with fee rates, the Liquidity Report transforms node management from a reactive process (fixing stuck channels) to a proactive strategy. It allows the operator to rebalance channels specifically to fill the gaps in their routing profile, capturing the fee revenue that was previously bypassing their node entirely. +### Analyzing Routing Quality by Fee Rate + +Beyond raw capacity, the Liquidity Report analyzes your channels through the lens of fee rates. The **Routable Inbound Chart**, located below the main liquidity visualization, plots your channels along two axes: + +- **X-axis**: the fee rate (in parts per million) associated with each channel. +- **Y-axis**: two perspectives are available. The **Channel Count** view shows how many channels fall into each fee range, while the **Channel Percentage** view shows the proportion of your total routing capacity available at each fee rate. + +This dual-perspective chart reveals the quality of your routing options, not just the quantity. It helps you answer specific strategic questions: + +- **Do I have inbound liquidity at competitive fee rates?** If all your capacity is concentrated in high-fee channels, the network's routing algorithms may consistently bypass you in favor of cheaper paths. +- **Are there dead zones in my fee distribution?** The chart may highlight fee ranges where you have zero routable capacity, marked with an attention indicator for channels that need intervention. + +Watch how this chart changes as you adjust the simulated payment size. You may discover that your node handles small payments across many fee ranges, but only a handful of channels can support medium or large payments. This insight allows you to rebalance or open new channels specifically to fill the gaps in your routing profile. + +### Summary + +The Liquidity Report transforms node management from a reactive process (fixing problems after they manifest) into a proactive strategy. By combining the routable liquidity visualization, the payment size simulation engine, and the fee rate analysis chart, you gain the ability to detect silent inefficiencies and address them before they cost you revenue. As we will see in the next chapter, this kind of granular control extends even further when we introduce virtual accounts on top of your node. ## LND Accounts 0d31ef81-4e77-4c5e-adc5-081df64c27ec ![video](https://www.youtube.com/watch?v=G1rv9dZQO5o) -### LND Accounts: Virtual Off-Chain Infrastructure +### The Problem of Shared Access + +Now that we understand how to monitor and optimize a node's liquidity, let us examine a different operational challenge: sharing that node's capabilities with multiple users or applications. + +In a typical LND deployment, any application that connects to the node receives broad access to its full balance and channel infrastructure. A mobile wallet, a tipping bot, and a merchant point-of-sale system might all authenticate with the same administrative macaroon. If any one of these applications is compromised, the attacker gains access to everything. This is a fragile security model, and it becomes increasingly dangerous as more services depend on a single node. + +Lightning Terminal solves this with a feature called **LND Accounts**. These are **virtual off-chain accounts** layered on top of a single LND node, each with its own authentication token, spending limits, and permission scope. Let us explore how they work and why they matter. + +### Understanding the Architecture + +It is crucial to understand what an LND Account is and, equally important, what it is not. An LND Account does not possess its own on-chain wallet, its own Lightning channels, or its own private keys. All cryptographic key management and liquidity remain under the control of the host LND node. The "account" is a logic layer: a virtual partition that tracks a balance and enforces access rules. + +In other words, the host node operator retains full custody of the underlying funds. The account holder enters a trust relationship with the node operator regarding the availability of those funds. This is, by design, a custodial arrangement at the account level. The operator manages the real channels and liquidity; the account holder operates within a sandboxed environment defined by the operator. + +This architecture is powered by the **RPC Middleware Interceptor**, which intercepts every API call made with an account macaroon and filters the responses accordingly. When an account holder queries their balance, for example, they see only their virtual allocation, not the node's full channel balance. On-chain balance always returns `0`. The channel list returns empty. Payment and invoice histories are filtered to show only transactions belonging to that specific account. + +### Security Through Segregation + +The primary value of LND Accounts is **risk containment through resource segregation**. Each account operates as a distinct, sandboxed environment with three layers of constraint: -Lightning Terminal (LitD) introduces a powerful primitive known as **LND Accounts**. These are virtual, off-chain accounts layered on top of a single Lightning Network Daemon (LND) node. Unlike independent nodes that manage their own channels and private keys, LND Accounts function as partitioned entities within the host node's existing infrastructure. +- **Granular permissions**: each account operates under a specific **macaroon authentication token** (native to LND) with restricted permission scopes. The standard account macaroon includes permissions like `info:read`, `invoices:read`, `invoices:write`, `offchain:read`, `offchain:write`, and `onchain:read`. +- **Budget allocations**: operators assign a strict spending limit in satoshis. Even if the connected application attempts to spend more, LND rejects the request at the protocol level. +- **Expiration enforcement**: accounts can be configured with time-limited validity (for example, 90 days). Once the expiration passes, the account's connection string ceases to function, preventing "zombie" permissions from becoming long-term vulnerabilities. -It is crucial to understand the architectural distinction: an LND Account does not possess its own on-chain wallet or Lightning channels. Instead, the primary LND node retains custody of all cryptographic keys and manages the underlying liquidity. The "account" is essentially a logic layer that tracks a virtual balance and enforces specific access rules managed by the host. This design allows operators to share their node's liquidity and connectivity with multiple users or applications without fragmenting the node’s capital or spinning up redundant infrastructure. +This layered model reduces what security professionals call the "blast radius" of a breach. If a specific account credential is stolen, the attacker is limited strictly to that account's remaining budget and permissions. The core node, other accounts, and the underlying channel infrastructure remain untouched. -### Security Architecture and Resource Segregation +### Creating an Account via the Terminal UI -The primary value proposition of LND Accounts is **Risk Containment** via segregation. In a standard deployment, connecting multiple applications (e.g., a mobile wallet, a tipping bot, and a merchant store) to a single LND node often grants them broad access to the node’s full balance. If one application is compromised, the entire node's funds are at risk. +Let us walk through the practical workflow for creating an LND Account using the Lightning Terminal web interface. We will use the **Lightning Node Connect** tab, which handles both standard connections and custodial account creation. -LND Accounts solve this by creating distinct, sandboxed environments for each application. -* **Granular Permissions:** Each account operates under a specific macaroon (authentication token) with restricted scopes. -* **Budget Allocations:** Operators can assign strict spending limits (e.g., 100,000 sats). Even if the application tries to spend more, the LND node will reject the request at the protocol level. -* **Expiration Enforcement:** Accounts can be configured with time-locks (e.g., 90 days), ensuring that temporary access grants automatically expire, preventing "zombie" permissions from becoming long-term vulnerabilities. +1. Navigate to the **Lightning Node Connect** tab in the LitD UI. +2. Click **Create a new session** and assign it a descriptive name (for example, `AccountsDemo`). +3. Under **Permission Types**, select **Custom Type** rather than a standard admin or read-only preset. +4. In the permissions panel, select **Custodial Account**. Notice that this selection reveals additional fields: a **balance allocation** (the spending limit in satoshis) and an **expiration date**. +5. Define the budget and expiration (for example, 100,000 sats with a 90-day expiry). +6. Click the **Submit button**. -This layered security model reduces the "blast radius" of a security breach. If a specific account credential is stolen, the attacker is limited strictly to that account's remaining budget and permissions, leaving the core node and other accounts untouched. +The system generates a **Lightning Node Connect pairing phrase** (and optionally a QR code) that encapsulates the account's connection credentials. This pairing phrase can be shared with the intended user or application. -### Configuration and Connection Workflow +**Important to note**: custodial accounts created this way connect exclusively through Lightning Node Connect. They cannot be used with the Terminal web interface directly; they are designed for wallet applications, browser extensions, or custom integrations. -Creating and managing these accounts is handled directly through the Lightning Terminal interface, specifically under the **Lightning Node Connect (LNC)** tab. +### Creating an Account via the CLI -The workflow moves beyond simple connection strings into **Custodial Account** configuration: -1. **Session Initialization:** The operator starts by creating a new session and selecting "Custom" permissions rather than a standard admin access level. -2. **Parameter Definition:** The interface prompts for critical constraints. The operator defines the **Balance Allocation** (the spending limit in satoshis) and the **Expiration Date**. -3. **Generation:** The system generates a proprietary connection string (pairing phrase) or QR code. +For operators who prefer command-line workflows, accounts can also be created using `litcli`: -**Connectivity:** -These accounts connect via **Lightning Node Connect (LNC)**. This protocol establishes an encrypted, end-to-end connection between the user (or application) and the node without requiring the operator to open ports on their router or expose their IP address. +```bash +litcli accounts create 50000 --save_to /tmp/user.macaroon +``` + +This command creates an account with a 50,000 satoshi budget and saves the corresponding macaroon to the specified path. You can then inspect the macaroon to verify its permissions: + +```bash +lncli printmacaroon --macaroon_file /tmp/user.macaroon +``` + +To list all existing accounts and their IDs: + +```bash +litcli accounts list +``` + +If you need to create an LNC session specifically tied to an account: + +```bash +litcli sessions add --label pointofsale --type account --account_id d64dbc31b28edf66 +``` + +And to test the account by querying the channel balance through its restricted macaroon: + +```bash +lncli --macaroonpath=/tmp/user.macaroon channelbalance +``` + +If a macaroon is lost but the account still exists, it can be reconstructed by baking a new base macaroon and adding the account-specific caveat: + +```bash +lncli bakemacaroon info:read invoices:read invoices:write offchain:read offchain:write onchain:read peers:read --save_to tmp.macaroon +lncli constrainmacaroon --custom_caveat_name account --custom_caveat_condition tmp.macaroon accounts.macaroon +rm tmp.macaroon +``` -**Practical Use Cases:** -This functionality is ideal for onboarding trusted peers or testing environments. For example, a node operator can create an account for a friend to experiment with Lightning payments. The friend downloads a compatible wallet, scans the QR code, and immediately has access to the Lightning Network using the operator's liquidity, but is strictly limited to the funds allocated in the virtual account. Similarly, developers can spin up separate accounts for different microservices, ensuring that a bug in one service cannot drain the wallet of another. +### Practical Use Cases + +This functionality opens several practical scenarios: + +- **Onboarding friends or family**: a node operator creates an account with a modest budget and shares the QR code. The recipient downloads a compatible wallet (such as Zeus), scans the code, and immediately has access to the Lightning Network using the operator's liquidity, without needing to manage channels or understand the underlying infrastructure. +- **Application isolation**: a developer running multiple microservices against a single node can create separate accounts for each service. A bug in one service cannot drain the wallet of another. +- **Enhanced security model**: when multiple applications connect to a single LND node, each receives its own constrained account rather than sharing a single administrative macaroon. Application A has its own permissions and budget; Application B has its own permissions and budget. A compromise of one does not affect the other. + +### Summary + +LND Accounts extend the capabilities of a single Lightning node by introducing **virtual off-chain partitions** with isolated budgets, permissions, and expiration policies. Whether configured through the Terminal UI or the command line, they provide a practical security layer for operators who share their node's infrastructure with multiple users or applications. In the next and final chapter, we will bring everything together by building a complete LitD node from scratch. ## RUN LITD: Building a Node from Scratch 710c2090-e905-4141-8b12-7a81d7c276a1 ![video](https://www.youtube.com/watch?v=lopHP_nF0tE) -### LITD Architecture and Repository Structure +### Why Build a Node from Scratch? -The Lightning Terminal Daemon (LITD) is a unified binary that bundles the core Lightning Network Daemon (LND) with essential operational tools: **Loop** (liquidity swaps), **Pool** (liquidity marketplace), **Faraday** (accounting/analytics), and **Taproot Assets**. By running these components as a single integrated system, developers and node operators avoid the complexity of managing five distinct daemons and their inter-process communications. +Throughout this course, we have worked with an already-running Lightning Terminal instance, exploring its features one by one. Now, in this final technical chapter, we will go through the entire process of building a LitD node from a bare server. This is where all the concepts we have studied converge into a single, hands-on deployment. -To streamline deployment, the community utilizes the **Run LITD** repository. Inspired by Alex Bosworth’s "Run LND," this repository is optimized for speed and standardized configuration. It offers three distinct implementation pathways depending on the operator's need for control: -1. **Automated Scripts:** Bash scripts that handle the end-to-end installation (ideal for rapid testing). -2. **Manual Checklists:** Step-by-step guides for operators who need to audit every command. -3. **Example Configurations:** Reference files for `bitcoin.conf`, `lit.conf`, and systemd services. +As we discussed in the very first chapter, **Lightning Terminal Daemon (LitD)** is a unified binary that bundles LND with Loop, Pool, Faraday, and Taproot Assets into a single integrated system. By running LitD rather than managing five separate daemons, we dramatically simplify the operational complexity of a full Lightning Labs stack. -### Hardware Prerequisites and Installation Stages +To streamline this deployment, we will use the **Run LitD** repository, a community resource inspired by Alex Bosworth's well-known "Run LND" guide. The Run LitD repository provides three complementary pathways: -Before deployment, operators must provision a server meeting minimum specifications. The scripts are tested specifically on **Ubuntu 24.04**. A baseline configuration requires at least **4GB of RAM** and sufficient storage. -* **Pruned Node:** ~80GB storage (sufficient for most Lightning operations). -* **Archival Node:** ~1TB+ storage (required only if you need a full historical copy of the blockchain). +1. **Automated bash scripts**: handle the end-to-end installation (ideal for rapid testing and development environments). +2. **Manual checklists**: step-by-step notes for operators who want to audit every command before executing it. +3. **Example configuration files**: reference `bitcoin.conf`, `lit.conf`, and `systemd` service files that can be adapted to any environment. -The installation workflow is divided into three sequential stages: -1. **Server Preparation:** Secures the environment by creating a dedicated user, configuring SSH keys, and disabling root login/password authentication. -2. **Bitcoin Core Setup:** Installs the Bitcoin backend. The repository supports both **Binary** (faster, pre-compiled) and **Source** (auditable, slower) installation methods. -3. **LITD Deployment:** Compiles or downloads the LITD binary. For source installations, this step automatically handles dependencies like Go, Node.js, and Yarn. +**Important disclaimer**: as noted in the repository itself, these scripts are designed for developers who want to spin up a node quickly for testing purposes. If you are building a production node with real funds, take the time to read through every script, audit every configuration line, and follow your own security best practices. Do not blindly trust any automation when real money is at stake. -### Configuration, Wallet Ops, and Service Management +### Server Requirements and Prerequisites -Unlike a standalone LND setup, LITD uses a unified configuration file located in the `.lit` directory. This introduces a specific syntax requirement: standard LND parameters must be prefixed with `lnd.`. For example, a setting that is `alias=MyNode` in LND becomes `lnd.alias=MyNode` in `lit.conf`. This separation allows the daemon to route configurations to the correct internal sub-server (e.g., specific settings for Loop or Faraday). +These scripts have been tested on **Ubuntu 24.04**. If you are running a different distribution, the process will likely work with minor adjustments, but be prepared for occasional differences in package names or paths. -**Wallet Initialization:** -Once the software is installed, the operator must manually start LITD to generate the wallet seed. The setup scripts include a secure password management mechanism that enables **Auto-Unlock**. This allows LITD to automatically decrypt the wallet upon system reboot, ensuring the node comes back online immediately after power failures or maintenance without manual intervention. +Here are the baseline hardware requirements: -**Systemd Integration:** -The final setup script wraps both Bitcoin Core and LITD in `systemd` service files. This transforms them into background services that start on boot (`systemctl enable litd`). Verification involves checking the service status logs to ensure the node is successfully syncing with the blockchain and that all bundled sub-servers (Loop, Pool) are active and communicating. +| Resource | Minimum | Notes | +|----------|---------|-------| +| **RAM (minimum)** | 4 GB | Sufficient for a pruned node with LitD | +| **Storage (pruned)** | ~80 GB | Default configuration in the scripts | +| **Storage (archival)** | ~1 TB+ | Only if you need full blockchain history | +| **Operating system** | Ubuntu 24.04 | Tested target; other Debian-based systems may work | -# Conclusion -90cfdd76-7deb-4162-87a5-24bb845ba786 +Note that the scripts configure a **pruned Bitcoin node** by default. If you want to run a full archival node, look for the pruning configuration line in the Bitcoin setup script and adjust it accordingly. For full archival nodes, you may also want to configure an external data store for the blockchain data; the Run LitD repository includes notes on how to do this. + +The installation proceeds in three stages, each handled by a separate script: + +1. **Server Preparation** (`server_setup.sh`): creates a dedicated user, configures SSH keys, disables root login and password authentication. +2. **Bitcoin Core Setup** (binary or source script): installs Bitcoin Core with signature verification. +3. **LitD Deployment** (two or three scripts depending on method): installs dependencies, compiles LitD from source, configures `lit.conf`, initializes the wallet, and sets up `systemd` services. + +### Stage 1: Server Preparation + +We begin by logging into our fresh Ubuntu server as root. The first task is to clone the Run LitD repository: + +```bash +git clone https://github.com/lightninglabs/run-litd.git +``` + +Navigate into the repository and examine the scripts: + +```bash +cd run-litd +ls scripts/ +``` + +The server setup script handles basic security hardening. Before running it, ensure it is executable: + +```bash +chmod +x scripts/server_setup.sh +``` + +Since we are logged in as root, we run it directly: + +```bash +./scripts/server_setup.sh +``` + +The script will prompt you for several pieces of information: + +1. **Sudo password for the new `ubuntu` user**: this creates a non-root user that will own all subsequent operations. +2. **SSH public keys**: paste the public keys you want to authorize for this user. Each key should be on its own line. Press Enter after the last key, then Ctrl+D to confirm. + +Once the script completes, it will have: +- Created a new `ubuntu` user with sudo privileges +- Configured SSH key-based authentication for that user +- Disabled root login over SSH +- Disabled password-based authentication + +At this point, log out of the root session and reconnect as the new `ubuntu` user: + +```bash +ssh ubuntu@ +``` + +After logging back in, move the repository to the new user's home directory and fix ownership: + +```bash +sudo mv /root/run-litd /home/ubuntu/ +sudo chown -R ubuntu:ubuntu /home/ubuntu/run-litd +``` + +### Stage 2: Installing Bitcoin Core + +With the server secured, we install the Bitcoin backend. The repository offers two methods: + +- **Binary installation**: downloads the pre-compiled Bitcoin Core binary and verifies signatures. Faster, suitable when the focus is on LitD rather than Bitcoin Core itself. +- **Source installation**: compiles Bitcoin Core from source. More thorough and auditable, but slower. + +For this walkthrough, we will use the binary method. Make the script executable and run it with `sudo`: + +```bash +chmod +x scripts/bitcoin_setup_binary.sh +sudo ./scripts/bitcoin_setup_binary.sh +``` + +The script performs the following operations automatically: +- Downloads the specified version of Bitcoin Core +- Verifies cryptographic signatures for security +- Installs the binary to the appropriate system path +- Creates the Bitcoin data directory with correct permissions +- Generates a `bitcoin.conf` configuration file +- Creates and enables a `systemd` service for `bitcoind` + +During execution, the script will output an **RPC connection string** (containing the `rpcuser` and `rpcpassword`). This is critical: + +``` +rpcuser=yourgenerateduser +rpcpassword=yourgeneratedpassword +``` + +**Copy this connection string immediately and store it safely.** You will need it when configuring LitD in the next stage. If you lose it or encounter connection errors between Bitcoin Core and LitD later, you can regenerate it by following the instructions in the repository's checklist. + +The script will also ask you to select a network: + +- **mainnet (production)**: for use with real bitcoin +- **signet (testing)**: recommended when learning + +For our demonstration, we select **signet for testing**. After the script completes, verify that Bitcoin Core is running: + +```bash +sudo systemctl status bitcoind +``` + +You should see the service active and running. Bitcoin Core will begin synchronizing with the blockchain in the background. + +### Stage 3: Installing LitD from Source + +Now we arrive at the core of this chapter: installing Lightning Terminal Daemon. We will compile from source, which provides a complete understanding of what is happening on the server. The repository also offers a binary download script if you prefer speed over transparency. + +The LitD source installation is divided into two (or three) scripts that run sequentially. + +#### Script 1: Install Dependencies + +The first script installs the build dependencies: **Go, Node.js, and Yarn**. + +```bash +chmod +x scripts/litd_setup_1.sh +sudo ./scripts/litd_setup_1.sh +``` + +This script: +- Installs the Go programming language (required to compile LitD and LND) +- Configures the `GOPATH` environment variable +- Installs Node.js (required for building the web UI) +- Installs Yarn (the package manager used by the Terminal frontend) + +Because the Go path configuration modifies the shell environment, log out and log back in after this script completes: + +```bash +exit +ssh ubuntu@ +``` + +Then verify that all dependencies were installed correctly: + +```bash +go version +``` + +You should see the installed Go version. Then check Node.js and Yarn: + +```bash +node --version +yarn --version +``` + +If all three commands return version numbers, the dependencies are properly installed and we can proceed. + +#### Script 2: Compile and Configure LitD + +The second script is the most substantial. It clones the Lightning Terminal repository, compiles the binary from source, and generates the configuration file. + +```bash +chmod +x scripts/litd_setup_2.sh +sudo ./scripts/litd_setup_2.sh +``` + +The compilation process takes approximately 5 to 10 minutes depending on your server's resources. Once complete, the script prompts you for configuration parameters: + +1. **Network selection**: enter `signet` (or `mainnet`, matching your Bitcoin Core configuration). +2. **RPC connection string**: paste the `rpcuser` and `rpcpassword` that you saved during the Bitcoin Core setup. Be careful with copy-paste errors here; a mismatched credential is the most common cause of connection failures between Bitcoin Core and LitD. +3. **UI password**: choose a password for the Lightning Terminal web interface. +4. **Node alias**: a human-readable name for your node (for example, `my-litd-node`). + +The script creates the configuration file at `~/.lit/lit.conf`. Let us examine what a typical configuration looks like: + +```ini +# Lightning Terminal configuration +lnd-mode=integrated + +# UI +uipassword=YOUR_SECURE_PASSWORD + +# LND settings (note the lnd. prefix) +lnd.bitcoin.active=1 +lnd.bitcoin.signetseednode=x.x.x.x +lnd.bitcoin.node=bitcoind +lnd.bitcoind.rpchost=127.0.0.1 +lnd.bitcoind.rpcuser=yourgenerateduser +lnd.bitcoind.rpcpass=yourgeneratedpassword +lnd.bitcoind.zmqpubrawblock=tcp://127.0.0.1:28332 +lnd.bitcoind.zmqpubrawtx=tcp://127.0.0.1:28333 +lnd.alias=my-litd-node + +# Taproot Assets settings can be added here +``` + +Notice the critical syntax: when running in **integrated mode**, all LND parameters must be prefixed with `lnd.`. A setting that would be `alias=my-litd-node` in a standalone `lnd.conf` becomes `lnd.alias=my-litd-node` in `lit.conf`. This prefix system allows the daemon to route each setting to the correct internal sub-server (LND, Loop, Pool, Faraday, or Taproot Assets). + +#### Wallet Initialization + +Before running the final setup script, we must initialize the LND wallet. This is a manual step that generates the cryptographic seed for your node. +Open two terminal windows connected to your server. In the first window, start LitD manually: +```bash +litd +``` + +LitD will start up but pause, indicating that it needs a wallet to be created or unlocked. In the second terminal window, create the wallet: + +```bash +lncli --network=signet create +``` + +**Note on network mismatch**: the `--network` flag must match your configured network. If there is a mismatch (for example, using `--network=mainnet` when LitD is configured for signet), you may encounter a macaroon error. + +The wallet creation process will prompt you for: + +1. **Wallet password**: enter the password (twice for confirmation). This is the password LitD will use to unlock the wallet on startup. +2. **New seed or existing seed**: select the option to create a new seed. +3. **Optional passphrase encryption**: you can skip this for testing environments. + +The system then displays your **24-word recovery seed**: + +``` +abandon ability able about above absent absorb abstract absurd abuse access accident ... +``` + +**Back up this seed immediately using your preferred secure backup method.** This seed is the master key to all funds on this node. If you lose it and your server fails, your funds are unrecoverable. + +#### Auto-Unlock Configuration + +The setup scripts include a mechanism for **automatic wallet unlocking**. During installation, a file is created containing the wallet password. This allows LitD to decrypt the wallet automatically on system reboot, ensuring your node comes back online after power failures or maintenance without manual intervention. + +The password file is stored securely with restricted permissions. You can verify its location and contents (on a test node) with: + +```bash +cat ~/.lit/wallet_password +``` + +In a production environment, you should carefully evaluate the security trade-offs of auto-unlock. Storing the password on disk means that anyone with root access to the server can unlock the wallet. For high-value nodes, you may prefer manual unlock after each reboot. + +After the wallet is initialized, stop LitD gracefully in the first terminal (Ctrl+C) and proceed to the final script. + +#### Script 3: Systemd Services and Final Configuration + +The third and final script wraps everything into `systemd` services and applies final configuration updates: + +```bash +chmod +x scripts/litd_setup_3.sh +sudo ./scripts/litd_setup_3.sh +``` + +This script: +- Updates the `lit.conf` with any remaining settings +- Creates a `systemd` service file for LitD at `/etc/systemd/system/litd.service` +- Enables and starts the LitD service + +Upon completion, the script displays a confirmation message. Verify that both services are running: + +```bash +sudo systemctl status bitcoind +sudo systemctl status litd +``` + +Both should show as active. You can also check the LitD logs for any errors: + +```bash +sudo journalctl -u litd -f +``` + +### Exploring the Installed System + +Now that our node is fully operational, let us take a moment to examine the file system structure that the scripts have created. + +The key directories are: + +| Path | Contents | +|------|----------| +| `~/.bitcoin/` | Bitcoin Core data directory and `bitcoin.conf` | +| `~/.lnd/` | LND data (channels, macaroons, wallet) | +| `~/.lit/` | LitD configuration (`lit.conf`) and TLS certificate | +| `~/.tapd/` | Taproot Assets daemon data | + +To inspect the Bitcoin Core configuration: + +```bash +cat ~/.bitcoin/bitcoin.conf +``` + +To inspect the LitD configuration: + +```bash +cat ~/.lit/lit.conf +``` + +The `systemd` service files are located at: + +```bash +ls /etc/systemd/system/bitcoind.service /etc/systemd/system/litd.service +``` + +These services are configured to start automatically on boot and restart on failure. This is essential for node reliability: you do not want to be manually restarting services at 3 AM because of a brief power interruption. + +To manage the services: + +```bash +# Stop LitD +sudo systemctl stop litd + +# Start LitD +sudo systemctl start litd + +# Restart LitD (after config changes) +sudo systemctl restart litd + +# View recent logs +sudo journalctl -u litd --since "10 minutes ago" +``` + +### Summary + +In this chapter, we have walked through the complete process of building a Lightning Terminal node from a bare Ubuntu server. We progressed through three stages: server hardening (SSH, dedicated user, disabled root access), Bitcoin Core installation (binary download with signature verification), and LitD compilation from source (Go, Node.js, Yarn dependencies, followed by the build and configuration). We initialized the wallet, configured auto-unlock for resilience, and wrapped everything in `systemd` services for production-grade process management. + +This is the culmination of everything we have covered in this course. You now have a fully operational LitD node with access to LND, Loop, Pool, Faraday, and Taproot Assets, all manageable from the Lightning Terminal web interface or via the command line. The health checks, autofees, liquidity reports, and account management features we explored in earlier chapters are all available on this node, ready to be configured according to your operational needs. + +# Conclusion +90cfdd76-7deb-4162-87a5-24bb845ba786 ## Ratings & Reviews dd13ca51-9c2c-4cb8-bdfc-c452f205229a - true - ## Final Exam - 2a19c10e-ced6-11f0-8ab2-cf79e817a351 true ## Conclusion 8cf6f7c4-a520-40e6-a198-42fdd0d78f3b +Over the course of LNP 404, we have progressively explored the full Lightning Terminal stack, moving from initial installation and connection all the way through to building a complete node from scratch. + +In **Part 1**, we established the foundations: installing LitD, connecting via Lightning Node Connect, understanding health checks, navigating the dashboard's insights and forwarding data, and configuring Autofees for dynamic fee management. + +In **Part 2**, we expanded our operational toolkit: managing multiple nodes from a single interface, opening channels efficiently through batch transactions, using Lightning Loop for non-custodial liquidity swaps, and leveraging Peer Insights to make informed decisions about channel partners. + +In **Part 3**, we completed the picture with the Liquidity Report (a diagnostic tool for silent liquidity problems), LND Accounts (virtual off-chain partitions for sharing node access securely), and the full Run LitD deployment walkthrough that tied every concept together in practice. + +The Lightning Network is still a rapidly evolving system. The tools we have covered in this course, particularly Lightning Terminal, Loop, Pool, Faraday, and Taproot Assets, continue to receive updates and new features. I encourage you to consult the official documentation at [docs.lightning.engineering](https://docs.lightning.engineering) regularly, and to experiment with the features on signet or testnet before deploying changes to a production node. + +If you found this course helpful, I would be very grateful if you could take a few moments to rate it and share your feedback. Your input helps improve the material for future students and supports the Plan B Network's mission to make Bitcoin education accessible to everyone. + +Thank you for following this course, and congratulations on reaching the end. You now have both the conceptual understanding and the practical skills to operate a Lightning node with confidence. Let's keep building. true From 63c0e533a15fb7ca39c8b756055e91102b317edd Mon Sep 17 00:00:00 2001 From: Rogzy Date: Sun, 22 Mar 2026 01:48:23 +0100 Subject: [PATCH 07/10] update: set LNP404 test_only=true for testnet-only deployment Co-Authored-By: Claude Opus 4.6 (1M context) --- courses/lnp404/course.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/courses/lnp404/course.yml b/courses/lnp404/course.yml index 8c207f6f066..a233ee92e5c 100644 --- a/courses/lnp404/course.yml +++ b/courses/lnp404/course.yml @@ -6,7 +6,7 @@ level: intermediate hours: 16 teaching_format: self_paced license: CC-BY-SA-V4 -test_only: false +test_only: true professors_id: - 303993a1-6506-4c25-b0b6-6d3f0497859b From 41ffdd6a9f0d02d7e8b071e2ad13f340e0e14391 Mon Sep 17 00:00:00 2001 From: Rogzy Date: Sun, 22 Mar 2026 02:01:25 +0100 Subject: [PATCH 08/10] =?UTF-8?q?update:=20rename=20LNP404=20=E2=86=92=20L?= =?UTF-8?q?NP304,=20fix=20level=20and=20hours?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Course re-indexed per course-indexing-logic: - Level: intermediate → advanced (300-level, not 400) - Hours: 16 → 6 (actual content ~3h video + reading) - Folder: lnp404/ → lnp304/ - All internal references updated Co-Authored-By: Claude Opus 4.6 (1M context) --- courses/{lnp404 => lnp304}/assets/en/001.webp | Bin courses/{lnp404 => lnp304}/assets/en/002.webp | Bin courses/{lnp404 => lnp304}/assets/en/003.webp | Bin courses/{lnp404 => lnp304}/assets/en/004.webp | Bin courses/{lnp404 => lnp304}/assets/en/005.webp | Bin courses/{lnp404 => lnp304}/assets/en/006.webp | Bin courses/{lnp404 => lnp304}/assets/en/007.webp | Bin .../{lnp404 => lnp304}/assets/thumbnail.webp | Bin courses/{lnp404 => lnp304}/course.yml | 4 ++-- courses/{lnp404 => lnp304}/en.md | 18 +++++++++--------- courses/{lnp404 => lnp304}/quizz/001/en.yml | 0 .../{lnp404 => lnp304}/quizz/001/question.yml | 0 courses/{lnp404 => lnp304}/quizz/002/en.yml | 0 .../{lnp404 => lnp304}/quizz/002/question.yml | 0 courses/{lnp404 => lnp304}/quizz/003/en.yml | 0 .../{lnp404 => lnp304}/quizz/003/question.yml | 0 courses/{lnp404 => lnp304}/quizz/004/en.yml | 0 .../{lnp404 => lnp304}/quizz/004/question.yml | 0 courses/{lnp404 => lnp304}/quizz/005/en.yml | 0 .../{lnp404 => lnp304}/quizz/005/question.yml | 0 courses/{lnp404 => lnp304}/quizz/006/en.yml | 0 .../{lnp404 => lnp304}/quizz/006/question.yml | 0 courses/{lnp404 => lnp304}/quizz/007/en.yml | 0 .../{lnp404 => lnp304}/quizz/007/question.yml | 0 courses/{lnp404 => lnp304}/quizz/008/en.yml | 0 .../{lnp404 => lnp304}/quizz/008/question.yml | 0 courses/{lnp404 => lnp304}/quizz/009/en.yml | 0 .../{lnp404 => lnp304}/quizz/009/question.yml | 0 courses/{lnp404 => lnp304}/quizz/010/en.yml | 0 .../{lnp404 => lnp304}/quizz/010/question.yml | 0 courses/{lnp404 => lnp304}/quizz/011/en.yml | 0 .../{lnp404 => lnp304}/quizz/011/question.yml | 0 courses/{lnp404 => lnp304}/quizz/012/en.yml | 0 .../{lnp404 => lnp304}/quizz/012/question.yml | 0 courses/{lnp404 => lnp304}/quizz/013/en.yml | 0 .../{lnp404 => lnp304}/quizz/013/question.yml | 0 courses/{lnp404 => lnp304}/quizz/014/en.yml | 0 .../{lnp404 => lnp304}/quizz/014/question.yml | 0 courses/{lnp404 => lnp304}/quizz/015/en.yml | 0 .../{lnp404 => lnp304}/quizz/015/question.yml | 0 courses/{lnp404 => lnp304}/quizz/016/en.yml | 0 .../{lnp404 => lnp304}/quizz/016/question.yml | 0 courses/{lnp404 => lnp304}/quizz/017/en.yml | 0 .../{lnp404 => lnp304}/quizz/017/question.yml | 0 courses/{lnp404 => lnp304}/quizz/018/en.yml | 0 .../{lnp404 => lnp304}/quizz/018/question.yml | 0 courses/{lnp404 => lnp304}/quizz/019/en.yml | 0 .../{lnp404 => lnp304}/quizz/019/question.yml | 0 courses/{lnp404 => lnp304}/quizz/020/en.yml | 0 .../{lnp404 => lnp304}/quizz/020/question.yml | 0 courses/{lnp404 => lnp304}/quizz/021/en.yml | 0 .../{lnp404 => lnp304}/quizz/021/question.yml | 0 courses/{lnp404 => lnp304}/quizz/022/en.yml | 0 .../{lnp404 => lnp304}/quizz/022/question.yml | 0 courses/{lnp404 => lnp304}/quizz/023/en.yml | 0 .../{lnp404 => lnp304}/quizz/023/question.yml | 0 courses/{lnp404 => lnp304}/quizz/024/en.yml | 0 .../{lnp404 => lnp304}/quizz/024/question.yml | 0 courses/{lnp404 => lnp304}/quizz/025/en.yml | 0 .../{lnp404 => lnp304}/quizz/025/question.yml | 0 courses/{lnp404 => lnp304}/quizz/026/en.yml | 0 .../{lnp404 => lnp304}/quizz/026/question.yml | 0 courses/{lnp404 => lnp304}/quizz/027/en.yml | 0 .../{lnp404 => lnp304}/quizz/027/question.yml | 0 courses/{lnp404 => lnp304}/quizz/028/en.yml | 0 .../{lnp404 => lnp304}/quizz/028/question.yml | 0 courses/{lnp404 => lnp304}/quizz/029/en.yml | 0 .../{lnp404 => lnp304}/quizz/029/question.yml | 0 courses/{lnp404 => lnp304}/quizz/030/en.yml | 0 .../{lnp404 => lnp304}/quizz/030/question.yml | 0 courses/{lnp404 => lnp304}/quizz/031/en.yml | 0 .../{lnp404 => lnp304}/quizz/031/question.yml | 0 courses/{lnp404 => lnp304}/quizz/032/en.yml | 0 .../{lnp404 => lnp304}/quizz/032/question.yml | 0 courses/{lnp404 => lnp304}/quizz/033/en.yml | 0 .../{lnp404 => lnp304}/quizz/033/question.yml | 0 courses/{lnp404 => lnp304}/quizz/034/en.yml | 0 .../{lnp404 => lnp304}/quizz/034/question.yml | 0 courses/{lnp404 => lnp304}/quizz/035/en.yml | 0 .../{lnp404 => lnp304}/quizz/035/question.yml | 0 courses/{lnp404 => lnp304}/quizz/036/en.yml | 0 .../{lnp404 => lnp304}/quizz/036/question.yml | 0 courses/{lnp404 => lnp304}/quizz/037/en.yml | 0 .../{lnp404 => lnp304}/quizz/037/question.yml | 0 courses/{lnp404 => lnp304}/quizz/038/en.yml | 0 .../{lnp404 => lnp304}/quizz/038/question.yml | 0 courses/{lnp404 => lnp304}/quizz/039/en.yml | 0 .../{lnp404 => lnp304}/quizz/039/question.yml | 0 courses/{lnp404 => lnp304}/quizz/040/en.yml | 0 .../{lnp404 => lnp304}/quizz/040/question.yml | 0 courses/{lnp404 => lnp304}/quizz/041/en.yml | 0 .../{lnp404 => lnp304}/quizz/041/question.yml | 0 courses/{lnp404 => lnp304}/quizz/042/en.yml | 0 .../{lnp404 => lnp304}/quizz/042/question.yml | 0 courses/{lnp404 => lnp304}/quizz/043/en.yml | 0 .../{lnp404 => lnp304}/quizz/043/question.yml | 0 courses/{lnp404 => lnp304}/quizz/044/en.yml | 0 .../{lnp404 => lnp304}/quizz/044/question.yml | 0 courses/{lnp404 => lnp304}/quizz/045/en.yml | 0 .../{lnp404 => lnp304}/quizz/045/question.yml | 0 courses/{lnp404 => lnp304}/quizz/046/en.yml | 0 .../{lnp404 => lnp304}/quizz/046/question.yml | 0 courses/{lnp404 => lnp304}/quizz/047/en.yml | 0 .../{lnp404 => lnp304}/quizz/047/question.yml | 0 courses/{lnp404 => lnp304}/quizz/048/en.yml | 0 .../{lnp404 => lnp304}/quizz/048/question.yml | 0 courses/{lnp404 => lnp304}/quizz/049/en.yml | 0 .../{lnp404 => lnp304}/quizz/049/question.yml | 0 courses/{lnp404 => lnp304}/quizz/050/en.yml | 0 .../{lnp404 => lnp304}/quizz/050/question.yml | 0 courses/{lnp404 => lnp304}/quizz/051/en.yml | 0 .../{lnp404 => lnp304}/quizz/051/question.yml | 0 courses/{lnp404 => lnp304}/quizz/052/en.yml | 0 .../{lnp404 => lnp304}/quizz/052/question.yml | 0 courses/{lnp404 => lnp304}/quizz/053/en.yml | 0 .../{lnp404 => lnp304}/quizz/053/question.yml | 0 courses/{lnp404 => lnp304}/quizz/054/en.yml | 0 .../{lnp404 => lnp304}/quizz/054/question.yml | 0 courses/{lnp404 => lnp304}/quizz/055/en.yml | 0 .../{lnp404 => lnp304}/quizz/055/question.yml | 0 120 files changed, 11 insertions(+), 11 deletions(-) rename courses/{lnp404 => lnp304}/assets/en/001.webp (100%) rename courses/{lnp404 => lnp304}/assets/en/002.webp (100%) rename courses/{lnp404 => lnp304}/assets/en/003.webp (100%) rename courses/{lnp404 => lnp304}/assets/en/004.webp (100%) rename courses/{lnp404 => lnp304}/assets/en/005.webp (100%) rename courses/{lnp404 => lnp304}/assets/en/006.webp (100%) rename courses/{lnp404 => lnp304}/assets/en/007.webp (100%) rename courses/{lnp404 => lnp304}/assets/thumbnail.webp (100%) rename courses/{lnp404 => lnp304}/course.yml (93%) rename courses/{lnp404 => lnp304}/en.md (99%) rename courses/{lnp404 => lnp304}/quizz/001/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/001/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/002/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/002/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/003/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/003/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/004/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/004/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/005/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/005/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/006/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/006/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/007/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/007/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/008/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/008/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/009/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/009/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/010/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/010/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/011/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/011/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/012/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/012/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/013/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/013/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/014/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/014/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/015/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/015/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/016/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/016/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/017/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/017/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/018/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/018/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/019/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/019/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/020/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/020/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/021/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/021/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/022/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/022/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/023/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/023/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/024/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/024/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/025/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/025/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/026/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/026/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/027/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/027/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/028/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/028/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/029/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/029/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/030/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/030/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/031/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/031/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/032/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/032/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/033/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/033/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/034/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/034/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/035/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/035/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/036/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/036/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/037/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/037/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/038/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/038/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/039/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/039/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/040/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/040/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/041/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/041/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/042/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/042/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/043/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/043/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/044/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/044/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/045/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/045/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/046/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/046/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/047/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/047/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/048/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/048/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/049/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/049/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/050/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/050/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/051/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/051/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/052/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/052/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/053/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/053/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/054/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/054/question.yml (100%) rename courses/{lnp404 => lnp304}/quizz/055/en.yml (100%) rename courses/{lnp404 => lnp304}/quizz/055/question.yml (100%) diff --git a/courses/lnp404/assets/en/001.webp b/courses/lnp304/assets/en/001.webp similarity index 100% rename from courses/lnp404/assets/en/001.webp rename to courses/lnp304/assets/en/001.webp diff --git a/courses/lnp404/assets/en/002.webp b/courses/lnp304/assets/en/002.webp similarity index 100% rename from courses/lnp404/assets/en/002.webp rename to courses/lnp304/assets/en/002.webp diff --git a/courses/lnp404/assets/en/003.webp b/courses/lnp304/assets/en/003.webp similarity index 100% rename from courses/lnp404/assets/en/003.webp rename to courses/lnp304/assets/en/003.webp diff --git a/courses/lnp404/assets/en/004.webp b/courses/lnp304/assets/en/004.webp similarity index 100% rename from courses/lnp404/assets/en/004.webp rename to courses/lnp304/assets/en/004.webp diff --git a/courses/lnp404/assets/en/005.webp b/courses/lnp304/assets/en/005.webp similarity index 100% rename from courses/lnp404/assets/en/005.webp rename to courses/lnp304/assets/en/005.webp diff --git a/courses/lnp404/assets/en/006.webp b/courses/lnp304/assets/en/006.webp similarity index 100% rename from courses/lnp404/assets/en/006.webp rename to courses/lnp304/assets/en/006.webp diff --git a/courses/lnp404/assets/en/007.webp b/courses/lnp304/assets/en/007.webp similarity index 100% rename from courses/lnp404/assets/en/007.webp rename to courses/lnp304/assets/en/007.webp diff --git a/courses/lnp404/assets/thumbnail.webp b/courses/lnp304/assets/thumbnail.webp similarity index 100% rename from courses/lnp404/assets/thumbnail.webp rename to courses/lnp304/assets/thumbnail.webp diff --git a/courses/lnp404/course.yml b/courses/lnp304/course.yml similarity index 93% rename from courses/lnp404/course.yml rename to courses/lnp304/course.yml index a233ee92e5c..bfb142a709d 100644 --- a/courses/lnp404/course.yml +++ b/courses/lnp304/course.yml @@ -2,8 +2,8 @@ id: 068234ae-1524-4947-9cb0-ea741b7f7c0f topic: protocol subtopic: lightning type: practice -level: intermediate -hours: 16 +level: advanced +hours: 6 teaching_format: self_paced license: CC-BY-SA-V4 test_only: true diff --git a/courses/lnp404/en.md b/courses/lnp304/en.md similarity index 99% rename from courses/lnp404/en.md rename to courses/lnp304/en.md index 12f1a6008db..40a939d1d96 100644 --- a/courses/lnp404/en.md +++ b/courses/lnp304/en.md @@ -69,7 +69,7 @@ Ready to take full control of your Lightning node? Let's get started. ## Course overview f4e2a1b3-5c6d-4e8f-9a0b-1d3c5e7f2a4b -Welcome to the LNP 404 course! Together, we will explore how to manage, optimize, and understand your Bitcoin Lightning node through the power of **Lightning Terminal** (LitD), an all-in-one management stack developed by Lightning Labs. +Welcome to the LNP 304 course! Together, we will explore how to manage, optimize, and understand your Bitcoin Lightning node through the power of **Lightning Terminal** (LitD), an all-in-one management stack developed by Lightning Labs. This course is built around the demo series by [Hannah Rosenberg](https://planb.academy/professors/hannah-rosenberg) from Lightning Labs. Each chapter pairs a video walkthrough with detailed written content, including the actual CLI commands, configuration files, and procedures you will need. @@ -209,7 +209,7 @@ litd --version If the version string prints correctly, the installation is complete. -![LNP404](assets/en/001.webp) +![LNP304](assets/en/001.webp) Let's move on to configuration. @@ -343,7 +343,7 @@ If you have not configured a domain name or SSL certificate (which is typical on Enter the UI password you defined in `lit.conf`, and you will see the Terminal interface. -![LNP404](assets/en/002.webp) +![LNP304](assets/en/002.webp) From here, you have access to all the management tools we will explore throughout this course: health checks, channel management, Loop, Pool, Autofees, and more. @@ -357,7 +357,7 @@ Here is how LNC works at a high level: your `litd` daemon makes an outgoing conn From the local Terminal interface, click the connection button to initiate an LNC session. The interface will generate a 10-word pairing phrase. Copy this phrase, then navigate to `terminal.lightning.engineering` in your browser. Paste the phrase, set a session password, and you are connected. -![LNP404](assets/en/003.webp) +![LNP304](assets/en/003.webp) #### Connecting via the Command Line @@ -375,7 +375,7 @@ This command creates a new administrative session and outputs a connection strin Let's recap what we have accomplished in this chapter. We installed `litd` from source by cloning the Lightning Labs repository and running `make install`. We verified that `rpcmiddleware.enable=true` is set in our LND configuration. We created a dedicated `lit.conf` file with all the parameters needed for remote mode operation. We set up a systemd service so that `litd` starts automatically and survives reboots. Finally, we connected to Terminal on the web using Lightning Node Connect. -![LNP404](assets/en/004.webp) +![LNP304](assets/en/004.webp) In the next chapter, we will explore what Terminal reveals about our node's health and discover how the health check system evaluates routing performance across six key metrics. @@ -400,7 +400,7 @@ When you connect to Terminal on the web, the homepage displays a summary of your 2. Click the **Explore** tab 3. Paste your public key into the search field -![LNP404](assets/en/005.webp) +![LNP304](assets/en/005.webp) This brings up a detailed profile of your node, including its overall score, current capacity, age, number of good peers, and centrality measure. Below these summary statistics, you will find the six individual health checks. @@ -449,7 +449,7 @@ Each health check includes a link to more detailed documentation. If you pass so ### Recommended Channels -![LNP404](assets/en/006.webp) +![LNP304](assets/en/006.webp) Scroll down on the Channels tab of the homepage, and you will find the **Recommended Channels** section. This feature identifies nodes on the network that would benefit from a well-connected peer, and it suggests that you be that peer. @@ -533,7 +533,7 @@ Let's now turn to the **Channels** tab, which represents the operational core of - **Total outbound capacity** (your ability to send or route outward) - **Total inbound capacity** (your ability to receive or route inward) -![LNP404](assets/en/007.webp) +![LNP304](assets/en/007.webp) But the real power of this tab lies in the **per-channel liquidity visualization**. For each channel, Terminal displays a visual bar showing the balance distribution between local (outbound) and inbound liquidity. At a glance, you can see: @@ -1654,7 +1654,7 @@ This is the culmination of everything we have covered in this course. You now ha ## Conclusion 8cf6f7c4-a520-40e6-a198-42fdd0d78f3b -Over the course of LNP 404, we have progressively explored the full Lightning Terminal stack, moving from initial installation and connection all the way through to building a complete node from scratch. +Over the course of LNP 304, we have progressively explored the full Lightning Terminal stack, moving from initial installation and connection all the way through to building a complete node from scratch. In **Part 1**, we established the foundations: installing LitD, connecting via Lightning Node Connect, understanding health checks, navigating the dashboard's insights and forwarding data, and configuring Autofees for dynamic fee management. diff --git a/courses/lnp404/quizz/001/en.yml b/courses/lnp304/quizz/001/en.yml similarity index 100% rename from courses/lnp404/quizz/001/en.yml rename to courses/lnp304/quizz/001/en.yml diff --git a/courses/lnp404/quizz/001/question.yml b/courses/lnp304/quizz/001/question.yml similarity index 100% rename from courses/lnp404/quizz/001/question.yml rename to courses/lnp304/quizz/001/question.yml diff --git a/courses/lnp404/quizz/002/en.yml b/courses/lnp304/quizz/002/en.yml similarity index 100% rename from courses/lnp404/quizz/002/en.yml rename to courses/lnp304/quizz/002/en.yml diff --git a/courses/lnp404/quizz/002/question.yml b/courses/lnp304/quizz/002/question.yml similarity index 100% rename from courses/lnp404/quizz/002/question.yml rename to courses/lnp304/quizz/002/question.yml diff --git a/courses/lnp404/quizz/003/en.yml b/courses/lnp304/quizz/003/en.yml similarity index 100% rename from courses/lnp404/quizz/003/en.yml rename to courses/lnp304/quizz/003/en.yml diff --git a/courses/lnp404/quizz/003/question.yml b/courses/lnp304/quizz/003/question.yml similarity index 100% rename from courses/lnp404/quizz/003/question.yml rename to courses/lnp304/quizz/003/question.yml diff --git a/courses/lnp404/quizz/004/en.yml b/courses/lnp304/quizz/004/en.yml similarity index 100% rename from courses/lnp404/quizz/004/en.yml rename to courses/lnp304/quizz/004/en.yml diff --git a/courses/lnp404/quizz/004/question.yml b/courses/lnp304/quizz/004/question.yml similarity index 100% rename from courses/lnp404/quizz/004/question.yml rename to courses/lnp304/quizz/004/question.yml diff --git a/courses/lnp404/quizz/005/en.yml b/courses/lnp304/quizz/005/en.yml similarity index 100% rename from courses/lnp404/quizz/005/en.yml rename to courses/lnp304/quizz/005/en.yml diff --git a/courses/lnp404/quizz/005/question.yml b/courses/lnp304/quizz/005/question.yml similarity index 100% rename from courses/lnp404/quizz/005/question.yml rename to courses/lnp304/quizz/005/question.yml diff --git a/courses/lnp404/quizz/006/en.yml b/courses/lnp304/quizz/006/en.yml similarity index 100% rename from courses/lnp404/quizz/006/en.yml rename to courses/lnp304/quizz/006/en.yml diff --git a/courses/lnp404/quizz/006/question.yml b/courses/lnp304/quizz/006/question.yml similarity index 100% rename from courses/lnp404/quizz/006/question.yml rename to courses/lnp304/quizz/006/question.yml diff --git a/courses/lnp404/quizz/007/en.yml b/courses/lnp304/quizz/007/en.yml similarity index 100% rename from courses/lnp404/quizz/007/en.yml rename to courses/lnp304/quizz/007/en.yml diff --git a/courses/lnp404/quizz/007/question.yml b/courses/lnp304/quizz/007/question.yml similarity index 100% rename from courses/lnp404/quizz/007/question.yml rename to courses/lnp304/quizz/007/question.yml diff --git a/courses/lnp404/quizz/008/en.yml b/courses/lnp304/quizz/008/en.yml similarity index 100% rename from courses/lnp404/quizz/008/en.yml rename to courses/lnp304/quizz/008/en.yml diff --git a/courses/lnp404/quizz/008/question.yml b/courses/lnp304/quizz/008/question.yml similarity index 100% rename from courses/lnp404/quizz/008/question.yml rename to courses/lnp304/quizz/008/question.yml diff --git a/courses/lnp404/quizz/009/en.yml b/courses/lnp304/quizz/009/en.yml similarity index 100% rename from courses/lnp404/quizz/009/en.yml rename to courses/lnp304/quizz/009/en.yml diff --git a/courses/lnp404/quizz/009/question.yml b/courses/lnp304/quizz/009/question.yml similarity index 100% rename from courses/lnp404/quizz/009/question.yml rename to courses/lnp304/quizz/009/question.yml diff --git a/courses/lnp404/quizz/010/en.yml b/courses/lnp304/quizz/010/en.yml similarity index 100% rename from courses/lnp404/quizz/010/en.yml rename to courses/lnp304/quizz/010/en.yml diff --git a/courses/lnp404/quizz/010/question.yml b/courses/lnp304/quizz/010/question.yml similarity index 100% rename from courses/lnp404/quizz/010/question.yml rename to courses/lnp304/quizz/010/question.yml diff --git a/courses/lnp404/quizz/011/en.yml b/courses/lnp304/quizz/011/en.yml similarity index 100% rename from courses/lnp404/quizz/011/en.yml rename to courses/lnp304/quizz/011/en.yml diff --git a/courses/lnp404/quizz/011/question.yml b/courses/lnp304/quizz/011/question.yml similarity index 100% rename from courses/lnp404/quizz/011/question.yml rename to courses/lnp304/quizz/011/question.yml diff --git a/courses/lnp404/quizz/012/en.yml b/courses/lnp304/quizz/012/en.yml similarity index 100% rename from courses/lnp404/quizz/012/en.yml rename to courses/lnp304/quizz/012/en.yml diff --git a/courses/lnp404/quizz/012/question.yml b/courses/lnp304/quizz/012/question.yml similarity index 100% rename from courses/lnp404/quizz/012/question.yml rename to courses/lnp304/quizz/012/question.yml diff --git a/courses/lnp404/quizz/013/en.yml b/courses/lnp304/quizz/013/en.yml similarity index 100% rename from courses/lnp404/quizz/013/en.yml rename to courses/lnp304/quizz/013/en.yml diff --git a/courses/lnp404/quizz/013/question.yml b/courses/lnp304/quizz/013/question.yml similarity index 100% rename from courses/lnp404/quizz/013/question.yml rename to courses/lnp304/quizz/013/question.yml diff --git a/courses/lnp404/quizz/014/en.yml b/courses/lnp304/quizz/014/en.yml similarity index 100% rename from courses/lnp404/quizz/014/en.yml rename to courses/lnp304/quizz/014/en.yml diff --git a/courses/lnp404/quizz/014/question.yml b/courses/lnp304/quizz/014/question.yml similarity index 100% rename from courses/lnp404/quizz/014/question.yml rename to courses/lnp304/quizz/014/question.yml diff --git a/courses/lnp404/quizz/015/en.yml b/courses/lnp304/quizz/015/en.yml similarity index 100% rename from courses/lnp404/quizz/015/en.yml rename to courses/lnp304/quizz/015/en.yml diff --git a/courses/lnp404/quizz/015/question.yml b/courses/lnp304/quizz/015/question.yml similarity index 100% rename from courses/lnp404/quizz/015/question.yml rename to courses/lnp304/quizz/015/question.yml diff --git a/courses/lnp404/quizz/016/en.yml b/courses/lnp304/quizz/016/en.yml similarity index 100% rename from courses/lnp404/quizz/016/en.yml rename to courses/lnp304/quizz/016/en.yml diff --git a/courses/lnp404/quizz/016/question.yml b/courses/lnp304/quizz/016/question.yml similarity index 100% rename from courses/lnp404/quizz/016/question.yml rename to courses/lnp304/quizz/016/question.yml diff --git a/courses/lnp404/quizz/017/en.yml b/courses/lnp304/quizz/017/en.yml similarity index 100% rename from courses/lnp404/quizz/017/en.yml rename to courses/lnp304/quizz/017/en.yml diff --git a/courses/lnp404/quizz/017/question.yml b/courses/lnp304/quizz/017/question.yml similarity index 100% rename from courses/lnp404/quizz/017/question.yml rename to courses/lnp304/quizz/017/question.yml diff --git a/courses/lnp404/quizz/018/en.yml b/courses/lnp304/quizz/018/en.yml similarity index 100% rename from courses/lnp404/quizz/018/en.yml rename to courses/lnp304/quizz/018/en.yml diff --git a/courses/lnp404/quizz/018/question.yml b/courses/lnp304/quizz/018/question.yml similarity index 100% rename from courses/lnp404/quizz/018/question.yml rename to courses/lnp304/quizz/018/question.yml diff --git a/courses/lnp404/quizz/019/en.yml b/courses/lnp304/quizz/019/en.yml similarity index 100% rename from courses/lnp404/quizz/019/en.yml rename to courses/lnp304/quizz/019/en.yml diff --git a/courses/lnp404/quizz/019/question.yml b/courses/lnp304/quizz/019/question.yml similarity index 100% rename from courses/lnp404/quizz/019/question.yml rename to courses/lnp304/quizz/019/question.yml diff --git a/courses/lnp404/quizz/020/en.yml b/courses/lnp304/quizz/020/en.yml similarity index 100% rename from courses/lnp404/quizz/020/en.yml rename to courses/lnp304/quizz/020/en.yml diff --git a/courses/lnp404/quizz/020/question.yml b/courses/lnp304/quizz/020/question.yml similarity index 100% rename from courses/lnp404/quizz/020/question.yml rename to courses/lnp304/quizz/020/question.yml diff --git a/courses/lnp404/quizz/021/en.yml b/courses/lnp304/quizz/021/en.yml similarity index 100% rename from courses/lnp404/quizz/021/en.yml rename to courses/lnp304/quizz/021/en.yml diff --git a/courses/lnp404/quizz/021/question.yml b/courses/lnp304/quizz/021/question.yml similarity index 100% rename from courses/lnp404/quizz/021/question.yml rename to courses/lnp304/quizz/021/question.yml diff --git a/courses/lnp404/quizz/022/en.yml b/courses/lnp304/quizz/022/en.yml similarity index 100% rename from courses/lnp404/quizz/022/en.yml rename to courses/lnp304/quizz/022/en.yml diff --git a/courses/lnp404/quizz/022/question.yml b/courses/lnp304/quizz/022/question.yml similarity index 100% rename from courses/lnp404/quizz/022/question.yml rename to courses/lnp304/quizz/022/question.yml diff --git a/courses/lnp404/quizz/023/en.yml b/courses/lnp304/quizz/023/en.yml similarity index 100% rename from courses/lnp404/quizz/023/en.yml rename to courses/lnp304/quizz/023/en.yml diff --git a/courses/lnp404/quizz/023/question.yml b/courses/lnp304/quizz/023/question.yml similarity index 100% rename from courses/lnp404/quizz/023/question.yml rename to courses/lnp304/quizz/023/question.yml diff --git a/courses/lnp404/quizz/024/en.yml b/courses/lnp304/quizz/024/en.yml similarity index 100% rename from courses/lnp404/quizz/024/en.yml rename to courses/lnp304/quizz/024/en.yml diff --git a/courses/lnp404/quizz/024/question.yml b/courses/lnp304/quizz/024/question.yml similarity index 100% rename from courses/lnp404/quizz/024/question.yml rename to courses/lnp304/quizz/024/question.yml diff --git a/courses/lnp404/quizz/025/en.yml b/courses/lnp304/quizz/025/en.yml similarity index 100% rename from courses/lnp404/quizz/025/en.yml rename to courses/lnp304/quizz/025/en.yml diff --git a/courses/lnp404/quizz/025/question.yml b/courses/lnp304/quizz/025/question.yml similarity index 100% rename from courses/lnp404/quizz/025/question.yml rename to courses/lnp304/quizz/025/question.yml diff --git a/courses/lnp404/quizz/026/en.yml b/courses/lnp304/quizz/026/en.yml similarity index 100% rename from courses/lnp404/quizz/026/en.yml rename to courses/lnp304/quizz/026/en.yml diff --git a/courses/lnp404/quizz/026/question.yml b/courses/lnp304/quizz/026/question.yml similarity index 100% rename from courses/lnp404/quizz/026/question.yml rename to courses/lnp304/quizz/026/question.yml diff --git a/courses/lnp404/quizz/027/en.yml b/courses/lnp304/quizz/027/en.yml similarity index 100% rename from courses/lnp404/quizz/027/en.yml rename to courses/lnp304/quizz/027/en.yml diff --git a/courses/lnp404/quizz/027/question.yml b/courses/lnp304/quizz/027/question.yml similarity index 100% rename from courses/lnp404/quizz/027/question.yml rename to courses/lnp304/quizz/027/question.yml diff --git a/courses/lnp404/quizz/028/en.yml b/courses/lnp304/quizz/028/en.yml similarity index 100% rename from courses/lnp404/quizz/028/en.yml rename to courses/lnp304/quizz/028/en.yml diff --git a/courses/lnp404/quizz/028/question.yml b/courses/lnp304/quizz/028/question.yml similarity index 100% rename from courses/lnp404/quizz/028/question.yml rename to courses/lnp304/quizz/028/question.yml diff --git a/courses/lnp404/quizz/029/en.yml b/courses/lnp304/quizz/029/en.yml similarity index 100% rename from courses/lnp404/quizz/029/en.yml rename to courses/lnp304/quizz/029/en.yml diff --git a/courses/lnp404/quizz/029/question.yml b/courses/lnp304/quizz/029/question.yml similarity index 100% rename from courses/lnp404/quizz/029/question.yml rename to courses/lnp304/quizz/029/question.yml diff --git a/courses/lnp404/quizz/030/en.yml b/courses/lnp304/quizz/030/en.yml similarity index 100% rename from courses/lnp404/quizz/030/en.yml rename to courses/lnp304/quizz/030/en.yml diff --git a/courses/lnp404/quizz/030/question.yml b/courses/lnp304/quizz/030/question.yml similarity index 100% rename from courses/lnp404/quizz/030/question.yml rename to courses/lnp304/quizz/030/question.yml diff --git a/courses/lnp404/quizz/031/en.yml b/courses/lnp304/quizz/031/en.yml similarity index 100% rename from courses/lnp404/quizz/031/en.yml rename to courses/lnp304/quizz/031/en.yml diff --git a/courses/lnp404/quizz/031/question.yml b/courses/lnp304/quizz/031/question.yml similarity index 100% rename from courses/lnp404/quizz/031/question.yml rename to courses/lnp304/quizz/031/question.yml diff --git a/courses/lnp404/quizz/032/en.yml b/courses/lnp304/quizz/032/en.yml similarity index 100% rename from courses/lnp404/quizz/032/en.yml rename to courses/lnp304/quizz/032/en.yml diff --git a/courses/lnp404/quizz/032/question.yml b/courses/lnp304/quizz/032/question.yml similarity index 100% rename from courses/lnp404/quizz/032/question.yml rename to courses/lnp304/quizz/032/question.yml diff --git a/courses/lnp404/quizz/033/en.yml b/courses/lnp304/quizz/033/en.yml similarity index 100% rename from courses/lnp404/quizz/033/en.yml rename to courses/lnp304/quizz/033/en.yml diff --git a/courses/lnp404/quizz/033/question.yml b/courses/lnp304/quizz/033/question.yml similarity index 100% rename from courses/lnp404/quizz/033/question.yml rename to courses/lnp304/quizz/033/question.yml diff --git a/courses/lnp404/quizz/034/en.yml b/courses/lnp304/quizz/034/en.yml similarity index 100% rename from courses/lnp404/quizz/034/en.yml rename to courses/lnp304/quizz/034/en.yml diff --git a/courses/lnp404/quizz/034/question.yml b/courses/lnp304/quizz/034/question.yml similarity index 100% rename from courses/lnp404/quizz/034/question.yml rename to courses/lnp304/quizz/034/question.yml diff --git a/courses/lnp404/quizz/035/en.yml b/courses/lnp304/quizz/035/en.yml similarity index 100% rename from courses/lnp404/quizz/035/en.yml rename to courses/lnp304/quizz/035/en.yml diff --git a/courses/lnp404/quizz/035/question.yml b/courses/lnp304/quizz/035/question.yml similarity index 100% rename from courses/lnp404/quizz/035/question.yml rename to courses/lnp304/quizz/035/question.yml diff --git a/courses/lnp404/quizz/036/en.yml b/courses/lnp304/quizz/036/en.yml similarity index 100% rename from courses/lnp404/quizz/036/en.yml rename to courses/lnp304/quizz/036/en.yml diff --git a/courses/lnp404/quizz/036/question.yml b/courses/lnp304/quizz/036/question.yml similarity index 100% rename from courses/lnp404/quizz/036/question.yml rename to courses/lnp304/quizz/036/question.yml diff --git a/courses/lnp404/quizz/037/en.yml b/courses/lnp304/quizz/037/en.yml similarity index 100% rename from courses/lnp404/quizz/037/en.yml rename to courses/lnp304/quizz/037/en.yml diff --git a/courses/lnp404/quizz/037/question.yml b/courses/lnp304/quizz/037/question.yml similarity index 100% rename from courses/lnp404/quizz/037/question.yml rename to courses/lnp304/quizz/037/question.yml diff --git a/courses/lnp404/quizz/038/en.yml b/courses/lnp304/quizz/038/en.yml similarity index 100% rename from courses/lnp404/quizz/038/en.yml rename to courses/lnp304/quizz/038/en.yml diff --git a/courses/lnp404/quizz/038/question.yml b/courses/lnp304/quizz/038/question.yml similarity index 100% rename from courses/lnp404/quizz/038/question.yml rename to courses/lnp304/quizz/038/question.yml diff --git a/courses/lnp404/quizz/039/en.yml b/courses/lnp304/quizz/039/en.yml similarity index 100% rename from courses/lnp404/quizz/039/en.yml rename to courses/lnp304/quizz/039/en.yml diff --git a/courses/lnp404/quizz/039/question.yml b/courses/lnp304/quizz/039/question.yml similarity index 100% rename from courses/lnp404/quizz/039/question.yml rename to courses/lnp304/quizz/039/question.yml diff --git a/courses/lnp404/quizz/040/en.yml b/courses/lnp304/quizz/040/en.yml similarity index 100% rename from courses/lnp404/quizz/040/en.yml rename to courses/lnp304/quizz/040/en.yml diff --git a/courses/lnp404/quizz/040/question.yml b/courses/lnp304/quizz/040/question.yml similarity index 100% rename from courses/lnp404/quizz/040/question.yml rename to courses/lnp304/quizz/040/question.yml diff --git a/courses/lnp404/quizz/041/en.yml b/courses/lnp304/quizz/041/en.yml similarity index 100% rename from courses/lnp404/quizz/041/en.yml rename to courses/lnp304/quizz/041/en.yml diff --git a/courses/lnp404/quizz/041/question.yml b/courses/lnp304/quizz/041/question.yml similarity index 100% rename from courses/lnp404/quizz/041/question.yml rename to courses/lnp304/quizz/041/question.yml diff --git a/courses/lnp404/quizz/042/en.yml b/courses/lnp304/quizz/042/en.yml similarity index 100% rename from courses/lnp404/quizz/042/en.yml rename to courses/lnp304/quizz/042/en.yml diff --git a/courses/lnp404/quizz/042/question.yml b/courses/lnp304/quizz/042/question.yml similarity index 100% rename from courses/lnp404/quizz/042/question.yml rename to courses/lnp304/quizz/042/question.yml diff --git a/courses/lnp404/quizz/043/en.yml b/courses/lnp304/quizz/043/en.yml similarity index 100% rename from courses/lnp404/quizz/043/en.yml rename to courses/lnp304/quizz/043/en.yml diff --git a/courses/lnp404/quizz/043/question.yml b/courses/lnp304/quizz/043/question.yml similarity index 100% rename from courses/lnp404/quizz/043/question.yml rename to courses/lnp304/quizz/043/question.yml diff --git a/courses/lnp404/quizz/044/en.yml b/courses/lnp304/quizz/044/en.yml similarity index 100% rename from courses/lnp404/quizz/044/en.yml rename to courses/lnp304/quizz/044/en.yml diff --git a/courses/lnp404/quizz/044/question.yml b/courses/lnp304/quizz/044/question.yml similarity index 100% rename from courses/lnp404/quizz/044/question.yml rename to courses/lnp304/quizz/044/question.yml diff --git a/courses/lnp404/quizz/045/en.yml b/courses/lnp304/quizz/045/en.yml similarity index 100% rename from courses/lnp404/quizz/045/en.yml rename to courses/lnp304/quizz/045/en.yml diff --git a/courses/lnp404/quizz/045/question.yml b/courses/lnp304/quizz/045/question.yml similarity index 100% rename from courses/lnp404/quizz/045/question.yml rename to courses/lnp304/quizz/045/question.yml diff --git a/courses/lnp404/quizz/046/en.yml b/courses/lnp304/quizz/046/en.yml similarity index 100% rename from courses/lnp404/quizz/046/en.yml rename to courses/lnp304/quizz/046/en.yml diff --git a/courses/lnp404/quizz/046/question.yml b/courses/lnp304/quizz/046/question.yml similarity index 100% rename from courses/lnp404/quizz/046/question.yml rename to courses/lnp304/quizz/046/question.yml diff --git a/courses/lnp404/quizz/047/en.yml b/courses/lnp304/quizz/047/en.yml similarity index 100% rename from courses/lnp404/quizz/047/en.yml rename to courses/lnp304/quizz/047/en.yml diff --git a/courses/lnp404/quizz/047/question.yml b/courses/lnp304/quizz/047/question.yml similarity index 100% rename from courses/lnp404/quizz/047/question.yml rename to courses/lnp304/quizz/047/question.yml diff --git a/courses/lnp404/quizz/048/en.yml b/courses/lnp304/quizz/048/en.yml similarity index 100% rename from courses/lnp404/quizz/048/en.yml rename to courses/lnp304/quizz/048/en.yml diff --git a/courses/lnp404/quizz/048/question.yml b/courses/lnp304/quizz/048/question.yml similarity index 100% rename from courses/lnp404/quizz/048/question.yml rename to courses/lnp304/quizz/048/question.yml diff --git a/courses/lnp404/quizz/049/en.yml b/courses/lnp304/quizz/049/en.yml similarity index 100% rename from courses/lnp404/quizz/049/en.yml rename to courses/lnp304/quizz/049/en.yml diff --git a/courses/lnp404/quizz/049/question.yml b/courses/lnp304/quizz/049/question.yml similarity index 100% rename from courses/lnp404/quizz/049/question.yml rename to courses/lnp304/quizz/049/question.yml diff --git a/courses/lnp404/quizz/050/en.yml b/courses/lnp304/quizz/050/en.yml similarity index 100% rename from courses/lnp404/quizz/050/en.yml rename to courses/lnp304/quizz/050/en.yml diff --git a/courses/lnp404/quizz/050/question.yml b/courses/lnp304/quizz/050/question.yml similarity index 100% rename from courses/lnp404/quizz/050/question.yml rename to courses/lnp304/quizz/050/question.yml diff --git a/courses/lnp404/quizz/051/en.yml b/courses/lnp304/quizz/051/en.yml similarity index 100% rename from courses/lnp404/quizz/051/en.yml rename to courses/lnp304/quizz/051/en.yml diff --git a/courses/lnp404/quizz/051/question.yml b/courses/lnp304/quizz/051/question.yml similarity index 100% rename from courses/lnp404/quizz/051/question.yml rename to courses/lnp304/quizz/051/question.yml diff --git a/courses/lnp404/quizz/052/en.yml b/courses/lnp304/quizz/052/en.yml similarity index 100% rename from courses/lnp404/quizz/052/en.yml rename to courses/lnp304/quizz/052/en.yml diff --git a/courses/lnp404/quizz/052/question.yml b/courses/lnp304/quizz/052/question.yml similarity index 100% rename from courses/lnp404/quizz/052/question.yml rename to courses/lnp304/quizz/052/question.yml diff --git a/courses/lnp404/quizz/053/en.yml b/courses/lnp304/quizz/053/en.yml similarity index 100% rename from courses/lnp404/quizz/053/en.yml rename to courses/lnp304/quizz/053/en.yml diff --git a/courses/lnp404/quizz/053/question.yml b/courses/lnp304/quizz/053/question.yml similarity index 100% rename from courses/lnp404/quizz/053/question.yml rename to courses/lnp304/quizz/053/question.yml diff --git a/courses/lnp404/quizz/054/en.yml b/courses/lnp304/quizz/054/en.yml similarity index 100% rename from courses/lnp404/quizz/054/en.yml rename to courses/lnp304/quizz/054/en.yml diff --git a/courses/lnp404/quizz/054/question.yml b/courses/lnp304/quizz/054/question.yml similarity index 100% rename from courses/lnp404/quizz/054/question.yml rename to courses/lnp304/quizz/054/question.yml diff --git a/courses/lnp404/quizz/055/en.yml b/courses/lnp304/quizz/055/en.yml similarity index 100% rename from courses/lnp404/quizz/055/en.yml rename to courses/lnp304/quizz/055/en.yml diff --git a/courses/lnp404/quizz/055/question.yml b/courses/lnp304/quizz/055/question.yml similarity index 100% rename from courses/lnp404/quizz/055/question.yml rename to courses/lnp304/quizz/055/question.yml From c653955ccc6dd14122cf60670133be8259932065 Mon Sep 17 00:00:00 2001 From: Rogzy Date: Sun, 22 Mar 2026 02:08:33 +0100 Subject: [PATCH 09/10] fix: correct Quiz 5 (Node.js version) and deduplicate Quiz 20 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Quiz 5: Node.js 2.1.5+ doesn't exist — corrected to "Go 1.21+ and Node.js" Quiz 20: was near-duplicate of Quiz 17 (both about 60-day baseline) — rewritten to ask about per-peer granularity instead Co-Authored-By: Claude Opus 4.6 (1M context) --- courses/lnp304/quizz/005/en.yml | 4 ++-- courses/lnp304/quizz/020/en.yml | 12 ++++++------ 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/courses/lnp304/quizz/005/en.yml b/courses/lnp304/quizz/005/en.yml index 07c4966b453..dc70c062e52 100644 --- a/courses/lnp304/quizz/005/en.yml +++ b/courses/lnp304/quizz/005/en.yml @@ -1,8 +1,8 @@ question: What are the minimum development tool requirements needed to install Lightning Terminal from source? -answer: Go 1.21.3+ and Node.js 2.1.5+ +answer: Go 1.21+ and Node.js wrong_answers: - Python 3.8+ and Docker 20.10+ - Rust 1.70+ and npm 9.0+ - Java 17+ and Yarn 3.0+ explanation: | - Lightning Terminal requires Go 1.21.3+ and Node.js 2.1.5+ as the minimum development tools for source installation. Go is needed to compile the backend code, while Node.js is required to build the UI assets during the compilation process. The other options mention different programming languages and tools that are not used in the Lightning Terminal build process. + Lightning Terminal requires Go 1.21+ and Node.js as the minimum development tools for source installation. Go is needed to compile the backend code, while Node.js is required to build the UI assets during the compilation process. The other options mention different programming languages and tools that are not used in the Lightning Terminal build process. diff --git a/courses/lnp304/quizz/020/en.yml b/courses/lnp304/quizz/020/en.yml index 60e6b8e3a78..19e7a47d917 100644 --- a/courses/lnp304/quizz/020/en.yml +++ b/courses/lnp304/quizz/020/en.yml @@ -1,8 +1,8 @@ -question: What approach does the Auto-Fees algorithm use to establish performance benchmarks before making fee adjustments? -answer: Analyzes forwarding traffic from the node's top five earning peers over approximately 60 days +question: At what granularity does the Auto-Fees algorithm apply fee adjustments across a node's channels? +answer: On a per-peer basis, tailoring adjustments to the specific routing dynamics of each channel relationship wrong_answers: - - Monitors all channel activity across the entire Lightning Network for 30 days - - Compares current fees against the global average of similar-sized Lightning nodes - - "Tracks the node's total revenue performance against predetermined profit targets" + - As a blanket policy applied uniformly across all channels on the entire node + - Only to the five highest-capacity channels while leaving smaller channels unchanged + - Randomly across different channel groups to test which fee levels generate the most revenue explanation: | - The Auto-Fees algorithm establishes baselines by specifically analyzing the forwarding traffic of the node's top five earning peers over roughly 60 days. This targeted approach focuses on the most profitable relationships rather than all channels or network-wide data. Once this historical baseline is established, the system compares recent traffic (last few days) against this trend to make informed adjustments. The other options are incorrect because the algorithm doesn't monitor the entire network, doesn't compare against global averages, and doesn't use predetermined profit targets as its primary benchmark. + Auto-Fees applies its logic on a per-peer basis rather than enforcing a blanket policy across the entire node. Each channel relationship receives individually tailored fee adjustments based on its specific routing dynamics and traffic patterns. This targeted approach ensures that strategic peers with high traffic aren't mispriced due to conditions on other channels. The operator retains the ability to manually override any specific channel's fees regardless of the algorithm's suggestions. From c83254e13c06a2de2a022d65c42bd6b620ad57cb Mon Sep 17 00:00:00 2001 From: Asi0Flammeus Date: Tue, 31 Mar 2026 09:55:09 +0200 Subject: [PATCH 10/10] fix: remove duplicate resources section, add version disclaimer - Removed duplicate "Documentation and resources" block (kept preamble copy) - Added link to releases page for LitD version check Co-Authored-By: Claude Opus 4.6 (1M context) --- courses/lnp304/en.md | 13 +------------ 1 file changed, 1 insertion(+), 12 deletions(-) diff --git a/courses/lnp304/en.md b/courses/lnp304/en.md index 40a939d1d96..6308c255916 100644 --- a/courses/lnp304/en.md +++ b/courses/lnp304/en.md @@ -108,17 +108,6 @@ This course assumes familiarity with the Linux command line (`bash`, `ssh`, `nan You will need either an existing LND node (testnet or mainnet) for the first 10 chapters, or a fresh Ubuntu server for the final chapter. If you have never set up a Lightning node before, I recommend starting with the [LNP 202 course](https://planb.academy/courses/lnp202). -### Documentation and resources - -Throughout this course, we reference the official Lightning Labs documentation: - -- [Lightning Terminal docs](https://docs.lightning.engineering/lightning-network-tools/lightning-terminal) -- [Loop docs](https://docs.lightning.engineering/lightning-network-tools/loop) -- [Pool docs](https://docs.lightning.engineering/lightning-network-tools/pool) -- [LND docs](https://docs.lightning.engineering/lightning-network-tools/lnd) -- [Run LITD repository](https://github.com/lightninglabs/lightning-terminal) -- [Lightning Node Connect](https://docs.lightning.engineering/lightning-network-tools/lightning-terminal/lightning-node-connect) - Ready to take full control of your Lightning node? Let's get started. # First steps of installing your Lightning Node @@ -189,7 +178,7 @@ git clone https://github.com/lightninglabs/lightning-terminal.git cd lightning-terminal ``` -Next, we check out the latest stable release. As of this writing, that is version `v0.12.2-alpha`: +Next, we check out the latest stable release. You can find it on the [official releases page](https://github.com/lightninglabs/lightning-terminal/releases). As of this writing, that is version `v0.12.2-alpha`, but always verify the current version before proceeding: ```bash git checkout v0.12.2-alpha