Merge pull request #11373 from starius/commit-fee-rate-floor
What changed, and why it matters
This patch fixes a bug where LND could propose or accept Lightning channel commitment transaction fees that were too low to be valid. Specifically, with a setting of max-commit-fee-rate-anchors=1, LND would propose 250 sat/kw, below the 253 sat/kw floor its own channel state machine requires. This could prevent channels from carrying payments or cause peers to reject or fail to sign updates. The fix enforces the 253 sat/kw minimum when opening channels, updating fees, and at startup configuration.
Upgrade nodes to this commit or later, especially those using anchor or taproot channels. Operators who set max-commit-fee-rate-anchors=1 should raise it to at least 1 sat/vbyte (253 sat/kw is the effective floor) and monitor startup warnings. Peers running older versions with the low setting may experience failed channel opens against upgraded nodes.
Security signals we found
Denial-of-service / channel-stalling: too-low commitment fee rates could leave a channel unable to carry HTLCs or unable to be signed by the peer
Interoperability failure: older nodes with max-commit-fee-rate-anchors=1 cannot open anchor/taproot channels to upgraded nodes until reconfigured
Configuration-hardening: startup warning when user-supplied cap is below enforced floor
Protocol sanity enforcement: fee floor applied before channel acceptor, preventing acceptor bypass of a hard consensus-like rule
Evidence from the diff
The commit enforces chainfee.FeePerKwFloor (253 sat/kw) as a hard floor for commitment fee rates. Changes include: rejecting inbound open_channel messages whose FeePerKiloWeight is below the floor before the channel acceptor is consulted; raising the proposed commit fee rate to the floor when initiating a channel, even if the anchor cap or fee estimator is lower; raising the minimum relay fee used in update_fee handling to the floor; and warning at startup if max-commit-fee-rate-anchors is configured below the floor. Tests cover rejection/acceptance at the boundary and proposed rate behavior for both anchor and static-remote-key channels.
Changed components
funding/manager.gohtlcswitch/link.goconfig.golnwallet/errors.gosample-lnd.confInspect captured patch +411 / −9
### config.go
@@ -41,6 +41,7 @@ import (
"github.com/lightningnetwork/lnd/lnrpc/signrpc"
"github.com/lightningnetwork/lnd/lnutils"
"github.com/lightningnetwork/lnd/lnwallet"
+ "github.com/lightningnetwork/lnd/lnwallet/chainfee"
"github.com/lightningnetwork/lnd/lnwire"
"github.com/lightningnetwork/lnd/onionmessage"
"github.com/lightningnetwork/lnd/routing"
@@ -504,7 +505,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. Must be large enough to ensure transaction propagation"`
+ 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."`
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."`
@@ -1856,6 +1857,18 @@ func ValidateConfig(cfg Config, interceptor signal.Interceptor, fileParser,
cfg.FwdHistoryDeleteBatchSize = channeldb.MaxResponseEvents
}
+ // 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
+ // for their configured cap.
+ anchorsCap := chainfee.SatPerVByte(cfg.MaxCommitFeeRateAnchors)
+ if anchorsCap.FeePerKWeight() < chainfee.FeePerKwFloor {
+ ltndLog.Warnf("max-commit-fee-rate-anchors=%d (%v) is below "+
+ "the minimum commitment fee rate, using %v instead",
+ cfg.MaxCommitFeeRateAnchors, anchorsCap.FeePerKWeight(),
+ chainfee.FeePerKwFloor)
+ }
+
if err := cfg.Gossip.Parse(); err != nil {
return nil, mkErr("error parsing gossip syncer: %v", err)
}
### docs/release-notes/unreleased/11373.md
@@ -0,0 +1,15 @@
+# Bug Fixes
+
+* lnd [no longer proposes a commitment fee rate below 253
+ sat/kw](https://github.com/lightningnetwork/lnd/pull/11373), the minimum it
+ 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.
+
+* 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.
### funding/manager.go
@@ -538,7 +538,9 @@ type Config struct {
EnableUpfrontShutdown bool
// MaxAnchorsCommitFeeRate is the max commitment fee rate we'll use as
- // the initiator for channels of the anchor type.
+ // the initiator for channels of the anchor type. A value below
+ // chainfee.FeePerKwFloor acts as the floor, as we never propose a
+ // commitment fee rate below it.
MaxAnchorsCommitFeeRate chainfee.SatPerKWeight
// DeleteAliasEdge allows the Manager to delete an alias channel edge
@@ -1575,6 +1577,23 @@ func (f *Manager) fundeeProcessOpenChannel(peer lnpeer.Peer,
return
}
+ // Reject a commitment fee rate below the floor that the channel state
+ // machine enforces for every later commitment. We can't raise the rate
+ // ourselves, as both sides need to construct the same commitment
+ // transactions. The floor applies to every commitment type, and the
+ // channel acceptor can't change the rate, so we check it before
+ // consulting the acceptor.
+ commitFeePerKw := chainfee.SatPerKWeight(msg.FeePerKiloWeight)
+ if commitFeePerKw < chainfee.FeePerKwFloor {
+ f.failFundingFlow(
+ peer, cid, lnwallet.ErrCommitFeeRateTooLow(
+ commitFeePerKw, chainfee.FeePerKwFloor,
+ ),
+ )
+
+ return
+ }
+
// Send the OpenChannel request to the ChannelAcceptor to determine
// whether this node will accept the channel.
chanReq := &chanacceptor.ChannelAcceptRequest{
@@ -1713,7 +1732,7 @@ func (f *Manager) fundeeProcessOpenChannel(peer lnpeer.Peer,
NodeAddr: peer.Address(),
LocalFundingAmt: 0,
RemoteFundingAmt: amt,
- CommitFeePerKw: chainfee.SatPerKWeight(msg.FeePerKiloWeight),
+ CommitFeePerKw: commitFeePerKw,
FundingFeePerKw: 0,
PushMSat: msg.PushAmount,
Flags: msg.ChannelFlags,
@@ -5016,6 +5035,10 @@ func (f *Manager) handleInitFundingMsg(msg *InitFundingMsg) {
commitFeePerKw = f.cfg.MaxAnchorsCommitFeeRate
}
+ // Never propose a commitment fee rate below the floor, as our peer
+ // would reject it. The floor takes precedence over a lower anchor cap.
+ commitFeePerKw = max(commitFeePerKw, chainfee.FeePerKwFloor)
+
var scidFeatureVal bool
if hasFeatures(
msg.Peer.LocalFeatures(), msg.Peer.RemoteFeatures(),
### funding/manager_test.go
@@ -469,6 +469,12 @@ func createTestFundingManager(t *testing.T, privKey *btcec.PrivateKey,
netParams := fundingNetParams.Params
estimator := chainfee.NewStaticEstimator(62500, 0)
+ // Like a node running with the default config, cap the commitment fee
+ // rate of anchor channels at 10 sat/vbyte.
+ maxAnchorsCommitFeeRate := chainfee.SatPerVByte(
+ lnwallet.DefaultAnchorsCommitMaxFeeRateSatPerVByte,
+ ).FeePerKWeight()
+
chainNotifier := &mockNotifier{
oneConfChannel: make(chan *chainntnfs.TxConfirmation, 1),
sixConfChannel: make(chan *chainntnfs.TxConfirmation, 1),
@@ -628,6 +634,7 @@ func createTestFundingManager(t *testing.T, privKey *btcec.PrivateKey,
MaxChanSize: MaxBtcFundingAmount,
MaxLocalCSVDelay: defaultMaxLocalCSVDelay,
MaxPendingChannels: lncfg.DefaultMaxPendingChannels,
+ MaxAnchorsCommitFeeRate: maxAnchorsCommitFeeRate,
NotifyOpenChannelEvent: evt.NotifyOpenChannelEvent,
OpenChannelPredicate: chainedAcceptor,
NotifyPendingOpenChannelEvent: evt.NotifyPendingOpenChannelEvent,
@@ -756,9 +763,10 @@ func recreateAliceFundingManager(t *testing.T, alice *testNode) {
FeeRate: 1000,
TimeLockDelta: 10,
},
- DefaultMinHtlcIn: 5,
- RequiredRemoteMaxValue: oldCfg.RequiredRemoteMaxValue,
- ReportShortChanID: oldCfg.ReportShortChanID,
+ DefaultMinHtlcIn: 5,
+ RequiredRemoteMaxValue: oldCfg.RequiredRemoteMaxValue,
+ ReportShortChanID: oldCfg.ReportShortChanID,
+ MaxAnchorsCommitFeeRate: oldCfg.MaxAnchorsCommitFeeRate,
PublishTransaction: func(txn *wire.MsgTx, _ string) error {
publishChan <- txn
return nil
@@ -5457,6 +5465,314 @@ func TestFundingManagerAcceptChanType(t *testing.T) {
assertNumPendingReservations(t, bob, alicePubKey, 1)
}
+// countingAcceptor is a channel acceptor that accepts every channel and counts
+// how often it's consulted.
+type countingAcceptor struct {
+ calls atomic.Int32
+}
+
+// Accept counts the call and accepts the channel with our default parameters.
+//
+// NOTE: This is part of the chanacceptor.ChannelAcceptor interface.
+func (c *countingAcceptor) Accept(
+ *acpt.ChannelAcceptRequest) *acpt.ChannelAcceptResponse {
+
+ c.calls.Add(1)
+
+ return &acpt.ChannelAcceptResponse{}
+}
+
+// TestFundingManagerCommitFeeRateFloor checks that the fundee rejects an
+// OpenChannel message proposing a commitment fee rate below the floor that the
+// channel state machine enforces for every later commitment, without
+// consulting the channel acceptor, and accepts one at or above the floor.
+func TestFundingManagerCommitFeeRateFloor(t *testing.T) {
+ t.Parallel()
+
+ staticRemoteKey := (*lnwire.ChannelType)(lnwire.NewRawFeatureVector(
+ lnwire.StaticRemoteKeyRequired,
+ ))
+ anchors := (*lnwire.ChannelType)(lnwire.NewRawFeatureVector(
+ lnwire.StaticRemoteKeyRequired,
+ lnwire.AnchorsZeroFeeHtlcTxRequired,
+ ))
+
+ floor := chainfee.FeePerKwFloor
+
+ // newOpenChannel returns an otherwise valid OpenChannel message from
+ // Alice that proposes the given channel type and commitment fee rate.
+ newOpenChannel := func(chanType *lnwire.ChannelType,
+ feeRate chainfee.SatPerKWeight) *lnwire.OpenChannel {
+
+ return &lnwire.OpenChannel{
+ ChainHash: *fundingNetParams.GenesisHash,
+ PendingChannelID: [32]byte{0x01},
+ FundingAmount: btcutil.Amount(10000000),
+ DustLimit: btcutil.Amount(546),
+ MaxValueInFlight: lnwire.MilliSatoshi(100000000),
+ ChannelReserve: btcutil.Amount(10000),
+ HtlcMinimum: lnwire.MilliSatoshi(1000),
+ FeePerKiloWeight: uint32(feeRate),
+ CsvDelay: 144,
+ MaxAcceptedHTLCs: 483,
+ FundingKey: alicePubKey,
+ RevocationPoint: alicePubKey,
+ PaymentPoint: alicePubKey,
+ DelayedPaymentPoint: alicePubKey,
+ HtlcPoint: alicePubKey,
+ FirstCommitmentPoint: alicePubKey,
+ ChannelType: chanType,
+ }
+ }
+
+ testCases := []struct {
+ name string
+ chanType *lnwire.ChannelType
+ feeRate chainfee.SatPerKWeight
+ accept bool
+ }{
+ {
+ name: "zero",
+ chanType: staticRemoteKey,
+ feeRate: 0,
+ },
+ {
+ name: "one",
+ chanType: staticRemoteKey,
+ feeRate: 1,
+ },
+ {
+ // A max-commit-fee-rate-anchors of 1 sat/vbyte
+ // converts to this rate.
+ name: "one sat per vbyte",
+ chanType: staticRemoteKey,
+ feeRate: chainfee.SatPerVByte(1).FeePerKWeight(),
+ },
+ {
+ name: "just below the floor",
+ chanType: staticRemoteKey,
+ feeRate: floor - 1,
+ },
+ {
+ name: "at the floor",
+ chanType: staticRemoteKey,
+ feeRate: floor,
+ accept: true,
+ },
+ {
+ name: "above the floor",
+ chanType: staticRemoteKey,
+ feeRate: floor + 1,
+ accept: true,
+ },
+ {
+ // The zero-fee HTLC transactions of anchor channels
+ // don't exempt the commitment transaction.
+ name: "anchors just below the floor",
+ chanType: anchors,
+ feeRate: floor - 1,
+ },
+ {
+ name: "anchors at the floor",
+ chanType: anchors,
+ feeRate: floor,
+ accept: true,
+ },
+ }
+
+ for _, tc := range testCases {
+ t.Run(tc.name, func(t *testing.T) {
+ t.Parallel()
+
+ acceptor := &countingAcceptor{}
+ useAcceptor := func(cfg *Config) {
+ cfg.OpenChannelPredicate = acceptor
+ }
+
+ alice, bob := setupFundingManagers(t, useAcceptor)
+ t.Cleanup(func() {
+ tearDownFundingManagers(t, alice, bob)
+ })
+
+ // Both peers support anchors, so the static remote key
+ // channel type explicitly asks for a channel without
+ // anchor outputs.
+ featureBits := []lnwire.FeatureBit{
+ lnwire.StaticRemoteKeyOptional,
+ lnwire.AnchorsZeroFeeHtlcTxOptional,
+ }
+ alice.localFeatures = featureBits
+ alice.remoteFeatures = featureBits
+ bob.localFeatures = featureBits
+ bob.remoteFeatures = featureBits
+
+ openChannelReq := newOpenChannel(
+ tc.chanType, tc.feeRate,
+ )
+ bob.fundingMgr.ProcessFundingMsg(openChannelReq, alice)
+
+ if tc.accept {
+ assertFundingMsgSent(
+ t, bob.msgChan, "AcceptChannel",
+ )
+ assertNumPendingReservations(
+ t, bob, alicePubKey, 1,
+ )
+ require.EqualValues(t, 1, acceptor.calls.Load())
+
+ return
+ }
+
+ // Bob should reject the channel with an error naming
+ // the fee rate, without consulting his channel acceptor
+ // or creating a reservation.
+ errMsg, ok := assertFundingMsgSent(
+ t, bob.msgChan, "Error",
+ ).(*lnwire.Error)
+ require.True(t, ok)
+
+ expectedErr := lnwallet.ErrCommitFeeRateTooLow(
+ tc.feeRate, floor,
+ )
+ require.Equal(
+ t, expectedErr.Error(), string(errMsg.Data),
+ )
+
+ pendingChanID := lnwire.ChannelID(
+ openChannelReq.PendingChannelID,
+ )
+ require.Equal(t, pendingChanID, errMsg.ChanID)
+ require.Zero(t, acceptor.calls.Load())
+ assertNumPendingReservations(t, bob, alicePubKey, 0)
+ })
+ }
+}
+
+// TestFundingManagerProposedCommitFeeRate checks the commitment fee rate that
+// the initiator proposes: the fee estimate, capped for anchor channels, but
+// never below the floor. The fundee should store the proposed rate unchanged.
+func TestFundingManagerProposedCommitFeeRate(t *testing.T) {
+ t.Parallel()
+
+ staticRemoteKey := (*lnwire.ChannelType)(lnwire.NewRawFeatureVector(
+ lnwire.StaticRemoteKeyRequired,
+ ))
+ anchors := (*lnwire.ChannelType)(lnwire.NewRawFeatureVector(
+ lnwire.StaticRemoteKeyRequired,
+ lnwire.AnchorsZeroFeeHtlcTxRequired,
+ ))
+
+ floor := chainfee.FeePerKwFloor
+
+ // A max-commit-fee-rate-anchors of 1 sat/vbyte converts to a cap below
+ // the floor.
+ lowCap := chainfee.SatPerVByte(1).FeePerKWeight()
+
+ // assertCommitFeeRate asserts that both commitments of the node's only
+ // pending channel use the given fee rate.
+ assertCommitFeeRate := func(t *testing.T, node *testNode,
+ feeRate chainfee.SatPerKWeight) {
+
+ t.Helper()
+
+ db := node.fundingMgr.cfg.Wallet.Cfg.Database
+ channels, err := db.FetchPendingChannels()
+ require.NoError(t, err)
+ require.Len(t, channels, 1)
+
+ channel := channels[0]
+ require.Equal(
+ t, btcutil.Amount(feeRate),
+ channel.LocalCommitment.FeePerKw,
+ )
+ require.Equal(
+ t, btcutil.Amount(feeRate),
+ channel.RemoteCommitment.FeePerKw,
+ )
+ }
+
+ testCases := []struct {
+ name string
+ chanType *lnwire.ChannelType
+ estimate chainfee.SatPerKWeight
+ anchorsCap chainfee.SatPerKWeight
+ expected chainfee.SatPerKWeight
+ }{
+ {
+ name: "anchors capped",
+ chanType: anchors,
+ estimate: 62500,
+ anchorsCap: 2500,
+ expected: 2500,
+ },
+ {
+ name: "anchors cap below floor",
+ chanType: anchors,
+ estimate: 62500,
+ anchorsCap: lowCap,
+ expected: floor,
+ },
+ {
+ name: "anchors estimate below floor",
+ chanType: anchors,
+ estimate: floor - 1,
+ anchorsCap: 2500,
+ expected: floor,
+ },
+ {
+ name: "static remote key ignores anchors cap",
+ chanType: staticRemoteKey,
+ estimate: 62500,
+ anchorsCap: 2500,
+ expected: 62500,
+ },
+ {
+ name: "static remote key estimate below floor",
+ chanType: staticRemoteKey,
+ estimate: floor - 1,
+ anchorsCap: 2500,
+ expected: floor,
+ },
+ }
+
+ for _, tc := range testCases {
+ t.Run(tc.name, func(t *testing.T) {
+ t.Parallel()
+
+ estimator := chainfee.NewStaticEstimator(
+ tc.estimate, 0,
+ )
+ setFeePolicy := func(cfg *Config) {
+ cfg.FeeEstimator = estimator
+ cfg.MaxAnchorsCommitFeeRate = tc.anchorsCap
+ }
+
+ alice, bob := setupFundingManagers(t, setFeePolicy)
+ t.Cleanup(func() {
+ tearDownFundingManagers(t, alice, bob)
+ })
+
+ featureBits := []lnwire.FeatureBit{
+ lnwire.StaticRemoteKeyOptional,
+ lnwire.AnchorsZeroFeeHtlcTxOptional,
+ }
+ alice.localFeatures = featureBits
+ alice.remoteFeatures = featureBits
+ bob.localFeatures = featureBits
+ bob.remoteFeatures = featureBits
+
+ updateChan := make(chan *lnrpc.OpenStatusUpdate)
+ openChannel(
+ t, alice, bob, 500000, 0, 1, updateChan, true,
+ tc.chanType,
+ )
+
+ assertCommitFeeRate(t, alice, tc.expected)
+ assertCommitFeeRate(t, bob, tc.expected)
+ })
+ }
+}
+
// TestFundingManagerZeroConf tests that the fundingmanager properly handles
// the whole flow for zero-conf channels.
func TestFundingManagerZeroConf(t *testing.T) {
### htlcswitch/link.go
@@ -3965,7 +3965,14 @@ func (l *channelLink) handleUpdateFee(ctx context.Context) error {
return fmt.Errorf("unable to sample network fee: %w", err)
}
- minRelayFee := l.cfg.FeeEstimator.RelayFeePerKW()
+ // The estimator's min relay fee can be below the floor that
+ // validateCommitmentSanity enforces, e.g. when the bitcoind and btcd
+ // estimators cap the median feefilter of our peers at a low estimate
+ // for the next block. The floor takes precedence, so we neither
+ // propose a fee rate below it nor keep one that's already below it.
+ minRelayFee := max(
+ l.cfg.FeeEstimator.RelayFeePerKW(), chainfee.FeePerKwFloor,
+ )
newCommitFee := l.channel.IdealCommitFeeRate(
netFee, minRelayFee,
### htlcswitch/link_test.go
@@ -4411,6 +4411,13 @@ func TestChannelLinkUpdateCommitFee(t *testing.T) {
{"bob", "alice", &lnwire.RevokeAndAck{}, false},
{"bob", "alice", &lnwire.CommitSig{}, false},
{"alice", "bob", &lnwire.RevokeAndAck{}, false},
+
+ // Fourth fee update.
+ {"alice", "bob", &lnwire.UpdateFee{}, false},
+ {"alice", "bob", &lnwire.CommitSig{}, false},
+ {"bob", "alice", &lnwire.RevokeAndAck{}, false},
+ {"bob", "alice", &lnwire.CommitSig{}, false},
+ {"alice", "bob", &lnwire.RevokeAndAck{}, false},
}
n.aliceServer.intersect(createInterceptorFunc("[alice] <-- [bob]",
"alice", messages, chanID, false))
@@ -4512,6 +4519,15 @@ func TestChannelLinkUpdateCommitFee(t *testing.T) {
// rate corresponding to the minimum relay fee.
newFeeRate = minRelayFee / 2
triggerFeeUpdate(newFeeRate, minRelayFee, minRelayFee, true)
+
+ // Triggering the link to update the fee of the channel with a fee
+ // estimate and a min relay fee below the fee floor, as the bitcoind
+ // and btcd estimators can report, should result in a fee rate at the
+ // floor rather than one the channel refuses to sign.
+ oneSatPerVByte := chainfee.SatPerVByte(1).FeePerKWeight()
+ triggerFeeUpdate(
+ oneSatPerVByte, oneSatPerVByte, chainfee.FeePerKwFloor, true,
+ )
}
// TestChannelLinkAcceptDuplicatePayment tests that if a link receives an
### lnwallet/errors.go
@@ -6,6 +6,7 @@ import (
"github.com/btcsuite/btcd/btcutil/v2"
"github.com/btcsuite/btcd/chainhash/v2"
+ "github.com/lightningnetwork/lnd/lnwallet/chainfee"
"github.com/lightningnetwork/lnd/lnwire"
)
@@ -164,6 +165,17 @@ func ErrChanTooLarge(chanSize, maxChanSize btcutil.Amount) ReservationError {
}
}
+// ErrCommitFeeRateTooLow returns an error indicating that the commitment fee
+// rate proposed by the remote party is below the minimum we accept.
+func ErrCommitFeeRateTooLow(feeRate,
+ minFeeRate chainfee.SatPerKWeight) ReservationError {
+
+ return ReservationError{
+ fmt.Errorf("commitment fee rate of %v is below the minimum "+
+ "of %v", feeRate, minFeeRate),
+ }
+}
+
// ErrInvalidDustLimit returns an error indicating that a proposed DustLimit
// was rejected.
func ErrInvalidDustLimit(dustLimit btcutil.Amount) ReservationError {
### sample-lnd.conf
@@ -487,8 +487,8 @@
; max-channel-fee-allocation=0.5
; The maximum fee rate in sat/vbyte that will be used for commitments of
-; channels of the anchors type. Must be large enough to ensure transaction
-; propagation
+; channels of the anchors type. If this is below the minimum commitment fee
+; rate of 253 sat/kw, the minimum is used instead.
; max-commit-fee-rate-anchors=10
; DEPRECATED: This value will be deprecated please use the new setting Why this scored 62/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.