lightningnetwork / lnd / 15283631962

func testBumpFeeLowBudget(ht *lntest.HarnessTest) {

        // Create a new node with a large `maxfeerate` so it's easier to run the

        // test.

        alice := ht.NewNode("Alice", []string{

                "--sweeper.maxfeerate=10000",

        })

        // Fund Alice 2 UTXOs, each has 100k sats. One of the UTXOs will be used

        // to create a tx which she sends some coins to herself. The other will

        // be used as the budget when CPFPing the above tx.

        coin := btcutil.Amount(100_000)

        ht.FundCoins(coin, alice)

        ht.FundCoins(coin, alice)

        // Alice sends 50k sats to herself.

        tx := ht.SendCoins(alice, alice, coin/2)

        txid := tx.TxHash()

        // Get Alice's wallet balance to calculate the fees used in the above

        // tx.

        resp := alice.RPC.WalletBalance()

        // balance is the expected final balance. Alice's initial balance is

        // 200k sats, with 100k sats as the budget for the sweeping tx, which

        // means her final balance should be 100k sats minus the mining fees

        // used in the above `SendCoins`.

        balance := btcutil.Amount(

                resp.UnconfirmedBalance + resp.ConfirmedBalance,

        )

        fee := coin*2 - balance

        ht.Logf("Alice's expected final balance=%v, fee=%v", balance, fee)

        // Alice now tries to bump the first output on this tx.

        op := &lnrpc.OutPoint{

                TxidBytes:   txid[:],

                OutputIndex: uint32(0),

        }

        value := btcutil.Amount(tx.TxOut[0].Value)

        // assertPendingSweepResp is a helper closure that asserts the response

        // from `PendingSweep` RPC is returned with expected values. It also

        // returns the sweeping tx for further checks.

        assertPendingSweepResp := func(budget uint64,

                deadline uint32) *wire.MsgTx {

                // Alice should still have one pending sweep.

                pendingSweep := ht.AssertNumPendingSweeps(alice, 1)[0]

                // Validate all fields returned from `PendingSweeps` are as

                // expected.

                require.Equal(ht, op.TxidBytes, pendingSweep.Outpoint.TxidBytes)

                require.Equal(ht, op.OutputIndex,

                        pendingSweep.Outpoint.OutputIndex)

                require.Equal(ht, walletrpc.WitnessType_TAPROOT_PUB_KEY_SPEND,

                        pendingSweep.WitnessType)

                require.EqualValuesf(ht, value, pendingSweep.AmountSat,

                        "amount not matched: want=%d, got=%d", value,

                        pendingSweep.AmountSat)

                require.True(ht, pendingSweep.Immediate)

                require.EqualValuesf(ht, budget, pendingSweep.Budget,

                        "budget not matched: want=%d, got=%d", budget,

                        pendingSweep.Budget)

                // Since the request doesn't specify a deadline, we expect the

                // existing deadline to be used.

                require.Equalf(ht, deadline, pendingSweep.DeadlineHeight,

                        "deadline height not matched: want=%d, got=%d",

                        deadline, pendingSweep.DeadlineHeight)

                // We expect to see Alice's original tx and her CPFP tx in the

                // mempool.

                txns := ht.GetNumTxsFromMempool(2)

                // Find the sweeping tx - assume it's the first item, if it has

                // the same txid as the parent tx, use the second item.

                sweepTx := txns[0]

                if sweepTx.TxHash() == tx.TxHash() {

                        sweepTx = txns[1]

                }

                return sweepTx

        budget := coin * 2

        // Use a deadlineDelta of 3 such that the fee func is initialized as,

        // - starting fee rate: 1 sat/vbyte

        // - deadline: 3

        // - budget: 200% of Alice's available funds.

        deadlineDelta := 3

        // First bump request - we expect it to succeed as Alice's current funds

        // can cover the fees used here given the position of the fee func is at

        // 0.

        bumpFeeReq := &walletrpc.BumpFeeRequest{

                Outpoint:      op,

                Budget:        uint64(budget),

                Immediate:     true,

                DeadlineDelta: uint32(deadlineDelta),

        }

        alice.RPC.BumpFee(bumpFeeReq)

        // Calculate the deadline height.

        deadline := ht.CurrentHeight() + uint32(deadlineDelta)

        // Assert the pending sweep is created with the expected values:

        // - deadline: 3+current height.

        // - budget: 2x the wallet balance.

        sweepTx1 := assertPendingSweepResp(uint64(budget), deadline)

        // Mine a block to trigger Alice's sweeper to fee bump the tx.

        //

        // Second bump request - we expect it to succeed as Alice's current

        // funds can cover the fees used here, which is 66.7% of her available

        // funds given the position of the fee func is at 1.

        ht.MineEmptyBlocks(1)

        // Assert the old sweeping tx has been replaced.

        ht.AssertTxNotInMempool(sweepTx1.TxHash())

        // Assert a new sweeping tx is made.

        sweepTx2 := assertPendingSweepResp(uint64(budget), deadline)

        // Mine a block to trigger Alice's sweeper to fee bump the tx.

        //

        // Third bump request - we expect it to fail as Alice's current funds

        // cannot cover the fees now, which is 133.3% of her available funds

        // given the position of the fee func is at 2.

        ht.MineEmptyBlocks(1)

        // Assert the above sweeping tx is still in the mempool.

        ht.AssertTxInMempool(sweepTx2.TxHash())

        // Fund Alice 200k sats, which will be used to cover the budget.

        //

        // TODO(yy): We are funding Alice more than enough - at this stage Alice

        // has a confirmed UTXO of `coin` amount in her wallet, so ideally we

        // should only fund another UTXO of `coin` amount. However, since the

        // confirmed wallet UTXO has already been used in sweepTx2, there's no

        // easy way to tell her wallet to reuse that UTXO in the upcoming

        // sweeping tx.

        // To properly fix it, we should provide more granular UTXO management

        // here by leveraing `LeaseOutput` - whenever we use a wallet UTXO, we

        // should lock it first. And when the sweeping attempt fails, we should

        // release it so the UTXO can be used again in another batch.

        walletTx := ht.FundCoinsUnconfirmed(coin*2, alice)

        // Mine a block to confirm the above funding coin.

        //

        // Fourth bump request - we expect it to succeed as Alice's current

        // funds can cover the full budget.

        ht.MineBlockWithTx(walletTx)

        flakeRaceInBitcoinClientNotifications(ht)

        // Assert Alice's previous sweeping tx has been replaced.

        ht.AssertTxNotInMempool(sweepTx2.TxHash())

        // Assert the pending sweep is created with the expected values:

        // - deadline: 3+current height.

        // - budget: 2x the wallet balance.

        sweepTx3 := assertPendingSweepResp(uint64(budget), deadline)

        require.NotEqual(ht, sweepTx2.TxHash(), sweepTx3.TxHash())

        // Mine the sweeping tx.

        ht.MineBlocksAndAssertNumTxes(1, 2)

        // Assert Alice's wallet balance.       a

        ht.WaitForBalanceConfirmed(alice, balance)

func testBumpFee(ht *lntest.HarnessTest) {

        alice := ht.NewNodeWithCoins("Alice", nil)

        runBumpFee(ht, alice)

}

func runBumpFee(ht *lntest.HarnessTest, alice *node.HarnessNode) {

        // Skip this test for neutrino, as it's not aware of mempool

        // transactions.

        if ht.IsNeutrinoBackend() {

                ht.Skipf("skipping BumpFee test for neutrino backend")

        }

        startFeeRate := uint64(1)

        // We'll start the test by sending Alice some coins, which she'll use

        // to send to herself.

        ht.FundCoins(btcutil.SatoshiPerBitcoin, alice)

        // Alice sends a coin to herself.

        tx := ht.SendCoins(alice, alice, btcutil.SatoshiPerBitcoin)

        txid := tx.TxHash()

        // Alice now tries to bump the first output on this tx.

        op := &lnrpc.OutPoint{

                TxidBytes:   txid[:],

                OutputIndex: uint32(0),

        }

        value := btcutil.Amount(tx.TxOut[0].Value)

        // assertPendingSweepResp is a helper closure that asserts the response

        // from `PendingSweep` RPC is returned with expected values. It also

        // returns the sweeping tx for further checks.

        assertPendingSweepResp := func(broadcastAttempts uint32, budget uint64,

                deadline uint32, startingFeeRate uint64) *wire.MsgTx {

                err := wait.NoError(func() error {

                        // Alice should still have one pending sweep.

                        ps := ht.AssertNumPendingSweeps(alice, 1)[0]

                        // Validate all fields returned from `PendingSweeps` are

                        // as expected.

                        //

                        // These fields should stay the same during the test so

                        // we assert the values without wait.

                        require.Equal(ht, op.TxidBytes, ps.Outpoint.TxidBytes)

                        require.Equal(ht, op.OutputIndex,

                                ps.Outpoint.OutputIndex)

                        require.Equal(ht,

                                walletrpc.WitnessType_TAPROOT_PUB_KEY_SPEND,

                                ps.WitnessType)

                        require.EqualValuesf(ht, value, ps.AmountSat,

                                "amount not matched: want=%d, got=%d", value,

                                ps.AmountSat)

                        // The following fields can change during the test so we

                        // return an error if they don't match, which will be

                        // checked again in this wait call.

                        if !ps.Immediate {

                                return fmt.Errorf("immediate should be true")

                        }

                        if broadcastAttempts != ps.BroadcastAttempts {

                                return fmt.Errorf("broadcastAttempts not "+

                                        "matched: want=%d, got=%d",

                                        broadcastAttempts, ps.BroadcastAttempts)

                        }

                        if budget != ps.Budget {

                                return fmt.Errorf("budget not matched: "+

                                        "want=%d, got=%d", budget, ps.Budget)

                        }

                        if deadline != ps.DeadlineHeight {

                                return fmt.Errorf("deadline height not "+

                                        "matched: want=%d, got=%d", deadline,

                                        ps.DeadlineHeight)

                        }

                        if startingFeeRate != ps.RequestedSatPerVbyte {

                                return fmt.Errorf("requested starting fee "+

                                        "rate not matched: want=%d, got=%d",

                                        startingFeeRate,

                                        ps.RequestedSatPerVbyte)

                        }

                        return nil

                require.NoError(ht, err, "timeout checking pending sweep")

                // We expect to see Alice's original tx and her CPFP tx in the

                // mempool.

                txns := ht.GetNumTxsFromMempool(2)

                // Find the sweeping tx - assume it's the first item, if it has

                // the same txid as the parent tx, use the second item.

                sweepTx := txns[0]

                if sweepTx.TxHash() == tx.TxHash() {

                        sweepTx = txns[1]

                }

                return sweepTx

        assertFeeRateEqual := func(expected uint64) {

                err := wait.NoError(func() error {

                        // Alice should still have one pending sweep.

                        pendingSweep := ht.AssertNumPendingSweeps(alice, 1)[0]

                        if pendingSweep.SatPerVbyte == expected {

                                return nil

                        }

                        return fmt.Errorf("expected current fee rate %d, got "+

                                "%d", expected, pendingSweep.SatPerVbyte)

                require.NoError(ht, err, "fee rate not updated")

        assertFeeRateGreater := func(expected uint64) {

                err := wait.NoError(func() error {

                        // Alice should still have one pending sweep.

                        pendingSweep := ht.AssertNumPendingSweeps(alice, 1)[0]

                        if pendingSweep.SatPerVbyte > expected {

                                return nil

                        }

                        return fmt.Errorf("expected current fee rate greater "+

                                "than %d, got %d", expected,

                                pendingSweep.SatPerVbyte)

                require.NoError(ht, err, "fee rate not updated")

        bumpFeeReq := &walletrpc.BumpFeeRequest{

                Outpoint: op,

                // We use a force param to create the sweeping tx immediately.

                Immediate: true,

        }

        alice.RPC.BumpFee(bumpFeeReq)

        // Since the request doesn't specify a deadline, we expect the default

        // deadline to be used.

        currentHeight := int32(ht.CurrentHeight())

        deadline := uint32(currentHeight + sweep.DefaultDeadlineDelta)

        // Assert the pending sweep is created with the expected values:

        // - broadcast attempts: 1.

        // - starting fee rate: 1 sat/vbyte (min relay fee rate).

        // - deadline: 1008 (default deadline).

        // - budget: 50% of the input value.

        sweepTx1 := assertPendingSweepResp(1, uint64(value/2), deadline, 0)

        // Since the request doesn't specify a starting fee rate, we expect the

        // min relay fee rate is used as the current fee rate.

        assertFeeRateEqual(startFeeRate)

        // First we test the case where we specify the conf target to increase

        // the starting fee rate of the fee function.

        confTargetFeeRate := chainfee.SatPerVByte(50)

        ht.SetFeeEstimateWithConf(confTargetFeeRate.FeePerKWeight(), 3)

        // Second bump request - we will specify the conf target and expect a

        // starting fee rate that is estimated using the provided estimator.

        // - starting fee rate: 50 sat/vbyte (conf target 3).

        // - deadline: 1008 (default deadline).

        // - budget: 50% of the input value.

        bumpFeeReq = &walletrpc.BumpFeeRequest{

                Outpoint: op,

                // We use a force param to create the sweeping tx immediately.

                Immediate:  true,

                TargetConf: 3,

        }

        alice.RPC.BumpFee(bumpFeeReq)

        // Alice's old sweeping tx should be replaced.

        ht.AssertTxNotInMempool(sweepTx1.TxHash())

        // Assert the pending sweep is created with the expected values:

        // - broadcast attempts: 2.

        // - starting fee rate: 50 sat/vbyte (conf target 3).

        // - deadline: 1008 (default deadline).

        // - budget: 50% of the input value.

        sweepTx2 := assertPendingSweepResp(

                2, uint64(value/2), deadline, uint64(confTargetFeeRate),

        )

        // testFeeRate sepcifies a starting fee rate in sat/vbyte.

        const testFeeRate = uint64(100)

        // Third bump request - we will specify the fee rate and expect a fee

        // func to change the starting fee rate of the fee function,

        // - starting fee rate: 100 sat/vbyte.

        // - deadline: 1008 (default deadline).

        // - budget: 50% of the input value.

        bumpFeeReq = &walletrpc.BumpFeeRequest{

                Outpoint: op,

                // We use a force param to create the sweeping tx immediately.

                Immediate:   true,

                SatPerVbyte: testFeeRate,

        }

        alice.RPC.BumpFee(bumpFeeReq)

        // Alice's old sweeping tx should be replaced.

        ht.AssertTxNotInMempool(sweepTx2.TxHash())

        // Assert the pending sweep is created with the expected values:

        // - broadcast attempts: 3.

        // - starting fee rate: 100 sat/vbyte.

        // - deadline: 1008 (default deadline).

        // - budget: 50% of the input value.

        sweepTx3 := assertPendingSweepResp(

                3, uint64(value/2), deadline, testFeeRate,

        )

        // We expect the requested starting fee rate to be the current fee

        // rate.

        assertFeeRateEqual(testFeeRate)

        // testBudget specifies a budget in sats.

        testBudget := uint64(float64(value) * 0.1)

        // Fourth bump request - we will specify the budget and expect a fee

        // func that has,

        // - starting fee rate: 100 sat/vbyte, stays unchanged.

        // - deadline: 1008 (default deadline).

        // - budget: 10% of the input value.

        bumpFeeReq = &walletrpc.BumpFeeRequest{

                Outpoint: op,

                // We use a force param to create the sweeping tx immediately.

                Immediate: true,

                Budget:    testBudget,

        }

        alice.RPC.BumpFee(bumpFeeReq)

        // Alice's old sweeping tx should be replaced.

        ht.AssertTxNotInMempool(sweepTx3.TxHash())

        // Assert the pending sweep is created with the expected values:

        // - broadcast attempts: 4.

        // - starting fee rate: 100 sat/vbyte, stays unchanged.

        // - deadline: 1008 (default deadline).

        // - budget: 10% of the input value.

        sweepTx4 := assertPendingSweepResp(4, testBudget, deadline, testFeeRate)

        // We expect the current fee rate to be increased because we ensure the

        // initial broadcast always succeeds.

        assertFeeRateGreater(testFeeRate)

        // Create a test deadline delta to use in the next test.

        testDeadlineDelta := uint32(100)

        deadlineHeight := uint32(currentHeight) + testDeadlineDelta

        // Fifth bump request - we will specify the deadline and expect a fee

        // func that has,

        // - starting fee rate: 100 sat/vbyte, stays unchanged.

        // - deadline: 100.

        // - budget: 10% of the input value, stays unchanged.

        bumpFeeReq = &walletrpc.BumpFeeRequest{

                Outpoint: op,

                // We use a force param to create the sweeping tx immediately.

                Immediate:     true,

                DeadlineDelta: testDeadlineDelta,

                Budget:        testBudget,

        }

        alice.RPC.BumpFee(bumpFeeReq)

        // Alice's old sweeping tx should be replaced.

        ht.AssertTxNotInMempool(sweepTx4.TxHash())

        // Assert the pending sweep is created with the expected values:

        // - broadcast attempts: 5.

        // - starting fee rate: 100 sat/vbyte, stays unchanged.

        // - deadline: 100.

        // - budget: 10% of the input value, stays unchanged.

        sweepTx5 := assertPendingSweepResp(

                5, testBudget, deadlineHeight, testFeeRate,

        )

        // We expect the current fee rate to be increased because we ensure the

        // initial broadcast always succeeds.

        assertFeeRateGreater(testFeeRate)

        // Sixth bump request - we test the behavior of `Immediate` - every

        // time it's called, the fee function will keep increasing the fee rate

        // until the broadcast can succeed. The fee func that has,

        // - starting fee rate: 100 sat/vbyte, stays unchanged.

        // - deadline: 100, stays unchanged.

        // - budget: 10% of the input value, stays unchanged.

        bumpFeeReq = &walletrpc.BumpFeeRequest{

                Outpoint: op,

                // We use a force param to create the sweeping tx immediately.

                Immediate: true,

        }

        alice.RPC.BumpFee(bumpFeeReq)

        // Alice's old sweeping tx should be replaced.

        ht.AssertTxNotInMempool(sweepTx5.TxHash())

        // Assert the pending sweep is created with the expected values:

        // - broadcast attempts: 6.

        // - starting fee rate: 100 sat/vbyte, stays unchanged.

        // - deadline: 100, stays unchanged.

        // - budget: 10% of the input value, stays unchanged.

        sweepTx6 := assertPendingSweepResp(

                6, testBudget, deadlineHeight, testFeeRate,

        )

        // We expect the current fee rate to be increased because we ensure the

        // initial broadcast always succeeds.

        assertFeeRateGreater(testFeeRate)

        smallBudget := uint64(1000)

        // Finally, we test the behavior of lowering the fee rate. The fee func

        // that has,

        // - starting fee rate: 1 sat/vbyte.

        // - deadline: 1.

        // - budget: 1000 sats.

        bumpFeeReq = &walletrpc.BumpFeeRequest{

                Outpoint: op,

                // We use a force param to create the sweeping tx immediately.

                Immediate:   true,

                SatPerVbyte: startFeeRate,

                // The budget and the deadline delta must be set together.

                Budget:        smallBudget,

                DeadlineDelta: 1,

        }

        alice.RPC.BumpFee(bumpFeeReq)

        // Calculate the ending fee rate, which is used in the above fee bump

        // when fee function's max posistion is reached.

        txWeight := ht.CalculateTxWeight(sweepTx6)

        endingFeeRate := chainfee.NewSatPerKWeight(

                btcutil.Amount(smallBudget), txWeight,

        )

        // Since the fee function has been maxed out, the starting fee rate for

        // the next sweep attempt should be the ending fee rate.

        //

        // TODO(yy): The weight estimator used in the sweeper gives a different

        // result than the weight calculated here, which is the result from

        // `blockchain.GetTransactionWeight`. For this particular tx:

        // - result from the `weightEstimator`: 445 wu

        // - result from `GetTransactionWeight`: 444 wu

        //

        // This means the fee rates are different,

        // - `weightEstimator`: 2247 sat/kw, or 8 sat/vb (8.988 round down)

        // - here we have 2252 sat/kw, or 9 sat/vb (9.008 round down)

        //

        // We should investigate and check whether if it's possible to make the

        // `weightEstimator` more accurate.

        expectedStartFeeRate := uint64(endingFeeRate.FeePerVByte()) - 1

        // Assert the pending sweep is created with the expected values:

        // - broadcast attempts: 7.

        // - starting fee rate: 8 sat/vbyte.

        // - deadline: 1.

        // - budget: 1000 sats.

        sweepTx7 := assertPendingSweepResp(

                7, smallBudget, uint32(currentHeight+1), expectedStartFeeRate,

        )

        // Since this budget is too small to cover the RBF, we expect the

        // sweeping attempt to fail.

        require.Equal(ht, sweepTx6.TxHash(), sweepTx7.TxHash(), "tx6 should "+

                "not be replaced: tx6=%v, tx7=%v", sweepTx6.TxHash(),

                sweepTx7.TxHash())

        // We expect the current fee rate to be increased because we ensure the

        // initial broadcast always succeeds.

        assertFeeRateGreater(testFeeRate)

        // Clean up the mempool.

        ht.MineBlocksAndAssertNumTxes(1, 2)

func testBumpFeeExternalInput(ht *lntest.HarnessTest) {

        alice := ht.NewNode("Alice", nil)

        bob := ht.NewNode("Bob", nil)

        // We'll start the test by sending Alice some coins, which she'll use

        // to send to Bob.

        ht.FundCoins(btcutil.SatoshiPerBitcoin, alice)

        // Alice sends 0.5 BTC to Bob. This tx should have two outputs - one

        // that belongs to Bob, the other is Alice's change output.

        tx := ht.SendCoins(alice, bob, btcutil.SatoshiPerBitcoin/2)

        txid := tx.TxHash()

        // Find the wrong index to perform the fee bump. We assume the first

        // output belongs to Bob, and switch to the second if the second output

        // has a larger output value. Given we've funded Alice 1 btc, she then

        // sends 0.5 btc to Bob, her change output will be below 0.5 btc after

        // paying the mining fees.

        wrongIndex := 0

        if tx.TxOut[0].Value < tx.TxOut[1].Value {

                wrongIndex = 1

        }

        op := &lnrpc.OutPoint{

                TxidBytes:   txid[:],

                OutputIndex: uint32(wrongIndex),

        }

        // Create a request with the wrong outpoint.

        bumpFeeReq := &walletrpc.BumpFeeRequest{

                Outpoint: op,

                // We use a force param to create the sweeping tx immediately.

                Immediate: true,

        }

        err := alice.RPC.BumpFeeAssertErr(bumpFeeReq)

        require.ErrorContains(ht, err, "does not belong to the wallet")

        // Clean up the mempool.

        ht.MineBlocksAndAssertNumTxes(1, 1)