12293715361

Committed 12 Dec 2024 09:38AM UTC coverage: 57.483% (+7.9%) from 49.538%

Build # 12293715361

Build Type

Pull #9348

github

Committed by

ziggie1984

Commit Message

github: update goveralls tool

The goverall tool had a bug regarding the module versioning of
golang packages see also
https://github.com/mattn/goveralls/pull/222 for more background.
Goveralls is wrapped by another library to make it available for
github actions. So the relevant PR which is referenced here in
LND is:
https://github.com/shogo82148/actions-goveralls/pull/521.

Pull Request Pull Request #9348: github: update goveralls tool

Run Details

101897 of 177264 relevant lines covered (57.48%)

24982.4 hits per line

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

0.0

/chanrestore.go

package lnd

import (
        "fmt"
        "math"
        "net"

        "github.com/btcsuite/btcd/btcec/v2"
        "github.com/btcsuite/btcd/chaincfg"
        "github.com/btcsuite/btcd/chaincfg/chainhash"
        "github.com/lightningnetwork/lnd/chanbackup"
        "github.com/lightningnetwork/lnd/channeldb"
        "github.com/lightningnetwork/lnd/contractcourt"
        "github.com/lightningnetwork/lnd/keychain"
        "github.com/lightningnetwork/lnd/lnwire"
        "github.com/lightningnetwork/lnd/shachain"
)

const (
        // mainnetSCBLaunchBlock is the approximate block height of the bitcoin
        // mainnet chain of the date when SCBs first were released in lnd
        // (v0.6.0-beta). The block date is 4/15/2019, 10:54 PM UTC.
        mainnetSCBLaunchBlock = 571800

        // testnetSCBLaunchBlock is the approximate block height of the bitcoin
        // testnet3 chain of the date when SCBs first were released in lnd
        // (v0.6.0-beta). The block date is 4/16/2019, 08:04 AM UTC.
        testnetSCBLaunchBlock = 1489300
)

// chanDBRestorer is an implementation of the chanbackup.ChannelRestorer
// interface that is able to properly map a Single backup, into a
// channeldb.ChannelShell which is required to fully restore a channel. We also
// need the secret key chain in order obtain the prior shachain root so we can
// verify the DLP protocol as initiated by the remote node.
type chanDBRestorer struct {
        db *channeldb.ChannelStateDB

        secretKeys keychain.SecretKeyRing

        chainArb *contractcourt.ChainArbitrator
}

// openChannelShell maps the static channel back up into an open channel
// "shell". We say shell as this doesn't include all the information required
// to continue to use the channel, only the minimal amount of information to
// insert this shell channel back into the database.
func (c *chanDBRestorer) openChannelShell(backup chanbackup.Single) (
        *channeldb.ChannelShell, error) {

        var err error

        // Each of the keys in our local channel config only have their
        // locators populate, so we'll re-derive the raw key now as we'll need
        // it in order to carry out the DLP protocol.
        backup.LocalChanCfg.MultiSigKey, err = c.secretKeys.DeriveKey(
                backup.LocalChanCfg.MultiSigKey.KeyLocator,
        )
        if err != nil {
                return nil, fmt.Errorf("unable to derive multi sig key: %w",
                        err)
        }
        backup.LocalChanCfg.RevocationBasePoint, err = c.secretKeys.DeriveKey(
                backup.LocalChanCfg.RevocationBasePoint.KeyLocator,
        )
        if err != nil {
                return nil, fmt.Errorf("unable to derive revocation key: %w",
                        err)
        }
        backup.LocalChanCfg.PaymentBasePoint, err = c.secretKeys.DeriveKey(
                backup.LocalChanCfg.PaymentBasePoint.KeyLocator,
        )
        if err != nil {
                return nil, fmt.Errorf("unable to derive payment key: %w", err)
        }
        backup.LocalChanCfg.DelayBasePoint, err = c.secretKeys.DeriveKey(
                backup.LocalChanCfg.DelayBasePoint.KeyLocator,
        )
        if err != nil {
                return nil, fmt.Errorf("unable to derive delay key: %w", err)
        }
        backup.LocalChanCfg.HtlcBasePoint, err = c.secretKeys.DeriveKey(
                backup.LocalChanCfg.HtlcBasePoint.KeyLocator,
        )
        if err != nil {
                return nil, fmt.Errorf("unable to derive htlc key: %w", err)
        }

        // The shachain root that seeds RevocationProducer for this channel.
        // It currently has two possible formats.
        var revRoot *chainhash.Hash

        // If the PubKey field is non-nil, then this shachain root is using the
        // legacy non-ECDH scheme.
        if backup.ShaChainRootDesc.PubKey != nil {
                ltndLog.Debugf("Using legacy revocation producer format for "+
                        "channel point %v", backup.FundingOutpoint)

                // Obtain the private key for the shachain root from the
                // encoded public key.
                privKey, err := c.secretKeys.DerivePrivKey(
                        backup.ShaChainRootDesc,
                )
                if err != nil {
                        return nil, fmt.Errorf("could not derive private key "+
                                "for legacy channel revocation root format: "+
                                "%v", err)
                }

                revRoot, err = chainhash.NewHash(privKey.Serialize())
                if err != nil {
                        return nil, err
                }
        } else {
                ltndLog.Debugf("Using new ECDH revocation producer format "+
                        "for channel point %v", backup.FundingOutpoint)

                // This is the scheme in which the shachain root is derived via
                // an ECDH operation on the private key of ShaChainRootDesc and
                // our public multisig key.
                ecdh, err := c.secretKeys.ECDH(
                        backup.ShaChainRootDesc,
                        backup.LocalChanCfg.MultiSigKey.PubKey,
                )
                if err != nil {
                        return nil, fmt.Errorf("unable to derive shachain "+
                                "root: %v", err)
                }

                ch := chainhash.Hash(ecdh)
                revRoot = &ch
        }

        shaChainProducer := shachain.NewRevocationProducer(*revRoot)

        var chanType channeldb.ChannelType
        switch backup.Version {
        case chanbackup.DefaultSingleVersion:
                chanType = channeldb.SingleFunderBit

        case chanbackup.TweaklessCommitVersion:
                chanType = channeldb.SingleFunderTweaklessBit

        case chanbackup.AnchorsCommitVersion:
                chanType = channeldb.AnchorOutputsBit
                chanType |= channeldb.SingleFunderTweaklessBit

        case chanbackup.AnchorsZeroFeeHtlcTxCommitVersion:
                chanType = channeldb.ZeroHtlcTxFeeBit
                chanType |= channeldb.AnchorOutputsBit
                chanType |= channeldb.SingleFunderTweaklessBit

        case chanbackup.ScriptEnforcedLeaseVersion:
                chanType = channeldb.LeaseExpirationBit
                chanType |= channeldb.ZeroHtlcTxFeeBit
                chanType |= channeldb.AnchorOutputsBit
                chanType |= channeldb.SingleFunderTweaklessBit

        case chanbackup.SimpleTaprootVersion:
                chanType = channeldb.ZeroHtlcTxFeeBit
                chanType |= channeldb.AnchorOutputsBit
                chanType |= channeldb.SingleFunderTweaklessBit
                chanType |= channeldb.SimpleTaprootFeatureBit

        case chanbackup.TapscriptRootVersion:
                chanType = channeldb.ZeroHtlcTxFeeBit
                chanType |= channeldb.AnchorOutputsBit
                chanType |= channeldb.SingleFunderTweaklessBit
                chanType |= channeldb.SimpleTaprootFeatureBit
                chanType |= channeldb.TapscriptRootBit

        default:
                return nil, fmt.Errorf("unknown Single version: %w", err)
        }

        ltndLog.Infof("SCB Recovery: created channel shell for ChannelPoint"+
                "(%v), chan_type=%v", backup.FundingOutpoint, chanType)

        chanShell := channeldb.ChannelShell{
                NodeAddrs: backup.Addresses,
                Chan: &channeldb.OpenChannel{
                        ChanType:                chanType,
                        ChainHash:               backup.ChainHash,
                        IsInitiator:             backup.IsInitiator,
                        Capacity:                backup.Capacity,
                        FundingOutpoint:         backup.FundingOutpoint,
                        ShortChannelID:          backup.ShortChannelID,
                        IdentityPub:             backup.RemoteNodePub,
                        IsPending:               false,
                        LocalChanCfg:            backup.LocalChanCfg,
                        RemoteChanCfg:           backup.RemoteChanCfg,
                        RemoteCurrentRevocation: backup.RemoteNodePub,
                        RevocationStore:         shachain.NewRevocationStore(),
                        RevocationProducer:      shaChainProducer,
                        ThawHeight:              backup.LeaseExpiry,
                },
        }

        return &chanShell, nil
}

// RestoreChansFromSingles attempts to map the set of single channel backups to
// channel shells that will be stored persistently. Once these shells have been
// stored on disk, we'll be able to connect to the channel peer an execute the
// data loss recovery protocol.
//
// NOTE: Part of the chanbackup.ChannelRestorer interface.
func (c *chanDBRestorer) RestoreChansFromSingles(backups ...chanbackup.Single) error {
        channelShells := make([]*channeldb.ChannelShell, 0, len(backups))
        firstChanHeight := uint32(math.MaxUint32)
        for _, backup := range backups {
                chanShell, err := c.openChannelShell(backup)
                if err != nil {
                        return err
                }

                // Find the block height of the earliest channel in this backup.
                chanHeight := chanShell.Chan.ShortChanID().BlockHeight
                if chanHeight != 0 && chanHeight < firstChanHeight {
                        firstChanHeight = chanHeight
                }

                channelShells = append(channelShells, chanShell)
        }

        // In case there were only unconfirmed channels, we will have to scan
        // the chain beginning from the launch date of SCBs.
        if firstChanHeight == math.MaxUint32 {
                chainHash := channelShells[0].Chan.ChainHash
                switch {
                case chainHash.IsEqual(chaincfg.MainNetParams.GenesisHash):
                        firstChanHeight = mainnetSCBLaunchBlock

                case chainHash.IsEqual(chaincfg.TestNet3Params.GenesisHash):
                        firstChanHeight = testnetSCBLaunchBlock

                default:
                        // Worst case: We have no height hint and start at
                        // block 1. Should only happen for SCBs in regtest
                        // and simnet.
                        firstChanHeight = 1
                }
        }

        // If there were channels in the backup that were not confirmed at the
        // time of the backup creation, they won't have a block height in the
        // ShortChanID which would lead to an error in the chain watcher.
        // We want to at least set the funding broadcast height that the chain
        // watcher can use instead. We have two possible fallback values for
        // the broadcast height that we are going to try here.
        for _, chanShell := range channelShells {
                channel := chanShell.Chan

                switch {
                // Fallback case 1: This is an unconfirmed channel from an old
                // backup file where we didn't have any workaround in place and
                // the short channel ID is 0:0:0. Best we can do here is set the
                // funding broadcast height to a reasonable value that we
                // determined earlier.
                case channel.ShortChanID().BlockHeight == 0:
                        channel.SetBroadcastHeight(firstChanHeight)

                // Fallback case 2: It is extremely unlikely at this point that
                // a channel we are trying to restore has a coinbase funding TX.
                // Therefore we can be quite certain that if the TxIndex is
                // zero but the block height wasn't, it was an unconfirmed
                // channel where we used the BlockHeight to encode the funding
                // TX broadcast height. To not end up with an invalid short
                // channel ID that looks valid, we restore the "original"
                // unconfirmed one here.
                case channel.ShortChannelID.TxIndex == 0:
                        broadcastHeight := channel.ShortChannelID.BlockHeight
                        channel.SetBroadcastHeight(broadcastHeight)
                        channel.ShortChannelID.BlockHeight = 0
                }
        }

        ltndLog.Infof("Inserting %v SCB channel shells into DB",
                len(channelShells))

        // Now that we have all the backups mapped into a series of Singles,
        // we'll insert them all into the database.
        if err := c.db.RestoreChannelShells(channelShells...); err != nil {
                return err
        }

        ltndLog.Infof("Informing chain watchers of new restored channels")

        // Finally, we'll need to inform the chain arbitrator of these new
        // channels so we'll properly watch for their ultimate closure on chain
        // and sweep them via the DLP.
        for _, restoredChannel := range channelShells {
                err := c.chainArb.WatchNewChannel(restoredChannel.Chan)
                if err != nil {
                        return err
                }
        }

        return nil
}

// A compile-time constraint to ensure chanDBRestorer implements
// chanbackup.ChannelRestorer.
var _ chanbackup.ChannelRestorer = (*chanDBRestorer)(nil)

// ConnectPeer attempts to connect to the target node at the set of available
// addresses. Once this method returns with a non-nil error, the connector
// should attempt to persistently connect to the target peer in the background
// as a persistent attempt.
//
// NOTE: Part of the chanbackup.PeerConnector interface.
func (s *server) ConnectPeer(nodePub *btcec.PublicKey, addrs []net.Addr) error {
        // Before we connect to the remote peer, we'll remove any connections
        // to ensure the new connection is created after this new link/channel
        // is known.
        if err := s.DisconnectPeer(nodePub); err != nil {
                ltndLog.Infof("Peer(%v) is already connected, proceeding "+
                        "with chan restore", nodePub.SerializeCompressed())
        }

        // For each of the known addresses, we'll attempt to launch a
        // persistent connection to the (pub, addr) pair. In the event that any
        // of them connect, all the other stale requests will be canceled.
        for _, addr := range addrs {
                netAddr := &lnwire.NetAddress{
                        IdentityKey: nodePub,
                        Address:     addr,
                }

                ltndLog.Infof("Attempting to connect to %v for SCB restore "+
                        "DLP", netAddr)

                // Attempt to connect to the peer using this full address. If
                // we're unable to connect to them, then we'll try the next
                // address in place of it.
                err := s.ConnectToPeer(netAddr, true, s.cfg.ConnectionTimeout)

                // If we're already connected to this peer, then we don't
                // consider this an error, so we'll exit here.
                if _, ok := err.(*errPeerAlreadyConnected); ok {
                        return nil

                } else if err != nil {
                        // Otherwise, something else happened, so we'll try the
                        // next address.
                        ltndLog.Errorf("unable to connect to %v to "+
                                "complete SCB restore: %v", netAddr, err)
                        continue
                }

                // If we connected no problem, then we can exit early as our
                // job here is done.
                return nil
        }

        return fmt.Errorf("unable to connect to peer %x for SCB restore",
                nodePub.SerializeCompressed())
}

1	package lnd
2
3	import (
4	"fmt"
5	"math"
6	"net"
7
8	"github.com/btcsuite/btcd/btcec/v2"
9	"github.com/btcsuite/btcd/chaincfg"
10	"github.com/btcsuite/btcd/chaincfg/chainhash"
11	"github.com/lightningnetwork/lnd/chanbackup"
12	"github.com/lightningnetwork/lnd/channeldb"
13	"github.com/lightningnetwork/lnd/contractcourt"
14	"github.com/lightningnetwork/lnd/keychain"
15	"github.com/lightningnetwork/lnd/lnwire"
16	"github.com/lightningnetwork/lnd/shachain"
17	)
18
19	const (
20	// mainnetSCBLaunchBlock is the approximate block height of the bitcoin
21	// mainnet chain of the date when SCBs first were released in lnd
22	// (v0.6.0-beta). The block date is 4/15/2019, 10:54 PM UTC.
23	mainnetSCBLaunchBlock = 571800
24
25	// testnetSCBLaunchBlock is the approximate block height of the bitcoin
26	// testnet3 chain of the date when SCBs first were released in lnd
27	// (v0.6.0-beta). The block date is 4/16/2019, 08:04 AM UTC.
28	testnetSCBLaunchBlock = 1489300
29	)
30
31	// chanDBRestorer is an implementation of the chanbackup.ChannelRestorer
32	// interface that is able to properly map a Single backup, into a
33	// channeldb.ChannelShell which is required to fully restore a channel. We also
34	// need the secret key chain in order obtain the prior shachain root so we can
35	// verify the DLP protocol as initiated by the remote node.
36	type chanDBRestorer struct {
37	db *channeldb.ChannelStateDB
38
39	secretKeys keychain.SecretKeyRing
40
41	chainArb *contractcourt.ChainArbitrator
42	}
43
44	// openChannelShell maps the static channel back up into an open channel
45	// "shell". We say shell as this doesn't include all the information required
46	// to continue to use the channel, only the minimal amount of information to
47	// insert this shell channel back into the database.
48	func (c *chanDBRestorer) openChannelShell(backup chanbackup.Single) (
49	*channeldb.ChannelShell, error) {	×
50		×
51	var err error	×
52		×
53	// Each of the keys in our local channel config only have their	×
54	// locators populate, so we'll re-derive the raw key now as we'll need	×
55	// it in order to carry out the DLP protocol.	×
56	backup.LocalChanCfg.MultiSigKey, err = c.secretKeys.DeriveKey(	×
57	backup.LocalChanCfg.MultiSigKey.KeyLocator,	×
58	)	×
59	if err != nil {	×
60	return nil, fmt.Errorf("unable to derive multi sig key: %w",	×
61	err)	×
62	}	×
63	backup.LocalChanCfg.RevocationBasePoint, err = c.secretKeys.DeriveKey(	×
64	backup.LocalChanCfg.RevocationBasePoint.KeyLocator,	×
65	)	×
66	if err != nil {	×
67	return nil, fmt.Errorf("unable to derive revocation key: %w",	×
68	err)	×
69	}	×
70	backup.LocalChanCfg.PaymentBasePoint, err = c.secretKeys.DeriveKey(	×
71	backup.LocalChanCfg.PaymentBasePoint.KeyLocator,	×
72	)	×
73	if err != nil {	×
74	return nil, fmt.Errorf("unable to derive payment key: %w", err)	×
75	}	×
76	backup.LocalChanCfg.DelayBasePoint, err = c.secretKeys.DeriveKey(	×
77	backup.LocalChanCfg.DelayBasePoint.KeyLocator,	×
78	)	×
79	if err != nil {	×
80	return nil, fmt.Errorf("unable to derive delay key: %w", err)	×
81	}	×
82	backup.LocalChanCfg.HtlcBasePoint, err = c.secretKeys.DeriveKey(	×
83	backup.LocalChanCfg.HtlcBasePoint.KeyLocator,	×
84	)	×
85	if err != nil {	×
86	return nil, fmt.Errorf("unable to derive htlc key: %w", err)	×
87	}	×
88
89	// The shachain root that seeds RevocationProducer for this channel.
90	// It currently has two possible formats.
91	var revRoot *chainhash.Hash	×
92		×
93	// If the PubKey field is non-nil, then this shachain root is using the	×
94	// legacy non-ECDH scheme.	×
95	if backup.ShaChainRootDesc.PubKey != nil {	×
96	ltndLog.Debugf("Using legacy revocation producer format for "+	×
97	"channel point %v", backup.FundingOutpoint)	×
98		×
99	// Obtain the private key for the shachain root from the	×
100	// encoded public key.	×
101	privKey, err := c.secretKeys.DerivePrivKey(	×
102	backup.ShaChainRootDesc,	×
103	)	×
104	if err != nil {	×
105	return nil, fmt.Errorf("could not derive private key "+	×
106	"for legacy channel revocation root format: "+	×
107	"%v", err)	×
108	}	×
109
110	revRoot, err = chainhash.NewHash(privKey.Serialize())	×
111	if err != nil {	×
112	return nil, err	×
113	}	×
114	} else {	×
115	ltndLog.Debugf("Using new ECDH revocation producer format "+	×
116	"for channel point %v", backup.FundingOutpoint)	×
117		×
118	// This is the scheme in which the shachain root is derived via	×
119	// an ECDH operation on the private key of ShaChainRootDesc and	×
120	// our public multisig key.	×
121	ecdh, err := c.secretKeys.ECDH(	×
122	backup.ShaChainRootDesc,	×
123	backup.LocalChanCfg.MultiSigKey.PubKey,	×
124	)	×
125	if err != nil {	×
126	return nil, fmt.Errorf("unable to derive shachain "+	×
127	"root: %v", err)	×
128	}	×
129
130	ch := chainhash.Hash(ecdh)	×
131	revRoot = &ch	×
132	}
133
134	shaChainProducer := shachain.NewRevocationProducer(*revRoot)	×
135		×
136	var chanType channeldb.ChannelType	×
137	switch backup.Version {	×
138	case chanbackup.DefaultSingleVersion:	×
139	chanType = channeldb.SingleFunderBit	×
140
141	case chanbackup.TweaklessCommitVersion:	×
142	chanType = channeldb.SingleFunderTweaklessBit	×
143
144	case chanbackup.AnchorsCommitVersion:	×
145	chanType = channeldb.AnchorOutputsBit	×
146	chanType \|= channeldb.SingleFunderTweaklessBit	×
147
148	case chanbackup.AnchorsZeroFeeHtlcTxCommitVersion:	×
149	chanType = channeldb.ZeroHtlcTxFeeBit	×
150	chanType \|= channeldb.AnchorOutputsBit	×
151	chanType \|= channeldb.SingleFunderTweaklessBit	×
152
153	case chanbackup.ScriptEnforcedLeaseVersion:	×
154	chanType = channeldb.LeaseExpirationBit	×
155	chanType \|= channeldb.ZeroHtlcTxFeeBit	×
156	chanType \|= channeldb.AnchorOutputsBit	×
157	chanType \|= channeldb.SingleFunderTweaklessBit	×
158
159	case chanbackup.SimpleTaprootVersion:	×
160	chanType = channeldb.ZeroHtlcTxFeeBit	×
161	chanType \|= channeldb.AnchorOutputsBit	×
162	chanType \|= channeldb.SingleFunderTweaklessBit	×
163	chanType \|= channeldb.SimpleTaprootFeatureBit	×
164
165	case chanbackup.TapscriptRootVersion:	×
166	chanType = channeldb.ZeroHtlcTxFeeBit	×
167	chanType \|= channeldb.AnchorOutputsBit	×
168	chanType \|= channeldb.SingleFunderTweaklessBit	×
169	chanType \|= channeldb.SimpleTaprootFeatureBit	×
170	chanType \|= channeldb.TapscriptRootBit	×
171
172	default:	×
173	return nil, fmt.Errorf("unknown Single version: %w", err)	×
174	}
175
176	ltndLog.Infof("SCB Recovery: created channel shell for ChannelPoint"+	×
177	"(%v), chan_type=%v", backup.FundingOutpoint, chanType)	×
178		×
179	chanShell := channeldb.ChannelShell{	×
180	NodeAddrs: backup.Addresses,	×
181	Chan: &channeldb.OpenChannel{	×
182	ChanType: chanType,	×
183	ChainHash: backup.ChainHash,	×
184	IsInitiator: backup.IsInitiator,	×
185	Capacity: backup.Capacity,	×
186	FundingOutpoint: backup.FundingOutpoint,	×
187	ShortChannelID: backup.ShortChannelID,	×
188	IdentityPub: backup.RemoteNodePub,	×
189	IsPending: false,	×
190	LocalChanCfg: backup.LocalChanCfg,	×
191	RemoteChanCfg: backup.RemoteChanCfg,	×
192	RemoteCurrentRevocation: backup.RemoteNodePub,	×
193	RevocationStore: shachain.NewRevocationStore(),	×
194	RevocationProducer: shaChainProducer,	×
195	ThawHeight: backup.LeaseExpiry,	×
196	},	×
197	}	×
198		×
199	return &chanShell, nil	×
200	}
201
202	// RestoreChansFromSingles attempts to map the set of single channel backups to
203	// channel shells that will be stored persistently. Once these shells have been
204	// stored on disk, we'll be able to connect to the channel peer an execute the
205	// data loss recovery protocol.
206	//
207	// NOTE: Part of the chanbackup.ChannelRestorer interface.
208	func (c *chanDBRestorer) RestoreChansFromSingles(backups ...chanbackup.Single) error {	×
209	channelShells := make([]*channeldb.ChannelShell, 0, len(backups))	×
210	firstChanHeight := uint32(math.MaxUint32)	×
211	for _, backup := range backups {	×
212	chanShell, err := c.openChannelShell(backup)	×
213	if err != nil {	×
214	return err	×
215	}	×
216
217	// Find the block height of the earliest channel in this backup.
218	chanHeight := chanShell.Chan.ShortChanID().BlockHeight	×
219	if chanHeight != 0 && chanHeight < firstChanHeight {	×
220	firstChanHeight = chanHeight	×
221	}	×
222
223	channelShells = append(channelShells, chanShell)	×
224	}
225
226	// In case there were only unconfirmed channels, we will have to scan
227	// the chain beginning from the launch date of SCBs.
228	if firstChanHeight == math.MaxUint32 {	×
229	chainHash := channelShells[0].Chan.ChainHash	×
230	switch {	×
231	case chainHash.IsEqual(chaincfg.MainNetParams.GenesisHash):	×
232	firstChanHeight = mainnetSCBLaunchBlock	×
233
234	case chainHash.IsEqual(chaincfg.TestNet3Params.GenesisHash):	×
235	firstChanHeight = testnetSCBLaunchBlock	×
236
237	default:	×
238	// Worst case: We have no height hint and start at	×
239	// block 1. Should only happen for SCBs in regtest	×
240	// and simnet.	×
241	firstChanHeight = 1	×
242	}
243	}
244
245	// If there were channels in the backup that were not confirmed at the
246	// time of the backup creation, they won't have a block height in the
247	// ShortChanID which would lead to an error in the chain watcher.
248	// We want to at least set the funding broadcast height that the chain
249	// watcher can use instead. We have two possible fallback values for
250	// the broadcast height that we are going to try here.
251	for _, chanShell := range channelShells {	×
252	channel := chanShell.Chan	×
253		×
254	switch {	×
255	// Fallback case 1: This is an unconfirmed channel from an old
256	// backup file where we didn't have any workaround in place and
257	// the short channel ID is 0:0:0. Best we can do here is set the
258	// funding broadcast height to a reasonable value that we
259	// determined earlier.
260	case channel.ShortChanID().BlockHeight == 0:	×
261	channel.SetBroadcastHeight(firstChanHeight)	×
262
263	// Fallback case 2: It is extremely unlikely at this point that
264	// a channel we are trying to restore has a coinbase funding TX.
265	// Therefore we can be quite certain that if the TxIndex is
266	// zero but the block height wasn't, it was an unconfirmed
267	// channel where we used the BlockHeight to encode the funding
268	// TX broadcast height. To not end up with an invalid short
269	// channel ID that looks valid, we restore the "original"
270	// unconfirmed one here.
271	case channel.ShortChannelID.TxIndex == 0:	×
272	broadcastHeight := channel.ShortChannelID.BlockHeight	×
273	channel.SetBroadcastHeight(broadcastHeight)	×
274	channel.ShortChannelID.BlockHeight = 0	×
275	}
276	}
277
278	ltndLog.Infof("Inserting %v SCB channel shells into DB",	×
279	len(channelShells))	×
280		×
281	// Now that we have all the backups mapped into a series of Singles,	×
282	// we'll insert them all into the database.	×
283	if err := c.db.RestoreChannelShells(channelShells...); err != nil {	×
284	return err	×
285	}	×
286
287	ltndLog.Infof("Informing chain watchers of new restored channels")	×
288		×
289	// Finally, we'll need to inform the chain arbitrator of these new	×
290	// channels so we'll properly watch for their ultimate closure on chain	×
291	// and sweep them via the DLP.	×
292	for _, restoredChannel := range channelShells {	×
293	err := c.chainArb.WatchNewChannel(restoredChannel.Chan)	×
294	if err != nil {	×
295	return err	×
296	}	×
297	}
298
299	return nil	×
300	}
301
302	// A compile-time constraint to ensure chanDBRestorer implements
303	// chanbackup.ChannelRestorer.
304	var _ chanbackup.ChannelRestorer = (*chanDBRestorer)(nil)
305
306	// ConnectPeer attempts to connect to the target node at the set of available
307	// addresses. Once this method returns with a non-nil error, the connector
308	// should attempt to persistently connect to the target peer in the background
309	// as a persistent attempt.
310	//
311	// NOTE: Part of the chanbackup.PeerConnector interface.
312	func (s server) ConnectPeer(nodePub btcec.PublicKey, addrs []net.Addr) error {	×
313	// Before we connect to the remote peer, we'll remove any connections	×
314	// to ensure the new connection is created after this new link/channel	×
315	// is known.	×
316	if err := s.DisconnectPeer(nodePub); err != nil {	×
317	ltndLog.Infof("Peer(%v) is already connected, proceeding "+	×
318	"with chan restore", nodePub.SerializeCompressed())	×
319	}	×
320
321	// For each of the known addresses, we'll attempt to launch a
322	// persistent connection to the (pub, addr) pair. In the event that any
323	// of them connect, all the other stale requests will be canceled.
324	for _, addr := range addrs {	×
325	netAddr := &lnwire.NetAddress{	×
326	IdentityKey: nodePub,	×
327	Address: addr,	×
328	}	×
329		×
330	ltndLog.Infof("Attempting to connect to %v for SCB restore "+	×
331	"DLP", netAddr)	×
332		×
333	// Attempt to connect to the peer using this full address. If	×
334	// we're unable to connect to them, then we'll try the next	×
335	// address in place of it.	×
336	err := s.ConnectToPeer(netAddr, true, s.cfg.ConnectionTimeout)	×
337		×
338	// If we're already connected to this peer, then we don't	×
339	// consider this an error, so we'll exit here.	×
340	if _, ok := err.(*errPeerAlreadyConnected); ok {	×
341	return nil	×
342		×
343	} else if err != nil {	×
344	// Otherwise, something else happened, so we'll try the	×
345	// next address.	×
346	ltndLog.Errorf("unable to connect to %v to "+	×
347	"complete SCB restore: %v", netAddr, err)	×
348	continue	×
349	}
350
351	// If we connected no problem, then we can exit early as our
352	// job here is done.
353	return nil	×
354	}
355
356	return fmt.Errorf("unable to connect to peer %x for SCB restore",	×
357	nodePub.SerializeCompressed())	×
358	}

lightningnetwork / lnd / 12293715361

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