12313002221

Committed 13 Dec 2024 09:25AM UTC coverage: 57.486% (+8.6%) from 48.92%

Build # 12313002221

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #9343 from ellemouton/contextGuard

fn: expand the ContextGuard and add tests

Run Details

101902 of 177264 relevant lines covered (57.49%)

24909.26 hits per line

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

0.0

/lncfg/config.go

package lncfg

import (
        "os"
        "os/user"
        "path/filepath"
        "strings"
        "time"
)

const (
        // DefaultConfigFilename is the default configuration file name lnd
        // tries to load.
        DefaultConfigFilename = "lnd.conf"

        // DefaultMaxPendingChannels is the default maximum number of incoming
        // pending channels permitted per peer.
        DefaultMaxPendingChannels = 1

        // DefaultIncomingBroadcastDelta defines the number of blocks before the
        // expiry of an incoming htlc at which we force close the channel. We
        // only go to chain if we also have the preimage to actually pull in the
        // htlc. BOLT #2 suggests 7 blocks. We use a few more for extra safety.
        // Within this window we need to get our sweep or 2nd level success tx
        // confirmed, because after that the remote party is also able to claim
        // the htlc using the timeout path.
        DefaultIncomingBroadcastDelta = 10

        // DefaultFinalCltvRejectDelta defines the number of blocks before the
        // expiry of an incoming exit hop htlc at which we cancel it back
        // immediately. It is an extra safety measure over the final cltv
        // requirement as it is defined in the invoice. It ensures that we
        // cancel back htlcs that, when held on to, may cause us to force close
        // the channel because we enter the incoming broadcast window. Bolt #11
        // suggests 9 blocks here. We use a few more for additional safety.
        //
        // There is still a small gap that remains between receiving the
        // RevokeAndAck and canceling back. If a new block arrives within that
        // window, we may still force close the channel. There is currently no
        // way to reject an UpdateAddHtlc of which we already know that it will
        // push us in the broadcast window.
        DefaultFinalCltvRejectDelta = DefaultIncomingBroadcastDelta + 3

        // DefaultCltvInterceptDelta defines the number of blocks before the
        // expiry of the htlc where we don't intercept anymore. This value must
        // be greater than CltvRejectDelta, because we don't want to offer htlcs
        // to the interceptor client for which there is no time left to resolve
        // them anymore.
        DefaultCltvInterceptDelta = DefaultFinalCltvRejectDelta + 3

        // DefaultOutgoingBroadcastDelta defines the number of blocks before the
        // expiry of an outgoing htlc at which we force close the channel. We
        // are not in a hurry to force close, because there is nothing to claim
        // for us. We do need to time the htlc out, because there may be an
        // incoming htlc that will time out too (albeit later). Bolt #2 suggests
        // a value of -1 here, but we allow one block less to prevent potential
        // confusion around the negative value. It means we force close the
        // channel at exactly the htlc expiry height.
        DefaultOutgoingBroadcastDelta = 0

        // DefaultOutgoingCltvRejectDelta defines the number of blocks before
        // the expiry of an outgoing htlc at which we don't want to offer it to
        // the next peer anymore. If that happens, we cancel back the incoming
        // htlc. This is to prevent the situation where we have an outstanding
        // htlc that brings or will soon bring us inside the outgoing broadcast
        // window and trigger us to force close the channel. Bolt #2 suggests a
        // value of 0. We pad it a bit, to prevent a slow round trip to the next
        // peer and a block arriving during that round trip to trigger force
        // closure.
        DefaultOutgoingCltvRejectDelta = DefaultOutgoingBroadcastDelta + 3

        // DefaultZombieSweeperInterval is the default time interval at which
        // unfinished (zombiestate) open channel flows are purged from memory.
        DefaultZombieSweeperInterval = 1 * time.Minute
)

// CleanAndExpandPath expands environment variables and leading ~ in the
// passed path, cleans the result, and returns it.
// This function is taken from https://github.com/btcsuite/btcd
func CleanAndExpandPath(path string) string {
        if path == "" {
                return ""
        }

        // Expand initial ~ to OS specific home directory.
        if strings.HasPrefix(path, "~") {
                var homeDir string
                u, err := user.Current()
                if err == nil {
                        homeDir = u.HomeDir
                } else {
                        homeDir = os.Getenv("HOME")
                }

                path = strings.Replace(path, "~", homeDir, 1)
        }

        // NOTE: The os.ExpandEnv doesn't work with Windows-style %VARIABLE%,
        // but the variables can still be expanded via POSIX-style $VARIABLE.
        return filepath.Clean(os.ExpandEnv(path))
}

// NormalizeNetwork returns the common name of a network type used to create
// file paths. This allows differently versioned networks to use the same path.
func NormalizeNetwork(network string) string {
        if strings.HasPrefix(network, "testnet") {
                return "testnet"
        }

        return network
}

1	package lncfg
2
3	import (
4	"os"
5	"os/user"
6	"path/filepath"
7	"strings"
8	"time"
9	)
10
11	const (
12	// DefaultConfigFilename is the default configuration file name lnd
13	// tries to load.
14	DefaultConfigFilename = "lnd.conf"
15
16	// DefaultMaxPendingChannels is the default maximum number of incoming
17	// pending channels permitted per peer.
18	DefaultMaxPendingChannels = 1
19
20	// DefaultIncomingBroadcastDelta defines the number of blocks before the
21	// expiry of an incoming htlc at which we force close the channel. We
22	// only go to chain if we also have the preimage to actually pull in the
23	// htlc. BOLT #2 suggests 7 blocks. We use a few more for extra safety.
24	// Within this window we need to get our sweep or 2nd level success tx
25	// confirmed, because after that the remote party is also able to claim
26	// the htlc using the timeout path.
27	DefaultIncomingBroadcastDelta = 10
28
29	// DefaultFinalCltvRejectDelta defines the number of blocks before the
30	// expiry of an incoming exit hop htlc at which we cancel it back
31	// immediately. It is an extra safety measure over the final cltv
32	// requirement as it is defined in the invoice. It ensures that we
33	// cancel back htlcs that, when held on to, may cause us to force close
34	// the channel because we enter the incoming broadcast window. Bolt #11
35	// suggests 9 blocks here. We use a few more for additional safety.
36	//
37	// There is still a small gap that remains between receiving the
38	// RevokeAndAck and canceling back. If a new block arrives within that
39	// window, we may still force close the channel. There is currently no
40	// way to reject an UpdateAddHtlc of which we already know that it will
41	// push us in the broadcast window.
42	DefaultFinalCltvRejectDelta = DefaultIncomingBroadcastDelta + 3
43
44	// DefaultCltvInterceptDelta defines the number of blocks before the
45	// expiry of the htlc where we don't intercept anymore. This value must
46	// be greater than CltvRejectDelta, because we don't want to offer htlcs
47	// to the interceptor client for which there is no time left to resolve
48	// them anymore.
49	DefaultCltvInterceptDelta = DefaultFinalCltvRejectDelta + 3
50
51	// DefaultOutgoingBroadcastDelta defines the number of blocks before the
52	// expiry of an outgoing htlc at which we force close the channel. We
53	// are not in a hurry to force close, because there is nothing to claim
54	// for us. We do need to time the htlc out, because there may be an
55	// incoming htlc that will time out too (albeit later). Bolt #2 suggests
56	// a value of -1 here, but we allow one block less to prevent potential
57	// confusion around the negative value. It means we force close the
58	// channel at exactly the htlc expiry height.
59	DefaultOutgoingBroadcastDelta = 0
60
61	// DefaultOutgoingCltvRejectDelta defines the number of blocks before
62	// the expiry of an outgoing htlc at which we don't want to offer it to
63	// the next peer anymore. If that happens, we cancel back the incoming
64	// htlc. This is to prevent the situation where we have an outstanding
65	// htlc that brings or will soon bring us inside the outgoing broadcast
66	// window and trigger us to force close the channel. Bolt #2 suggests a
67	// value of 0. We pad it a bit, to prevent a slow round trip to the next
68	// peer and a block arriving during that round trip to trigger force
69	// closure.
70	DefaultOutgoingCltvRejectDelta = DefaultOutgoingBroadcastDelta + 3
71
72	// DefaultZombieSweeperInterval is the default time interval at which
73	// unfinished (zombiestate) open channel flows are purged from memory.
74	DefaultZombieSweeperInterval = 1 * time.Minute
75	)
76
77	// CleanAndExpandPath expands environment variables and leading ~ in the
78	// passed path, cleans the result, and returns it.
79	// This function is taken from https://github.com/btcsuite/btcd
80	func CleanAndExpandPath(path string) string {	×
81	if path == "" {	×
82	return ""	×
83	}	×
84
85	// Expand initial ~ to OS specific home directory.
86	if strings.HasPrefix(path, "~") {	×
87	var homeDir string	×
88	u, err := user.Current()	×
89	if err == nil {	×
90	homeDir = u.HomeDir	×
91	} else {	×
92	homeDir = os.Getenv("HOME")	×
93	}	×
94
95	path = strings.Replace(path, "~", homeDir, 1)	×
96	}
97
98	// NOTE: The os.ExpandEnv doesn't work with Windows-style %VARIABLE%,
99	// but the variables can still be expanded via POSIX-style $VARIABLE.
100	return filepath.Clean(os.ExpandEnv(path))	×
101	}
102
103	// NormalizeNetwork returns the common name of a network type used to create
104	// file paths. This allows differently versioned networks to use the same path.
105	func NormalizeNetwork(network string) string {	×
106	if strings.HasPrefix(network, "testnet") {	×
107	return "testnet"	×
108	}	×
109
110	return network	×
111	}

lightningnetwork / lnd / 12313002221

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