staticaddr: high fee versions of the htlc tx

Author: hieblmi

staticaddr/loopin/actions.go

@@ -118,21 +118,53 @@ func (f *FSM) InitHtlcAction(_ fsm.EventContext) fsm.EventType {
 	}
 
 	f.loopIn.HtlcCltvExpiry = loopInResp.HtlcExpiry
+
+	// Retrieve htlc tx server nonces.
 	f.htlcServerNonces, err = toNonces(loopInResp.HtlcServerNonces)
 	if err != nil {
 		return f.HandleError(err)
 	}
+	f.htlcServerNoncesHighFee, err = toNonces(
+		loopInResp.HtlcServerNoncesHighFee,
+	)
+	if err != nil {
+		return f.HandleError(err)
+	}
+	f.htlcServerNoncesExtremelyHighFee, err = toNonces(
+		loopInResp.HtlcServerNoncesExtremelyHighFee,
+	)
+	if err != nil {
+		return f.HandleError(err)
+	}
 
 	// We need to defend against the server setting high fees for the htlc
 	// tx since we might have to sweep the timeout path. We maximally allow
 	// 20% of the swap value to be spent on fees.
-	f.loopIn.HtlcTxFeeRate = chainfee.SatPerKWeight(loopInResp.HtlcFeeRate)
-	fee := f.loopIn.HtlcTxFeeRate.FeeForWeight(f.loopIn.htlcWeight())
+	feeRate := chainfee.SatPerKWeight(loopInResp.HtlcFeeRate)
+	fee := feeRate.FeeForWeight(f.loopIn.htlcWeight())
+	if fee > f.loopIn.TotalDepositAmount()/5 {
+		return f.HandleError(errors.New("fee is higher than 20% of " +
+			"sweep value"))
+	}
+	f.loopIn.HtlcTxFeeRate = feeRate
 
+	highFeeRate := chainfee.SatPerKWeight(loopInResp.HighHtlcFeeRate)
+	fee = highFeeRate.FeeForWeight(f.loopIn.htlcWeight())
 	if fee > f.loopIn.TotalDepositAmount()/5 {
 		return f.HandleError(errors.New("fee is higher than 20% of " +
 			"sweep value"))
 	}
+	f.loopIn.HtlcTxHighFeeRate = highFeeRate
+
+	extremelyHighFeeRate := chainfee.SatPerKWeight(
+		loopInResp.ExtremelyHighHtlcFeeRate,
+	)
+	fee = extremelyHighFeeRate.FeeForWeight(f.loopIn.htlcWeight())
+	if fee > f.loopIn.TotalDepositAmount()/5 {
+		return f.HandleError(errors.New("fee is higher than 20% of " +
+			"sweep value"))
+	}
+	f.loopIn.HtlcTxExtremelyHighFeeRate = extremelyHighFeeRate
 
 	// Derive the sweep address for the htlc timeout sweep tx.
 	sweepAddress, err := f.cfg.WalletKit.NextAddr(
@@ -171,38 +203,78 @@ func (f *FSM) SignHtlcTxAction(_ fsm.EventContext) fsm.EventType {
 		return f.HandleError(err)
 	}
 
-	// Create a musig2 session for each deposit.
+	// Create a musig2 session for each deposit and different htlc tx fee
+	// rates.
 	htlcSessions, clientHtlcNonces, err := f.loopIn.createMusig2Sessions(
 		f.ctx, f.cfg.Signer,
 	)
 	if err != nil {
 		return f.HandleError(err)
 	}
-	f.htlcMusig2Sessions = htlcSessions
-	f.htlcClientNonces, err = toNonces(clientHtlcNonces)
+	htlcSessionsHighFee, highFeeNonces, err := f.loopIn.createMusig2Sessions(
+		f.ctx, f.cfg.Signer,
+	)
+	if err != nil {
+		return f.HandleError(err)
+	}
+	htlcSessionsExtremelyHighFee, extremelyHighNonces, err := f.loopIn.createMusig2Sessions( //nolint:lll
+		f.ctx, f.cfg.Signer,
+	)
 	if err != nil {
 		return f.HandleError(err)
 	}
 
-	htlcTx, err := f.loopIn.createHtlcTx(f.cfg.ChainParams)
+	// Create the htlc txns for different fee rates.
+	htlcTx, err := f.loopIn.createHtlcTx(
+		f.cfg.ChainParams, f.loopIn.HtlcTxFeeRate,
+	)
+	if err != nil {
+		return f.HandleError(err)
+	}
+	htlcTxHighFee, err := f.loopIn.createHtlcTx(
+		f.cfg.ChainParams, f.loopIn.HtlcTxHighFeeRate,
+	)
+	if err != nil {
+		return f.HandleError(err)
+	}
+	htlcTxExtremelyHighFee, err := f.loopIn.createHtlcTx(
+		f.cfg.ChainParams, f.loopIn.HtlcTxExtremelyHighFeeRate,
+	)
 	if err != nil {
 		return f.HandleError(err)
 	}
 
-	// Next we'll get our htlc tx signatures.
+	// Next we'll get our htlc tx signatures for different fee rates.
 	htlcSigs, err := f.loopIn.signMusig2Tx(
 		f.ctx, htlcTx, f.cfg.Signer, htlcSessions, f.htlcServerNonces,
 	)
 	if err != nil {
 		return f.HandleError(err)
 	}
-	f.htlcClientSigs = htlcSigs
+	htlcSigsHighFee, err := f.loopIn.signMusig2Tx(
+		f.ctx, htlcTxHighFee, f.cfg.Signer, htlcSessionsHighFee,
+		f.htlcServerNoncesHighFee,
+	)
+	if err != nil {
+		return f.HandleError(err)
+	}
+	htlcSigsExtremelyHighFee, err := f.loopIn.signMusig2Tx(
+		f.ctx, htlcTxExtremelyHighFee, f.cfg.Signer,
+		htlcSessionsExtremelyHighFee, f.htlcServerNoncesExtremelyHighFee,
+	)
+	if err != nil {
+		return f.HandleError(err)
+	}
 
 	// Push htlc tx sigs to server.
 	pushHtlcReq := &looprpc.PushStaticAddressHtlcSigsRequest{
-		SwapHash:         f.loopIn.SwapHash[:],
-		HtlcClientNonces: clientHtlcNonces,
-		HtlcClientSigs:   htlcSigs,
+		SwapHash:                         f.loopIn.SwapHash[:],
+		HtlcClientNonces:                 clientHtlcNonces,
+		HtlcClientNoncesHighFee:          highFeeNonces,
+		HtlcClientNoncesExtremelyHighFee: extremelyHighNonces,
+		HtlcClientSigs:                   htlcSigs,
+		HtlcClientSigsHighFee:            htlcSigsHighFee,
+		HtlcClientSigsExtremelyHighFee:   htlcSigsExtremelyHighFee,
 	}
 	sigPushResp, err := f.cfg.StaticAddressServerClient.PushStaticAddressHtlcSigs( //nolint:lll
 		f.ctx, pushHtlcReq,

staticaddr/loopin/fsm.go

@@ -26,21 +26,17 @@ type FSM struct {
 	// MuSig2 data must not be re-used across restarts, hence it is not
 	// persisted.
 	//
-	// htlcMusig2Sessions contains all the loop-in musig2 sessions that will
-	// be used for the htlc transaction.
-	htlcMusig2Sessions []*input.MuSig2SessionInfo
-
-	// htlcClientNonces contains all the nonces that the client sent for
-	// the htlc musig2 sessions.
-	htlcClientNonces [][musig2.PubNonceSize]byte
-
 	// htlcServerNonces contains all the nonces that the server generated
 	// for the htlc musig2 sessions.
 	htlcServerNonces [][musig2.PubNonceSize]byte
 
-	// htlcClientSigs contains all the signatures that the client generated
+	// htlcServerNonces contains all the nonces that the server generated
+	// for the htlc musig2 sessions.
+	htlcServerNoncesHighFee [][musig2.PubNonceSize]byte
+
+	// htlcServerNonces contains all the nonces that the server generated
 	// for the htlc musig2 sessions.
-	htlcClientSigs [][]byte
+	htlcServerNoncesExtremelyHighFee [][musig2.PubNonceSize]byte
 
 	// sweeplessMusig2Sessions contains all the loop-in musig2 sessions that
 	// will be used for signing the sweepless sweep transaction.

staticaddr/loopin/loopin.go

@@ -115,6 +115,14 @@ type StaticAddressLoopIn struct {
 	// HtlcTxFeeRate is the fee rate that is used for the htlc transaction.
 	HtlcTxFeeRate chainfee.SatPerKWeight
 
+	// HtlcTxHighFeeRate is the fee rate that is used for the htlc
+	// transaction.
+	HtlcTxHighFeeRate chainfee.SatPerKWeight
+
+	// HtlcTxExtremelyHighFeeRate is the fee rate that is used for the htlc
+	// transaction.
+	HtlcTxExtremelyHighFeeRate chainfee.SatPerKWeight
+
 	// HtlcTimeoutSweepTxHash is the hash of the htlc timeout sweep tx.
 	HtlcTimeoutSweepTxHash *chainhash.Hash
 
@@ -309,8 +317,8 @@ func (l *StaticAddressLoopIn) signMusig2Tx(ctx context.Context,
 
 // createHtlcTx creates the transaction that spend the deposit outpoints into
 // a htlc outpoint.
-func (l *StaticAddressLoopIn) createHtlcTx(chainParams *chaincfg.Params) (
-	*wire.MsgTx, error) {
+func (l *StaticAddressLoopIn) createHtlcTx(chainParams *chaincfg.Params,
+	feeRate chainfee.SatPerKWeight) (*wire.MsgTx, error) {
 
 	// First Create the tx.
 	msgTx := wire.NewMsgTx(2)
@@ -326,7 +334,7 @@ func (l *StaticAddressLoopIn) createHtlcTx(chainParams *chaincfg.Params) (
 
 	// Calculate htlc tx fee for server provided fee rate.
 	weight := l.htlcWeight()
-	fee := l.HtlcTxFeeRate.FeeForWeight(weight)
+	fee := feeRate.FeeForWeight(weight)
 
 	htlc, err := l.getHtlc(chainParams)
 	if err != nil {