lnwallet: update channel state machine to use new ScriptDescriptor interface

In this commit, we update the channel state machine to use the new
ScriptDescriptor interface. This fixes some subtle issues with the
existing commits, as for p2wsh we always sign the same witness script,
but for p2tr, the witness script differs depending on which branch is
taken.

With the new abstractions, we can treat p2wsh and p2tr as the same
mostly, right up until we need to obtain a control block or a tap tweak.

All tests have been updated accordingly.

lnwallet/channel.go

@@ -821,8 +821,8 @@ func (lc *LightningChannel) diskHtlcToPayDesc(feeRate chainfee.SatPerKWeight,
 		if err != nil {
 			return pd, err
 		}
-		ourP2WSH = scriptInfo.PkScript
-		ourWitnessScript = scriptInfo.WitnessScript
+		ourP2WSH = scriptInfo.PkScript()
+		ourWitnessScript = scriptInfo.WitnessScriptToSign()
 	}
 	isDustRemote := HtlcIsDust(
 		chanType, htlc.Incoming, false, feeRate,
@@ -836,8 +836,8 @@ func (lc *LightningChannel) diskHtlcToPayDesc(feeRate chainfee.SatPerKWeight,
 		if err != nil {
 			return pd, err
 		}
-		theirP2WSH = scriptInfo.PkScript
-		theirWitnessScript = scriptInfo.WitnessScript
+		theirP2WSH = scriptInfo.PkScript()
+		theirWitnessScript = scriptInfo.WitnessScriptToSign()
 	}
 
 	// Reconstruct the proper local/remote output indexes from the HTLC's
@@ -1575,8 +1575,8 @@ func (lc *LightningChannel) logUpdateToPayDesc(logUpdate *channeldb.LogUpdate,
 				return nil, err
 			}
 
-			pd.theirPkScript = scriptInfo.PkScript
-			pd.theirWitnessScript = scriptInfo.WitnessScript
+			pd.theirPkScript = scriptInfo.PkScript()
+			pd.theirWitnessScript = scriptInfo.WitnessScriptToSign()
 		}
 
 	// For HTLC's we're offered we'll fetch the original offered HTLC
@@ -2480,7 +2480,6 @@ func NewBreachRetribution(chanState *channeldb.OpenChannel, stateNum uint64,
 
 	// If the returned *RevocationLog is non-nil, use it to derive the info
 	// we need.
-	isTaproot := chanState.ChanType.IsTaproot()
 	if revokedLog != nil {
 		br, ourAmt, theirAmt, err = createBreachRetribution(
 			revokedLog, spendTx, chanState, keyRing,
@@ -2513,12 +2512,21 @@ func NewBreachRetribution(chanState *channeldb.OpenChannel, stateNum uint64,
 	// If our balance exceeds the remote party's dust limit, instantiate
 	// the sign descriptor for our output.
 	if ourAmt >= int64(chanState.RemoteChanCfg.DustLimit) {
+		// As we're about to sweep our own output w/o a delay, we'll obtain
+		// the witness script for the success/delay path.
+		witnessScript, err := ourScript.WitnessScriptForPath(
+			input.ScriptPathDelay,
+		)
+		if err != nil {
+			return nil, err
+		}
+
 		br.LocalOutputSignDesc = &input.SignDescriptor{
 			SingleTweak:   keyRing.LocalCommitKeyTweak,
 			KeyDesc:       chanState.LocalChanCfg.PaymentBasePoint,
-			WitnessScript: ourScript.WitnessScript,
+			WitnessScript: witnessScript,
 			Output: &wire.TxOut{
-				PkScript: ourScript.PkScript,
+				PkScript: ourScript.PkScript(),
 				Value:    ourAmt,
 			},
 			HashType: txscript.SigHashAll,
@@ -2527,13 +2535,16 @@ func NewBreachRetribution(chanState *channeldb.OpenChannel, stateNum uint64,
 		// For taproot channels, we'll make sure to set the script path
 		// spend (as our output on their revoked tx still needs the
 		// delay), and set the control block.
-		if isTaproot {
+		if scriptTree, ok := ourScript.(input.TapscriptDescriptor); ok {
 			br.LocalOutputSignDesc.SignMethod = input.TaprootScriptSpendSignMethod
 
-			ctrlBlock := input.MakeTaprootCtrlBlock(
-				br.LocalOutputSignDesc.WitnessScript,
-				&input.TaprootNUMSKey, ourScript.ScriptTree,
+			ctrlBlock, err := scriptTree.CtrlBlockForPath(
+				input.ScriptPathDelay,
 			)
+			if err != nil {
+				return nil, err
+			}
+
 			br.LocalOutputSignDesc.ControlBlock, err = ctrlBlock.ToBytes()
 			if err != nil {
 				return nil, err
@@ -2544,28 +2555,45 @@ func NewBreachRetribution(chanState *channeldb.OpenChannel, stateNum uint64,
 	// Similarly, if their balance exceeds the remote party's dust limit,
 	// assemble the sign descriptor for their output, which we can sweep.
 	if theirAmt >= int64(chanState.RemoteChanCfg.DustLimit) {
+		// As we're trying to defend the channel against a breach
+		// attempt from the remote party, we want to obain the
+		// revocation witness script here.
+		witnessScript, err := theirScript.WitnessScriptForPath(
+			input.ScriptPathRevocation,
+		)
+		if err != nil {
+			return nil, err
+		}
+
 		br.RemoteOutputSignDesc = &input.SignDescriptor{
 			KeyDesc: chanState.LocalChanCfg.
 				RevocationBasePoint,
 			DoubleTweak:   commitmentSecret,
-			WitnessScript: theirScript.WitnessScript,
+			WitnessScript: witnessScript,
 			Output: &wire.TxOut{
-				PkScript: theirScript.PkScript,
+				PkScript: theirScript.PkScript(),
 				Value:    theirAmt,
 			},
 			HashType: txscript.SigHashAll,
 		}
 
-		// For taproot channels, the remote ouput (the revoked outuput)
-		// can be spent using a single key spend, now that we know the
-		// revocation key.
-		if isTaproot {
-			br.RemoteOutputSignDesc.SignMethod = input.TaprootKeySpendSignMethod
+		// For taproot channels, the remote output (the revoked output)
+		// is spent with a script path to ensure all information 3rd
+		// parties need to sweep anchors is revealed on chain.
+		if scriptTree, ok := theirScript.(input.TapscriptDescriptor); ok {
+			//nolint:lll
+			br.RemoteOutputSignDesc.SignMethod = input.TaprootScriptSpendSignMethod
 
-			// We'll also need to set the taptweak as we'll be
-			// signing with the full output key.
-			tapscriptRoot := theirScript.ScriptTree.RootNode.TapHash()
-			br.RemoteOutputSignDesc.TapTweak = tapscriptRoot[:]
+			ctrlBlock, err := scriptTree.CtrlBlockForPath(
+				input.ScriptPathRevocation,
+			)
+			if err != nil {
+				return nil, err
+			}
+			br.RemoteOutputSignDesc.ControlBlock, err = ctrlBlock.ToBytes()
+			if err != nil {
+				return nil, err
+			}
 		}
 	}
 
@@ -2621,9 +2649,9 @@ func createHtlcRetribution(chanState *channeldb.OpenChannel,
 		KeyDesc: chanState.LocalChanCfg.
 			RevocationBasePoint,
 		DoubleTweak:   commitmentSecret,
-		WitnessScript: scriptInfo.WitnessScript,
+		WitnessScript: scriptInfo.WitnessScriptToSign(),
 		Output: &wire.TxOut{
-			PkScript: scriptInfo.PkScript,
+			PkScript: scriptInfo.PkScript(),
 			Value:    int64(htlc.Amt),
 		},
 		HashType: txscript.SigHashAll,
@@ -2632,20 +2660,26 @@ func createHtlcRetribution(chanState *channeldb.OpenChannel,
 	// For taproot HTLC outputs, we need to set the sign method to key
 	// spend, and also set the tap tweak root needed to derive the proper
 	// private key.
-	if chanState.ChanType.IsTaproot() {
+	if scriptTree, ok := scriptInfo.(input.TapscriptDescriptor); ok {
 		signDesc.SignMethod = input.TaprootKeySpendSignMethod
 
-		tapscriptRoot := scriptInfo.ScriptTree.RootNode.TapHash()
-		signDesc.TapTweak = tapscriptRoot[:]
+		signDesc.TapTweak = scriptTree.TapTweak()
+	}
+
+	// The second levle script we sign will always be the sucess path.
+	secondLevelWitnessScript, err := secondLevelScript.WitnessScriptForPath(
+		input.ScriptPathSuccess,
+	)
+	if err != nil {
+		return emptyRetribution, err
 	}
 
 	// If this is a taproot output, we'll also need to obtain the second
 	// level tap tweak as well.
 	var secondLevelTapTweak [32]byte
-	if chanState.ChanType.IsTaproot() {
-		tapscriptRoot := secondLevelScript.ScriptTree.RootNode.TapHash()
+	if scriptTree, ok := secondLevelScript.(input.TapscriptDescriptor); ok {
 		copy(
-			secondLevelTapTweak[:], tapscriptRoot[:],
+			secondLevelTapTweak[:], scriptTree.TapTweak(),
 		)
 	}
 
@@ -2655,7 +2689,8 @@ func createHtlcRetribution(chanState *channeldb.OpenChannel,
 			Hash:  commitHash,
 			Index: uint32(htlc.OutputIndex),
 		},
-		SecondLevelWitnessScript: secondLevelScript.WitnessScript,
+		SecondLevelWitnessScript: secondLevelWitnessScript,
+		SecondLevelTapTweak:      secondLevelTapTweak,
 		IsIncoming:               htlc.Incoming,
 	}, nil
 }
@@ -2778,7 +2813,7 @@ func createBreachRetribution(revokedLog *channeldb.RevocationLog,
 func createBreachRetributionLegacy(revokedLog *channeldb.ChannelCommitment,
 	chanState *channeldb.OpenChannel, keyRing *CommitmentKeyRing,
 	commitmentSecret *btcec.PrivateKey,
-	ourScript, theirScript *ScriptInfo,
+	ourScript, theirScript input.ScriptDescriptor,
 	leaseExpiry uint32) (*BreachRetribution, int64, int64, error) {
 
 	commitHash := revokedLog.CommitTx.TxHash()
@@ -2793,9 +2828,9 @@ func createBreachRetributionLegacy(revokedLog *channeldb.ChannelCommitment,
 	// to find the exact index of the commitment outputs.
 	for i, txOut := range revokedLog.CommitTx.TxOut {
 		switch {
-		case bytes.Equal(txOut.PkScript, ourScript.PkScript):
+		case bytes.Equal(txOut.PkScript, ourScript.PkScript()):
 			ourOutpoint.Index = uint32(i)
-		case bytes.Equal(txOut.PkScript, theirScript.PkScript):
+		case bytes.Equal(txOut.PkScript, theirScript.PkScript()):
 			theirOutpoint.Index = uint32(i)
 		}
 	}
@@ -6398,7 +6433,7 @@ func NewUnilateralCloseSummary(chanState *channeldb.OpenChannel, signer input.Si
 	)
 
 	for outputIndex, txOut := range commitTxBroadcast.TxOut {
-		if bytes.Equal(txOut.PkScript, selfScript.PkScript) {
+		if bytes.Equal(txOut.PkScript, selfScript.PkScript()) {
 			selfPoint = &wire.OutPoint{
 				Hash:  *commitSpend.SpenderTxHash,
 				Index: uint32(outputIndex),
@@ -6414,15 +6449,25 @@ func NewUnilateralCloseSummary(chanState *channeldb.OpenChannel, signer input.Si
 	var commitResolution *CommitOutputResolution
 	if selfPoint != nil {
 		localPayBase := chanState.LocalChanCfg.PaymentBasePoint
+
+		// As the remote party has force closed, we just need the
+		// success witness script.
+		witnessScript, err := selfScript.WitnessScriptForPath(
+			input.ScriptPathSuccess,
+		)
+		if err != nil {
+			return nil, err
+		}
+
 		commitResolution = &CommitOutputResolution{
 			SelfOutPoint: *selfPoint,
 			SelfOutputSignDesc: input.SignDescriptor{
 				KeyDesc:       localPayBase,
 				SingleTweak:   keyRing.LocalCommitKeyTweak,
-				WitnessScript: selfScript.WitnessScript,
+				WitnessScript: witnessScript,
 				Output: &wire.TxOut{
 					Value:    localBalance,
-					PkScript: selfScript.PkScript,
+					PkScript: selfScript.PkScript(),
 				},
 				HashType: txscript.SigHashAll,
 			},
@@ -6431,16 +6476,16 @@ func NewUnilateralCloseSummary(chanState *channeldb.OpenChannel, signer input.Si
 
 		// For taproot channels, we'll need to set some additional
 		// fields to ensure the output can be swept.
-		//
-		// TODO(roasbef): abstract into new func
-		if chanState.ChanType.IsTaproot() {
+		if scriptTree, ok := selfScript.(input.TapscriptDescriptor); ok {
 			commitResolution.SelfOutputSignDesc.SignMethod =
 				input.TaprootScriptSpendSignMethod
 
-			ctrlBlock := input.MakeTaprootCtrlBlock(
-				commitResolution.SelfOutputSignDesc.WitnessScript,
-				&input.TaprootNUMSKey, selfScript.ScriptTree,
+			ctrlBlock, err := scriptTree.CtrlBlockForPath(
+				input.ScriptPathSuccess,
 			)
+			if err != nil {
+				return nil, err
+			}
 			commitResolution.SelfOutputSignDesc.ControlBlock, err = ctrlBlock.ToBytes()
 			if err != nil {
 				return nil, err
@@ -6630,8 +6675,17 @@ func newOutgoingHtlcResolution(signer input.Signer,
 	if err != nil {
 		return nil, err
 	}
-	htlcPkScript := htlcScriptInfo.PkScript
-	htlcWitnessScript := htlcScriptInfo.WitnessScript
+	htlcPkScript := htlcScriptInfo.PkScript()
+
+	// As this is an outgoing HTLC, we just care about the timeout path
+	// here.
+	scriptPath := input.ScriptPathTimeout
+	htlcWitnessScript, err := htlcScriptInfo.WitnessScriptForPath(
+		scriptPath,
+	)
+	if err != nil {
+		return nil, err
+	}
 
 	// If we're spending this HTLC output from the remote node's
 	// commitment, then we won't need to go to the second level as our
@@ -6650,12 +6704,16 @@ func newOutgoingHtlcResolution(signer input.Signer,
 			HashType: txscript.SigHashAll,
 		}
 
-		if chanType.IsTaproot() {
+		scriptTree, ok := htlcScriptInfo.(input.TapscriptDescriptor)
+		if ok {
 			signDesc.SignMethod = input.TaprootScriptSpendSignMethod
-			ctrlBlock := input.MakeTaprootCtrlBlock(
-				htlcWitnessScript, keyRing.RevocationKey,
-				htlcScriptInfo.ScriptTree,
+
+			ctrlBlock, err := scriptTree.CtrlBlockForPath(
+				scriptPath,
 			)
+			if err != nil {
+				return nil, err
+			}
 			signDesc.ControlBlock, err = ctrlBlock.ToBytes()
 			if err != nil {
 				return nil, err
@@ -6718,7 +6776,7 @@ func newOutgoingHtlcResolution(signer input.Signer,
 	// for the timeout transaction, and populate it as well.
 	sigHashType := HtlcSigHashType(chanType)
 	var timeoutWitness wire.TxWitness
-	if chanType.IsTaproot() {
+	if scriptTree, ok := htlcScriptInfo.(input.TapscriptDescriptor); ok {
 		// TODO(roasbeef): make sure default elsewhere
 		timeoutSignDesc.SignMethod = input.TaprootScriptSpendSignMethod
 		timeoutSignDesc.HashType = txscript.SigHashDefault
@@ -6726,7 +6784,7 @@ func newOutgoingHtlcResolution(signer input.Signer,
 		timeoutWitness, err = input.SenderHTLCScriptTaprootTimeout(
 			htlcSig, sigHashType, signer, &timeoutSignDesc,
 			timeoutTx, keyRing.RevocationKey,
-			htlcScriptInfo.ScriptTree,
+			scriptTree.TapScriptTree(),
 		)
 		if err != nil {
 			return nil, err
@@ -6761,7 +6819,7 @@ func newOutgoingHtlcResolution(signer input.Signer,
 	// transaction creates so we can generate the signDesc required to
 	// complete the claim process after a delay period.
 	var (
-		htlcSweepScript *ScriptInfo
+		htlcSweepScript input.ScriptDescriptor
 		signMethod      input.SignMethod
 		ctrlBlock       []byte
 	)
@@ -6781,21 +6839,29 @@ func newOutgoingHtlcResolution(signer input.Signer,
 			return nil, err
 		}
 
-		htlcSweepScript = &ScriptInfo{
-			PkScript:      secondLevelScriptTree.PkScript,
-			WitnessScript: secondLevelScriptTree.SuccessTapLeaf.Script,
-		}
-
 		signMethod = input.TaprootScriptSpendSignMethod
 
-		controlBlock := input.MakeTaprootCtrlBlock(
-			htlcSweepScript.WitnessScript, keyRing.RevocationKey,
-			secondLevelScriptTree.TapscriptTree,
+		controlBlock, err := secondLevelScriptTree.CtrlBlockForPath(
+			input.ScriptPathSuccess,
 		)
+		if err != nil {
+			return nil, err
+		}
 		ctrlBlock, err = controlBlock.ToBytes()
 		if err != nil {
 			return nil, err
 		}
+
+		htlcSweepScript = secondLevelScriptTree
+	}
+
+	// In this case, the witness script that needs to be signed will always
+	// be that of the success path.
+	htlcSweepWitnessScript, err := htlcSweepScript.WitnessScriptForPath(
+		input.ScriptPathSuccess,
+	)
+	if err != nil {
+		return nil, err
 	}
 
 	localDelayTweak := input.SingleTweakBytes(
@@ -6813,9 +6879,9 @@ func newOutgoingHtlcResolution(signer input.Signer,
 		SweepSignDesc: input.SignDescriptor{
 			KeyDesc:       localChanCfg.DelayBasePoint,
 			SingleTweak:   localDelayTweak,
-			WitnessScript: htlcSweepScript.WitnessScript,
+			WitnessScript: htlcSweepWitnessScript,
 			Output: &wire.TxOut{
-				PkScript: htlcSweepScript.PkScript,
+				PkScript: htlcSweepScript.PkScript(),
 				Value:    int64(secondLevelOutputAmt),
 			},
 			HashType:     txscript.SigHashAll,
@@ -6854,8 +6920,17 @@ func newIncomingHtlcResolution(signer input.Signer,
 		return nil, err
 	}
 
-	htlcPkScript := scriptInfo.PkScript
-	htlcWitnessScript := scriptInfo.WitnessScript
+	htlcPkScript := scriptInfo.PkScript()
+
+	// As this is an incoming HTLC, we're attempting to sweep with the
+	// success path.
+	scriptPath := input.ScriptPathSuccess
+	htlcWitnessScript, err := scriptInfo.WitnessScriptForPath(
+		scriptPath,
+	)
+	if err != nil {
+		return nil, err
+	}
 
 	// If we're spending this output from the remote node's commitment,
 	// then we can skip the second layer and spend the output directly.
@@ -6873,12 +6948,12 @@ func newIncomingHtlcResolution(signer input.Signer,
 			HashType: txscript.SigHashAll,
 		}
 
-		if chanType.IsTaproot() {
+		if scriptTree, ok := scriptInfo.(input.TapscriptDescriptor); ok {
 			signDesc.SignMethod = input.TaprootScriptSpendSignMethod
-			ctrlBlock := input.MakeTaprootCtrlBlock(
-				htlcWitnessScript, keyRing.RevocationKey,
-				scriptInfo.ScriptTree,
-			)
+			ctrlBlock, err := scriptTree.CtrlBlockForPath(scriptPath)
+			if err != nil {
+				return nil, err
+			}
 			signDesc.ControlBlock, err = ctrlBlock.ToBytes()
 			if err != nil {
 				return nil, err
@@ -6935,14 +7010,14 @@ func newIncomingHtlcResolution(signer input.Signer,
 	// becomes known.
 	var successWitness wire.TxWitness
 	sigHashType := HtlcSigHashType(chanType)
-	if chanType.IsTaproot() {
-		// TODO(roasbeef): make sure default elsewhere
+	if scriptTree, ok := scriptInfo.(input.TapscriptDescriptor); ok {
 		successSignDesc.HashType = txscript.SigHashDefault
 		successSignDesc.SignMethod = input.TaprootScriptSpendSignMethod
 
 		successWitness, err = input.ReceiverHTLCScriptTaprootRedeem(
 			htlcSig, sigHashType, nil, signer, &successSignDesc,
-			successTx, keyRing.RevocationKey, scriptInfo.ScriptTree,
+			successTx, keyRing.RevocationKey,
+			scriptTree.TapScriptTree(),
 		)
 		if err != nil {
 			return nil, err
@@ -6976,7 +7051,7 @@ func newIncomingHtlcResolution(signer input.Signer,
 	// creates so we can generate the proper signDesc to sweep it after the
 	// CSV delay has passed.
 	var (
-		htlcSweepScript *ScriptInfo
+		htlcSweepScript input.ScriptDescriptor
 		signMethod      input.SignMethod
 		ctrlBlock       []byte
 	)
@@ -6996,23 +7071,31 @@ func newIncomingHtlcResolution(signer input.Signer,
 			return nil, err
 		}
 
-		htlcSweepScript = &ScriptInfo{
-			PkScript:      secondLevelScriptTree.PkScript,
-			WitnessScript: secondLevelScriptTree.SuccessTapLeaf.Script,
-		}
-
 		signMethod = input.TaprootScriptSpendSignMethod
 
-		controlBlock := input.MakeTaprootCtrlBlock(
-			htlcSweepScript.WitnessScript, keyRing.RevocationKey,
-			secondLevelScriptTree.TapscriptTree,
+		controlBlock, err := secondLevelScriptTree.CtrlBlockForPath(
+			input.ScriptPathSuccess,
 		)
+		if err != nil {
+			return nil, err
+		}
 		ctrlBlock, err = controlBlock.ToBytes()
 		if err != nil {
 			return nil, err
 		}
 
 		// TODO(roasbeef): conslidate logic to reduce vertical noise
+
+		htlcSweepScript = secondLevelScriptTree
+	}
+
+	// In this case, the witness script that needs to be signed will always
+	// be that of the success path.
+	htlcSweepWitnessScript, err := htlcSweepScript.WitnessScriptForPath(
+		input.ScriptPathSuccess,
+	)
+	if err != nil {
+		return nil, err
 	}
 
 	localDelayTweak := input.SingleTweakBytes(
@@ -7029,9 +7112,9 @@ func newIncomingHtlcResolution(signer input.Signer,
 		SweepSignDesc: input.SignDescriptor{
 			KeyDesc:       localChanCfg.DelayBasePoint,
 			SingleTweak:   localDelayTweak,
-			WitnessScript: htlcSweepScript.WitnessScript,
+			WitnessScript: htlcSweepWitnessScript,
 			Output: &wire.TxOut{
-				PkScript: htlcSweepScript.PkScript,
+				PkScript: htlcSweepScript.PkScript(),
 				Value:    int64(secondLevelOutputAmt),
 			},
 			HashType:     txscript.SigHashAll,
@@ -7281,7 +7364,7 @@ func NewLocalForceCloseSummary(chanState *channeldb.OpenChannel,
 		delayOut   *wire.TxOut
 	)
 	for i, txOut := range commitTx.TxOut {
-		if !bytes.Equal(toLocalScript.PkScript, txOut.PkScript) {
+		if !bytes.Equal(toLocalScript.PkScript(), txOut.PkScript) {
 			continue
 		}
 
@@ -7298,6 +7381,16 @@ func NewLocalForceCloseSummary(chanState *channeldb.OpenChannel,
 	// nil.
 	var commitResolution *CommitOutputResolution
 	if delayOut != nil {
+		// When attempting to sweep our own output, we only need the
+		// witness script for the delay path
+		scriptPath := input.ScriptPathDelay
+		witnessScript, err := toLocalScript.WitnessScriptForPath(
+			scriptPath,
+		)
+		if err != nil {
+			return nil, err
+		}
+
 		localBalance := delayOut.Value
 		commitResolution = &CommitOutputResolution{
 			SelfOutPoint: wire.OutPoint{
@@ -7307,7 +7400,7 @@ func NewLocalForceCloseSummary(chanState *channeldb.OpenChannel,
 			SelfOutputSignDesc: input.SignDescriptor{
 				KeyDesc:       chanState.LocalChanCfg.DelayBasePoint,
 				SingleTweak:   keyRing.LocalCommitKeyTweak,
-				WitnessScript: toLocalScript.WitnessScript,
+				WitnessScript: witnessScript,
 				Output: &wire.TxOut{
 					PkScript: delayOut.PkScript,
 					Value:    localBalance,
@@ -7321,14 +7414,17 @@ func NewLocalForceCloseSummary(chanState *channeldb.OpenChannel,
 		// fields to ensure the output can be swept.
 		//
 		// TODO(roasbef): abstract into new func
-		if chanState.ChanType.IsTaproot() {
+		scriptTree, ok := toLocalScript.(input.TapscriptDescriptor)
+		if ok {
 			commitResolution.SelfOutputSignDesc.SignMethod =
 				input.TaprootScriptSpendSignMethod
 
-			ctrlBlock := input.MakeTaprootCtrlBlock(
-				commitResolution.SelfOutputSignDesc.WitnessScript,
-				keyRing.RevocationKey, toLocalScript.ScriptTree,
+			ctrlBlock, err := scriptTree.CtrlBlockForPath(
+				scriptPath,
 			)
+			if err != nil {
+				return nil, err
+			}
 			commitResolution.SelfOutputSignDesc.ControlBlock, err = ctrlBlock.ToBytes()
 			if err != nil {
 				return nil, err
@@ -7712,15 +7808,26 @@ func NewAnchorResolution(chanState *channeldb.OpenChannel,
 		localAnchor, remoteAnchor = remoteAnchor, localAnchor
 	}
 
+	// TODO(roasbeef): remote anchor not needed above
+
 	// Look up the script on the commitment transaction. It may not be
 	// present if there is no output paying to us.
 	found, index := input.FindScriptOutputIndex(
-		commitTx, localAnchor.PkScript,
+		commitTx, localAnchor.PkScript(),
 	)
 	if !found {
 		return nil, nil
 	}
 
+	// For anchor outputs, we'll only ever care about the success path.
+	// script (sweep after 1 block csv delay).
+	anchorWitnessScript, err := localAnchor.WitnessScriptForPath(
+		input.ScriptPathSuccess,
+	)
+	if err != nil {
+		return nil, err
+	}
+
 	outPoint := &wire.OutPoint{
 		Hash:  commitTx.TxHash(),
 		Index: index,
@@ -7729,9 +7836,9 @@ func NewAnchorResolution(chanState *channeldb.OpenChannel,
 	// Instantiate the sign descriptor that allows sweeping of the anchor.
 	signDesc := &input.SignDescriptor{
 		KeyDesc:       chanState.LocalChanCfg.MultiSigKey,
-		WitnessScript: localAnchor.WitnessScript,
+		WitnessScript: anchorWitnessScript,
 		Output: &wire.TxOut{
-			PkScript: localAnchor.PkScript,
+			PkScript: localAnchor.PkScript(),
 			Value:    int64(anchorSize),
 		},
 		HashType: txscript.SigHashAll,
@@ -7739,12 +7846,12 @@ func NewAnchorResolution(chanState *channeldb.OpenChannel,
 
 	// For taproot outputs, we'll need to ensure that the proper sign
 	// method is used, and the tweak as well.
-	if chanState.ChanType.IsTaproot() {
+	if scriptTree, ok := localAnchor.(input.TapscriptDescriptor); ok {
 		signDesc.SignMethod = input.TaprootKeySpendSignMethod
 		signDesc.HashType = txscript.SigHashDefault
 
 		signDesc.PrevOutputFetcher = txscript.NewCannedPrevOutputFetcher(
-			localAnchor.PkScript, int64(anchorSize),
+			localAnchor.PkScript(), int64(anchorSize),
 		)
 
 		// For anchor outputs with taproot channels, the key desc is
@@ -7766,13 +7873,9 @@ func NewAnchorResolution(chanState *channeldb.OpenChannel,
 			signDesc.KeyDesc = chanState.LocalChanCfg.PaymentBasePoint
 		}
 
-		// TODO(roasbeef): need to be payment point if remote, delay
-		// point otherwise?
-
 		// Finally, as this is a keyspend method, we'll need to also
 		// include the taptweak as well.
-		tapscriptRoot := localAnchor.ScriptTree.RootNode.TapHash()
-		signDesc.TapTweak = tapscriptRoot[:]
+		signDesc.TapTweak = scriptTree.TapTweak()
 	}
 
 	var witnessWeight int64

lnwallet/channel_test.go

@@ -9915,11 +9915,11 @@ func TestCreateBreachRetributionLegacy(t *testing.T) {
 	theirOp := revokedLog.CommitTx.TxOut[1]
 
 	// Create the dummy scripts.
-	ourScript := &ScriptInfo{
-		PkScript: ourOp.PkScript,
+	ourScript := &WitnessScriptDesc{
+		OutputScript: ourOp.PkScript,
 	}
-	theirScript := &ScriptInfo{
-		PkScript: theirOp.PkScript,
+	theirScript := &WitnessScriptDesc{
+		OutputScript: theirOp.PkScript,
 	}
 
 	// Create the breach retribution using the legacy format.

lnwallet/commitment.go

@@ -180,20 +180,41 @@ func DeriveCommitmentKeys(commitPoint *btcec.PublicKey,
 	return keyRing
 }
 
-// ScriptInfo holds a redeem script and hash.
-type ScriptInfo struct {
-	// PkScript is the output's PkScript.
-	PkScript []byte
+// WitnessScriptDesc holds the output script and the witness script for p2wsh
+// outputs.
+type WitnessScriptDesc struct {
+	// OutputScript is the output's PkScript.
+	OutputScript []byte
 
 	// WitnessScript is the full script required to properly redeem the
 	// output. This field should be set to the full script if a p2wsh
 	// output is being signed. For p2wkh it should be set equal to the
 	// PkScript.
 	WitnessScript []byte
+}
 
-	// ScriptTree is the script tree that stores all the scripts that are
-	// committed to by the above PkScript, if it's a P2TR script template.
-	ScriptTree *txscript.IndexedTapScriptTree
+// PkScript is the public key script that commits to the final
+// contract.
+func (w *WitnessScriptDesc) PkScript() []byte {
+	return w.OutputScript
+}
+
+// WitnessScript returns the witness script that we'll use when signing for the
+// remote party, and also verifying signatures on our transactions. As an
+// example, when we create an outgoing HTLC for the remote party, we want to
+// sign their success path.
+func (w *WitnessScriptDesc) WitnessScriptToSign() []byte {
+	return w.WitnessScript
+}
+
+// WitnessScriptForPath returns the witness script for the given spending path.
+// An error is returned if the path is unknown. This is useful as when
+// constructing a contrl block for a given path, one also needs witness script
+// being signed.
+func (w *WitnessScriptDesc) WitnessScriptForPath(path input.ScriptPath,
+) ([]byte, error) {
+
+	return w.WitnessScript, nil
 }
 
 // CommitScriptToSelf constructs the public key script for the output on the
@@ -203,8 +224,9 @@ type ScriptInfo struct {
 // party learns of the preimage to the revocation hash, then they can claim all
 // the settled funds in the channel, plus the unsettled funds.
 func CommitScriptToSelf(chanType channeldb.ChannelType, initiator bool,
-	selfKey, revokeKey *btcec.PublicKey, csvDelay, leaseExpiry uint32) (
-	*ScriptInfo, error) {
+	selfKey, revokeKey *btcec.PublicKey, csvDelay, leaseExpiry uint32,
+) (
+	input.ScriptDescriptor, error) {
 
 	switch {
 	// For taproot scripts, we'll need to make a slightly modified script
@@ -213,28 +235,9 @@ func CommitScriptToSelf(chanType channeldb.ChannelType, initiator bool,
 	//
 	// Our "redeem" script here is just the taproot witness program.
 	case chanType.IsTaproot():
-		toLocalScriptTree, err := input.NewLocalCommitScriptTree(
+		return input.NewLocalCommitScriptTree(
 			csvDelay, selfKey, revokeKey,
 		)
-		if err != nil {
-			return nil, fmt.Errorf("unable to generate taproot "+
-				"key: %w", err)
-		}
-
-		toLocalPkScript, err := input.PayToTaprootScript(
-			toLocalScriptTree.TaprootKey,
-		)
-		if err != nil {
-			return nil, fmt.Errorf("unable to gen taproot "+
-				"pkscript: %w", err)
-		}
-
-		// TODO(rosabeef): recator to be able to get script key
-		return &ScriptInfo{
-			WitnessScript: toLocalScriptTree.SettleLeaf.Script,
-			PkScript:      toLocalPkScript,
-			ScriptTree:    toLocalScriptTree.TapscriptTree,
-		}, nil
 
 	// If we are the initiator of a leased channel, then we have an
 	// additional CLTV requirement in addition to the usual CSV
@@ -254,8 +257,8 @@ func CommitScriptToSelf(chanType channeldb.ChannelType, initiator bool,
 			return nil, err
 		}
 
-		return &ScriptInfo{
-			PkScript:      toLocalScriptHash,
+		return &WitnessScriptDesc{
+			OutputScript:  toLocalScriptHash,
 			WitnessScript: toLocalRedeemScript,
 		}, nil
 
@@ -274,8 +277,8 @@ func CommitScriptToSelf(chanType channeldb.ChannelType, initiator bool,
 			return nil, err
 		}
 
-		return &ScriptInfo{
-			PkScript:      toLocalScriptHash,
+		return &WitnessScriptDesc{
+			OutputScript:  toLocalScriptHash,
 			WitnessScript: toLocalRedeemScript,
 		}, nil
 	}
@@ -288,7 +291,7 @@ func CommitScriptToSelf(chanType channeldb.ChannelType, initiator bool,
 // what must be satisfied in order to spend the output.
 func CommitScriptToRemote(chanType channeldb.ChannelType, initiator bool,
 	remoteKey *btcec.PublicKey,
-	leaseExpiry uint32) (*ScriptInfo, uint32, error) {
+	leaseExpiry uint32) (input.ScriptDescriptor, uint32, error) {
 
 	switch {
 	// If we are not the initiator of a leased channel, then the remote
@@ -307,8 +310,8 @@ func CommitScriptToRemote(chanType channeldb.ChannelType, initiator bool,
 			return nil, 0, err
 		}
 
-		return &ScriptInfo{
-			PkScript:      p2wsh,
+		return &WitnessScriptDesc{
+			OutputScript:  p2wsh,
 			WitnessScript: script,
 		}, 1, nil
 
@@ -323,18 +326,7 @@ func CommitScriptToRemote(chanType channeldb.ChannelType, initiator bool,
 			return nil, 0, err
 		}
 
-		toRemotePkScript, err := input.PayToTaprootScript(
-			toRemoteScriptTree.TaprootKey,
-		)
-		if err != nil {
-			return nil, 0, err
-		}
-
-		return &ScriptInfo{
-			WitnessScript: toRemoteScriptTree.SettleLeaf.Script,
-			PkScript:      toRemotePkScript,
-			ScriptTree:    toRemoteScriptTree.TapscriptTree,
-		}, 1, nil
+		return toRemoteScriptTree, 1, nil
 
 	// If this channel type has anchors, we derive the delayed to_remote
 	// script.
@@ -349,8 +341,8 @@ func CommitScriptToRemote(chanType channeldb.ChannelType, initiator bool,
 			return nil, 0, err
 		}
 
-		return &ScriptInfo{
-			PkScript:      p2wsh,
+		return &WitnessScriptDesc{
+			OutputScript:  p2wsh,
 			WitnessScript: script,
 		}, 1, nil
 
@@ -363,9 +355,9 @@ func CommitScriptToRemote(chanType channeldb.ChannelType, initiator bool,
 
 		// Since this is a regular P2WKH, the WitnessScipt and PkScript
 		// should both be set to the script hash.
-		return &ScriptInfo{
+		return &WitnessScriptDesc{
+			OutputScript:  p2wkh,
 			WitnessScript: p2wkh,
-			PkScript:      p2wkh,
 		}, 0, nil
 	}
 }
@@ -417,59 +409,48 @@ func HtlcSecondLevelInputSequence(chanType channeldb.ChannelType) uint32 {
 // we are generating the to_local script for.
 func SecondLevelHtlcScript(chanType channeldb.ChannelType, initiator bool,
 	revocationKey, delayKey *btcec.PublicKey,
-	csvDelay, leaseExpiry uint32) (*ScriptInfo, error) {
+	csvDelay, leaseExpiry uint32) (input.ScriptDescriptor, error) {
 
-	var (
-		witnessScript []byte
-		pkScript      []byte
-		err           error
-	)
 	switch {
 	// For taproot channels, the pkScript is a segwit v1 p2tr output.
 	case chanType.IsTaproot():
-		taprootOutputKey, err := input.TaprootSecondLevelHtlcScript(
+		return input.TaprootSecondLevelScriptTree(
 			revocationKey, delayKey, csvDelay,
 		)
-		if err != nil {
-			return nil, err
-		}
-
-		pkScript, err = input.PayToTaprootScript(taprootOutputKey)
-		if err != nil {
-			return nil, err
-		}
 
 	// If we are the initiator of a leased channel, then we have an
 	// additional CLTV requirement in addition to the usual CSV
 	// requirement.
 	case initiator && chanType.HasLeaseExpiration():
-		witnessScript, err = input.LeaseSecondLevelHtlcScript(
+		witnessScript, err := input.LeaseSecondLevelHtlcScript(
 			revocationKey, delayKey, csvDelay, leaseExpiry,
 		)
 
-		pkScript, err = input.WitnessScriptHash(witnessScript)
+		pkScript, err := input.WitnessScriptHash(witnessScript)
 		if err != nil {
 			return nil, err
 		}
 
+		return &WitnessScriptDesc{
+			OutputScript:  pkScript,
+			WitnessScript: witnessScript,
+		}, nil
+
 	default:
-		witnessScript, err = input.SecondLevelHtlcScript(
+		witnessScript, err := input.SecondLevelHtlcScript(
 			revocationKey, delayKey, csvDelay,
 		)
 
-		pkScript, err = input.WitnessScriptHash(witnessScript)
+		pkScript, err := input.WitnessScriptHash(witnessScript)
 		if err != nil {
 			return nil, err
 		}
-	}
-	if err != nil {
-		return nil, err
-	}
 
-	return &ScriptInfo{
-		PkScript:      pkScript,
-		WitnessScript: witnessScript,
-	}, nil
+		return &WitnessScriptDesc{
+			OutputScript:  pkScript,
+			WitnessScript: witnessScript,
+		}, nil
+	}
 }
 
 // CommitWeight returns the base commitment weight before adding HTLCs.
@@ -529,11 +510,14 @@ func HtlcSuccessFee(chanType channeldb.ChannelType,
 // anchor.
 func CommitScriptAnchors(chanType channeldb.ChannelType,
 	localChanCfg, remoteChanCfg *channeldb.ChannelConfig,
-	keyRing *CommitmentKeyRing) (*ScriptInfo, *ScriptInfo, error) {
+	keyRing *CommitmentKeyRing) (
+	input.ScriptDescriptor, input.ScriptDescriptor, error) {
 
 	var (
-		anchorScript func(key *btcec.PublicKey) (*ScriptInfo, error)
-		keySelector  func(*channeldb.ChannelConfig,
+		anchorScript func(key *btcec.PublicKey) (
+			input.ScriptDescriptor, error)
+
+		keySelector func(*channeldb.ChannelConfig,
 			bool) *btcec.PublicKey
 	)
 
@@ -542,25 +526,11 @@ func CommitScriptAnchors(chanType channeldb.ChannelType,
 	// level key is now the (relative) local delay and remote public key,
 	// since these are fully revealed once the commitment hits the chain.
 	case chanType.IsTaproot():
-		anchorScript = func(key *btcec.PublicKey) (*ScriptInfo, error) {
-			anchorScriptTree, err := input.NewAnchorScriptTree(
+		anchorScript = func(key *btcec.PublicKey,
+		) (input.ScriptDescriptor, error) {
+			return input.NewAnchorScriptTree(
 				key,
 			)
-			if err != nil {
-				return nil, err
-			}
-
-			anchorPkScript, err := input.PayToTaprootScript(
-				anchorScriptTree.TaprootKey,
-			)
-			if err != nil {
-				return nil, err
-			}
-
-			return &ScriptInfo{
-				PkScript:   anchorPkScript,
-				ScriptTree: anchorScriptTree.TapscriptTree,
-			}, nil
 		}
 
 		keySelector = func(cfg *channeldb.ChannelConfig,
@@ -578,7 +548,9 @@ func CommitScriptAnchors(chanType channeldb.ChannelType,
 	default:
 		// For normal channels, we'll create a p2wsh script based on
 		// the target key.
-		anchorScript = func(key *btcec.PublicKey) (*ScriptInfo, error) {
+		anchorScript = func(key *btcec.PublicKey,
+		) (input.ScriptDescriptor, error) {
+
 			script, err := input.CommitScriptAnchor(key)
 			if err != nil {
 				return nil, err
@@ -589,8 +561,8 @@ func CommitScriptAnchors(chanType channeldb.ChannelType,
 				return nil, err
 			}
 
-			return &ScriptInfo{
-				PkScript:      scriptHash,
+			return &WitnessScriptDesc{
+				OutputScript:  scriptHash,
 				WitnessScript: script,
 			}, nil
 		}
@@ -924,7 +896,7 @@ func CreateCommitTx(chanType channeldb.ChannelType,
 	localOutput := amountToLocal >= localChanCfg.DustLimit
 	if localOutput {
 		commitTx.AddTxOut(&wire.TxOut{
-			PkScript: toLocalScript.PkScript,
+			PkScript: toLocalScript.PkScript(),
 			Value:    int64(amountToLocal),
 		})
 	}
@@ -932,7 +904,7 @@ func CreateCommitTx(chanType channeldb.ChannelType,
 	remoteOutput := amountToRemote >= localChanCfg.DustLimit
 	if remoteOutput {
 		commitTx.AddTxOut(&wire.TxOut{
-			PkScript: toRemoteScript.PkScript,
+			PkScript: toRemoteScript.PkScript(),
 			Value:    int64(amountToRemote),
 		})
 	}
@@ -950,7 +922,7 @@ func CreateCommitTx(chanType channeldb.ChannelType,
 		// or there are HTLCs.
 		if localOutput || numHTLCs > 0 {
 			commitTx.AddTxOut(&wire.TxOut{
-				PkScript: localAnchor.PkScript,
+				PkScript: localAnchor.PkScript(),
 				Value:    int64(anchorSize),
 			})
 		}
@@ -959,7 +931,7 @@ func CreateCommitTx(chanType channeldb.ChannelType,
 		// output or there are HTLCs.
 		if remoteOutput || numHTLCs > 0 {
 			commitTx.AddTxOut(&wire.TxOut{
-				PkScript: remoteAnchor.PkScript,
+				PkScript: remoteAnchor.PkScript(),
 				Value:    int64(anchorSize),
 			})
 		}
@@ -1013,7 +985,7 @@ func CoopCloseBalance(chanType channeldb.ChannelType, isInitiator bool,
 // channel.
 func genSegwitV0HtlcScript(chanType channeldb.ChannelType,
 	isIncoming, ourCommit bool, timeout uint32, rHash [32]byte,
-	keyRing *CommitmentKeyRing) (*ScriptInfo, error) {
+	keyRing *CommitmentKeyRing) (*WitnessScriptDesc, error) {
 
 	var (
 		witnessScript []byte
@@ -1077,8 +1049,8 @@ func genSegwitV0HtlcScript(chanType channeldb.ChannelType,
 		return nil, err
 	}
 
-	return &ScriptInfo{
-		PkScript:      htlcP2WSH,
+	return &WitnessScriptDesc{
+		OutputScript:  htlcP2WSH,
 		WitnessScript: witnessScript,
 	}, nil
 }
@@ -1086,12 +1058,12 @@ func genSegwitV0HtlcScript(chanType channeldb.ChannelType,
 // genTaprootHtlcScript generates the HTLC scripts for a taproot+musig2
 // channel.
 func genTaprootHtlcScript(isIncoming, ourCommit bool, timeout uint32,
-	rHash [32]byte, keyRing *CommitmentKeyRing) (*ScriptInfo, error) {
+	rHash [32]byte,
+	keyRing *CommitmentKeyRing) (*input.HtlcScriptTree, error) {
 
 	var (
-		taprootKey        *btcec.PublicKey
-		secondLevelScript []byte
-		tapScriptTree     *txscript.IndexedTapScriptTree
+		htlcScriptTree *input.HtlcScriptTree
+		err            error
 	)
 
 	// Generate the proper redeem scripts for the HTLC output modified by
@@ -1102,127 +1074,68 @@ func genTaprootHtlcScript(isIncoming, ourCommit bool, timeout uint32,
 	// transaction. So we need to use the receiver's version of HTLC the
 	// script.
 	case isIncoming && ourCommit:
-		scriptTree, err := input.ReceiverHTLCScriptTaproot(
+		htlcScriptTree, err = input.ReceiverHTLCScriptTaproot(
 			timeout, keyRing.RemoteHtlcKey, keyRing.LocalHtlcKey,
-			keyRing.RevocationKey, rHash[:],
+			keyRing.RevocationKey, rHash[:], ourCommit,
 		)
-		if err != nil {
-			return nil, err
-		}
-
-		tapScriptTree = scriptTree.TapscriptTree
-		taprootKey = scriptTree.TaprootKey
-
-		// As this is an HTLC on our commitment transaction, the second
-		// level path we care about here is the success path.
-		// Therefore, we'll grab the tapLeaf corresponding to the
-		// success path.
-		secondLevelScript = scriptTree.SuccessTapLeaf.Script
 
 	// We're being paid via an HTLC by the remote party, and the HTLC is
 	// being added to their commitment transaction, so we use the sender's
 	// version of the HTLC script.
 	case isIncoming && !ourCommit:
-		scriptTree, err := input.SenderHTLCScriptTaproot(
+		htlcScriptTree, err = input.SenderHTLCScriptTaproot(
 			keyRing.RemoteHtlcKey, keyRing.LocalHtlcKey,
-			keyRing.RevocationKey, rHash[:],
+			keyRing.RevocationKey, rHash[:], ourCommit,
 		)
-		if err != nil {
-			return nil, err
-		}
-
-		tapScriptTree = scriptTree.TapscriptTree
-		taprootKey = scriptTree.TaprootKey
-
-		// In this case, this is an incoming HTLC on the commitment
-		// transaction of the remote party, so we'll return the timeout
-		// tapleaf since that's the second level spend they need in the
-		// case of a broadcast.
-		secondLevelScript = scriptTree.TimeoutTapLeaf.Script
 
 	// We're sending an HTLC which is being added to our commitment
 	// transaction. Therefore, we need to use the sender's version of the
 	// HTLC script.
 	case !isIncoming && ourCommit:
-		scriptTree, err := input.SenderHTLCScriptTaproot(
+		htlcScriptTree, err = input.SenderHTLCScriptTaproot(
 			keyRing.LocalHtlcKey, keyRing.RemoteHtlcKey,
-			keyRing.RevocationKey, rHash[:],
+			keyRing.RevocationKey, rHash[:], ourCommit,
 		)
 		if err != nil {
 			return nil, err
 		}
 
-		tapScriptTree = scriptTree.TapscriptTree
-		taprootKey = scriptTree.TaprootKey
-
-		// This is an outgoing HTLC on our commitment transaction, so
-		// we need to be able to generate/verify signatures for the
-		// timeout path.
-		secondLevelScript = scriptTree.TimeoutTapLeaf.Script
-
 	// Finally, we're paying the remote party via an HTLC, which is being
 	// added to their commitment transaction. Therefore, we use the
 	// receiver's version of the HTLC script.
 	case !isIncoming && !ourCommit:
-		scriptTree, err := input.ReceiverHTLCScriptTaproot(
+		htlcScriptTree, err = input.ReceiverHTLCScriptTaproot(
 			timeout, keyRing.LocalHtlcKey, keyRing.RemoteHtlcKey,
-			keyRing.RevocationKey, rHash[:],
+			keyRing.RevocationKey, rHash[:], ourCommit,
 		)
 		if err != nil {
 			return nil, err
 		}
-
-		tapScriptTree = scriptTree.TapscriptTree
-		taprootKey = scriptTree.TaprootKey
-
-		// This is an outgoing HTLC on the remote party's commitment
-		// transaction. In this case if they go on chain, they'll need
-		// the second level success spend, so we grab that tapscript
-		// path.
-		secondLevelScript = scriptTree.SuccessTapLeaf.Script
 	}
 
-	// Now that we have the redeem scripts, create the P2TR public key
-	// script for the output itself.
-	p2trOutput, err := input.PayToTaprootScript(taprootKey)
-	if err != nil {
-		return nil, err
-	}
-
-	return &ScriptInfo{
-		PkScript:      p2trOutput,
-		WitnessScript: secondLevelScript,
-		ScriptTree:    tapScriptTree,
-	}, nil
+	return htlcScriptTree, nil
 }
 
 // genHtlcScript generates the proper P2WSH public key scripts for the HTLC
 // output modified by two-bits denoting if this is an incoming HTLC, and if the
-// HTLC is being applied to their commitment transaction or ours.
+// HTLC is being applied to their commitment transaction or ours. A script
+// multiplexer for the various spending paths is returned. The script path that
+// we need to sign for the remote party (2nd level HTLCs) is also returned
+// along side the multiplexer.
 func genHtlcScript(chanType channeldb.ChannelType, isIncoming, ourCommit bool,
-	timeout uint32, rHash [32]byte,
-	keyRing *CommitmentKeyRing) (*ScriptInfo, error) {
-
-	var (
-		scriptInfo *ScriptInfo
-		err        error
-	)
+	timeout uint32, rHash [32]byte, keyRing *CommitmentKeyRing,
+) (input.ScriptDescriptor, error) {
 
 	if !chanType.IsTaproot() {
-		scriptInfo, err = genSegwitV0HtlcScript(
+		return genSegwitV0HtlcScript(
 			chanType, isIncoming, ourCommit, timeout, rHash,
 			keyRing,
 		)
 	} else {
-		scriptInfo, err = genTaprootHtlcScript(
+		return genTaprootHtlcScript(
 			isIncoming, ourCommit, timeout, rHash, keyRing,
 		)
 	}
-	if err != nil {
-		return nil, err
-	}
-
-	return scriptInfo, nil
 }
 
 // addHTLC adds a new HTLC to the passed commitment transaction. One of four
@@ -1246,21 +1159,22 @@ func addHTLC(commitTx *wire.MsgTx, ourCommit bool,
 		return err
 	}
 
-	witnessProgram := scriptInfo.PkScript
-	witnessScript := scriptInfo.WitnessScript
+	pkScript := scriptInfo.PkScript()
 
 	// Add the new HTLC outputs to the respective commitment transactions.
 	amountPending := int64(paymentDesc.Amount.ToSatoshis())
-	commitTx.AddTxOut(wire.NewTxOut(amountPending, witnessProgram))
+	commitTx.AddTxOut(wire.NewTxOut(amountPending, pkScript))
 
 	// Store the pkScript of this particular PaymentDescriptor so we can
 	// quickly locate it within the commitment transaction later.
 	if ourCommit {
-		paymentDesc.ourPkScript = witnessProgram
-		paymentDesc.ourWitnessScript = witnessScript
+		paymentDesc.ourPkScript = pkScript
+
+		paymentDesc.ourWitnessScript = scriptInfo.WitnessScriptToSign()
 	} else {
-		paymentDesc.theirPkScript = witnessProgram
-		paymentDesc.theirWitnessScript = witnessScript
+		paymentDesc.theirPkScript = pkScript
+
+		paymentDesc.theirWitnessScript = scriptInfo.WitnessScriptToSign()
 	}
 
 	return nil
@@ -1329,9 +1243,9 @@ func findOutputIndexesFromRemote(revocationPreimage *chainhash.Hash,
 	// Now compare the scripts to find our/their output index.
 	for i, txOut := range chanCommit.CommitTx.TxOut {
 		switch {
-		case bytes.Equal(txOut.PkScript, ourScript.PkScript):
+		case bytes.Equal(txOut.PkScript, ourScript.PkScript()):
 			ourIndex = uint32(i)
-		case bytes.Equal(txOut.PkScript, theirScript.PkScript):
+		case bytes.Equal(txOut.PkScript, theirScript.PkScript()):
 			theirIndex = uint32(i)
 		}
 	}

lnwallet/transactions.go

@@ -66,8 +66,6 @@ func CreateHtlcSuccessTx(chanType channeldb.ChannelType, initiator bool,
 	}
 	successTx.AddTxIn(txin)
 
-	var pkScript []byte
-
 	// Next, we'll generate the script used as the output for all second
 	// level HTLC which forces a covenant w.r.t what can be done with all
 	// HTLC outputs.
@@ -79,13 +77,11 @@ func CreateHtlcSuccessTx(chanType channeldb.ChannelType, initiator bool,
 		return nil, err
 	}
 
-	pkScript = scriptInfo.PkScript
-
 	// Finally, the output is simply the amount of the HTLC (minus the
 	// required fees), paying to the timeout script.
 	successTx.AddTxOut(&wire.TxOut{
 		Value:    int64(htlcAmt),
-		PkScript: pkScript,
+		PkScript: scriptInfo.PkScript(),
 	})
 
 	return successTx, nil
@@ -133,8 +129,6 @@ func CreateHtlcTimeoutTx(chanType channeldb.ChannelType, initiator bool,
 	}
 	timeoutTx.AddTxIn(txin)
 
-	var pkScript []byte
-
 	// Next, we'll generate the script used as the output for all second
 	// level HTLC which forces a covenant w.r.t what can be done with all
 	// HTLC outputs.
@@ -146,13 +140,11 @@ func CreateHtlcTimeoutTx(chanType channeldb.ChannelType, initiator bool,
 		return nil, err
 	}
 
-	pkScript = scriptInfo.PkScript
-
 	// Finally, the output is simply the amount of the HTLC (minus the
 	// required fees), paying to the regular second level HTLC script.
 	timeoutTx.AddTxOut(&wire.TxOut{
 		Value:    int64(htlcAmt),
-		PkScript: pkScript,
+		PkScript: scriptInfo.PkScript(),
 	})
 
 	return timeoutTx, nil