itest: add log-only local reputation itest

Add an integration test that runs a forwarding node with the reputation
subsystem enabled through a successful forward, a downstream-failed forward,
and a warm restart. It asserts non-interference (payments behave exactly as
without the subsystem) and, via a new HarnessTest.AssertNodeLogContains helper,
that the node actually computes reputation by matching the "Reputation gained"
log line after a forward and again after the restart.

Author: GeorgeTsagk

itest/list_on_test.go

@@ -10,6 +10,10 @@ import (
 )
 
 var allTestCases = []*lntest.TestCase{
+	{
+		Name:     "local reputation log only",
+		TestFunc: testLocalReputationLogOnly,
+	},
 	{
 		Name:     "update channel status",
 		TestFunc: testUpdateChanStatus,

itest/lnd_reputation_test.go

@@ -0,0 +1,98 @@
+package itest
+
+import (
+	"github.com/btcsuite/btcd/btcutil"
+	"github.com/lightningnetwork/lnd/lnrpc"
+	"github.com/lightningnetwork/lnd/lnrpc/routerrpc"
+	"github.com/lightningnetwork/lnd/lntest"
+)
+
+// testLocalReputationLogOnly verifies that enabling the experimental,
+// read-only local reputation subsystem on a forwarding node does not affect
+// routing. It exercises the end-to-end log-only invariant across the paths the
+// switch hooks observe — a successful forward, a failed forward, and a warm
+// restart — asserting forwarding behaviour is unchanged in every case.
+//
+// Beyond non-interference, it also verifies the subsystem actually computes
+// reputation: after a successful forward, Bob's log must contain the
+// "Reputation gained" summary (emitted only when the resolution yields a
+// positive effective fee), confirming the hooks fed a real, positive
+// reputation update. (Asserting exact per-channel values over RPC is deferred
+// to the P10 debug read-out; the log assertion gives behavioural coverage now.)
+func testLocalReputationLogOnly(ht *lntest.HarnessTest) {
+	const chanAmt = btcutil.Amount(100_000)
+	const paymentAmt = 1000
+
+	// Alice -> Bob -> Carol, with Bob (the forwarding node) running the
+	// experimental read-only reputation subsystem.
+	alice := ht.NewNodeWithCoins("Alice", nil)
+	bob := ht.NewNodeWithCoins("Bob", []string{"--routing.reputation"})
+	carol := ht.NewNode("Carol", nil)
+
+	ht.ConnectNodes(alice, bob)
+	ht.ConnectNodes(bob, carol)
+
+	// Open Alice -> Bob and Bob -> Carol.
+	chanPointAB := ht.OpenChannel(
+		alice, bob, lntest.OpenChannelParams{Amt: chanAmt},
+	)
+	chanPointBC := ht.OpenChannel(
+		bob, carol, lntest.OpenChannelParams{Amt: chanAmt},
+	)
+
+	// Make sure Alice has learned of the Bob -> Carol channel so she can
+	// route the multi-hop payment.
+	ht.AssertChannelInGraph(alice, chanPointBC)
+
+	// 1. Successful forward. Carol invoices, Alice pays via Bob. With Bob's
+	// reputation subsystem in log-only mode this must succeed exactly as it
+	// would without it (Bob observes OnForward + OnSettle).
+	payReqs, _, _ := ht.CreatePayReqs(carol, paymentAmt, 1)
+	ht.CompletePaymentRequests(alice, payReqs)
+
+	// The forward earned Bob a fee, which his reputation subsystem must
+	// record as a positive reputation gain for the outgoing (Bob -> Carol)
+	// channel. The "Reputation gained" summary is logged at Info only when
+	// the effective fee is positive, so its presence confirms the subsystem
+	// observed the forward+settle and computed a real, positive update.
+	ht.AssertNodeLogContains(bob, "Reputation gained: outgoing=")
+
+	// 2. Failed forward. A payment to Carol with an unknown payment hash is
+	// routed Alice -> Bob -> Carol and rejected at Carol, so Bob observes
+	// the forward and its downstream failure (OnFail). Bob must remain
+	// unaffected and the payment must fail cleanly.
+	failReq := &routerrpc.SendPaymentRequest{
+		Dest:           carol.PubKey[:],
+		Amt:            paymentAmt,
+		PaymentHash:    ht.Random32Bytes(),
+		FinalCltvDelta: finalCltvDelta,
+		FeeLimitMsat:   noFeeLimitMsat,
+	}
+	ht.SendPaymentAssertFail(
+		alice, failReq,
+		lnrpc.PaymentFailureReason_FAILURE_REASON_INCORRECT_PAYMENT_DETAILS, //nolint:ll
+	)
+
+	// 3. Warm restart. Restarting Bob reloads persisted reputation
+	// state and discards any in-flight HTLC tracking (the documented
+	// log-only behaviour). Bob must come back and keep forwarding.
+	ht.RestartNode(bob)
+	ht.EnsureConnected(alice, bob)
+	ht.EnsureConnected(bob, carol)
+	ht.AssertNodeNumChannels(bob, 2)
+	ht.AssertChannelActive(bob, chanPointAB)
+	ht.AssertChannelActive(bob, chanPointBC)
+
+	// A subsequent payment must still forward successfully after the warm
+	// restart.
+	payReqs2, _, _ := ht.CreatePayReqs(carol, paymentAmt, 1)
+	ht.CompletePaymentRequests(alice, payReqs2)
+
+	// The post-restart forward must again be observed and scored,
+	// confirming the subsystem resumes computing reputation after a
+	// warm restart.
+	ht.AssertNodeLogContains(bob, "Reputation gained: outgoing=")
+
+	ht.CloseChannel(alice, chanPointAB)
+	ht.CloseChannel(bob, chanPointBC)
+}

lntest/harness_assertion.go

@@ -8,6 +8,8 @@ import (
 	"encoding/json"
 	"fmt"
 	"math"
+	"os"
+	"path/filepath"
 	"sort"
 	"strings"
 	"time"
@@ -60,6 +62,48 @@ func (h *HarnessTest) WaitForBlockchainSync(hn *node.HarnessNode) {
 	require.NoError(h, err, "timeout waiting for blockchain sync")
 }
 
+// AssertNodeLogContains waits until the node's lnd.log contains the given
+// substring, failing the test if it does not appear within DefaultTimeout.
+// Logs flush asynchronously, so the file is polled. This is used to assert on
+// log-only subsystem behaviour (e.g. the read-only reputation subsystem) that
+// is not otherwise exposed over RPC.
+func (h *HarnessTest) AssertNodeLogContains(hn *node.HarnessNode,
+	substr string) {
+
+	err := wait.NoError(func() error {
+		var found bool
+		_ = filepath.WalkDir(hn.Cfg.LogDir, func(path string,
+			d os.DirEntry, err error) error {
+
+			if err != nil || d.IsDir() || found {
+				return nil
+			}
+			if filepath.Base(path) != "lnd.log" {
+				return nil
+			}
+
+			data, readErr := os.ReadFile(path)
+			if readErr == nil && strings.Contains(
+				string(data), substr,
+			) {
+
+				found = true
+			}
+
+			return nil
+		})
+
+		if found {
+			return nil
+		}
+
+		return fmt.Errorf("%s log does not contain %q", hn.Name(),
+			substr)
+	}, DefaultTimeout)
+
+	require.NoError(h, err, "timeout waiting for log substring %q", substr)
+}
+
 // WaitForBlockchainSyncTo waits until the node is synced to bestBlock.
 func (h *HarnessTest) WaitForBlockchainSyncTo(hn *node.HarnessNode,
 	bestBlock chainhash.Hash) {