Skip waiting for signed boarding ins/forfeit txs if none is required

server/internal/core/application/covenant.go

@@ -401,10 +401,15 @@ func (s *covenantService) SignRoundTx(ctx context.Context, signedRoundTx string)
 	defer s.currentRoundLock.Unlock()
 	currentRound := s.currentRound
 
-	combined, err := s.builder.VerifyAndCombinePartialTx(currentRound.UnsignedTx, signedRoundTx)
+	numSignedInputs, combined, err := s.builder.VerifyAndCombinePartialTx(
+		currentRound.UnsignedTx, signedRoundTx,
+	)
 	if err != nil {
 		return fmt.Errorf("failed to verify and combine partial tx: %s", err)
 	}
+	if numSignedInputs == 0 {
+		return nil
+	}
 
 	s.currentRound.UnsignedTx = combined
 

server/internal/core/application/covenantless.go

@@ -759,6 +759,10 @@ func (s *covenantlessService) UpdateTxRequestStatus(_ context.Context, id string
 }
 
 func (s *covenantlessService) SignVtxos(ctx context.Context, forfeitTxs []string) error {
+	if len(forfeitTxs) <= 0 {
+		return nil
+	}
+
 	if err := s.forfeitTxs.sign(forfeitTxs); err != nil {
 		return err
 	}
@@ -778,10 +782,15 @@ func (s *covenantlessService) SignRoundTx(ctx context.Context, signedRoundTx str
 	defer s.currentRoundLock.Unlock()
 	currentRound := s.currentRound
 
-	combined, err := s.builder.VerifyAndCombinePartialTx(currentRound.UnsignedTx, signedRoundTx)
+	numSignedInputs, combined, err := s.builder.VerifyAndCombinePartialTx(
+		currentRound.UnsignedTx, signedRoundTx,
+	)
 	if err != nil {
 		return fmt.Errorf("failed to verify and combine partial tx: %s", err)
 	}
+	if numSignedInputs == 0 {
+		return nil
+	}
 
 	s.currentRound.UnsignedTx = combined
 
@@ -1469,68 +1478,78 @@ func (s *covenantlessService) finalizeRound(notes []note.Note, roundEndTime time
 		}
 	}()
 
-	remainingTime := time.Until(roundEndTime)
-	select {
-	case <-s.forfeitsBoardingSigsChan:
-		log.Debug("all forfeit txs and boarding inputs signatures have been sent")
-	case <-time.After(remainingTime):
-		log.Debug("timeout waiting for forfeit txs and boarding inputs signatures")
-	}
-
-	forfeitTxs, err := s.forfeitTxs.pop()
-	if err != nil {
-		changes = round.Fail(fmt.Errorf("failed to finalize round: %s", err))
-		log.WithError(err).Warn("failed to finalize round")
-		return
-	}
-
-	if err := s.verifyForfeitTxsSigs(forfeitTxs); err != nil {
-		changes = round.Fail(err)
-		log.WithError(err).Warn("failed to validate forfeit txs")
-		return
-	}
-
-	log.Debugf("signing round transaction %s\n", round.Id)
-
-	boardingInputsIndexes := make([]int, 0)
-	boardingInputs := make([]domain.VtxoKey, 0)
 	roundTx, err := psbt.NewFromRawBytes(strings.NewReader(round.UnsignedTx), true)
 	if err != nil {
 		log.Debugf("failed to parse round tx: %s", round.UnsignedTx)
 		changes = round.Fail(fmt.Errorf("failed to parse round tx: %s", err))
 		log.WithError(err).Warn("failed to parse round tx")
 		return
 	}
-
-	for i, in := range roundTx.Inputs {
+	includesBoardingInputs := false
+	for _, in := range roundTx.Inputs {
 		if len(in.TaprootLeafScript) > 0 {
-			if len(in.TaprootScriptSpendSig) == 0 {
-				err = fmt.Errorf("missing tapscript spend sig for input %d", i)
-				changes = round.Fail(err)
-				log.WithError(err).Warn("missing boarding sig")
-				return
-			}
-
-			boardingInputsIndexes = append(boardingInputsIndexes, i)
-			boardingInputs = append(boardingInputs, domain.VtxoKey{
-				Txid: roundTx.UnsignedTx.TxIn[i].PreviousOutPoint.Hash.String(),
-				VOut: roundTx.UnsignedTx.TxIn[i].PreviousOutPoint.Index,
-			})
+			includesBoardingInputs = true
+			break
 		}
 	}
 
-	signedRoundTx := round.UnsignedTx
+	txToSign := round.UnsignedTx
+	boardingInputs := make([]domain.VtxoKey, 0)
+	forfeitTxs := make([]string, 0)
+
+	if len(s.forfeitTxs.forfeitTxs) > 0 || includesBoardingInputs {
+		remainingTime := time.Until(roundEndTime)
+		select {
+		case <-s.forfeitsBoardingSigsChan:
+			log.Debug("all forfeit txs and boarding inputs signatures have been sent")
+		case <-time.After(remainingTime):
+			log.Debug("timeout waiting for forfeit txs and boarding inputs signatures")
+		}
 
-	if len(boardingInputsIndexes) > 0 {
-		signedRoundTx, err = s.wallet.SignTransactionTapscript(ctx, signedRoundTx, boardingInputsIndexes)
+		forfeitTxs, err = s.forfeitTxs.pop()
 		if err != nil {
-			changes = round.Fail(fmt.Errorf("failed to sign round tx: %s", err))
-			log.WithError(err).Warn("failed to sign round tx")
+			changes = round.Fail(fmt.Errorf("failed to finalize round: %s", err))
+			log.WithError(err).Warn("failed to finalize round")
+			return
+		}
+
+		if err := s.verifyForfeitTxsSigs(forfeitTxs); err != nil {
+			changes = round.Fail(err)
+			log.WithError(err).Warn("failed to validate forfeit txs")
 			return
 		}
+
+		boardingInputsIndexes := make([]int, 0)
+		for i, in := range roundTx.Inputs {
+			if len(in.TaprootLeafScript) > 0 {
+				if len(in.TaprootScriptSpendSig) == 0 {
+					err = fmt.Errorf("missing tapscript spend sig for input %d", i)
+					changes = round.Fail(err)
+					log.WithError(err).Warn("missing boarding sig")
+					return
+				}
+
+				boardingInputsIndexes = append(boardingInputsIndexes, i)
+				boardingInputs = append(boardingInputs, domain.VtxoKey{
+					Txid: roundTx.UnsignedTx.TxIn[i].PreviousOutPoint.Hash.String(),
+					VOut: roundTx.UnsignedTx.TxIn[i].PreviousOutPoint.Index,
+				})
+			}
+		}
+
+		if len(boardingInputsIndexes) > 0 {
+			txToSign, err = s.wallet.SignTransactionTapscript(ctx, txToSign, boardingInputsIndexes)
+			if err != nil {
+				changes = round.Fail(fmt.Errorf("failed to sign round tx: %s", err))
+				log.WithError(err).Warn("failed to sign round tx")
+				return
+			}
+		}
 	}
 
-	signedRoundTx, err = s.wallet.SignTransaction(ctx, signedRoundTx, true)
+	log.Debugf("signing transaction %s\n", round.Id)
+
+	signedRoundTx, err := s.wallet.SignTransaction(ctx, txToSign, true)
 	if err != nil {
 		changes = round.Fail(fmt.Errorf("failed to sign round tx: %s", err))
 		log.WithError(err).Warn("failed to sign round tx")

server/internal/core/ports/tx_builder.go

@@ -56,6 +56,6 @@ type TxBuilder interface {
 	VerifyTapscriptPartialSigs(tx string) (valid bool, txid string, err error)
 	// FindLeaves returns all the leaves txs that are reachable from the given outpoint
 	FindLeaves(vtxoTree tree.TxTree, fromtxid string, vout uint32) (leaves []tree.Node, err error)
-	VerifyAndCombinePartialTx(dest string, src string) (string, error)
+	VerifyAndCombinePartialTx(dest string, src string) (int, string, error)
 	GetTxID(tx string) (string, error)
 }

server/internal/infrastructure/tx-builder/covenant/builder.go

@@ -1001,36 +1001,37 @@ func (b *txBuilder) minRelayFeeConnectorTx() (uint64, error) {
 }
 
 // This method aims to verify and add partial signature from boarding input
-func (b *txBuilder) VerifyAndCombinePartialTx(dest string, src string) (string, error) {
+func (b *txBuilder) VerifyAndCombinePartialTx(dest string, src string) (int, string, error) {
 	roundPset, err := psetv2.NewPsetFromBase64(dest)
 	if err != nil {
-		return "", err
+		return -1, "", err
 	}
 
 	sourcePset, err := psetv2.NewPsetFromBase64(src)
 	if err != nil {
-		return "", err
+		return -1, "", err
 	}
 
 	roundUtx, err := roundPset.UnsignedTx()
 	if err != nil {
-		return "", err
+		return -1, "", err
 	}
 
 	sourceUtx, err := sourcePset.UnsignedTx()
 	if err != nil {
-		return "", err
+		return -1, "", err
 	}
 
 	if roundUtx.TxHash().String() != sourceUtx.TxHash().String() {
-		return "", fmt.Errorf("txid mismatch")
+		return -1, "", fmt.Errorf("txid mismatch")
 	}
 
 	roundSigner, err := psetv2.NewSigner(roundPset)
 	if err != nil {
-		return "", err
+		return -1, "", err
 	}
 
+	signedInputsCount := 0
 	for i, input := range sourcePset.Inputs {
 		if len(input.TapScriptSig) == 0 || len(input.TapLeafScript) == 0 {
 			continue
@@ -1040,38 +1041,43 @@ func (b *txBuilder) VerifyAndCombinePartialTx(dest string, src string) (string,
 
 		leafHash, err := chainhash.NewHash(partialSig.LeafHash)
 		if err != nil {
-			return "", err
+			return -1, "", err
 		}
 
 		preimage, err := b.getTaprootPreimage(sourcePset, i, leafHash)
 		if err != nil {
-			return "", err
+			return -1, "", err
 		}
 
 		sig, err := schnorr.ParseSignature(partialSig.Signature)
 		if err != nil {
-			return "", err
+			return -1, "", err
 		}
 
 		pubkey, err := schnorr.ParsePubKey(partialSig.PubKey)
 		if err != nil {
-			return "", err
+			return -1, "", err
 		}
 
 		if !sig.Verify(preimage, pubkey) {
-			return "", fmt.Errorf("invalid signature")
+			return -1, "", fmt.Errorf("invalid signature")
 		}
 
 		if err := roundSigner.AddInTapLeafScript(i, input.TapLeafScript[0]); err != nil {
-			return "", err
+			return -1, "", err
 		}
 
 		if err := roundSigner.SignTaprootInputTapscriptSig(i, partialSig); err != nil {
-			return "", err
+			return -1, "", err
 		}
+		signedInputsCount++
 	}
 
-	return roundSigner.Pset.ToBase64()
+	b64, err := roundSigner.Pset.ToBase64()
+	if err != nil {
+		return -1, "", err
+	}
+	return signedInputsCount, b64, nil
 }
 
 func (b *txBuilder) getTaprootPreimage(pset *psetv2.Pset, inputIndex int, leafHash *chainhash.Hash) ([]byte, error) {

server/internal/infrastructure/tx-builder/covenantless/builder.go

@@ -1049,49 +1049,48 @@ func (b *txBuilder) minRelayFeeConnectorTx() (uint64, error) {
 	return b.wallet.MinRelayFee(context.Background(), uint64(common.ConnectorTxSize))
 }
 
-func (b *txBuilder) VerifyAndCombinePartialTx(dest string, src string) (string, error) {
+func (b *txBuilder) VerifyAndCombinePartialTx(dest string, src string) (int, string, error) {
 	roundTx, err := psbt.NewFromRawBytes(strings.NewReader(dest), true)
 	if err != nil {
-		return "", err
+		return -1, "", err
 	}
 
 	sourceTx, err := psbt.NewFromRawBytes(strings.NewReader(src), true)
 	if err != nil {
-		return "", err
+		return -1, "", err
 	}
 
 	if sourceTx.UnsignedTx.TxHash().String() != roundTx.UnsignedTx.TxHash().String() {
-		return "", fmt.Errorf("txids do not match")
+		return -1, "", fmt.Errorf("txids do not match")
 	}
 
-	for i, in := range sourceTx.Inputs {
-		isMultisigTaproot := len(in.TaprootLeafScript) > 0
+	signedInputsCount := 0
+	for i, sourceInput := range sourceTx.Inputs {
+		isMultisigTaproot := len(sourceInput.TaprootLeafScript) > 0
 		if isMultisigTaproot {
 			// check if the source tx signs the leaf
-			sourceInput := sourceTx.Inputs[i]
-
 			if len(sourceInput.TaprootScriptSpendSig) == 0 {
 				continue
 			}
 
 			partialSig := sourceInput.TaprootScriptSpendSig[0]
 			preimage, err := b.getTaprootPreimage(sourceTx, i, sourceInput.TaprootLeafScript[0].Script)
 			if err != nil {
-				return "", err
+				return -1, "", err
 			}
 
 			sig, err := schnorr.ParseSignature(partialSig.Signature)
 			if err != nil {
-				return "", err
+				return -1, "", err
 			}
 
 			pubkey, err := schnorr.ParsePubKey(partialSig.XOnlyPubKey)
 			if err != nil {
-				return "", err
+				return -1, "", err
 			}
 
 			if !sig.Verify(preimage, pubkey) {
-				return "", fmt.Errorf(
+				return -1, "", fmt.Errorf(
 					"invalid signature for input %s:%d",
 					sourceTx.UnsignedTx.TxIn[i].PreviousOutPoint.Hash.String(),
 					sourceTx.UnsignedTx.TxIn[i].PreviousOutPoint.Index,
@@ -1100,10 +1099,15 @@ func (b *txBuilder) VerifyAndCombinePartialTx(dest string, src string) (string,
 
 			roundTx.Inputs[i].TaprootScriptSpendSig = sourceInput.TaprootScriptSpendSig
 			roundTx.Inputs[i].TaprootLeafScript = sourceInput.TaprootLeafScript
+			signedInputsCount++
 		}
 	}
 
-	return roundTx.B64Encode()
+	b64, err := roundTx.B64Encode()
+	if err != nil {
+		return -1, "", err
+	}
+	return signedInputsCount, b64, nil
 }
 
 func (b *txBuilder) minRelayFeeTreeTx() (uint64, error) {