multi: implement spec-compliant coop close

htlcswitch/link.go

@@ -334,6 +334,12 @@ type ChannelLinkConfig struct {
 	// is called. It takes a quit chan that is used as a precaution to
 	// avoid deadlock.
 	NotifyCoopReady func(chanPoint *wire.OutPoint, quit chan struct{})
+
+	// RetransmitShutdown is a boolean that indicates whether the link
+	// should retransmit a Shutdown during the Reestablish flow. This
+	// automatically starts the link in "shutdown mode" so that new HTLCs
+	// are not accepted or sent.
+	RetransmitShutdown bool
 }
 
 // channelLink is the service which drives a channel's commitment update
@@ -825,6 +831,25 @@ func (l *channelLink) syncChanStates() error {
 			}
 		}
 
+		// If we have been signaled to retransmit Shutdown, we'll do so
+		// here.
+		if l.cfg.RetransmitShutdown {
+			// Recreate the Shutdown message.
+			shutdownMsg := lnwire.NewShutdown(
+				l.ChanID(),
+				l.channel.LocalUpfrontShutdownScript(),
+			)
+
+			// Flip the shutdownInit bool.
+			l.shutdownInit = true
+
+			err = l.cfg.Peer.SendMessage(false, shutdownMsg)
+			if err != nil {
+				return fmt.Errorf("unable to re-send "+
+					"Shutdown: %v", err)
+			}
+		}
+
 		// In any case, we'll then process their ChanSync message.
 		l.log.Info("received re-establishment message from remote side")
 

htlcswitch/link_test.go

@@ -6342,6 +6342,73 @@ func TestPendingCommitTicker(t *testing.T) {
 	}
 }
 
+// TestShutdownRetransmit tests that the link is able to properly retransmit a
+// Shutdown message if it restarts.
+func TestShutdownRetransmit(t *testing.T) {
+	t.Parallel()
+
+	// Create the three hop network even though we'll only be using Alice
+	// and Bob.
+	const aliceInitialBalance = btcutil.SatoshiPerBitcoin * 3
+	channels, _, err := createClusterChannels(
+		t, aliceInitialBalance, btcutil.SatoshiPerBitcoin*5,
+	)
+	require.NoError(t, err)
+
+	n := newThreeHopNetwork(t, channels.aliceToBob, channels.bobToAlice,
+		channels.bobToCarol, channels.carolToBob, testStartingHeight)
+
+	// Set up the message interceptors to ensure the proper messages are
+	// sent and received in the correct order.
+	chanID := n.aliceChannelLink.ChanID()
+	messages := []expectedMessage{
+		{"alice", "bob", &lnwire.ChannelReestablish{}, false},
+		{"bob", "alice", &lnwire.ChannelReestablish{}, false},
+
+		{"alice", "bob", &lnwire.FundingLocked{}, false},
+		{"bob", "alice", &lnwire.FundingLocked{}, false},
+
+		{"alice", "bob", &lnwire.Shutdown{}, false},
+		{"bob", "alice", &lnwire.Shutdown{}, false},
+	}
+	n.aliceServer.intersect(createInterceptorFunc("[alice] <-- [bob]",
+		"alice", messages, chanID, false))
+	n.bobServer.intersect(createInterceptorFunc("[alice] --> [bob]", "bob",
+		messages, chanID, false))
+
+	closeReqChan := make(chan *ChanClose, 2)
+	notifyShutdown := func(req *ChanClose, quit chan struct{}) {
+		select {
+		case closeReqChan <- req:
+		default:
+		}
+	}
+
+	coopReadyChan := make(chan struct{}, 2)
+	notifyCoopReady := func(chanPoint *wire.OutPoint, quit chan struct{}) {
+		select {
+		case coopReadyChan <- struct{}{}:
+		default:
+		}
+	}
+
+	// Set the closure functions for Alice and Bob.
+	n.aliceChannelLink.cfg.NotifySendingShutdown = notifyShutdown
+	n.aliceChannelLink.cfg.NotifyCoopReady = notifyCoopReady
+	n.firstBobChannelLink.cfg.NotifySendingShutdown = notifyShutdown
+	n.firstBobChannelLink.cfg.NotifyCoopReady = notifyCoopReady
+
+	// Set the RetransmitShutdown config option for Alice.
+	n.aliceChannelLink.cfg.RetransmitShutdown = true
+
+	err = n.start()
+	require.NoError(t, err)
+	defer n.stop()
+	defer func() {
+		_ = n.feeEstimator.Stop()
+	}()
+}
+
 // TestCustomShutdownScript tests that it's possible to set a custom shutdown
 // script when using the NotifyShouldShutdown call.
 func TestCustomShutdownScript(t *testing.T) {

peer/brontide.go

@@ -972,6 +972,47 @@ func (p *Brontide) addLink(chanPoint *wire.OutPoint,
 		return err
 	}
 
+	chanID := lnwire.NewChanIDFromOutPoint(chanPoint)
+
+	// If we need to retransmit Shutdown, create a ChanCloser and give it
+	// the Shutdown message.
+	retransmitShutdown := lnChan.State().HasSentShutdown()
+	if retransmitShutdown {
+		feePerKw, err := p.cfg.FeeEstimator.EstimateFeePerKW(
+			p.cfg.CoopCloseTargetConfs,
+		)
+		if err != nil {
+			return err
+		}
+
+		// Since we've sent Shutdown, the delivery script is already
+		// persisted. We won't know if it's locally initiated or not.
+		// At this stage, this is fine so we set it to true.
+		chanCloser, err := p.createChanCloser(
+			lnChan, lnChan.LocalUpfrontShutdownScript(), feePerKw,
+			nil, true,
+		)
+		if err != nil {
+			peerLog.Errorf("unable to create chan closer: %v", err)
+			return err
+		}
+
+		p.activeChanCloses[chanID] = chanCloser
+
+		shutdownMsg := lnwire.NewShutdown(
+			chanID, lnChan.LocalUpfrontShutdownScript(),
+		)
+
+		// Give the Shutdown message to the ChanCloser without sending
+		// it. The link will send it during retransmission.
+		_, _, err = chanCloser.ProcessCloseMsg(shutdownMsg, false)
+		if err != nil {
+			peerLog.Errorf("unable to process shutdown: %v", err)
+			delete(p.activeChanCloses, chanID)
+			return err
+		}
+	}
+
 	//nolint:lll
 	linkCfg := htlcswitch.ChannelLinkConfig{
 		Peer:                   p,
@@ -1014,13 +1055,13 @@ func (p *Brontide) addLink(chanPoint *wire.OutPoint,
 		DeliveryAddr:            deliveryAddr,
 		NotifySendingShutdown:   p.HandleLocalCloseChanReqs,
 		NotifyCoopReady:         p.HandleCoopReady,
+		RetransmitShutdown:      retransmitShutdown,
 	}
 
 	// Before adding our new link, purge the switch of any pending or live
 	// links going by the same channel id. If one is found, we'll shut it
 	// down to ensure that the mailboxes are only ever under the control of
 	// one link.
-	chanID := lnwire.NewChanIDFromOutPoint(chanPoint)
 	p.cfg.Switch.RemoveLink(chanID)
 
 	// With the channel link created, we'll now notify the htlc switch so