Merge pull request #6 from BoostyLabs/vs/estimation_upgrade

bitcoin/txbuilder: added variable estimation params, estimation logic updated

Author: gutmann03

bitcoin/txbuilder/fees.go

@@ -0,0 +1,133 @@
+// Copyright (C) 2025 Creditor Corp. Group.
+// See LICENSE for copying information.
+
+package txbuilder
+
+import (
+	"errors"
+	"math/big"
+
+	"github.com/btcsuite/btcd/btcutil"
+	"github.com/btcsuite/btcd/chaincfg"
+)
+
+var (
+	// headerSizeVBytes defined rough tx header size in vBytes.
+	headerSizeVBytes = big.NewInt(11)
+)
+
+// PaymentDataFees holds additional info to build more accurate fee estimation.
+type PaymentDataFees struct {
+	InputSizeVBytes   *big.Int // defines input size in virtual bytes.
+	WitnessSizeVBytes *big.Int // defines witness size in virtual bytes.
+	OutputSizeVBytes  *big.Int // defines output size in virtual bytes.
+}
+
+// NewDefaultPaymentDataFees builds default estimation data for provided address.
+// NOTE: Default estimation data assumes the next type to script mapping:
+//
+//	P2PKH  - single signature
+//	P2SH   - 2-of-3 multisig
+//	P2WPKH - single signature
+//	P2WSH  - 2-of-3 multisig
+//	P2TR   - key-spend path (single signature)
+//
+// INFO: Sizes were taken from this calculator: https://bitcoinops.org/en/tools/calc-size/.
+func NewDefaultPaymentDataFees(address btcutil.Address) (*PaymentDataFees, error) {
+	var inputSizeVByte, witnessSizeVBytes, outputSizeVBytes int64
+	switch address.(type) {
+	case *btcutil.AddressPubKey:
+		return nil, errors.New("unsupported address type: too old (P2PK)")
+	case *btcutil.AddressPubKeyHash:
+		inputSizeVByte, witnessSizeVBytes, outputSizeVBytes = 41, 107, 34
+	case *btcutil.AddressScriptHash:
+		inputSizeVByte, witnessSizeVBytes, outputSizeVBytes = 43, 254, 32
+	case *btcutil.AddressWitnessPubKeyHash:
+		inputSizeVByte, witnessSizeVBytes, outputSizeVBytes = 41, 27, 31
+	case *btcutil.AddressWitnessScriptHash:
+		inputSizeVByte, witnessSizeVBytes, outputSizeVBytes = 41, 64, 43
+	case *btcutil.AddressTaproot:
+		inputSizeVByte, witnessSizeVBytes, outputSizeVBytes = 41, 17, 43
+	default:
+		return nil, errors.New("unsupported address type")
+	}
+
+	return &PaymentDataFees{
+		InputSizeVBytes:   big.NewInt(inputSizeVByte),
+		WitnessSizeVBytes: big.NewInt(witnessSizeVBytes),
+		OutputSizeVBytes:  big.NewInt(outputSizeVBytes),
+	}, nil
+}
+
+// Filled returns true is struct was properly initialized and all fields are filled.
+func (pdf *PaymentDataFees) Filled() bool {
+	return pdf != nil && pdf.InputSizeVBytes != nil && pdf.WitnessSizeVBytes != nil && pdf.OutputSizeVBytes != nil
+}
+
+// RoughTxSize holds data to make rough estimation of tx in vBytes.
+type RoughTxSize struct {
+	IncludeHeader bool                 // to include or not tx header vBytes size into a count.
+	Elements      []*EstimationElement // estimation elements.
+	ExtraExpenses *big.Int             // defines extra expenses (in vBytes) from previous estimation or for another logic needs. optional.
+}
+
+// EstimationElement holds data needed to estimate fee part for PaymentData group.
+type EstimationElement struct {
+	*PaymentDataFees
+	InputsNumber  int // number of inputs of PaymentData address.
+	OutputsNumber int // number of outputs of PaymentData address.
+}
+
+// Estimate returns rough estimation of tx in vBytes.
+func (params *RoughTxSize) Estimate() *big.Int {
+	size := big.NewInt(0)
+	if params.IncludeHeader {
+		size.Add(size, headerSizeVBytes)
+	}
+
+	for _, element := range params.Elements {
+		signedInputSize := new(big.Int).Add(element.InputSizeVBytes, element.WitnessSizeVBytes)
+		inputsFee := new(big.Int).Mul(signedInputSize, big.NewInt(int64(element.InputsNumber)))
+		size.Add(size, inputsFee)
+
+		outputsFee := new(big.Int).Mul(element.OutputSizeVBytes, big.NewInt(int64(element.OutputsNumber)))
+		size.Add(size, outputsFee)
+	}
+
+	if params.ExtraExpenses != nil {
+		size.Add(size, params.ExtraExpenses)
+	}
+
+	return size
+}
+
+// NewEstimationElementFromStringAddress is a constructor for EstimationElement that additionally parses address from string.
+func NewEstimationElementFromStringAddress(address string, inputs, outputs int, networkParams *chaincfg.Params) (*EstimationElement, error) {
+	addr, err := btcutil.DecodeAddress(address, networkParams)
+	if err != nil {
+		return nil, err
+	}
+
+	addressDataFees, err := NewDefaultPaymentDataFees(addr)
+	if err != nil {
+		return nil, err
+	}
+
+	if inputs < 0 || outputs < 0 {
+		return nil, errors.New("inputs and outputs must be >= 0")
+	}
+
+	return &EstimationElement{
+		PaymentDataFees: addressDataFees,
+		InputsNumber:    inputs,
+		OutputsNumber:   outputs,
+	}, nil
+}
+
+// CalculateTxFee calculates tx network fee from tx size in vBytes and sat/kVb price.
+func CalculateTxFee(txSizeVBytes, satoshiPerKVByte *big.Int) (fee *big.Int) {
+	fee = new(big.Int).Mul(txSizeVBytes, satoshiPerKVByte)
+	fee.Quo(fee, big.NewInt(1000))
+
+	return fee
+}

bitcoin/txbuilder/fees_test.go

@@ -0,0 +1,89 @@
+// Copyright (C) 2025 Creditor Corp. Group.
+// See LICENSE for copying information.
+
+package txbuilder_test
+
+import (
+	"math/big"
+	"testing"
+
+	"github.com/btcsuite/btcd/btcutil"
+	"github.com/btcsuite/btcd/chaincfg"
+	"github.com/stretchr/testify/require"
+
+	"github.com/BoostyLabs/blockchain/bitcoin/txbuilder"
+)
+
+func TestNewDefaultPaymentDataFees(t *testing.T) {
+	type unknownAddressType struct {
+		btcutil.Address
+	}
+	chainParams := &chaincfg.MainNetParams
+	tests := []struct {
+		name    string
+		address btcutil.Address
+		sum     int64
+		errStr  string
+	}{
+		{
+			name:    "P2PK",
+			address: btcutilAddress(t, "034cf21794aef30e95631c1e43b91412cd6e7d4734a44eec91eb45518aa81f6390", chainParams),
+			errStr:  "unsupported address type: too old (P2PK)",
+		},
+		{
+			name:    "P2PKH",
+			address: btcutilAddress(t, "13yQfEYjcDZt72pyoyhAZgr3qe8vvwrwgH", chainParams),
+			sum:     182,
+		},
+		{
+			name:    "P2SH",
+			address: btcutilAddress(t, "33qK7XqdJ3v5ySvnN9PugSRZsK2ahL5U1B", chainParams),
+			sum:     329,
+		},
+		{
+			name:    "P2WPKH",
+			address: btcutilAddress(t, "bc1qhl00zlummcd9zc5ppu3klmnp4m7slkuvuq4lz0", chainParams),
+			sum:     99,
+		},
+		{
+			name:    "P2WSH",
+			address: btcutilAddress(t, "bc1q6qj9wcc5lqshlyk427437e9rkevlcsuuypsukaqhmckjf8exdqmsa0pqxh", chainParams),
+			sum:     148,
+		},
+		{
+			name:    "P2TR",
+			address: btcutilAddress(t, "bc1pvep2j3hym7tp69zyd3pwhe7a7exztrtg6wwhdd66fwx2ewfwag7qgawmug", chainParams),
+			sum:     101,
+		},
+		{
+			name:    "UNKNOWN",
+			address: unknownAddressType{btcutilAddress(t, "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa", chainParams)},
+			errStr:  "unsupported address type",
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			got, err := txbuilder.NewDefaultPaymentDataFees(test.address)
+			if test.errStr != "" {
+				require.Error(t, err)
+				require.Contains(t, err.Error(), test.errStr)
+				return
+			}
+			require.NoError(t, err)
+			require.NotNil(t, got)
+
+			sum := big.NewInt(0)
+			sum.Add(sum, got.InputSizeVBytes)
+			sum.Add(sum, got.WitnessSizeVBytes)
+			sum.Add(sum, got.OutputSizeVBytes)
+			require.EqualValues(t, test.sum, sum.Int64())
+		})
+	}
+}
+
+func btcutilAddress(t *testing.T, address string, params *chaincfg.Params) btcutil.Address {
+	addr, err := btcutil.DecodeAddress(address, params)
+	require.NoError(t, err)
+
+	return addr
+}