multi: implement awareness of the final/production taproot channel variant

chanbackup/single.go

@@ -59,6 +59,11 @@ const (
 	// channel with a top level tapscript commitment.
 	TapscriptRootVersion = 6
 
+	// SimpleTaprootFinalVersion is a version that denotes this channel is
+	// using the production musig2 based taproot commitment format with
+	// final scripts (OP_CHECKSIGVERIFY instead of OP_CHECKSIG + OP_DROP).
+	SimpleTaprootFinalVersion = 7
+
 	// closeTxVersionMask is the byte mask used that is ORed to version byte
 	// on wire indicating that the backup has CloseTxInputs.
 	closeTxVersionMask = 1 << 7
@@ -94,7 +99,8 @@ func DecodeVersion(encoded byte) (SingleBackupVersion, bool) {
 // IsTaproot returns if this is a backup of a taproot channel. This will also be
 // true for simple taproot overlay channels when a version is added.
 func (v SingleBackupVersion) IsTaproot() bool {
-	return v == SimpleTaprootVersion || v == TapscriptRootVersion
+	return v == SimpleTaprootVersion || v == TapscriptRootVersion ||
+		v == SimpleTaprootFinalVersion
 }
 
 // HasTapscriptRoot returns true if the channel is using a top level tapscript
@@ -302,6 +308,9 @@ func NewSingle(channel *channeldb.OpenChannel,
 	}
 
 	switch {
+	case channel.ChanType.IsTaprootFinal():
+		single.Version = SimpleTaprootFinalVersion
+
 	case channel.ChanType.IsTaproot():
 		if channel.ChanType.HasTapscriptRoot() {
 			single.Version = TapscriptRootVersion
@@ -351,6 +360,7 @@ func (s *Single) Serialize(w io.Writer) error {
 	case ScriptEnforcedLeaseVersion:
 	case SimpleTaprootVersion:
 	case TapscriptRootVersion:
+	case SimpleTaprootFinalVersion:
 	default:
 		return fmt.Errorf("unable to serialize w/ unknown "+
 			"version: %v", s.Version)
@@ -585,6 +595,7 @@ func (s *Single) Deserialize(r io.Reader) error {
 	case ScriptEnforcedLeaseVersion:
 	case SimpleTaprootVersion:
 	case TapscriptRootVersion:
+	case SimpleTaprootFinalVersion:
 	default:
 		return fmt.Errorf("unable to de-serialize w/ unknown "+
 			"version: %v", s.Version)

channeldb/channel.go

@@ -437,6 +437,11 @@ const (
 	// level tapscript commitment. This MUST be set along with the
 	// SimpleTaprootFeatureBit.
 	TapscriptRootBit ChannelType = 1 << 11
+
+	// TaprootFinalBit indicates that this is a MuSig2 channel using the
+	// final/production taproot scripts and feature bits 80/81. This MUST
+	// be set along with the SimpleTaprootFeatureBit.
+	TaprootFinalBit ChannelType = 1 << 12
 )
 
 // IsSingleFunder returns true if the channel type if one of the known single
@@ -513,6 +518,12 @@ func (c ChannelType) HasTapscriptRoot() bool {
 	return c&TapscriptRootBit == TapscriptRootBit
 }
 
+// IsTaprootFinal returns true if the channel is using final/production taproot
+// scripts and feature bits.
+func (c ChannelType) IsTaprootFinal() bool {
+	return c&TaprootFinalBit == TaprootFinalBit
+}
+
 // ChannelStateBounds are the parameters from OpenChannel and AcceptChannel
 // that are responsible for providing bounds on the state space of the abstract
 // channel state. These values must be remembered for normal channel operation
@@ -1903,6 +1914,7 @@ func NewMusigVerificationNonce(pubKey *btcec.PublicKey, targetHeight uint64,
 // modify our typical chan sync message to ensure they force close even if
 // we're on the very first state.
 func (c *OpenChannel) ChanSyncMsg() (*lnwire.ChannelReestablish, error) {
+
 	c.Lock()
 	defer c.Unlock()
 
@@ -1982,18 +1994,21 @@ func (c *OpenChannel) ChanSyncMsg() (*lnwire.ChannelReestablish, error) {
 				"nonce: %w", err)
 		}
 
-		// Populate the legacy LocalNonce field for backwards
-		// compatibility.
-		nextTaprootNonce = lnwire.SomeMusig2Nonce(nextNonce.PubNonce)
-
-		// Also populate the new LocalNonces field. For channel
-		// re-establishment, we'll key our nonce by the funding txid.
 		fundingTxid := c.FundingOutpoint.Hash
-		noncesMap := make(map[chainhash.Hash]lnwire.Musig2Nonce)
-		noncesMap[fundingTxid] = nextNonce.PubNonce
-		nextLocalNonces = lnwire.SomeLocalNonces(
-			lnwire.LocalNoncesData{NoncesMap: noncesMap},
-		)
+		nonce := nextNonce.PubNonce
+
+		// Final taproot channels use the map-based LocalNonces
+		// field keyed by funding TXID. Staging channels use the
+		// legacy single LocalNonce field.
+		if c.ChanType.IsTaprootFinal() {
+			noncesMap := make(map[chainhash.Hash]lnwire.Musig2Nonce)
+			noncesMap[fundingTxid] = nonce
+			nextLocalNonces = lnwire.SomeLocalNonces(
+				lnwire.LocalNoncesData{NoncesMap: noncesMap},
+			)
+		} else {
+			nextTaprootNonce = lnwire.SomeMusig2Nonce(nonce)
+		}
 	}
 
 	return &lnwire.ChannelReestablish{

chanrestore.go

@@ -170,6 +170,13 @@ func (c *chanDBRestorer) openChannelShell(backup chanbackup.Single) (
 		chanType |= channeldb.SimpleTaprootFeatureBit
 		chanType |= channeldb.TapscriptRootBit
 
+	case chanbackup.SimpleTaprootFinalVersion:
+		chanType = channeldb.ZeroHtlcTxFeeBit
+		chanType |= channeldb.AnchorOutputsBit
+		chanType |= channeldb.SingleFunderTweaklessBit
+		chanType |= channeldb.SimpleTaprootFeatureBit
+		chanType |= channeldb.TaprootFinalBit
+
 	default:
 		return nil, fmt.Errorf("unknown Single version: %w", err)
 	}

cmd/commands/cmd_open_channel.go

@@ -59,9 +59,10 @@ Signed base64 encoded PSBT or hex encoded raw wire TX (or path to file): `
 	// of memory issues or other weird errors.
 	psbtMaxFileSize = 1024 * 1024
 
-	channelTypeTweakless     = "tweakless"
-	channelTypeAnchors       = "anchors"
-	channelTypeSimpleTaproot = "taproot"
+	channelTypeTweakless          = "tweakless"
+	channelTypeAnchors            = "anchors"
+	channelTypeSimpleTaproot      = "taproot"
+	channelTypeSimpleTaprootFinal = "taproot-final"
 )
 
 // TODO(roasbeef): change default number of confirmations.
@@ -254,9 +255,10 @@ var openChannelCommand = cli.Command{
 		cli.StringFlag{
 			Name: "channel_type",
 			Usage: fmt.Sprintf("(optional) the type of channel to "+
-				"propose to the remote peer (%q, %q, %q)",
+				"propose to the remote peer (%q, %q, %q, %q)",
 				channelTypeTweakless, channelTypeAnchors,
-				channelTypeSimpleTaproot),
+				channelTypeSimpleTaproot,
+				channelTypeSimpleTaprootFinal),
 		},
 		cli.BoolFlag{
 			Name: "zero_conf",
@@ -447,6 +449,8 @@ func openChannel(ctx *cli.Context) error {
 		req.CommitmentType = lnrpc.CommitmentType_ANCHORS
 	case channelTypeSimpleTaproot:
 		req.CommitmentType = lnrpc.CommitmentType_SIMPLE_TAPROOT
+	case channelTypeSimpleTaprootFinal:
+		req.CommitmentType = lnrpc.CommitmentType_SIMPLE_TAPROOT_FINAL
 	default:
 		return fmt.Errorf("unsupported channel type %v", channelType)
 	}

contractcourt/chain_arbitrator.go

@@ -124,7 +124,7 @@ type ChainArbitratorConfig struct {
 	IncubateOutputs func(wire.OutPoint,
 		fn.Option[lnwallet.OutgoingHtlcResolution],
 		fn.Option[lnwallet.IncomingHtlcResolution],
-		uint32, fn.Option[int32]) error
+		uint32, fn.Option[int32], ...IncubateOption) error
 
 	// PreimageDB is a global store of all known pre-images. We'll use this
 	// to decide if we should broadcast a commitment transaction to claim

contractcourt/channel_arbitrator.go

@@ -2434,6 +2434,13 @@ func (c *ChannelArbitrator) prepContractResolutions(
 		return htlcResolvers, nil
 	}
 
+	// Determine the channel type once before the resolution loop so we
+	// don't repeat the nil check on every iteration.
+	var chanType channeldb.ChannelType
+	if chanState != nil {
+		chanType = chanState.ChanType
+	}
+
 	// For each HTLC, we'll either act immediately, meaning we'll instantly
 	// fail the HTLC, or we'll act only once the transaction has been
 	// confirmed, in which case we'll need an HTLC resolver.
@@ -2460,7 +2467,8 @@ func (c *ChannelArbitrator) prepContractResolutions(
 				}
 
 				resolver := newSuccessResolver(
-					resolution, height, htlc, resolverCfg,
+					resolution, height, htlc, chanType,
+					resolverCfg,
 				)
 				if chanState != nil {
 					resolver.SupplementState(chanState)
@@ -2488,7 +2496,8 @@ func (c *ChannelArbitrator) prepContractResolutions(
 				}
 
 				resolver := newTimeoutResolver(
-					resolution, height, htlc, resolverCfg,
+					resolution, height, htlc, chanType,
+					resolverCfg,
 				)
 				if chanState != nil {
 					resolver.SupplementState(chanState)
@@ -2528,7 +2537,7 @@ func (c *ChannelArbitrator) prepContractResolutions(
 				}
 
 				resolver := newIncomingContestResolver(
-					resolution, height, htlc,
+					resolution, height, htlc, chanType,
 					resolverCfg,
 				)
 				if chanState != nil {
@@ -2560,7 +2569,8 @@ func (c *ChannelArbitrator) prepContractResolutions(
 				}
 
 				resolver := newOutgoingContestResolver(
-					resolution, height, htlc, resolverCfg,
+					resolution, height, htlc, chanType,
+					resolverCfg,
 				)
 				if chanState != nil {
 					resolver.SupplementState(chanState)

contractcourt/channel_arbitrator_test.go

@@ -378,7 +378,8 @@ func createTestChannelArbitrator(t *testing.T, log ArbitratorLog,
 		IncubateOutputs: func(wire.OutPoint,
 			fn.Option[lnwallet.OutgoingHtlcResolution],
 			fn.Option[lnwallet.IncomingHtlcResolution],
-			uint32, fn.Option[int32]) error {
+			uint32, fn.Option[int32],
+			...IncubateOption) error {
 
 			incubateChan <- struct{}{}
 			return nil

contractcourt/commit_sweep_resolver.go

@@ -470,11 +470,19 @@ func (c *commitSweepResolver) decideWitnessType() (input.WitnessType, error) {
 	// commitment tweak to discern which type of commitment this is.
 	var witnessType input.WitnessType
 	switch {
-	// The local delayed output for a taproot channel.
+	// The local delayed output for a final taproot channel.
+	case isLocalCommitTx && c.chanType.IsTaprootFinal():
+		witnessType = input.TaprootLocalCommitSpendFinal
+
+	// The local delayed output for a staging taproot channel.
 	case isLocalCommitTx && c.chanType.IsTaproot():
 		witnessType = input.TaprootLocalCommitSpend
 
-	// The CSV 1 delayed output for a taproot channel.
+	// The CSV 1 delayed output for a final taproot channel.
+	case !isLocalCommitTx && c.chanType.IsTaprootFinal():
+		witnessType = input.TaprootRemoteCommitSpendFinal
+
+	// The CSV 1 delayed output for a staging taproot channel.
 	case !isLocalCommitTx && c.chanType.IsTaproot():
 		witnessType = input.TaprootRemoteCommitSpend
 

contractcourt/htlc_incoming_contest_resolver.go

@@ -42,10 +42,11 @@ type htlcIncomingContestResolver struct {
 // newIncomingContestResolver instantiates a new incoming htlc contest resolver.
 func newIncomingContestResolver(
 	res lnwallet.IncomingHtlcResolution, broadcastHeight uint32,
-	htlc channeldb.HTLC, resCfg ResolverConfig) *htlcIncomingContestResolver {
+	htlc channeldb.HTLC, chanType channeldb.ChannelType,
+	resCfg ResolverConfig) *htlcIncomingContestResolver {
 
 	success := newSuccessResolver(
-		res, broadcastHeight, htlc, resCfg,
+		res, broadcastHeight, htlc, chanType, resCfg,
 	)
 
 	return &htlcIncomingContestResolver{

contractcourt/htlc_outgoing_contest_resolver.go

@@ -24,10 +24,11 @@ type htlcOutgoingContestResolver struct {
 // resolver.
 func newOutgoingContestResolver(res lnwallet.OutgoingHtlcResolution,
 	broadcastHeight uint32, htlc channeldb.HTLC,
+	chanType channeldb.ChannelType,
 	resCfg ResolverConfig) *htlcOutgoingContestResolver {
 
 	timeout := newTimeoutResolver(
-		res, broadcastHeight, htlc, resCfg,
+		res, broadcastHeight, htlc, chanType, resCfg,
 	)
 
 	return &htlcOutgoingContestResolver{

contractcourt/htlc_success_resolver.go

@@ -50,6 +50,9 @@ type htlcSuccessResolver struct {
 	// htlc contains information on the htlc that we are resolving on-chain.
 	htlc channeldb.HTLC
 
+	// chanType denotes the type of channel the HTLC belongs to.
+	chanType channeldb.ChannelType
+
 	// currentReport stores the current state of the resolver for reporting
 	// over the rpc interface. This should only be reported in case we have
 	// a non-nil SignDetails on the htlcResolution, otherwise the nursery
@@ -67,13 +70,15 @@ type htlcSuccessResolver struct {
 // newSuccessResolver instanties a new htlc success resolver.
 func newSuccessResolver(res lnwallet.IncomingHtlcResolution,
 	broadcastHeight uint32, htlc channeldb.HTLC,
+	chanType channeldb.ChannelType,
 	resCfg ResolverConfig) *htlcSuccessResolver {
 
 	h := &htlcSuccessResolver{
 		contractResolverKit: *newContractResolverKit(resCfg),
 		htlcResolution:      res,
 		broadcastHeight:     broadcastHeight,
 		htlc:                htlc,
+		chanType:            chanType,
 	}
 
 	h.initReport()
@@ -373,6 +378,17 @@ func (h *htlcSuccessResolver) HtlcPoint() wire.OutPoint {
 	return h.htlcResolution.HtlcPoint()
 }
 
+// SupplementState allows the user of a ContractResolver to supplement it with
+// state required for the proper resolution of a contract. This restores the
+// channel type which is needed to select the correct witness type for
+// production taproot channels after restart.
+//
+// NOTE: Part of the ContractResolver interface.
+func (h *htlcSuccessResolver) SupplementState(state *channeldb.OpenChannel) {
+	h.htlcLeaseResolver.SupplementState(state)
+	h.chanType = state.ChanType
+}
+
 // SupplementDeadline does nothing for an incoming htlc resolver.
 //
 // NOTE: Part of the htlcContractResolver interface.
@@ -409,6 +425,12 @@ func (h *htlcSuccessResolver) isTaproot() bool {
 	)
 }
 
+// isTaprootFinal returns true if the htlc output is from a final taproot
+// channel.
+func (h *htlcSuccessResolver) isTaprootFinal() bool {
+	return h.chanType.IsTaprootFinal()
+}
+
 // sweepRemoteCommitOutput creates a sweep request to sweep the HTLC output on
 // the remote commitment via the direct preimage-spend.
 func (h *htlcSuccessResolver) sweepRemoteCommitOutput() error {
@@ -417,7 +439,19 @@ func (h *htlcSuccessResolver) sweepRemoteCommitOutput() error {
 	// sweeping transaction, and generate a witness.
 	var inp input.Input
 
-	if h.isTaproot() {
+	switch {
+	case h.isTaprootFinal():
+		inp = lnutils.Ptr(input.MakeTaprootHtlcSucceedInputFinal(
+			&h.htlcResolution.ClaimOutpoint,
+			&h.htlcResolution.SweepSignDesc,
+			h.htlcResolution.Preimage[:],
+			h.broadcastHeight,
+			h.htlcResolution.CsvDelay,
+			input.WithResolutionBlob(
+				h.htlcResolution.ResolutionBlob,
+			),
+		))
+	case h.isTaproot():
 		inp = lnutils.Ptr(input.MakeTaprootHtlcSucceedInput(
 			&h.htlcResolution.ClaimOutpoint,
 			&h.htlcResolution.SweepSignDesc,
@@ -428,7 +462,7 @@ func (h *htlcSuccessResolver) sweepRemoteCommitOutput() error {
 				h.htlcResolution.ResolutionBlob,
 			),
 		))
-	} else {
+	default:
 		inp = lnutils.Ptr(input.MakeHtlcSucceedInput(
 			&h.htlcResolution.ClaimOutpoint,
 			&h.htlcResolution.SweepSignDesc,
@@ -562,9 +596,12 @@ func (h *htlcSuccessResolver) sweepSuccessTxOutput() error {
 	// Let the sweeper sweep the second-level output now that the
 	// CSV/CLTV locks have expired.
 	var witType input.StandardWitnessType
-	if h.isTaproot() {
+	switch {
+	case h.isTaprootFinal():
+		witType = input.TaprootHtlcAcceptedSuccessSecondLevelFinal
+	case h.isTaproot():
 		witType = input.TaprootHtlcAcceptedSuccessSecondLevel
-	} else {
+	default:
 		witType = input.HtlcAcceptedSuccessSecondLevel
 	}
 	inp := h.makeSweepInput(
@@ -634,6 +671,7 @@ func (h *htlcSuccessResolver) resolveLegacySuccessTx() error {
 		h.ChanPoint, fn.None[lnwallet.OutgoingHtlcResolution](),
 		fn.Some(h.htlcResolution),
 		h.broadcastHeight, fn.Some(int32(h.htlc.RefundTimeout)),
+		WithChanType(h.chanType),
 	)
 	if err != nil {
 		return err