feat(broadcast): add fee adjustment for transaction broadcasting (#17)

Author: lmquang

internal/btcrpc/blockstream/blockstream.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"io"
 	"net/http"
+	"regexp"
 	"strconv"
 	"strings"
 
@@ -50,7 +51,24 @@ func (c *blockstream) BroadcastTx(txHex string) (string, error) {
 	}
 
 	if resp.StatusCode != 200 {
-		return "", fmt.Errorf("status code: %v, failed to broadcast transaction: %s", resp.StatusCode, body)
+		// Check for minimum relay fee error
+		bodyStr := string(body)
+
+		// Regex to extract minimum fee from error message
+		minFeeRegex := regexp.MustCompile(`min relay fee not met, (\d+) < (\d+)`)
+		matches := minFeeRegex.FindStringSubmatch(bodyStr)
+
+		if len(matches) == 3 {
+			minFee, _ := strconv.ParseInt(matches[2], 10, 64)
+
+			return "", &BroadcastTxError{
+				Message:    fmt.Sprintf("status code: %v, failed to broadcast transaction: %s", resp.StatusCode, bodyStr),
+				StatusCode: resp.StatusCode,
+				MinFee:     minFee,
+			}
+		}
+
+		return "", fmt.Errorf("status code: %v, failed to broadcast transaction: %s", resp.StatusCode, bodyStr)
 	}
 
 	return string(body), nil

internal/btcrpc/blockstream/interface.go

@@ -2,6 +2,18 @@ package blockstream
 
 import "github.com/dwarvesf/icy-backend/internal/model"
 
+// BroadcastTxError represents a detailed error when broadcasting a transaction
+type BroadcastTxError struct {
+	Message    string
+	StatusCode int
+	MinFee     int64 // Minimum fee required in satoshis
+}
+
+// Error implements the error interface
+func (e *BroadcastTxError) Error() string {
+	return e.Message
+}
+
 type IBlockStream interface {
 	BroadcastTx(txHex string) (hash string, err error)
 	EstimateFees() (fees map[string]float64, err error)

internal/btcrpc/btcrpc.go

@@ -3,9 +3,11 @@ package btcrpc
 import (
 	"fmt"
 	"strconv"
+	"strings"
 
 	"github.com/btcsuite/btcd/btcutil"
 	"github.com/btcsuite/btcd/chaincfg"
+	"github.com/btcsuite/btcd/wire"
 
 	"github.com/dwarvesf/icy-backend/internal/btcrpc/blockstream"
 	"github.com/dwarvesf/icy-backend/internal/model"
@@ -86,8 +88,8 @@ func (b *BtcRpc) Send(receiverAddressStr string, amount *model.Web3BigInt) (stri
 		return "", err
 	}
 
-	// Serialize & broadcast tx
-	txID, err := b.broadcast(tx)
+	// Serialize & broadcast tx with potential fee adjustment
+	txID, err := b.broadcastWithFeeAdjustment(tx, selectedUTXOs, receiverAddress, senderAddress, amountToSend, changeAmount)
 	if err != nil {
 		b.logger.Error("[btcrpc.Send][broadcast]", map[string]string{
 			"error": err.Error(),
@@ -98,6 +100,104 @@ func (b *BtcRpc) Send(receiverAddressStr string, amount *model.Web3BigInt) (stri
 	return txID, nil
 }
 
+// broadcastWithFeeAdjustment attempts to broadcast the transaction,
+// and if it fails due to minimum relay fee, attempts to increase the fee by 5%
+func (b *BtcRpc) broadcastWithFeeAdjustment(
+	tx *wire.MsgTx,
+	selectedUTXOs []blockstream.UTXO,
+	receiverAddress btcutil.Address,
+	senderAddress *btcutil.AddressWitnessPubKeyHash,
+	amountToSend, changeAmount int64,
+) (string, error) {
+	// First attempt to broadcast
+	txID, err := b.broadcast(tx)
+	if err == nil {
+		return txID, nil
+	}
+
+	// Check if the error is specifically about minimum relay fee
+	broadcastErr, ok := err.(*blockstream.BroadcastTxError)
+	if ok && strings.Contains(broadcastErr.Error(), "min relay fee not met") {
+		b.logger.Info("[btcrpc.Send][FeeAdjustment]", map[string]string{
+			"message": "Attempting to adjust transaction fee",
+		})
+
+		// Use the minimum fee from the error if available
+		var adjustedFee, currentFee int64
+		if broadcastErr.MinFee > 0 {
+			// Use the minimum fee from the error
+			adjustedFee = broadcastErr.MinFee
+
+			// Fallback to calculating current fee if no minimum fee in error
+			feeRates, err := b.blockstream.EstimateFees()
+			if err != nil {
+				return "", fmt.Errorf("failed to get fee rates for adjustment: %v", err)
+			}
+
+			currentFee, err = b.calculateTxFee(feeRates, len(selectedUTXOs), 2, 6)
+			if err != nil {
+				return "", fmt.Errorf("failed to calculate current fee: %v", err)
+			}
+
+			if adjustedFee > int64(float64(currentFee)*1.05) {
+				return "", fmt.Errorf("fee too high to adjust, adjusted fee: %d, current fee: %d", adjustedFee, currentFee)
+			}
+		} else {
+			// Fallback to calculating fee if no minimum fee in error
+			feeRates, err := b.blockstream.EstimateFees()
+			if err != nil {
+				return "", fmt.Errorf("failed to get fee rates for adjustment: %v", err)
+			}
+
+			currentFee, err = b.calculateTxFee(feeRates, len(selectedUTXOs), 2, 6)
+			if err != nil {
+				return "", fmt.Errorf("failed to calculate current fee: %v", err)
+			}
+
+			// Adjust fee to be 5% higher
+			adjustedFee = int64(float64(currentFee) * 1.05)
+		}
+
+		b.logger.Info("[btcrpc.Send][FeeAdjustment]", map[string]string{
+			"currentFee":   strconv.FormatInt(currentFee, 10),
+			"adjustedFee":  strconv.FormatInt(adjustedFee, 10),
+			"changeAmount": strconv.FormatInt(changeAmount, 10),
+			"amountToSend": strconv.FormatInt(amountToSend, 10),
+		})
+
+		// Calculate adjusted change amount
+		adjustedChangeAmount := changeAmount - (adjustedFee - currentFee)
+
+		// If adjusted change amount becomes negative, we can't proceed
+		if adjustedChangeAmount < 0 {
+			return "", fmt.Errorf("insufficient funds to adjust transaction fee")
+		}
+
+		// Recreate transaction with adjusted fee
+		adjustedTx, err := b.prepareTx(selectedUTXOs, receiverAddress, senderAddress, amountToSend, adjustedChangeAmount)
+		if err != nil {
+			return "", fmt.Errorf("failed to prepare adjusted transaction: %v", err)
+		}
+
+		// Re-sign the transaction
+		privKey, _, err := b.getSelfPrivKeyAndAddress(b.appConfig.Bitcoin.WalletWIF)
+		if err != nil {
+			return "", fmt.Errorf("failed to get private key for re-signing: %v", err)
+		}
+
+		err = b.sign(adjustedTx, privKey, senderAddress, selectedUTXOs)
+		if err != nil {
+			return "", fmt.Errorf("failed to sign adjusted transaction: %v", err)
+		}
+
+		// Attempt to broadcast adjusted transaction
+		return b.broadcast(adjustedTx)
+	}
+
+	// If it's a different error, return the original error
+	return "", err
+}
+
 func (b *BtcRpc) CurrentBalance() (*model.Web3BigInt, error) {
 	balance, err := b.blockstream.GetBTCBalance(b.appConfig.Blockchain.BTCTreasuryAddress)
 	if err != nil {

internal/btcrpc/helper.go

@@ -276,26 +276,6 @@ func (b *BtcRpc) selectUTXOs(address string, amountToSend int64) (selected []blo
 		return nil, 0, err
 	}
 
-	// blk := "6"
-	// minFee, ok := feeRates[blk]
-	// if !ok {
-	// 	return nil, 0, fmt.Errorf("no fee rate available for target %s blocks", blk)
-	// }
-	// for block, fee := range feeRates {
-	// 	if fee <= maxTxFee {
-	// 		minFee = fee
-	// 		blk = block
-	// 		break
-	// 	}
-	// }
-	// if minFee > maxTxFee {
-	// 	return nil, 0, fmt.Errorf("fee rate %f exceeds maximum threshold: %d USD", minFee, maxTxFee)
-	// }
-	// targetBlocks, err := strconv.Atoi(blk)
-	// if err != nil {
-	// 	return nil, 0, fmt.Errorf("failed to convert block string to int: %v", err)
-	// }
-
 	// Iteratively select UTXOs until we have enough to cover amount + fee
 	var totalSelected int64
 	var fee int64
@@ -313,8 +293,16 @@ func (b *BtcRpc) selectUTXOs(address string, amountToSend int64) (selected []blo
 			return nil, 0, err
 		}
 
+		if fee > amountToSend {
+			return nil, 0, fmt.Errorf("fee exceeds amount to send: fee %d, amountToSend %d", fee, amountToSend)
+		}
+
 		// if we have enough to cover amount + current fee => return selected UTXOs and change amount
 		if totalSelected >= amountToSend+fee {
+			b.logger.Info("[selectUTXOs] calculateTxFee", map[string]string{
+				"amountToSend": fmt.Sprintf("%d", amountToSend),
+				"fee":          fmt.Sprintf("%d", fee),
+			})
 			changeAmount = totalSelected - amountToSend - fee
 			return selected, changeAmount, nil
 		}

internal/handler/swap/swap.go

@@ -91,7 +91,7 @@ func (h *handler) CreateSwapRequest(c *gin.Context) {
 		return
 	}
 	if icyAmountFloat < h.appConfig.MinIcySwapAmount {
-		c.JSON(http.StatusBadRequest, view.CreateResponse[any](nil, fmt.Errorf("minimum ICY amount is %s", h.appConfig.MinIcySwapAmount), nil, "invalid ICY amount"))
+		c.JSON(http.StatusBadRequest, view.CreateResponse[any](nil, fmt.Errorf("minimum ICY amount is %v", h.appConfig.MinIcySwapAmount), nil, "invalid ICY amount"))
 		return
 	}