tapchannel: properly thread thru lock time for 2nd level HTLCs

In this commit, we fix an existing logic gap related to 2nd level HTLCs.
Before if we were signing a timeout for the remote party, neither of us
would properly apply the lock time to the vPkt.

In this commit, we fix it by first gaining a new `whoseCommit` param in
`FetchLeavesFromCommit`. We then use that to decide when to use a non
zero CLTV timeout.

Author: Roasbeef

server.go

@@ -771,7 +771,7 @@ func (s *Server) FetchLeavesFromCommit(chanState lnwl.AuxChanState,
 	// The aux leaf creator is fully stateless, and we don't need to wait
 	// for the server to be started before being able to use it.
 	return tapchannel.FetchLeavesFromCommit(
-		s.chainParams, chanState, com, keys,
+		s.chainParams, chanState, com, keys, whoseCommit,
 	)
 }
 

tapchannel/aux_leaf_creator.go

@@ -8,10 +8,12 @@ import (
 	"github.com/btcsuite/btcd/txscript"
 	"github.com/btcsuite/btcd/wire"
 	"github.com/lightninglabs/taproot-assets/address"
+	"github.com/lightninglabs/taproot-assets/fn"
 	cmsg "github.com/lightninglabs/taproot-assets/tapchannelmsg"
 	"github.com/lightningnetwork/lnd/channeldb"
 	lfn "github.com/lightningnetwork/lnd/fn"
 	"github.com/lightningnetwork/lnd/input"
+	"github.com/lightningnetwork/lnd/lntypes"
 	lnwl "github.com/lightningnetwork/lnd/lnwallet"
 	"github.com/lightningnetwork/lnd/tlv"
 )
@@ -78,7 +80,8 @@ func FetchLeavesFromView(chainParams *address.ChainParams,
 // to the passed aux blob, and an existing channel commitment.
 func FetchLeavesFromCommit(chainParams *address.ChainParams,
 	chanState lnwl.AuxChanState, com channeldb.ChannelCommitment,
-	keys lnwl.CommitmentKeyRing) lfn.Result[lnwl.CommitDiffAuxResult] {
+	keys lnwl.CommitmentKeyRing,
+	whoseCommit lntypes.ChannelParty) lfn.Result[lnwl.CommitDiffAuxResult] {
 
 	type returnType = lnwl.CommitDiffAuxResult
 
@@ -115,9 +118,17 @@ func FetchLeavesFromCommit(chainParams *address.ChainParams,
 				continue
 			}
 
+			// If this is an incoming HTLC (to us), but on the
+			// remote party's commitment transaction, then they'll
+			// need to go to the second level to time it out.
+			var cltvTimeout fn.Option[uint32]
+			if whoseCommit == lntypes.Remote {
+				cltvTimeout = fn.Some(htlc.RefundTimeout)
+			}
+
 			leaf, err := CreateSecondLevelHtlcTx(
 				chanState, com.CommitTx, htlc.Amt.ToSatoshis(),
-				keys, chainParams, htlcOutputs,
+				keys, chainParams, htlcOutputs, cltvTimeout,
 			)
 			if err != nil {
 				return lfn.Err[returnType](fmt.Errorf("unable "+
@@ -147,9 +158,17 @@ func FetchLeavesFromCommit(chainParams *address.ChainParams,
 				continue
 			}
 
+			// If this is an outgoing commit on our local
+			// commitment, then we'll need to go to the second level
+			// to time out it out.
+			var cltvTimeout fn.Option[uint32]
+			if whoseCommit == lntypes.Local {
+				cltvTimeout = fn.Some(htlc.RefundTimeout)
+			}
+
 			leaf, err := CreateSecondLevelHtlcTx(
 				chanState, com.CommitTx, htlc.Amt.ToSatoshis(),
-				keys, chainParams, htlcOutputs,
+				keys, chainParams, htlcOutputs, cltvTimeout,
 			)
 			if err != nil {
 				return lfn.Err[returnType](fmt.Errorf("unable "+

tapchannel/aux_leaf_signer.go

@@ -358,9 +358,17 @@ func verifyHtlcSignature(chainParams *address.ChainParams,
 	keyRing lnwallet.CommitmentKeyRing, sigs []*cmsg.AssetSig,
 	htlcOutputs []*cmsg.AssetOutput, baseJob lnwallet.BaseAuxJob) error {
 
+	// If we're validating a signature for an outgoing HTLC, then it's an
+	// outgoing HTLC for the remote party, so we'll need to sign it with the
+	// proper lock time.
+	var htlcTimeout fn.Option[uint32]
+	if !baseJob.Incoming {
+		htlcTimeout = fn.Some(baseJob.HTLC.Timeout)
+	}
+
 	vPackets, err := htlcSecondLevelPacketsFromCommit(
 		chainParams, chanState, commitTx, baseJob.KeyRing, htlcOutputs,
-		baseJob,
+		baseJob, htlcTimeout,
 	)
 	if err != nil {
 		return fmt.Errorf("error generating second level packets: %w",
@@ -494,9 +502,17 @@ func (s *AuxLeafSigner) generateHtlcSignature(chanState lnwallet.AuxChanState,
 	signDesc input.SignDescriptor,
 	baseJob lnwallet.BaseAuxJob) (lnwallet.AuxSigJobResp, error) {
 
+	// If we're generating a signature for an incoming HTLC, then it's an
+	// outgoing HTLC for the remote party, so we'll need to sign it with the
+	// proper lock time.
+	var htlcTimeout fn.Option[uint32]
+	if baseJob.Incoming {
+		htlcTimeout = fn.Some(baseJob.HTLC.Timeout)
+	}
+
 	vPackets, err := htlcSecondLevelPacketsFromCommit(
 		s.cfg.ChainParams, chanState, commitTx, baseJob.KeyRing,
-		htlcOutputs, baseJob,
+		htlcOutputs, baseJob, htlcTimeout,
 	)
 	if err != nil {
 		return lnwallet.AuxSigJobResp{}, fmt.Errorf("error generating "+
@@ -584,11 +600,12 @@ func (s *AuxLeafSigner) generateHtlcSignature(chanState lnwallet.AuxChanState,
 func htlcSecondLevelPacketsFromCommit(chainParams *address.ChainParams,
 	chanState lnwallet.AuxChanState, commitTx *wire.MsgTx,
 	keyRing lnwallet.CommitmentKeyRing, htlcOutputs []*cmsg.AssetOutput,
-	baseJob lnwallet.BaseAuxJob) ([]*tappsbt.VPacket, error) {
+	baseJob lnwallet.BaseAuxJob,
+	htlcTimeout fn.Option[uint32]) ([]*tappsbt.VPacket, error) {
 
 	packets, _, err := CreateSecondLevelHtlcPackets(
 		chanState, commitTx, baseJob.HTLC.Amount.ToSatoshis(),
-		keyRing, chainParams, htlcOutputs,
+		keyRing, chainParams, htlcOutputs, htlcTimeout,
 	)
 	if err != nil {
 		return nil, fmt.Errorf("error creating second level HTLC "+

tapchannel/aux_sweeper.go

@@ -201,10 +201,15 @@ func (a *AuxSweeper) createSweepVpackets(sweepInputs []*cmsg.AssetOutput,
 	// the output information locked in, as this was a pre-signed
 	// transaction.
 	if sweepDesc.auxSigInfo.IsSome() {
+		var cltvTimeout fn.Option[uint32]
+		sweepDesc.absoluteDelay.WhenSome(func(delay uint64) {
+			cltvTimeout = fn.Some(uint32(delay))
+		})
+
 		alloc, err := createSecondLevelHtlcAllocations(
 			resReq.ChanType, resReq.Initiator, sweepInputs,
 			resReq.HtlcAmt, resReq.CommitCsvDelay, *resReq.KeyRing,
-			fn.Some(resReq.ContractPoint.Index),
+			fn.Some(resReq.ContractPoint.Index), cltvTimeout,
 		)
 		if err != nil {
 			return lfn.Err[returnType](err)
@@ -1962,6 +1967,7 @@ func newBlobWithWitnessInfo(i input.Input) lfn.Result[blobWithWitnessInfo] {
 }
 
 // prepVpkts decodes the set of vPkts, supplementing them as needed to ensure
+
 // all inputs can be swept properly.
 func prepVpkts(bRes lfn.Result[blobWithWitnessInfo],
 	secondLevel bool) (*vPktsWithInput, error) {

tapchannel/commitment.go

@@ -1226,7 +1226,7 @@ func collectOutputs(a *Allocation,
 func createSecondLevelHtlcAllocations(chanType channeldb.ChannelType,
 	initiator bool, htlcOutputs []*cmsg.AssetOutput, htlcAmt btcutil.Amount,
 	commitCsvDelay uint32, keys lnwallet.CommitmentKeyRing,
-	outputIndex fn.Option[uint32],
+	outputIndex fn.Option[uint32], htlcTimeout fn.Option[uint32],
 ) ([]*Allocation, error) {
 
 	// TODO(roasbeef): thaw height not implemented for taproot chans rn
@@ -1267,6 +1267,8 @@ func createSecondLevelHtlcAllocations(chanType channeldb.ChannelType,
 		SortTaprootKeyBytes: schnorr.SerializePubKey(
 			htlcTree.TaprootKey,
 		),
+		// TODO(roasbeef): don't need it here?
+		CLTV: htlcTimeout.UnwrapOr(0),
 	}}
 
 	return allocations, nil
@@ -1277,14 +1279,13 @@ func createSecondLevelHtlcAllocations(chanType channeldb.ChannelType,
 func CreateSecondLevelHtlcPackets(chanState lnwallet.AuxChanState,
 	commitTx *wire.MsgTx, htlcAmt btcutil.Amount,
 	keys lnwallet.CommitmentKeyRing, chainParams *address.ChainParams,
-	htlcOutputs []*cmsg.AssetOutput) ([]*tappsbt.VPacket, []*Allocation,
-	error) {
+	htlcOutputs []*cmsg.AssetOutput, htlcTimeout fn.Option[uint32],
+) ([]*tappsbt.VPacket, []*Allocation, error) {
 
 	allocations, err := createSecondLevelHtlcAllocations(
 		chanState.ChanType, chanState.IsInitiator,
-		htlcOutputs, htlcAmt,
-		uint32(chanState.LocalChanCfg.CsvDelay), keys,
-		fn.None[uint32](),
+		htlcOutputs, htlcAmt, uint32(chanState.LocalChanCfg.CsvDelay),
+		keys, fn.None[uint32](), htlcTimeout,
 	)
 	if err != nil {
 		return nil, nil, err
@@ -1303,6 +1304,15 @@ func CreateSecondLevelHtlcPackets(chanState lnwallet.AuxChanState,
 		return nil, nil, fmt.Errorf("error distributing coins: %w", err)
 	}
 
+	// If the HTLC timeout was present, then we'll also manually add it as a
+	// param to the vOut here, as it's just used for sorting with
+	// allocations.
+	for _, vPkt := range vPackets {
+		for _, o := range vPkt.Outputs {
+			o.LockTime = uint64(htlcTimeout.UnwrapOr(0))
+		}
+	}
+
 	ctx := context.Background()
 	for idx := range vPackets {
 		err := tapsend.PrepareOutputAssets(ctx, vPackets[idx])
@@ -1320,12 +1330,14 @@ func CreateSecondLevelHtlcPackets(chanState lnwallet.AuxChanState,
 func CreateSecondLevelHtlcTx(chanState lnwallet.AuxChanState,
 	commitTx *wire.MsgTx, htlcAmt btcutil.Amount,
 	keys lnwallet.CommitmentKeyRing, chainParams *address.ChainParams,
-	htlcOutputs []*cmsg.AssetOutput) (input.AuxTapLeaf, error) {
+	htlcOutputs []*cmsg.AssetOutput, htlcTimeout fn.Option[uint32],
+) (input.AuxTapLeaf, error) {
 
 	none := input.NoneTapLeaf()
 
 	vPackets, allocations, err := CreateSecondLevelHtlcPackets(
 		chanState, commitTx, htlcAmt, keys, chainParams, htlcOutputs,
+		htlcTimeout,
 	)
 	if err != nil {
 		return none, fmt.Errorf("error creating second level HTLC "+
@@ -1353,6 +1365,7 @@ func CreateSecondLevelHtlcTx(chanState lnwallet.AuxChanState,
 	if err != nil {
 		return none, fmt.Errorf("error creating aux leaf: %w", err)
 	}
+
 	return lfn.Some(auxLeaf), nil
 }