13536249039

Committed 26 Feb 2025 03:42AM UTC coverage: 57.462% (-1.4%) from 58.835%

Build # 13536249039

Build Type

Pull #8453

github

Committed by

Roasbeef

Commit Message

peer: update chooseDeliveryScript to gen script if needed

In this commit, we update `chooseDeliveryScript` to generate a new
script if needed. This allows us to fold in a few other lines that
always followed this function into this expanded function.

The tests have been updated accordingly.

Pull Request Pull Request #8453: [4/4] - multi: integrate new rbf coop close FSM into the existing peer flow

Run Details

275 of 1318 new or added lines in 22 files covered. (20.86%)

19521 existing lines in 257 files now uncovered.

103858 of 180741 relevant lines covered (57.46%)

24750.23 hits per line

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

0.0

/chainreg/taproot_check.go

package chainreg

import (
        "encoding/json"

        "github.com/btcsuite/btcd/rpcclient"
)

// backendSupportsTaproot returns true if the backend understands the taproot
// soft fork.
func backendSupportsTaproot(rpc *rpcclient.Client) bool {
        // First, we'll try to access the normal getblockchaininfo call.
        chainInfo, err := rpc.GetBlockChainInfo()
        if err == nil {
                // If this call worked, then we'll check that the taproot
                // deployment is defined.
                switch {
                // Bitcoind versions before 0.19 and also btcd use the
                // SoftForks fields.
                case chainInfo.SoftForks != nil:
                        _, ok := chainInfo.SoftForks.Bip9SoftForks["taproot"]
                        if ok {
                                return ok
                        }

                // Bitcoind versions after 0.19 will use the UnifiedSoftForks
                // field that factors in the set of "buried" soft forks.
                case chainInfo.UnifiedSoftForks != nil:
                        _, ok := chainInfo.UnifiedSoftForks.SoftForks["taproot"]
                        if ok {
                                return ok
                        }
                }
        }

        // The user might be running a newer version of bitcoind that doesn't
        // implement the getblockchaininfo call any longer, so we'll fall back
        // here.
        //
        // Alternatively, the fork wasn't specified, but the user might be
        // running a newer version of bitcoind that still has the
        // getblockchaininfo call, but doesn't populate the data, so we'll hit
        // the new getdeploymentinfo call.
        resp, err := rpc.RawRequest("getdeploymentinfo", nil)
        if err != nil {
                log.Warnf("unable to make getdeploymentinfo request: %v", err)
                return false
        }

        info := struct {
                Deployments map[string]struct {
                        Type   string `json:"type"`
                        Active bool   `json:"active"`
                        Height int32  `json:"height"`
                } `json:"deployments"`
        }{}
        if err := json.Unmarshal(resp, &info); err != nil {
                log.Warnf("unable to decode getdeploymentinfo resp: %v", err)
                return false
        }

        _, ok := info.Deployments["taproot"]
        return ok
}

1	package chainreg
2
3	import (
4	"encoding/json"
5
6	"github.com/btcsuite/btcd/rpcclient"
7	)
8
9	// backendSupportsTaproot returns true if the backend understands the taproot
10	// soft fork.
UNCOV 11	func backendSupportsTaproot(rpc *rpcclient.Client) bool {	×
UNCOV 12	// First, we'll try to access the normal getblockchaininfo call.	×
UNCOV 13	chainInfo, err := rpc.GetBlockChainInfo()	×
UNCOV 14	if err == nil {	×
UNCOV 15	// If this call worked, then we'll check that the taproot	×
UNCOV 16	// deployment is defined.	×
UNCOV 17	switch {	×
18	// Bitcoind versions before 0.19 and also btcd use the
19	// SoftForks fields.
UNCOV 20	case chainInfo.SoftForks != nil:	×
UNCOV 21	_, ok := chainInfo.SoftForks.Bip9SoftForks["taproot"]	×
UNCOV 22	if ok {	×
UNCOV 23	return ok	×
UNCOV 24	}	×
25
26	// Bitcoind versions after 0.19 will use the UnifiedSoftForks
27	// field that factors in the set of "buried" soft forks.
UNCOV 28	case chainInfo.UnifiedSoftForks != nil:	×
UNCOV 29	_, ok := chainInfo.UnifiedSoftForks.SoftForks["taproot"]	×
UNCOV 30	if ok {	×
31	return ok	×
32	}	×
33	}
34	}
35
36	// The user might be running a newer version of bitcoind that doesn't
37	// implement the getblockchaininfo call any longer, so we'll fall back
38	// here.
39	//
40	// Alternatively, the fork wasn't specified, but the user might be
41	// running a newer version of bitcoind that still has the
42	// getblockchaininfo call, but doesn't populate the data, so we'll hit
43	// the new getdeploymentinfo call.
UNCOV 44	resp, err := rpc.RawRequest("getdeploymentinfo", nil)	×
UNCOV 45	if err != nil {	×
46	log.Warnf("unable to make getdeploymentinfo request: %v", err)	×
47	return false	×
48	}	×
49
UNCOV 50	info := struct {	×
UNCOV 51	Deployments map[string]struct {	×
UNCOV 52	Type string `json:"type"`	×
UNCOV 53	Active bool `json:"active"`	×
UNCOV 54	Height int32 `json:"height"`	×
UNCOV 55	} `json:"deployments"`	×
UNCOV 56	}{}	×
UNCOV 57	if err := json.Unmarshal(resp, &info); err != nil {	×
58	log.Warnf("unable to decode getdeploymentinfo resp: %v", err)	×
59	return false	×
60	}	×
61
UNCOV 62	_, ok := info.Deployments["taproot"]	×
UNCOV 63	return ok	×
64	}

lightningnetwork / lnd / 13536249039

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