feat: return output specific errors when creating transactions

boltz/btc.go

@@ -66,6 +66,10 @@ func (transaction *BtcTransaction) FindVout(network *Network, addressToFind stri
 	return 0, 0, errors.New("Could not find address in transaction")
 }
 
+func (transaction *BtcTransaction) VoutValue(vout uint32) (uint64, error) {
+	return uint64(transaction.MsgTx().TxOut[vout].Value), nil
+}
+
 func getPrevoutFetcher(tx *wire.MsgTx, outputs []OutputDetails) txscript.PrevOutputFetcher {
 	previous := make(map[wire.OutPoint]*wire.TxOut)
 	for i, input := range tx.TxIn {
@@ -99,11 +103,9 @@ func btcTaprootHash(transaction Transaction, outputs []OutputDetails, index int)
 	)
 }
 
-func constructBtcTransaction(network *Network, outputs []OutputDetails) (Transaction, error) {
+func constructBtcTransaction(network *Network, outputs []OutputDetails, outValues map[string]uint64) (Transaction, error) {
 	transaction := wire.NewMsgTx(wire.TxVersion)
 
-	outValues := make(map[string]int64)
-
 	for _, output := range outputs {
 		// Set the highest timeout block height as locktime
 		if !output.Cooperative {
@@ -119,14 +121,6 @@ func constructBtcTransaction(network *Network, outputs []OutputDetails) (Transac
 		input.Sequence = 0
 
 		transaction.AddTxIn(input)
-
-		value := lockupTx.MsgTx().TxOut[output.Vout].Value
-		if value < int64(output.Fee) {
-			return nil, fmt.Errorf("output value for swap %s less than fee: %d < %d", output.SwapId, value, output.Fee)
-		}
-		//nolint:gosimple
-		existingValue, _ := outValues[output.Address]
-		outValues[output.Address] = existingValue + value - int64(output.Fee)
 	}
 
 	for rawAddress, value := range outValues {
@@ -143,7 +137,7 @@ func constructBtcTransaction(network *Network, outputs []OutputDetails) (Transac
 
 		transaction.AddTxOut(&wire.TxOut{
 			PkScript: outputScript,
-			Value:    value,
+			Value:    int64(value),
 		})
 	}
 

boltz/liquid.go

@@ -70,6 +70,14 @@ func (transaction *LiquidTransaction) FindVout(network *Network, addressToFind s
 
 }
 
+func (transaction *LiquidTransaction) VoutValue(vout uint32) (uint64, error) {
+	result, err := confidential.UnblindOutputWithKey(transaction.Outputs[vout], transaction.OurOutputBlindingKey.Serialize())
+	if err != nil {
+		return 0, err
+	}
+	return result.Value, nil
+}
+
 func (transaction *LiquidTransaction) VSize() uint64 {
 	witnessSize := transaction.SerializeSize(true, true) - transaction.SerializeSize(false, true)
 	return uint64(transaction.SerializeSize(false, true)) + uint64(math.Ceil(float64(witnessSize)/4))
@@ -107,7 +115,7 @@ func liquidTaprootHash(transaction *liquidtx.Transaction, network *Network, outp
 	return hash[:]
 }
 
-func constructLiquidTransaction(network *Network, outputs []OutputDetails) (Transaction, error) {
+func constructLiquidTransaction(network *Network, outputs []OutputDetails, outValues map[string]uint64) (Transaction, error) {
 	p, err := psetv2.New(nil, nil, nil)
 	if err != nil {
 		return nil, err
@@ -118,6 +126,7 @@ func constructLiquidTransaction(network *Network, outputs []OutputDetails) (Tran
 	}
 
 	var inPrivateBlindingKeys [][]byte
+	var totalFee uint64
 
 	for i, output := range outputs {
 		lockupTx := output.LockupTransaction.(*LiquidTransaction)
@@ -150,6 +159,8 @@ func constructLiquidTransaction(network *Network, outputs []OutputDetails) (Tran
 			}
 			inPrivateBlindingKeys = append(inPrivateBlindingKeys, lockupTx.OurOutputBlindingKey.Serialize())
 		}
+
+		totalFee += output.Fee
 	}
 
 	zkpGenerator := confidential.NewZKPGeneratorFromBlindingKeys(inPrivateBlindingKeys, nil)
@@ -159,18 +170,6 @@ func constructLiquidTransaction(network *Network, outputs []OutputDetails) (Tran
 		return nil, errors.New("Failed to unblind inputs: " + err.Error())
 	}
 
-	outValues := make(map[string]uint64)
-	var totalFee uint64
-	for i, input := range ownedInputs {
-		if input.Value < outputs[i].Fee {
-			return nil, fmt.Errorf("input value for swap %s less than fee: %d < %d", outputs[i].SwapId, input.Value, outputs[i].Fee)
-		}
-		address := outputs[i].Address
-		existingValue := outValues[address]
-		outValues[address] = existingValue + input.Value - outputs[i].Fee
-		totalFee += outputs[i].Fee
-	}
-
 	btcAsset := network.Liquid.AssetID
 
 	txOutputs := []psetv2.OutputArgs{

boltz/transaction.go

@@ -16,6 +16,7 @@ type Transaction interface {
 	Serialize() (string, error)
 	VSize() uint64
 	FindVout(network *Network, address string) (uint32, uint64, error)
+	VoutValue(vout uint32) (uint64, error)
 }
 
 type OutputDetails struct {
@@ -60,108 +61,148 @@ func NewTxFromHex(currency Currency, hexString string, ourOutputBlindingKey *btc
 	return NewBtcTxFromHex(hexString)
 }
 
-func ConstructTransaction(network *Network, currency Currency, outputs []OutputDetails, satPerVbyte float64, boltzApi *Boltz) (Transaction, []uint64, error) {
-	var construct func(*Network, []OutputDetails) (Transaction, error)
+type OutputResult struct {
+	Err error
+	Fee uint64
+}
+
+func ConstructTransaction(network *Network, currency Currency, outputs []OutputDetails, satPerVbyte float64, boltzApi *Boltz) (Transaction, []OutputResult, error) {
+	construct := constructBtcTransaction
 	if currency == CurrencyLiquid {
 		construct = constructLiquidTransaction
-	} else if currency == CurrencyBtc {
-		construct = constructBtcTransaction
-	} else {
-		return nil, nil, fmt.Errorf("invalid pair: %v", currency)
 	}
+	results := make([]OutputResult, len(outputs))
+
+	getOutValues := func(fee uint64) map[string]uint64 {
+		outValues := make(map[string]uint64)
 
-	noFeeTransaction, err := construct(network, outputs)
+		outLen := uint64(len(outputs))
+		feePerOutput := fee / outLen
+		feeRemainder := fee % outLen
+
+		for i := range outputs {
+			output := &outputs[i]
+			output.Fee = feePerOutput + feeRemainder
+			results[i].Fee = output.Fee
+			feeRemainder = 0
+
+			value, err := output.LockupTransaction.VoutValue(output.Vout)
+			if err != nil {
+				results[i].Err = err
+				continue
+			}
 
+			if value < output.Fee {
+				results[i].Err = fmt.Errorf("value than fee: %d < %d", value, output.Fee)
+				continue
+			}
+
+			outValues[output.Address] += value - output.Fee
+		}
+		return outValues
+	}
+
+	noFeeTransaction, err := construct(network, outputs, getOutValues(0))
 	if err != nil {
 		return nil, nil, err
 	}
 
 	fee := uint64(float64(noFeeTransaction.VSize()) * satPerVbyte)
 
-	outLen := uint64(len(outputs))
-	feePerOutput := fee / outLen
-	feeRemainder := fee % outLen
-
-	fees := make([]uint64, len(outputs))
-	for i := range outputs {
-		outputs[i].Fee = feePerOutput + feeRemainder
-		fees[i] = outputs[i].Fee
-		feeRemainder = 0
-	}
-
-	transaction, err := construct(network, outputs)
+	transaction, err := construct(network, outputs, getOutValues(fee))
 	if err != nil {
 		return nil, nil, err
 	}
 
+	var retry []OutputDetails
+
 	for i, output := range outputs {
 		if output.Cooperative {
-			if boltzApi == nil {
-				return nil, nil, errors.New("boltzApi is required for cooperative transactions")
-			}
-			session, err := NewSigningSession(outputs[i].SwapTree)
-			if err != nil {
-				return nil, nil, fmt.Errorf("could not initialize signing session: %w", err)
-			}
-
 			serialized, err := transaction.Serialize()
 			if err != nil {
 				return nil, nil, fmt.Errorf("could not serialize transaction: %w", err)
 			}
 
-			pubNonce := session.PublicNonce()
-			refundRequest := &RefundRequest{
-				Transaction: serialized,
-				PubNonce:    pubNonce[:],
-				Index:       i,
-			}
-			claimRequest := &ClaimRequest{
-				Transaction: serialized,
-				PubNonce:    pubNonce[:],
-				Index:       i,
-				Preimage:    output.Preimage,
-			}
-			var signature *PartialSignature
-			if output.SwapType == ReverseSwap {
-				signature, err = boltzApi.ClaimReverseSwap(output.SwapId, claimRequest)
-			} else if output.SwapType == NormalSwap {
-				signature, err = boltzApi.RefundSwap(output.SwapId, refundRequest)
-			} else {
-				signature, err = func() (*PartialSignature, error) {
-					if output.IsRefund() {
-						return boltzApi.RefundChainSwap(output.SwapId, refundRequest)
-					}
-					if output.RefundSwapTree == nil {
-						return nil, errors.New("RefundSwapTree is required for cooperatively claiming chain swap")
-					}
-					boltzSession, err := NewSigningSession(output.RefundSwapTree)
-					if err != nil {
-						return nil, fmt.Errorf("could not initialize signing session: %w", err)
-					}
-					details, err := boltzApi.GetChainSwapClaimDetails(output.SwapId)
-					if err != nil {
-						return nil, err
-					}
-					boltzSignature, err := boltzSession.Sign(details.TransactionHash, details.PubNonce)
-					if err != nil {
-						return nil, fmt.Errorf("could not sign transaction: %w", err)
-					}
-					return boltzApi.ExchangeChainSwapClaimSignature(output.SwapId, &ChainSwapSigningRequest{
-						Preimage:  output.Preimage,
-						Signature: boltzSignature,
-						ToSign:    claimRequest,
-					})
-				}()
-			}
-			if err != nil {
-				return nil, nil, fmt.Errorf("could not get partial signature from boltz: %w", err)
-			}
+			err = func() error {
+				if boltzApi == nil {
+					return errors.New("boltzApi is required for cooperative transactions")
+				}
+
+				session, err := NewSigningSession(outputs[i].SwapTree)
+				if err != nil {
+					return fmt.Errorf("could not initialize signing session: %w", err)
+				}
+
+				pubNonce := session.PublicNonce()
+				refundRequest := &RefundRequest{
+					Transaction: serialized,
+					PubNonce:    pubNonce[:],
+					Index:       i,
+				}
+				claimRequest := &ClaimRequest{
+					Transaction: serialized,
+					PubNonce:    pubNonce[:],
+					Index:       i,
+					Preimage:    output.Preimage,
+				}
+				var signature *PartialSignature
+				if output.SwapType == ReverseSwap {
+					signature, err = boltzApi.ClaimReverseSwap(output.SwapId, claimRequest)
+				} else if output.SwapType == NormalSwap {
+					signature, err = boltzApi.RefundSwap(output.SwapId, refundRequest)
+				} else {
+					signature, err = func() (*PartialSignature, error) {
+						if output.IsRefund() {
+							return boltzApi.RefundChainSwap(output.SwapId, refundRequest)
+						}
+						if output.RefundSwapTree == nil {
+							return nil, errors.New("RefundSwapTree is required for cooperatively claiming chain swap")
+						}
+						boltzSession, err := NewSigningSession(output.RefundSwapTree)
+						if err != nil {
+							return nil, fmt.Errorf("could not initialize signing session: %w", err)
+						}
+						details, err := boltzApi.GetChainSwapClaimDetails(output.SwapId)
+						if err != nil {
+							return nil, err
+						}
+						boltzSignature, err := boltzSession.Sign(details.TransactionHash, details.PubNonce)
+						if err != nil {
+							return nil, fmt.Errorf("could not sign transaction: %w", err)
+						}
+						return boltzApi.ExchangeChainSwapClaimSignature(output.SwapId, &ChainSwapSigningRequest{
+							Preimage:  output.Preimage,
+							Signature: boltzSignature,
+							ToSign:    claimRequest,
+						})
+					}()
+				}
+				if err != nil {
+					return fmt.Errorf("could not get partial signature from boltz: %w", err)
+				}
+
+				if err := session.Finalize(transaction, outputs, network, signature); err != nil {
+					return fmt.Errorf("could not finalize signing session: %w", err)
+				}
+
+				return nil
+			}()
 
-			if err := session.Finalize(transaction, outputs, network, signature); err != nil {
-				return nil, nil, fmt.Errorf("could not finalize signing session: %w", err)
+			if err != nil {
+				if output.IsRefund() {
+					results[i].Err = err
+				} else {
+					nonCoop := outputs[i]
+					nonCoop.Cooperative = false
+					retry = append(retry, nonCoop)
+				}
 			}
 		}
 	}
 
-	return transaction, fees, err
+	if len(retry) > 0 {
+		return ConstructTransaction(network, currency, retry, satPerVbyte, boltzApi)
+	}
+
+	return transaction, results, err
 }

cmd/boltzd/boltzd_test.go

@@ -1140,6 +1140,7 @@ func TestChainSwap(t *testing.T) {
 					swap, err := client.CreateChainSwap(&boltzrpc.CreateChainSwapRequest{
 						Pair:          pair,
 						RefundAddress: &refundAddress,
+						ToAddress:     &toAddress,
 						Amount:        amount + 100,
 						ExternalPay:   &externalPay,
 					})

nursery/chain.go

@@ -176,7 +176,7 @@ func (nursery *Nursery) handleChainSwapStatus(swap *database.ChainSwap, status b
 		}
 
 		output := nursery.getChainSwapClaimOutput(swap)
-		_, err := nursery.claimOutputs(swap.Pair.To, []*Output{output})
+		_, err := nursery.createTransaction(swap.Pair.To, []*Output{output})
 		if err != nil {
 			handleError("Could not claim chain swap output: " + err.Error())
 			return