multi: add option_independent_secrets channel type

chanacceptor/rpcacceptor.go

@@ -262,9 +262,10 @@ func (r *RPCAcceptor) sendAcceptRequests(errChan chan error,
 			// counterpart. Also determine whether the zero-conf or
 			// scid-alias channel types are set.
 			var (
-				commitmentType lnrpc.CommitmentType
-				wantsZeroConf  bool
-				wantsScidAlias bool
+				commitmentType          lnrpc.CommitmentType
+				wantsZeroConf           bool
+				wantsScidAlias          bool
+				wantsIndependentSecrets bool
 			)
 
 			if req.OpenChanMsg.ChannelType != nil {
@@ -289,6 +290,15 @@ func (r *RPCAcceptor) sendAcceptRequests(errChan chan error,
 
 					wantsScidAlias = true
 				}
+
+				// acceptorCommitmentType sets this bit aside,
+				// so it's reported on its own.
+				if channelFeatures.IsSet(
+					lnwire.IndependentSecretsRequired,
+				) {
+
+					wantsIndependentSecrets = true
+				}
 			}
 
 			acceptRequests[pendingChanID] = newRequest
@@ -311,6 +321,8 @@ func (r *RPCAcceptor) sendAcceptRequests(errChan chan error,
 				CommitmentType:   commitmentType,
 				WantsZeroConf:    wantsZeroConf,
 				WantsScidAlias:   wantsScidAlias,
+
+				WantsIndependentSecrets: wantsIndependentSecrets,
 			}
 
 			if err := r.send(chanAcceptReq); err != nil {
@@ -457,6 +469,10 @@ func acceptorCommitmentType(
 	shape := channelFeatures.Clone()
 	shape.Unset(lnwire.UnifiedSigsRequired)
 
+	// option_independent_secrets changes how per-commitment secrets are
+	// stored, not the shape of the commitment, so it's set aside too.
+	shape.Unset(lnwire.IndependentSecretsRequired)
+
 	switch {
 	case shape.OnlyContains(
 		lnwire.ZeroConfRequired,

chanacceptor/rpcacceptor_independent_secrets_test.go

@@ -0,0 +1,102 @@
+package chanacceptor
+
+import (
+	"testing"
+
+	"github.com/btcsuite/btcd/btcec/v2"
+	"github.com/btcsuite/btcd/chaincfg"
+	"github.com/lightningnetwork/lnd/lnrpc"
+	"github.com/lightningnetwork/lnd/lnwire"
+	"github.com/stretchr/testify/require"
+)
+
+// TestAcceptorCommitmentTypeIgnoresIndependentSecrets checks that a channel
+// carrying option_independent_secrets, alone or with option_unified_sigs, is
+// reported by its commitment type, as the same channel without it is.
+func TestAcceptorCommitmentTypeIgnoresIndependentSecrets(t *testing.T) {
+	t.Parallel()
+
+	base := []lnwire.FeatureBit{
+		lnwire.StaticRemoteKeyRequired,
+		lnwire.AnchorsZeroFeeHtlcTxRequired,
+	}
+
+	for _, extra := range [][]lnwire.FeatureBit{
+		{lnwire.IndependentSecretsRequired},
+		{lnwire.IndependentSecretsRequired, lnwire.UnifiedSigsRequired},
+	} {
+		bits := append(append([]lnwire.FeatureBit{}, base...), extra...)
+		vec := lnwire.NewRawFeatureVector(bits...)
+		require.Equal(t, lnrpc.CommitmentType_ANCHORS,
+			acceptorCommitmentType(vec), "%v", bits)
+
+		// The caller's vector is not changed.
+		require.True(t, vec.IsSet(lnwire.IndependentSecretsRequired))
+	}
+}
+
+// TestAcceptorReportsIndependentSecrets checks that the request sent to the
+// channel acceptor says whether the proposed channel type carries
+// option_independent_secrets, which commitment_type leaves out.
+func TestAcceptorReportsIndependentSecrets(t *testing.T) {
+	t.Parallel()
+
+	node := btcec.NewPublicKey(
+		new(btcec.FieldVal).SetInt(1), new(btcec.FieldVal).SetInt(1),
+	)
+
+	for _, withBit := range []bool{false, true} {
+		bits := []lnwire.FeatureBit{
+			lnwire.StaticRemoteKeyRequired,
+			lnwire.AnchorsZeroFeeHtlcTxRequired,
+		}
+		if withBit {
+			bits = append(bits, lnwire.IndependentSecretsRequired)
+		}
+		chanType := lnwire.ChannelType(*lnwire.NewRawFeatureVector(
+			bits...,
+		))
+
+		// The acceptor sends each request once; the mock remote answers
+		// the pending channel it names, and the test reads what was sent.
+		sent := make(chan *lnrpc.ChannelAcceptRequest, 1)
+		pending := make(chan []byte, 1)
+		quit := make(chan struct{})
+		acceptor := NewRPCAcceptor(
+			func() (*lnrpc.ChannelAcceptResponse, error) {
+				select {
+				case id := <-pending:
+					return &lnrpc.ChannelAcceptResponse{
+						PendingChanId: id,
+					}, nil
+				case <-quit:
+					return nil, errShuttingDown
+				}
+			},
+			func(req *lnrpc.ChannelAcceptRequest) error {
+				sent <- req
+				pending <- req.PendingChanId
+				return nil
+			},
+			testTimeout*5, &chaincfg.RegressionNetParams, quit,
+		)
+		errChan := make(chan error, 1)
+		go func() { errChan <- acceptor.Run() }()
+
+		acceptor.Accept(&ChannelAcceptRequest{
+			Node: node,
+			OpenChanMsg: &lnwire.OpenChannel{
+				PendingChannelID: [32]byte{1},
+				ChannelType:      &chanType,
+			},
+		})
+
+		req := <-sent
+		require.Equal(t, withBit, req.WantsIndependentSecrets)
+		require.Equal(t, lnrpc.CommitmentType_ANCHORS,
+			req.CommitmentType)
+
+		close(quit)
+		require.ErrorIs(t, <-errChan, errShuttingDown)
+	}
+}

chanbackup/independent_secrets_test.go

@@ -0,0 +1,58 @@
+package chanbackup
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/lightningnetwork/lnd/channeldb"
+	"github.com/lightningnetwork/lnd/lnencrypt"
+	"github.com/stretchr/testify/require"
+)
+
+// TestSingleIgnoresIndependentSecrets checks that a channel with
+// option_independent_secrets backs up exactly like the same channel without
+// it. A static channel backup only lets the node ask its peer to force close,
+// after which it never receives a revocation again, so the add-on has nothing
+// to restore and the backup format stays unchanged.
+func TestSingleIgnoresIndependentSecrets(t *testing.T) {
+	t.Parallel()
+
+	keyRing := &lnencrypt.MockKeyRing{}
+
+	channel, err := genRandomOpenChannelShell()
+	require.NoError(t, err)
+
+	base := channeldb.SingleFunderTweaklessBit |
+		channeldb.AnchorOutputsBit | channeldb.ZeroHtlcTxFeeBit
+
+	pack := func(chanType channeldb.ChannelType) Single {
+		channel.ChanType = chanType
+		single := NewSingle(channel, nil)
+
+		var b bytes.Buffer
+		require.NoError(t, single.PackToWriter(&b, keyRing))
+
+		var unpacked Single
+		require.NoError(t, unpacked.UnpackFromReader(
+			bytes.NewReader(b.Bytes()), keyRing,
+		))
+
+		return unpacked
+	}
+
+	for _, extra := range []channeldb.ChannelType{
+		0, channeldb.UnifiedSigsBit,
+	} {
+		plain := pack(base | extra)
+		independent := pack(
+			base | extra | channeldb.IndependentSecretsBit,
+		)
+
+		require.Equal(t, plain.Version, independent.Version)
+		require.Equal(t, plain.UnifiedSigs, independent.UnifiedSigs)
+		anchors := SingleBackupVersion(
+			AnchorsZeroFeeHtlcTxCommitVersion,
+		)
+		require.Equal(t, anchors, independent.Version)
+	}
+}