Merge pull request #11380 from ziggie1984/fix-update-fee-floor
What changed, and why it matters
This update to the Lightning Network Daemon (LND) fixes several related bugs around commitment transaction fee rates for anchor-style channels. It prevents LND from accepting or sending fee updates below the protocol minimum, clamps a configuration value that could overflow and silently turn into a much lower fee, and cleans up a wallet reservation leak when an incoming channel open is rejected. The practical effect is to stop channels from being created or updated with fees so low that they cannot carry payments, and to prevent a misconfiguration from accidentally disabling the intended fee cap.
Upgrade nodes running LND to a version containing this commit, especially if they use anchor or taproot channels with non-default max-commit-fee-rate-anchors settings. Review any channels opened with fee rates below 253 sat/kw, as they may now be unable to update fees and could require cooperative closure.
Security signals we found
Rejection of sub-floor commitment fee updates before they are logged or signed
Integer-overflow mitigation for max-commit-fee-rate-anchors via clamping
Resource-leak fix for declined incoming channel reservations
Defense-in-depth floor check retained inside validateCommitmentSanity
Release notes explicitly describe the security/robustness relevance
Evidence from the diff
The commit merges PR #11380 and builds on PR #11373. Key changes: (1) lnwallet/channel.go adds validateFeeRateFloor and calls it in both LightningChannel.validateFeeRate and ReceiveUpdateFee, rejecting fee rates below chainfee.FeePerKwFloor (253 sat/kw) before they enter the update log. (2) config.go clamps MaxCommitFeeRateAnchors to lncfg.MaxAllowedFeeRate (10000 sat/vbyte) during validation, preventing an integer overflow when converting to sat/kw. (3) funding/manager.go ensures the fundee cancels its wallet reservation if it declines an open_channel message, fixing a resource leak. (4) lnwallet/wallet.go adds locking around ActiveReservations. Tests and release notes are updated accordingly.
Changed components
lnwallet/channel.golnwallet/wallet.gofunding/manager.goconfig.gosample-lnd.confInspect captured patch +286 / −33
### config.go
@@ -265,6 +265,22 @@ const (
defaultNoDisconnectOnPongFailure = false
)
+// clampMaxCommitFeeRateAnchors caps the configured max commitment fee rate of
+// anchor channels, in sat/vbyte, at the largest fee rate we ever use. Fee
+// estimates are already capped at that ceiling, so a larger value behaves the
+// same, but converting a huge value to sat/kw would overflow.
+func clampMaxCommitFeeRateAnchors(feeRate uint64) uint64 {
+ maxFeeRate := uint64(lncfg.MaxAllowedFeeRate)
+ if feeRate <= maxFeeRate {
+ return feeRate
+ }
+
+ ltndLog.Warnf("max-commit-fee-rate-anchors=%d exceeds maximum (%d), "+
+ "clamping to maximum", feeRate, maxFeeRate)
+
+ return maxFeeRate
+}
+
// validateMaxOutgoingCltvExpiry validates the configured maximum outgoing CLTV
// expiry against the node's default time lock delta.
func validateMaxOutgoingCltvExpiry(maxCltvExpiry, timeLockDelta uint32) error {
@@ -505,7 +521,7 @@ type Config struct {
MaxChannelFeeAllocation float64 `long:"max-channel-fee-allocation" description:"The maximum percentage of total funds that can be allocated to a channel's commitment fee. This only applies for the initiator of the channel. Valid values are within [0.1, 1]."`
- MaxCommitFeeRateAnchors uint64 `long:"max-commit-fee-rate-anchors" description:"The maximum fee rate in sat/vbyte that will be used for commitments of channels of the anchors type. If this is below the minimum commitment fee rate of 253 sat/kw, the minimum is used instead."`
+ MaxCommitFeeRateAnchors uint64 `long:"max-commit-fee-rate-anchors" description:"The maximum fee rate in sat/vbyte that will be used for commitments of channels of the anchors type. If this is below the minimum commitment fee rate of 253 sat/kw, the minimum is used instead. Values above 10000 sat/vbyte are clamped to 10000."`
DryRunMigration bool `long:"dry-run-migration" description:"If true, lnd will abort committing a migration if it would otherwise have been successful. This leaves the database unmodified, and still compatible with the previously active version of lnd."`
@@ -1857,6 +1873,10 @@ func ValidateConfig(cfg Config, interceptor signal.Interceptor, fileParser,
cfg.FwdHistoryDeleteBatchSize = channeldb.MaxResponseEvents
}
+ cfg.MaxCommitFeeRateAnchors = clampMaxCommitFeeRateAnchors(
+ cfg.MaxCommitFeeRateAnchors,
+ )
+
// The commitment fee floor takes precedence over a lower cap on the
// commitment fee rate of anchor channels, both when opening a channel
// and when updating its fee. Let the operator know if that's the case
### config_test.go
@@ -2,11 +2,14 @@ package lnd
import (
"fmt"
+ "math"
"testing"
"github.com/lightningnetwork/lnd/chainreg"
"github.com/lightningnetwork/lnd/htlcswitch"
"github.com/lightningnetwork/lnd/lncfg"
+ "github.com/lightningnetwork/lnd/lnwallet"
+ "github.com/lightningnetwork/lnd/lnwallet/chainfee"
"github.com/lightningnetwork/lnd/routing"
"github.com/lightningnetwork/lnd/tor"
"github.com/stretchr/testify/require"
@@ -224,6 +227,67 @@ func TestValidateConfigTrickleDelay(t *testing.T) {
}
}
+// TestClampMaxCommitFeeRateAnchors asserts that max-commit-fee-rate-anchors
+// is capped at the fee rate ceiling, so that converting it to sat/kw can't
+// overflow.
+func TestClampMaxCommitFeeRateAnchors(t *testing.T) {
+ t.Parallel()
+
+ maxFeeRate := uint64(lncfg.MaxAllowedFeeRate)
+ defaultFeeRate := uint64(
+ lnwallet.DefaultAnchorsCommitMaxFeeRateSatPerVByte,
+ )
+
+ tests := []struct {
+ name string
+ feeRate uint64
+ expected uint64
+ }{
+ {
+ name: "minimum unchanged",
+ feeRate: 1,
+ expected: 1,
+ },
+ {
+ name: "default unchanged",
+ feeRate: defaultFeeRate,
+ expected: defaultFeeRate,
+ },
+ {
+ name: "maximum unchanged",
+ feeRate: maxFeeRate,
+ expected: maxFeeRate,
+ },
+ {
+ name: "above maximum clamped",
+ feeRate: maxFeeRate + 1,
+ expected: maxFeeRate,
+ },
+ {
+ name: "overflowing value clamped",
+ feeRate: math.MaxUint64,
+ expected: maxFeeRate,
+ },
+ }
+
+ for _, tc := range tests {
+ t.Run(tc.name, func(t *testing.T) {
+ feeRate := clampMaxCommitFeeRateAnchors(tc.feeRate)
+ require.Equal(t, tc.expected, feeRate)
+
+ // The clamped value must convert to a sat/kw fee rate
+ // within the ceiling.
+ feeRateKw := chainfee.SatPerVByte(
+ feeRate,
+ ).FeePerKWeight()
+ require.Positive(t, feeRateKw)
+ require.LessOrEqual(
+ t, feeRateKw, chainfee.FeePerKwCeiling,
+ )
+ })
+ }
+}
+
// TestValidateMaxOutgoingCltvExpiry asserts that max-cltv-expiry accepts
// values within its supported bounds and rejects values outside them.
func TestValidateMaxOutgoingCltvExpiry(t *testing.T) {
### docs/release-notes/unreleased/11373.md
@@ -5,11 +5,22 @@
accepts for any commitment. This happened with
`max-commit-fee-rate-anchors=1`, which converts to 250 sat/kw, and with a
bitcoind or btcd backend that reported fee rates below the minimum. lnd now
- also raises the commitment fee rate of channels it opened below the minimum,
- and warns at startup if `max-commit-fee-rate-anchors` is below it.
+ also attempts to raise the commitment fee rate of channels it opened below
+ the minimum, and warns at startup if `max-commit-fee-rate-anchors` is below
+ it. If a pre-existing channel was opened below the minimum and cannot now
+ afford it, lnd [rejects the invalid fee
+ update](https://github.com/lightningnetwork/lnd/pull/11380) before adding or
+ sending it. lnd also rejects an incoming `update_fee` below the minimum
+ instead of force closing the channel on the next `commit_sig`.
* lnd now [rejects an `open_channel` with a commitment fee rate below 253
sat/kw](https://github.com/lightningnetwork/lnd/pull/11373) instead of
accepting a channel that couldn't carry HTLCs. Nodes running an older lnd
with `max-commit-fee-rate-anchors=1` can't open anchor or taproot channels
to an upgraded node until they raise that setting or upgrade.
+
+* lnd now [clamps `max-commit-fee-rate-anchors` to 10000
+ sat/vbyte](https://github.com/lightningnetwork/lnd/pull/11380) and logs a
+ warning if it is set higher. Previously a huge value overflowed when
+ converted to sat/kw, which made lnd use the minimum relay fee for anchor
+ commitments instead of the configured cap.
### funding/manager.go
@@ -1751,6 +1751,19 @@ func (f *Manager) fundeeProcessOpenChannel(peer lnpeer.Peer,
return
}
+ // Until the reservation is added to activeReservations below, this
+ // function owns it and releases it when returning early.
+ reservationTracked := false
+ defer func() {
+ if reservationTracked {
+ return
+ }
+
+ if err := reservation.Cancel(); err != nil {
+ log.Errorf("Unable to cancel reservation: %v", err)
+ }
+ }()
+
log.Debugf("Initialized channel reservation: zeroConf=%v, psbt=%v, "+
"cannedShim=%v", reservation.IsZeroConf(),
reservation.IsPsbt(), reservation.IsCannedShim())
@@ -1937,6 +1950,7 @@ func (f *Manager) fundeeProcessOpenChannel(peer lnpeer.Peer,
peer: peer,
}
f.activeReservations[peerIDKey][msg.PendingChannelID] = resCtx
+ reservationTracked = true
f.resMtx.Unlock()
// Update the timestamp once the fundingOpenMsg has been handled.
### funding/manager_test.go
@@ -1985,6 +1985,49 @@ func testLocalCSVLimit(t *testing.T, aliceMaxCSV, bobRequiredCSV uint16) {
}
}
+// TestFundingManagerFundeeReservationCleanup checks that the fundee releases
+// its wallet reservation when it declines an open_channel message.
+func TestFundingManagerFundeeReservationCleanup(t *testing.T) {
+ t.Parallel()
+
+ alice, bob := setupFundingManagers(t)
+ t.Cleanup(func() {
+ tearDownFundingManagers(t, alice, bob)
+ })
+
+ // Make Bob require a CSV delay above Alice's maximum, so that Alice
+ // declines the channel.
+ alice.fundingMgr.cfg.MaxLocalCSVDelay = 400
+ bob.fundingMgr.cfg.RequiredRemoteDelay = func(_ btcutil.Amount) uint16 {
+ return 500
+ }
+
+ initReq := &InitFundingMsg{
+ Peer: alice,
+ TargetPubkey: alice.privKey.PubKey(),
+ ChainHash: *fundingNetParams.GenesisHash,
+ LocalFundingAmt: 200000,
+ FundingFeePerKw: 1000,
+ Updates: make(chan *lnrpc.OpenStatusUpdate),
+ Err: make(chan error, 1),
+ }
+ bob.fundingMgr.InitFundingWorkflow(initReq)
+
+ openChannelReq, ok := assertFundingMsgSent(
+ t, bob.msgChan, "OpenChannel",
+ ).(*lnwire.OpenChannel)
+ require.True(t, ok)
+
+ alice.fundingMgr.ProcessFundingMsg(openChannelReq, bob)
+ assertFundingMsgSent(t, alice.msgChan, "Error")
+
+ // Alice must not have any reservations left in her wallet.
+ wallet := alice.fundingMgr.cfg.Wallet
+ require.Eventually(t, func() bool {
+ return len(wallet.ActiveReservations()) == 0
+ }, 5*time.Second, 10*time.Millisecond)
+}
+
func TestFundingManagerRestartBehavior(t *testing.T) {
t.Parallel()
### lnwallet/channel.go
@@ -9451,10 +9451,26 @@ func (lc *LightningChannel) StateSnapshot() *channeldb.ChannelSnapshot {
return lc.channelState.Snapshot()
}
-// validateFeeRate ensures that if the passed fee is applied to the channel,
-// and a new commitment is created (which evaluates this fee), then the
-// initiator of the channel does not dip below their reserve.
+// validateFeeRateFloor rejects a fee below the floor before it is added to an
+// update log. The same check in validateCommitmentSanity remains as defense in
+// depth.
+func validateFeeRateFloor(feePerKw chainfee.SatPerKWeight) error {
+ if feePerKw < chainfee.FeePerKwFloor {
+ return fmt.Errorf("commitment fee per kw %v below fee floor %v",
+ feePerKw, chainfee.FeePerKwFloor)
+ }
+
+ return nil
+}
+
+// validateFeeRate ensures that the passed fee meets the commitment fee floor
+// and that applying it to a new commitment does not make the initiator dip
+// below their reserve.
func (lc *LightningChannel) validateFeeRate(feePerKw chainfee.SatPerKWeight) error {
+ if err := validateFeeRateFloor(feePerKw); err != nil {
+ return err
+ }
+
// We'll ensure that we can accommodate this new fee change, yet still
// be above our reserve balance. Otherwise, we'll reject the fee
// update.
@@ -9583,6 +9599,10 @@ func (lc *LightningChannel) ReceiveUpdateFee(feePerKw chainfee.SatPerKWeight) er
return fmt.Errorf("received fee update as initiator")
}
+ if err := validateFeeRateFloor(feePerKw); err != nil {
+ return err
+ }
+
// TODO(roasbeef): or just modify to use the other balance?
pd := &paymentDescriptor{
ChanID: lc.ChannelID(),
### lnwallet/channel_test.go
@@ -8647,18 +8647,22 @@ func TestChannelMaxFeeRate(t *testing.T) {
func TestIdealCommitFeeRate(t *testing.T) {
t.Parallel()
- // propertyTest tests that the validateFeeRate function always passes
- // for the output returned by IdealCommitFeeRate for any valid random
- // inputs fed to IdealCommitFeeRate.
+ // propertyTest checks that validateFeeRate passes for the output of
+ // IdealCommitFeeRate. The minimum relay fee is floored to match the
+ // value passed by the link.
propertyTest := func(c *LightningChannel) func(ma maxAlloc,
netFee, minRelayFee, maxAnchorFee fee) bool {
return func(ma maxAlloc, netFee, minRelayFee,
maxAnchorFee fee) bool {
+ minRelay := max(
+ chainfee.SatPerKWeight(minRelayFee),
+ chainfee.FeePerKwFloor,
+ )
idealFeeRate := c.IdealCommitFeeRate(
chainfee.SatPerKWeight(netFee),
- chainfee.SatPerKWeight(minRelayFee),
+ minRelay,
chainfee.SatPerKWeight(maxAnchorFee),
float64(ma),
)
@@ -8966,6 +8970,70 @@ func TestChannelFeeRateFloor(t *testing.T) {
}
}
+// TestFeeUpdateRejectBelowFloor tests that a fee selected for a pre-existing
+// below-floor channel is rejected before it is added to the update log.
+func TestFeeUpdateRejectBelowFloor(t *testing.T) {
+ t.Parallel()
+
+ const (
+ channelCapacity = btcutil.Amount(500_000)
+ aliceBalance = btcutil.Amount(5_045)
+ )
+
+ chanType := channeldb.SingleFunderTweaklessBit |
+ channeldb.AnchorOutputsBit | channeldb.ZeroHtlcTxFeeBit
+ feePerKw := chainfee.FeePerKwFloor - 3
+ commitFee := feePerKw.FeeForWeight(CommitWeight(chanType))
+ aliceBalanceBeforeFees := aliceBalance + commitFee + 2*AnchorSize
+
+ aliceChannel, _, err := createTestChannels(
+ t, chanType, channelCapacity, aliceBalanceBeforeFees, feePerKw,
+ )
+ require.NoError(t, err, "unable to create test channels")
+ localBalance := aliceChannel.channelState.LocalCommitment.LocalBalance
+ require.Equal(t, aliceBalance, localBalance.ToSatoshis())
+
+ absoluteMaxFee, _ := aliceChannel.MaxFeeRate(1)
+ require.Equal(t, chainfee.SatPerKWeight(251), absoluteMaxFee)
+
+ idealFeeRate := aliceChannel.IdealCommitFeeRate(
+ chainfee.FeePerKwFloor, chainfee.FeePerKwFloor, feePerKw, 0.5,
+ )
+ require.Equal(t, absoluteMaxFee, idealFeeRate)
+
+ initialLogIndex := aliceChannel.updateLogs.Local.logIndex
+ require.False(t, aliceChannel.OweCommitment())
+
+ err = aliceChannel.UpdateFee(idealFeeRate)
+ require.ErrorContains(t, err, "below fee floor")
+ require.Equal(t, initialLogIndex,
+ aliceChannel.updateLogs.Local.logIndex)
+ require.False(t, aliceChannel.OweCommitment())
+}
+
+// TestReceiveUpdateFeeRejectBelowFloor tests that an incoming fee update
+// below the floor is rejected before it is added to the remote update log.
+func TestReceiveUpdateFeeRejectBelowFloor(t *testing.T) {
+ t.Parallel()
+
+ _, bobChannel, err := CreateTestChannels(
+ t, channeldb.SingleFunderTweaklessBit,
+ )
+ require.NoError(t, err, "unable to create test channels")
+
+ initialLogIndex := bobChannel.updateLogs.Remote.logIndex
+
+ err = bobChannel.ReceiveUpdateFee(chainfee.FeePerKwFloor - 1)
+ require.ErrorContains(t, err, "below fee floor")
+ require.Equal(t, initialLogIndex,
+ bobChannel.updateLogs.Remote.logIndex)
+ require.Zero(t, bobChannel.updateLogs.Remote.Len())
+
+ // A fee update at the floor is still accepted.
+ require.NoError(t, bobChannel.ReceiveUpdateFee(chainfee.FeePerKwFloor))
+ require.Equal(t, 1, bobChannel.updateLogs.Remote.Len())
+}
+
// TestFetchParent tests lookup of an entry's parent in the appropriate log.
func TestFetchParent(t *testing.T) {
tests := []struct {
### lnwallet/test_utils.go
@@ -126,7 +126,21 @@ func CreateTestChannels(t *testing.T, chanType channeldb.ChannelType,
return nil, nil, err
}
- channelBal := channelCapacity / 2
+ return createTestChannels(
+ t, chanType, channelCapacity, channelCapacity/2, 6000,
+ dbModifiers...,
+ )
+}
+
+// createTestChannels creates a pair of test channels with a configurable
+// capacity, initiator balance before fees and commitment fee rate.
+func createTestChannels(t *testing.T, chanType channeldb.ChannelType,
+ channelCapacity, aliceBalanceBeforeFees btcutil.Amount,
+ feePerKw chainfee.SatPerKWeight,
+ dbModifiers ...channeldb.OptionModifier) (*LightningChannel,
+ *LightningChannel, error) {
+
+ bobBalance := channelCapacity - aliceBalanceBeforeFees
csvTimeoutAlice := uint32(5)
csvTimeoutBob := uint32(4)
isAliceInitiator := true
@@ -237,8 +251,9 @@ func CreateTestChannels(t *testing.T, chanType channeldb.ChannelType,
aliceCommitPoint := input.ComputeCommitmentPoint(aliceFirstRevoke[:])
aliceCommitTx, bobCommitTx, err := CreateCommitmentTxns(
- channelBal, channelBal, &aliceCfg, &bobCfg, aliceCommitPoint,
- bobCommitPoint, *fundingTxIn, chanType, isAliceInitiator, 0,
+ aliceBalanceBeforeFees, bobBalance, &aliceCfg, &bobCfg,
+ aliceCommitPoint, bobCommitPoint, *fundingTxIn, chanType,
+ isAliceInitiator, 0,
)
if err != nil {
return nil, nil, err
@@ -247,26 +262,21 @@ func CreateTestChannels(t *testing.T, chanType channeldb.ChannelType,
dbAlice := channeldb.OpenForTesting(t, t.TempDir(), dbModifiers...)
dbBob := channeldb.OpenForTesting(t, t.TempDir(), dbModifiers...)
- estimator := chainfee.NewStaticEstimator(6000, 0)
- feePerKw, err := estimator.EstimateFeePerKW(1)
- if err != nil {
- return nil, nil, err
- }
- commitFee := calcStaticFee(chanType, 0)
+ commitFee := feePerKw.FeeForWeight(CommitWeight(chanType))
var anchorAmt btcutil.Amount
if chanType.HasAnchors() {
anchorAmt += 2 * AnchorSize
}
aliceBalance := lnwire.NewMSatFromSatoshis(
- channelBal - commitFee - anchorAmt,
+ aliceBalanceBeforeFees - commitFee - anchorAmt,
)
- bobBalance := lnwire.NewMSatFromSatoshis(channelBal)
+ bobBalanceMSat := lnwire.NewMSatFromSatoshis(bobBalance)
aliceLocalCommit := channeldb.ChannelCommitment{
CommitHeight: 0,
LocalBalance: aliceBalance,
- RemoteBalance: bobBalance,
+ RemoteBalance: bobBalanceMSat,
CommitFee: commitFee,
FeePerKw: btcutil.Amount(feePerKw),
CommitTx: aliceCommitTx,
@@ -275,15 +285,15 @@ func CreateTestChannels(t *testing.T, chanType channeldb.ChannelType,
aliceRemoteCommit := channeldb.ChannelCommitment{
CommitHeight: 0,
LocalBalance: aliceBalance,
- RemoteBalance: bobBalance,
+ RemoteBalance: bobBalanceMSat,
CommitFee: commitFee,
FeePerKw: btcutil.Amount(feePerKw),
CommitTx: bobCommitTx,
CommitSig: testSigBytes,
}
bobLocalCommit := channeldb.ChannelCommitment{
CommitHeight: 0,
- LocalBalance: bobBalance,
+ LocalBalance: bobBalanceMSat,
RemoteBalance: aliceBalance,
CommitFee: commitFee,
FeePerKw: btcutil.Amount(feePerKw),
@@ -292,7 +302,7 @@ func CreateTestChannels(t *testing.T, chanType channeldb.ChannelType,
}
bobRemoteCommit := channeldb.ChannelCommitment{
CommitHeight: 0,
- LocalBalance: bobBalance,
+ LocalBalance: bobBalanceMSat,
RemoteBalance: aliceBalance,
CommitFee: commitFee,
FeePerKw: btcutil.Amount(feePerKw),
### lnwallet/update_log_test.go
@@ -149,13 +149,12 @@ func TestReceiveUpdateFeeReplacement(t *testing.T) {
)
require.NoError(t, err)
+ // Start at the fee floor, since lower fee rates are rejected.
const numUpdates = 10_000
- for i := 1; i <= numUpdates; i++ {
- require.NoError(
- t, bobChannel.ReceiveUpdateFee(
- chainfee.SatPerKWeight(i),
- ),
- )
+ const firstFeeRate = chainfee.FeePerKwFloor
+ const lastFeeRate = firstFeeRate + numUpdates - 1
+ for feeRate := firstFeeRate; feeRate <= lastFeeRate; feeRate++ {
+ require.NoError(t, bobChannel.ReceiveUpdateFee(feeRate))
}
require.Equal(t, uint64(1), bobChannel.updateLogs.Remote.logIndex)
@@ -172,7 +171,7 @@ func TestReceiveUpdateFeeReplacement(t *testing.T) {
require.Len(t, feeUpdates, 1)
require.Equal(
- t, int64(numUpdates), int64(feeUpdates[0].Amount.ToSatoshis()),
+ t, int64(lastFeeRate), int64(feeUpdates[0].Amount.ToSatoshis()),
)
require.Zero(t, feeUpdates[0].LogIndex)
}
### lnwallet/wallet.go
@@ -677,6 +677,9 @@ func (l *LightningWallet) ResetReservations() {
// ActiveReservations returns a slice of all the currently active
// (non-canceled) reservations.
func (l *LightningWallet) ActiveReservations() []*ChannelReservation {
+ l.limboMtx.RLock()
+ defer l.limboMtx.RUnlock()
+
reservations := make([]*ChannelReservation, 0, len(l.fundingLimbo))
for _, reservation := range l.fundingLimbo {
reservations = append(reservations, reservation)
### sample-lnd.conf
@@ -488,7 +488,8 @@
; The maximum fee rate in sat/vbyte that will be used for commitments of
; channels of the anchors type. If this is below the minimum commitment fee
-; rate of 253 sat/kw, the minimum is used instead.
+; rate of 253 sat/kw, the minimum is used instead. Values above 10000 sat/vbyte
+; are clamped to 10000.
; max-commit-fee-rate-anchors=10
; DEPRECATED: This value will be deprecated please use the new setting Why this scored 59/100
Community notes
Notes can correct, qualify, or add evidence to the AI analysis. Every note shown here has been validated by a human moderator.
The AI analysis stands alone for now. Submit a note if you can add evidence or important context.