13202016262

Committed 07 Feb 2025 02:33PM UTC coverage: 49.349% (-8.3%) from 57.696%

Build # 13202016262

Build Type

Pull #9448

github

Committed by

yyforyongyu

Commit Message

docs: add release notes

Pull Request Pull Request #9448: sweep: properly handle failed sweeping txns

Run Details

298 of 342 new or added lines in 3 files covered. (87.13%)

27243 existing lines in 433 files now uncovered.

100923 of 204509 relevant lines covered (49.35%)

1.54 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

4.93

/lntest/unittest/backend.go

package unittest

import (
        "fmt"
        "os/exec"
        "path/filepath"
        "testing"
        "time"

        "github.com/btcsuite/btcd/chaincfg"
        "github.com/btcsuite/btcd/integration/rpctest"
        "github.com/btcsuite/btcwallet/chain"
        "github.com/btcsuite/btcwallet/walletdb"
        "github.com/lightninglabs/neutrino"
        "github.com/lightningnetwork/lnd/kvdb"
        "github.com/lightningnetwork/lnd/lntest/port"
        "github.com/lightningnetwork/lnd/lntest/wait"
        "github.com/stretchr/testify/require"
)

var (
        // TrickleInterval is the interval at which the miner should trickle
        // transactions to its peers. We'll set it small to ensure the miner
        // propagates transactions quickly in the tests.
        TrickleInterval = 10 * time.Millisecond
)

var (
        // NetParams are the default network parameters for the tests.
        NetParams = &chaincfg.RegressionNetParams
)

// NewMiner spawns testing harness backed by a btcd node that can serve as a
// miner.
func NewMiner(t *testing.T, netParams *chaincfg.Params, extraArgs []string,
        createChain bool, spendableOutputs uint32) *rpctest.Harness {

        t.Helper()

        // Add the trickle interval argument to the extra args.
        trickle := fmt.Sprintf("--trickleinterval=%v", TrickleInterval)
        extraArgs = append(extraArgs, trickle)

        node, err := rpctest.New(netParams, nil, extraArgs, "")
        require.NoError(t, err, "unable to create backend node")
        t.Cleanup(func() {
                require.NoError(t, node.TearDown())
        })

        // We want to overwrite some of the connection settings to make the
        // tests more robust. We might need to restart the backend while there
        // are already blocks present, which will take a bit longer than the
        // 1 second the default settings amount to. Doubling both values will
        // give us retries up to 4 seconds.
        node.MaxConnRetries = rpctest.DefaultMaxConnectionRetries * 2
        node.ConnectionRetryTimeout = rpctest.DefaultConnectionRetryTimeout * 2

        if err := node.SetUp(createChain, spendableOutputs); err != nil {
                t.Fatalf("unable to set up backend node: %v", err)
        }

        // Next mine enough blocks in order for segwit and the CSV package
        // soft-fork to activate.
        numBlocks := netParams.MinerConfirmationWindow*2 + 17
        _, err = node.Client.Generate(numBlocks)
        require.NoError(t, err, "failed to generate blocks")

        return node
}

// NewBitcoindBackend spawns a new bitcoind node that connects to a miner at the
// specified address. The txindex boolean can be set to determine whether the
// backend node should maintain a transaction index. The rpcpolling boolean
// can be set to determine whether bitcoind's RPC polling interface should be
// used for block and tx notifications or if its ZMQ interface should be used.
// A connection to the newly spawned bitcoind node is returned.
func NewBitcoindBackend(t *testing.T, netParams *chaincfg.Params,
        minerAddr string, txindex, rpcpolling bool) *chain.BitcoindConn {

        t.Helper()

        tempBitcoindDir := t.TempDir()

        rpcPort := port.NextAvailablePort()
        torBindPort := port.NextAvailablePort()
        zmqBlockPort := port.NextAvailablePort()
        zmqTxPort := port.NextAvailablePort()
        zmqBlockHost := fmt.Sprintf("tcp://127.0.0.1:%d", zmqBlockPort)
        zmqTxHost := fmt.Sprintf("tcp://127.0.0.1:%d", zmqTxPort)

        args := []string{
                "-connect=" + minerAddr,
                "-datadir=" + tempBitcoindDir,
                "-regtest",
                "-rpcauth=weks:469e9bb14ab2360f8e226efed5ca6fd$507c670e800a95" +
                        "284294edb5773b05544b220110063096c221be9933c82d38e1",
                fmt.Sprintf("-rpcport=%d", rpcPort),
                fmt.Sprintf("-bind=127.0.0.1:%d=onion", torBindPort),
                "-disablewallet",
                "-zmqpubrawblock=" + zmqBlockHost,
                "-zmqpubrawtx=" + zmqTxHost,
        }
        if txindex {
                args = append(args, "-txindex")
        }

        bitcoind := exec.Command("bitcoind", args...)
        if err := bitcoind.Start(); err != nil {
                t.Fatalf("unable to start bitcoind: %v", err)
        }
        t.Cleanup(func() {
                _ = bitcoind.Process.Kill()
                _ = bitcoind.Wait()
        })

        // Wait for the bitcoind instance to start up.
        time.Sleep(time.Second)

        host := fmt.Sprintf("127.0.0.1:%d", rpcPort)
        cfg := &chain.BitcoindConfig{
                ChainParams: netParams,
                Host:        host,
                User:        "weks",
                Pass:        "weks",
                // Fields only required for pruned nodes, not needed for these
                // tests.
                Dialer:             nil,
                PrunedModeMaxPeers: 0,
        }

        if rpcpolling {
                cfg.PollingConfig = &chain.PollingConfig{
                        BlockPollingInterval: time.Millisecond * 20,
                        TxPollingInterval:    time.Millisecond * 20,
                }
        } else {
                cfg.ZMQConfig = &chain.ZMQConfig{
                        ZMQBlockHost:    zmqBlockHost,
                        ZMQTxHost:       zmqTxHost,
                        ZMQReadDeadline: 5 * time.Second,
                }
        }

        var conn *chain.BitcoindConn
        err := wait.NoError(func() error {
                var err error
                conn, err = chain.NewBitcoindConn(cfg)
                if err != nil {
                        return err
                }

                return conn.Start()
        }, 10*time.Second)
        if err != nil {
                t.Fatalf("unable to establish connection to bitcoind at %v: "+
                        "%v", tempBitcoindDir, err)
        }
        t.Cleanup(conn.Stop)

        return conn
}

// NewNeutrinoBackend spawns a new neutrino node that connects to a miner at
// the specified address.
func NewNeutrinoBackend(t *testing.T, netParams *chaincfg.Params,
        minerAddr string) *neutrino.ChainService {

        t.Helper()

        spvDir := t.TempDir()

        dbName := filepath.Join(spvDir, "neutrino.db")
        spvDatabase, err := walletdb.Create(
                "bdb", dbName, true, kvdb.DefaultDBTimeout,
        )
        if err != nil {
                t.Fatalf("unable to create walletdb: %v", err)
        }
        t.Cleanup(func() {
                spvDatabase.Close()
        })

        // Create an instance of neutrino connected to the running btcd
        // instance.
        spvConfig := neutrino.Config{
                DataDir:      spvDir,
                Database:     spvDatabase,
                ChainParams:  *netParams,
                ConnectPeers: []string{minerAddr},
        }
        spvNode, err := neutrino.NewChainService(spvConfig)
        if err != nil {
                t.Fatalf("unable to create neutrino: %v", err)
        }

        // We'll also wait for the instance to sync up fully to the chain
        // generated by the btcd instance.
        _ = spvNode.Start()
        for !spvNode.IsCurrent() {
                time.Sleep(time.Millisecond * 100)
        }
        t.Cleanup(func() {
                _ = spvNode.Stop()
        })

        return spvNode
}

func init() {
        // Before we start any node, we need to make sure that any btcd or
        // bitcoind node that is started through the RPC harness uses a unique
        // port as well to avoid any port collisions.
        rpctest.ListenAddressGenerator =
                port.GenerateSystemUniqueListenerAddresses
}

1	package unittest
2
3	import (
4	"fmt"
5	"os/exec"
6	"path/filepath"
7	"testing"
8	"time"
9
10	"github.com/btcsuite/btcd/chaincfg"
11	"github.com/btcsuite/btcd/integration/rpctest"
12	"github.com/btcsuite/btcwallet/chain"
13	"github.com/btcsuite/btcwallet/walletdb"
14	"github.com/lightninglabs/neutrino"
15	"github.com/lightningnetwork/lnd/kvdb"
16	"github.com/lightningnetwork/lnd/lntest/port"
17	"github.com/lightningnetwork/lnd/lntest/wait"
18	"github.com/stretchr/testify/require"
19	)
20
21	var (
22	// TrickleInterval is the interval at which the miner should trickle
23	// transactions to its peers. We'll set it small to ensure the miner
24	// propagates transactions quickly in the tests.
25	TrickleInterval = 10 * time.Millisecond
26	)
27
28	var (
29	// NetParams are the default network parameters for the tests.
30	NetParams = &chaincfg.RegressionNetParams
31	)
32
33	// NewMiner spawns testing harness backed by a btcd node that can serve as a
34	// miner.
35	func NewMiner(t testing.T, netParams chaincfg.Params, extraArgs []string,
UNCOV 36	createChain bool, spendableOutputs uint32) *rpctest.Harness {	×
UNCOV 37		×
UNCOV 38	t.Helper()	×
UNCOV 39		×
UNCOV 40	// Add the trickle interval argument to the extra args.	×
UNCOV 41	trickle := fmt.Sprintf("--trickleinterval=%v", TrickleInterval)	×
UNCOV 42	extraArgs = append(extraArgs, trickle)	×
UNCOV 43		×
UNCOV 44	node, err := rpctest.New(netParams, nil, extraArgs, "")	×
UNCOV 45	require.NoError(t, err, "unable to create backend node")	×
UNCOV 46	t.Cleanup(func() {	×
UNCOV 47	require.NoError(t, node.TearDown())	×
UNCOV 48	})	×
49
50	// We want to overwrite some of the connection settings to make the
51	// tests more robust. We might need to restart the backend while there
52	// are already blocks present, which will take a bit longer than the
53	// 1 second the default settings amount to. Doubling both values will
54	// give us retries up to 4 seconds.
UNCOV 55	node.MaxConnRetries = rpctest.DefaultMaxConnectionRetries * 2	×
UNCOV 56	node.ConnectionRetryTimeout = rpctest.DefaultConnectionRetryTimeout * 2	×
UNCOV 57		×
UNCOV 58	if err := node.SetUp(createChain, spendableOutputs); err != nil {	×
59	t.Fatalf("unable to set up backend node: %v", err)	×
60	}	×
61
62	// Next mine enough blocks in order for segwit and the CSV package
63	// soft-fork to activate.
UNCOV 64	numBlocks := netParams.MinerConfirmationWindow*2 + 17	×
UNCOV 65	_, err = node.Client.Generate(numBlocks)	×
UNCOV 66	require.NoError(t, err, "failed to generate blocks")	×
UNCOV 67		×
UNCOV 68	return node	×
69	}
70
71	// NewBitcoindBackend spawns a new bitcoind node that connects to a miner at the
72	// specified address. The txindex boolean can be set to determine whether the
73	// backend node should maintain a transaction index. The rpcpolling boolean
74	// can be set to determine whether bitcoind's RPC polling interface should be
75	// used for block and tx notifications or if its ZMQ interface should be used.
76	// A connection to the newly spawned bitcoind node is returned.
77	func NewBitcoindBackend(t testing.T, netParams chaincfg.Params,
UNCOV 78	minerAddr string, txindex, rpcpolling bool) *chain.BitcoindConn {	×
UNCOV 79		×
UNCOV 80	t.Helper()	×
UNCOV 81		×
UNCOV 82	tempBitcoindDir := t.TempDir()	×
UNCOV 83		×
UNCOV 84	rpcPort := port.NextAvailablePort()	×
UNCOV 85	torBindPort := port.NextAvailablePort()	×
UNCOV 86	zmqBlockPort := port.NextAvailablePort()	×
UNCOV 87	zmqTxPort := port.NextAvailablePort()	×
UNCOV 88	zmqBlockHost := fmt.Sprintf("tcp://127.0.0.1:%d", zmqBlockPort)	×
UNCOV 89	zmqTxHost := fmt.Sprintf("tcp://127.0.0.1:%d", zmqTxPort)	×
UNCOV 90		×
UNCOV 91	args := []string{	×
UNCOV 92	"-connect=" + minerAddr,	×
UNCOV 93	"-datadir=" + tempBitcoindDir,	×
UNCOV 94	"-regtest",	×
UNCOV 95	"-rpcauth=weks:469e9bb14ab2360f8e226efed5ca6fd$507c670e800a95" +	×
UNCOV 96	"284294edb5773b05544b220110063096c221be9933c82d38e1",	×
UNCOV 97	fmt.Sprintf("-rpcport=%d", rpcPort),	×
UNCOV 98	fmt.Sprintf("-bind=127.0.0.1:%d=onion", torBindPort),	×
UNCOV 99	"-disablewallet",	×
UNCOV 100	"-zmqpubrawblock=" + zmqBlockHost,	×
UNCOV 101	"-zmqpubrawtx=" + zmqTxHost,	×
UNCOV 102	}	×
UNCOV 103	if txindex {	×
UNCOV 104	args = append(args, "-txindex")	×
UNCOV 105	}	×
106
UNCOV 107	bitcoind := exec.Command("bitcoind", args...)	×
UNCOV 108	if err := bitcoind.Start(); err != nil {	×
109	t.Fatalf("unable to start bitcoind: %v", err)	×
110	}	×
UNCOV 111	t.Cleanup(func() {	×
UNCOV 112	_ = bitcoind.Process.Kill()	×
UNCOV 113	_ = bitcoind.Wait()	×
UNCOV 114	})	×
115
116	// Wait for the bitcoind instance to start up.
UNCOV 117	time.Sleep(time.Second)	×
UNCOV 118		×
UNCOV 119	host := fmt.Sprintf("127.0.0.1:%d", rpcPort)	×
UNCOV 120	cfg := &chain.BitcoindConfig{	×
UNCOV 121	ChainParams: netParams,	×
UNCOV 122	Host: host,	×
UNCOV 123	User: "weks",	×
UNCOV 124	Pass: "weks",	×
UNCOV 125	// Fields only required for pruned nodes, not needed for these	×
UNCOV 126	// tests.	×
UNCOV 127	Dialer: nil,	×
UNCOV 128	PrunedModeMaxPeers: 0,	×
UNCOV 129	}	×
UNCOV 130		×
UNCOV 131	if rpcpolling {	×
UNCOV 132	cfg.PollingConfig = &chain.PollingConfig{	×
UNCOV 133	BlockPollingInterval: time.Millisecond * 20,	×
UNCOV 134	TxPollingInterval: time.Millisecond * 20,	×
UNCOV 135	}	×
UNCOV 136	} else {	×
UNCOV 137	cfg.ZMQConfig = &chain.ZMQConfig{	×
UNCOV 138	ZMQBlockHost: zmqBlockHost,	×
UNCOV 139	ZMQTxHost: zmqTxHost,	×
UNCOV 140	ZMQReadDeadline: 5 * time.Second,	×
UNCOV 141	}	×
UNCOV 142	}	×
143
UNCOV 144	var conn *chain.BitcoindConn	×
UNCOV 145	err := wait.NoError(func() error {	×
UNCOV 146	var err error	×
UNCOV 147	conn, err = chain.NewBitcoindConn(cfg)	×
UNCOV 148	if err != nil {	×
149	return err	×
150	}	×
151
UNCOV 152	return conn.Start()	×
153	}, 10*time.Second)
UNCOV 154	if err != nil {	×
155	t.Fatalf("unable to establish connection to bitcoind at %v: "+	×
156	"%v", tempBitcoindDir, err)	×
157	}	×
UNCOV 158	t.Cleanup(conn.Stop)	×
UNCOV 159		×
UNCOV 160	return conn	×
161	}
162
163	// NewNeutrinoBackend spawns a new neutrino node that connects to a miner at
164	// the specified address.
165	func NewNeutrinoBackend(t testing.T, netParams chaincfg.Params,
UNCOV 166	minerAddr string) *neutrino.ChainService {	×
UNCOV 167		×
UNCOV 168	t.Helper()	×
UNCOV 169		×
UNCOV 170	spvDir := t.TempDir()	×
UNCOV 171		×
UNCOV 172	dbName := filepath.Join(spvDir, "neutrino.db")	×
UNCOV 173	spvDatabase, err := walletdb.Create(	×
UNCOV 174	"bdb", dbName, true, kvdb.DefaultDBTimeout,	×
UNCOV 175	)	×
UNCOV 176	if err != nil {	×
177	t.Fatalf("unable to create walletdb: %v", err)	×
178	}	×
UNCOV 179	t.Cleanup(func() {	×
UNCOV 180	spvDatabase.Close()	×
UNCOV 181	})	×
182
183	// Create an instance of neutrino connected to the running btcd
184	// instance.
UNCOV 185	spvConfig := neutrino.Config{	×
UNCOV 186	DataDir: spvDir,	×
UNCOV 187	Database: spvDatabase,	×
UNCOV 188	ChainParams: *netParams,	×
UNCOV 189	ConnectPeers: []string{minerAddr},	×
UNCOV 190	}	×
UNCOV 191	spvNode, err := neutrino.NewChainService(spvConfig)	×
UNCOV 192	if err != nil {	×
193	t.Fatalf("unable to create neutrino: %v", err)	×
194	}	×
195
196	// We'll also wait for the instance to sync up fully to the chain
197	// generated by the btcd instance.
UNCOV 198	_ = spvNode.Start()	×
UNCOV 199	for !spvNode.IsCurrent() {	×
UNCOV 200	time.Sleep(time.Millisecond * 100)	×
UNCOV 201	}	×
UNCOV 202	t.Cleanup(func() {	×
UNCOV 203	_ = spvNode.Stop()	×
UNCOV 204	})	×
205
UNCOV 206	return spvNode	×
207	}
208
209	func init() {	3✔
210	// Before we start any node, we need to make sure that any btcd or	3✔
211	// bitcoind node that is started through the RPC harness uses a unique	3✔
212	// port as well to avoid any port collisions.	3✔
213	rpctest.ListenAddressGenerator =	3✔
214	port.GenerateSystemUniqueListenerAddresses	3✔
215	}	3✔

lightningnetwork / lnd / 13202016262

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous