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

/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/btcsuite/btcd/wire"
        "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")

        // Create a slice of channel points.
        chanPoints := make([]wire.OutPoint, 0, len(channelShells))

        // 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
                }

                chanPoints = append(
                        chanPoints, restoredChannel.Chan.FundingOutpoint,
                )
        }

        // With all the channels restored, we'll now re-send the blockbeat.
        c.chainArb.RedispatchBlockbeat(chanPoints)

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

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