chanrestore: add new file to house chanbackup interface implementations

The `openChannelShell` method now includes the new config information
within the open channel shells. Additionally, we now properly re-derive
all keys from our local chan config so they're useable immediately in
the channel state machine.

We extend the `chanDBRestorer.RestoreChansFromSingles` method to also
add the new channels to the chain arbitrator once they've been restored
on disk. We do this in order to ensure that we catch the channel closure
on chain once the DLP protocol beings.

chanrestore.go

@@ -0,0 +1,196 @@
+package main
+
+import (
+	"fmt"
+	"net"
+
+	"github.com/btcsuite/btcd/btcec"
+	"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"
+)
+
+// 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.DB
+
+	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) {
+
+	// First, we'll also need to obtain the private key for the shachain
+	// root from the encoded public key.
+	//
+	// TODO(roasbeef): now adds req for hardware signers to impl
+	// shachain...
+	privKey, err := c.secretKeys.DerivePrivKey(backup.ShaChainRootDesc)
+	if err != nil {
+		return nil, nil
+	}
+	revRoot, err := chainhash.NewHash(privKey.Serialize())
+	if err != nil {
+		return nil, err
+	}
+	shaChainProducer := shachain.NewRevocationProducer(*revRoot)
+
+	// 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: %v", err)
+	}
+	backup.LocalChanCfg.RevocationBasePoint, err = c.secretKeys.DeriveKey(
+		backup.LocalChanCfg.RevocationBasePoint.KeyLocator,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("unable to derive revocation key: %v", err)
+	}
+	backup.LocalChanCfg.PaymentBasePoint, err = c.secretKeys.DeriveKey(
+		backup.LocalChanCfg.PaymentBasePoint.KeyLocator,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("unable to derive payment key: %v", err)
+	}
+	backup.LocalChanCfg.DelayBasePoint, err = c.secretKeys.DeriveKey(
+		backup.LocalChanCfg.DelayBasePoint.KeyLocator,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("unable to derive delay key: %v", err)
+	}
+	backup.LocalChanCfg.HtlcBasePoint, err = c.secretKeys.DeriveKey(
+		backup.LocalChanCfg.HtlcBasePoint.KeyLocator,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("unable to derive htlc key: %v", err)
+	}
+
+	chanShell := channeldb.ChannelShell{
+		NodeAddrs: backup.Addresses,
+		Chan: &channeldb.OpenChannel{
+			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,
+		},
+	}
+
+	// TODO(roasbeef): move this mapping elsewhere?
+
+	// When we make a channel, we mark that the channel has been restored,
+	// this will signal to other sub-systems to not attempt to use the
+	// channel as if it was a regular one.
+	chanStatus := channeldb.ChanStatusDefault |
+		channeldb.ChanStatusRestored
+
+	chanShell.Chan.ApplyChanStatus(chanStatus)
+
+	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))
+	for _, backup := range backups {
+		chanShell, err := c.openChannelShell(backup)
+		if err != nil {
+			return err
+		}
+
+		channelShells = append(channelShells, chanShell)
+	}
+
+	ltndLog.Infof("Inserting %v SCB channel shells into DB")
+
+	// 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 {
+	// 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 cancelled.
+	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.
+		if err := s.ConnectToPeer(netAddr, true); err != nil {
+			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())
+}