multi: log additional information for local force closures

channeldb/channel_test.go

@@ -1087,7 +1087,8 @@ func TestFetchWaitingCloseChannels(t *testing.T) {
 			},
 		)
 
-		if err := channel.MarkCommitmentBroadcasted(closeTx, true); err != nil {
+		if err := channel.MarkCommitmentBroadcasted(closeTx,
+			&LocalForceCloseInsights{}); err != nil {
 			t.Fatalf("unable to mark commitment broadcast: %v", err)
 		}
 
@@ -1291,7 +1292,8 @@ func TestCloseInitiator(t *testing.T) {
 			// local initiator.
 			updateChannel: func(c *OpenChannel) error {
 				return c.MarkCommitmentBroadcasted(
-					&wire.MsgTx{}, true,
+					&wire.MsgTx{},
+					&LocalForceCloseInsights{},
 				)
 			},
 			expectedStatuses: []ChannelStatus{
@@ -1633,3 +1635,45 @@ func TestOnionBlobIncorrectLength(t *testing.T) {
 	_, err := DeserializeHtlcs(&b)
 	require.ErrorIs(t, err, ErrOnionBlobLength)
 }
+
+// TestLocalForceCloseInitiatorEncoding tests serializing and deserializing
+// LocalForceCloseInitiator.
+func TestLocalForceCloseInitiatorEncoding(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name string
+		data LocalForceCloseInitiator
+	}{
+		{
+			name: "chain action initiated",
+			data: ChainActionsInitiated,
+		},
+		{
+			name: "user initiated",
+			data: ChainActionsInitiated,
+		},
+		{
+			name: "custom initiator",
+			data: LocalForceCloseInitiator("invalid update"),
+		},
+	}
+
+	for _, testCase := range testCases {
+		testCase := testCase
+
+		t.Run(testCase.name, func(t *testing.T) {
+			t.Parallel()
+
+			var b bytes.Buffer
+			err := SerializeLocalForceCloseInitiator(&b,
+				&testCase.data)
+			require.NoError(t, err)
+
+			r := bytes.NewReader(b.Bytes())
+			data, err := DeserializeLocalForceCloseInitiator(r)
+			require.NoError(t, err)
+			require.Equal(t, testCase.data, data)
+		})
+	}
+}

contractcourt/briefcase.go

@@ -118,6 +118,30 @@ type ArbitratorLog interface {
 	// introduced.
 	FetchChainActions() (ChainActionMap, error)
 
+	// LogLocalForceCloseInitiator records the passed-in
+	// localForceCloseInitiator object within the ArbitratorLog for deferred
+	// consumption. This is typically invoked when the channel force closure
+	// is first initiated either by the user or automatically (
+	// link error, HTLC actions, etc.).
+	LogLocalForceCloseInitiator(
+		initiator channeldb.LocalForceCloseInitiator) error
+
+	// FetchLocalForceCloseInitiator attempts to fetch the
+	// localForceCloseInitiator object that was previously logged in the
+	// ArbitratorLog.
+	FetchLocalForceCloseInitiator() (channeldb.LocalForceCloseInitiator,
+		error)
+
+	// LogLocalFCChainActions records the passed-in chainActionMap
+	// for the force closed channel into the ArbitratorLog for deferred
+	// consumption.
+	LogLocalFCChainActions(ChainActionMap)
+
+	// FetchLocalFCChainActions attempts to fetch the chainActionMap
+	// for the force closed channel that was previously logged in the
+	// ArbitratorLog.
+	FetchLocalFCChainActions() (map[string][]channeldb.HTLC, error)
+
 	// WipeHistory is to be called ONLY once *all* contracts have been
 	// fully resolved, and the channel closure if finalized. This method
 	// will delete all on-disk state within the persistent log.
@@ -366,6 +390,14 @@ var (
 	// taprootDataKey is the key we'll use to store taproot specific data
 	// for the set of channels we'll need to sweep/claim.
 	taprootDataKey = []byte("taproot-data")
+
+	// localForceCloseInitiatorKey is the key that we use to store the
+	// localForceCloseInitiator object within the log, if any.
+	localForceCloseInitiatorKey = []byte("local-force-close-info")
+
+	// fcChainActionKey is the key that we use to store the chain actions
+	// during a force close.
+	fcChainActionKey = []byte("htlc-map-key")
 )
 
 var (
@@ -1047,6 +1079,133 @@ func (b *boltArbitratorLog) FetchChainActions() (ChainActionMap, error) {
 	return actionsMap, nil
 }
 
+// LogLocalForceCloseInitiator records the passed-in localForceCloseInitiator
+// object within the ArbitratorLog for deferred consumption. This is
+// typically invoked when the channel force closure is first initiated
+// either by the user or automatically (link error, HTLC actions, etc.).
+func (b *boltArbitratorLog) LogLocalForceCloseInitiator(
+	info channeldb.LocalForceCloseInitiator) error {
+
+	return kvdb.Update(b.db, func(tx kvdb.RwTx) error {
+		scopeBucket, err := tx.CreateTopLevelBucket(b.scopeKey[:])
+		if err != nil {
+			return err
+		}
+		var buf bytes.Buffer
+		if err := channeldb.SerializeLocalForceCloseInitiator(&buf,
+			&info); err != nil {
+			return err
+		}
+
+		return scopeBucket.Put(localForceCloseInitiatorKey, buf.Bytes())
+	}, func() {})
+}
+
+// FetchLocalForceCloseInitiator attempts to fetch the localForceCloseInitiator
+// object that was previously logged in the ArbitratorLog.
+func (b *boltArbitratorLog) FetchLocalForceCloseInitiator() (
+	channeldb.LocalForceCloseInitiator,
+	error) {
+
+	var init channeldb.LocalForceCloseInitiator
+	err := kvdb.View(b.db, func(tx kvdb.RTx) error {
+		scopeBucket := tx.ReadBucket(b.scopeKey[:])
+		if scopeBucket == nil {
+			return errScopeBucketNoExist
+		}
+
+		infoBytes := scopeBucket.Get(localForceCloseInitiatorKey)
+		if infoBytes == nil {
+			return nil
+		}
+
+		infoReader := bytes.NewReader(infoBytes)
+		lcInfo, err := channeldb.DeserializeLocalForceCloseInitiator(
+			infoReader)
+		if err != nil {
+			return err
+		}
+
+		init = lcInfo
+
+		return nil
+	}, func() {})
+
+	if err != nil {
+		return "", err
+	}
+
+	return init, nil
+}
+
+// LogLocalFCChainActions records the passed-in chainActionMap
+// for the force closed channel into the ArbitratorLog for deferred
+// consumption.
+func (b *boltArbitratorLog) LogLocalFCChainActions(
+	chainActions ChainActionMap) {
+
+	htlcMap := make(map[string][]channeldb.HTLC)
+	for action, htlcs := range chainActions {
+		htlcMap[action.String()] = htlcs
+	}
+
+	err := kvdb.Update(b.db, func(tx kvdb.RwTx) error {
+		scopeBucket, err := tx.CreateTopLevelBucket(b.scopeKey[:])
+		if err != nil {
+			return err
+		}
+		var buf bytes.Buffer
+		if err := channeldb.SerializeChainActions(&buf,
+			&htlcMap); err != nil {
+			return err
+		}
+
+		return scopeBucket.Put(fcChainActionKey, buf.Bytes())
+	}, func() {})
+
+	if err != nil {
+		log.Error(err)
+	}
+}
+
+// FetchLocalFCChainActions attempts to fetch the chainActionMap
+// for the force closed channel that was previously logged in the
+// ArbitratorLog.
+func (b *boltArbitratorLog) FetchLocalFCChainActions() (
+	map[string][]channeldb.HTLC,
+	error) {
+
+	var chainAction map[string][]channeldb.HTLC
+	err := kvdb.View(b.db, func(tx kvdb.RTx) error {
+		scopeBucket := tx.ReadBucket(b.scopeKey[:])
+		if scopeBucket == nil {
+			return errScopeBucketNoExist
+		}
+
+		chainActionBytes := scopeBucket.Get(fcChainActionKey)
+		if len(chainActionBytes) == 0 {
+			return nil
+		}
+
+		chainActionReader := bytes.NewReader(chainActionBytes)
+		chMap, err := channeldb.DeserializeChainActions(
+			chainActionReader)
+		if err != nil {
+			return err
+		}
+
+		chainAction = chMap
+
+		return nil
+	}, func() {})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return chainAction, nil
+}
+
 // InsertConfirmedCommitSet stores the known set of active HTLCs at the time
 // channel closure. We'll use this to reconstruct our set of chain actions anew
 // based on the confirmed and pending commitment state.

contractcourt/chain_arbitrator.go

@@ -1057,13 +1057,74 @@ type forceCloseReq struct {
 	closeTx chan *wire.MsgTx
 }
 
+// ForceCloseContractOption is used for providing functional options to callers
+// of ForceCloseContract().
+type ForceCloseContractOption func(*ChannelArbitrator)
+
+// UserInitiatedForceClose is a functional option for ForceCloseContract() that
+// signifies that the force close is purely user-initiated.
+func UserInitiatedForceClose(ca *ChannelArbitrator) {
+	// Just log errors since this is not a critical part of the force close
+	// flow.
+	err := ca.log.LogLocalForceCloseInitiator(channeldb.UserInitiated)
+	if err != nil {
+		log.Errorf("Error logging user initiated force "+
+			"close initiator: %v", err.Error())
+	}
+
+	log.Info("Logged user initiated force close.")
+}
+
+// LinkFailureErrorForceClose is a functional option for ForceCloseContract()
+// that signifies that the force close is due to a link failure. Requires the
+// error message of the link failure to be specified.
+func LinkFailureErrorForceClose(errorMsg string) ForceCloseContractOption {
+	return func(ca *ChannelArbitrator) {
+		// Just log errors since this is not a critical part of the
+		// force close flow.
+		err := ca.log.LogLocalForceCloseInitiator(
+			channeldb.LocalForceCloseInitiator(errorMsg))
+
+		if err != nil {
+			log.Errorf("Error logging link failure error force "+
+				"close initiator: %v",
+				err.Error())
+		}
+		log.Infof("Logged link failure error force close: %v", errorMsg)
+	}
+}
+
+// ChainTriggerForceClose is a functional option for ForceCloseContract() that
+// signifies that the force close is due to a chain trigger.
+func ChainTriggerForceClose(
+	chainActions ChainActionMap) ForceCloseContractOption {
+
+	return func(ca *ChannelArbitrator) {
+		// Ignore errors since logging force close info is not a
+		// critical part of the force close flow.
+		err := ca.log.LogLocalForceCloseInitiator(
+			channeldb.ChainActionsInitiated)
+
+		if err != nil {
+			log.Errorf("Error logging chain action force "+
+				"close initiator: %v",
+				err.Error())
+		}
+		ca.log.LogLocalFCChainActions(chainActions)
+
+		log.Info("Logged chain trigger initiated force close.")
+	}
+}
+
 // ForceCloseContract attempts to force close the channel infield by the passed
 // channel point. A force close will immediately terminate the contract,
 // causing it to enter the resolution phase. If the force close was successful,
 // then the force close transaction itself will be returned.
 //
 // TODO(roasbeef): just return the summary itself?
-func (c *ChainArbitrator) ForceCloseContract(chanPoint wire.OutPoint) (*wire.MsgTx, error) {
+func (c *ChainArbitrator) ForceCloseContract(chanPoint wire.OutPoint,
+	opt ForceCloseContractOption) (*wire.MsgTx, error) {
+
 	c.Lock()
 	arbitrator, ok := c.activeChannels[chanPoint]
 	c.Unlock()
@@ -1072,6 +1133,7 @@ func (c *ChainArbitrator) ForceCloseContract(chanPoint wire.OutPoint) (*wire.Msg
 	}
 
 	log.Infof("Attempting to force close ChannelPoint(%v)", chanPoint)
+	opt(arbitrator)
 
 	// Before closing, we'll attempt to send a disable update for the
 	// channel. We do so before closing the channel as otherwise the current

contractcourt/chain_arbitrator_test.go

@@ -60,7 +60,8 @@ func TestChainArbitratorRepublishCloses(t *testing.T) {
 	for i := 0; i < numChans/2; i++ {
 		closeTx := channels[i].FundingTxn.Copy()
 		closeTx.TxIn[0].PreviousOutPoint = channels[i].FundingOutpoint
-		err := channels[i].MarkCommitmentBroadcasted(closeTx, true)
+		err := channels[i].MarkCommitmentBroadcasted(closeTx,
+			&channeldb.LocalForceCloseInsights{})
 		if err != nil {
 			t.Fatal(err)
 		}