feat(btc): txn add EstimateTransactionSize().

core/btc/transaction_build.go

@@ -18,56 +18,59 @@ const (
 )
 
 type Transaction struct {
-	inputs    []input
-	outputs   []output
-	netParams *chaincfg.Params
+	netParams      *chaincfg.Params
+	msgTx          *wire.MsgTx
+	prevOutFetcher *txscript.MultiPrevOutFetcher
 }
 
-type input struct {
-	outPoint *wire.OutPoint
-	prevOut  *wire.TxOut
-}
-
-type output *wire.TxOut
-
 func NewTransaction(chainnet string) (*Transaction, error) {
 	net, err := netParamsOf(chainnet)
 	if err != nil {
 		return nil, err
 	}
-	return &Transaction{netParams: net}, nil
+	tx := wire.NewMsgTx(wire.TxVersion)
+	prevOutFetcher := txscript.NewMultiPrevOutFetcher(nil)
+	return &Transaction{
+		netParams:      net,
+		msgTx:          tx,
+		prevOutFetcher: prevOutFetcher,
+	}, nil
 }
 
 func (t *Transaction) TotalInputValue() int64 {
 	total := int64(0)
-	for _, v := range t.inputs {
-		total += v.prevOut.Value
+	for _, v := range t.msgTx.TxIn {
+		out := t.prevOutFetcher.FetchPrevOutput(v.PreviousOutPoint)
+		total += out.Value
 	}
 	return total
 }
 
 func (t *Transaction) TotalOutputValue() int64 {
 	total := int64(0)
-	for _, v := range t.outputs {
+	for _, v := range t.msgTx.TxOut {
 		total += v.Value
 	}
 	return total
 }
 
+func (t *Transaction) EstimateTransactionSize() int64 {
+	return virtualSize(ensureSignOrFakeSign(t.msgTx, t.prevOutFetcher))
+}
+
 func (t *Transaction) AddInput(txId string, index int64, address string, value int64) error {
 	outPoint, err := outPoint(txId, uint32(index))
 	if err != nil {
 		return err
 	}
-	pkScript, err := addrToPkScript(address, t.netParams)
+	pkScript, err := addressToPkScript(address, t.netParams)
 	if err != nil {
 		return err
 	}
-	input := input{
-		outPoint: outPoint,
-		prevOut:  wire.NewTxOut(value, pkScript),
-	}
-	t.inputs = append(t.inputs, input)
+	txIn := wire.NewTxIn(outPoint, nil, nil)
+	prevOut := wire.NewTxOut(value, pkScript)
+	t.msgTx.TxIn = append(t.msgTx.TxIn, txIn)
+	t.prevOutFetcher.AddPrevOut(*outPoint, prevOut)
 	return nil
 }
 
@@ -80,11 +83,9 @@ func (t *Transaction) AddInput2(txId string, index int64, prevTx string) error {
 	if err != nil {
 		return err
 	}
-	input := input{
-		outPoint: outPoint,
-		prevOut:  prevOut,
-	}
-	t.inputs = append(t.inputs, input)
+	txIn := wire.NewTxIn(outPoint, nil, nil)
+	t.msgTx.TxIn = append(t.msgTx.TxIn, txIn)
+	t.prevOutFetcher.AddPrevOut(*outPoint, prevOut)
 	return nil
 }
 
@@ -93,12 +94,12 @@ func (t *Transaction) AddOutput(address string, value int64) error {
 	if value == 0 {
 		return t.AddOpReturn(address)
 	}
-	pkScript, err := addrToPkScript(address, t.netParams)
+	pkScript, err := addressToPkScript(address, t.netParams)
 	if err != nil {
 		return err
 	}
 	output := wire.NewTxOut(value, pkScript)
-	t.outputs = append(t.outputs, output)
+	t.msgTx.TxOut = append(t.msgTx.TxOut, output)
 	return nil
 }
 
@@ -109,7 +110,7 @@ func (t *Transaction) AddOpReturn(opReturn string) error {
 		return err
 	}
 	output := wire.NewTxOut(0, script)
-	t.outputs = append(t.outputs, output)
+	t.msgTx.TxOut = append(t.msgTx.TxOut, output)
 	return nil
 }
 
@@ -139,7 +140,7 @@ func prevTxOut(preTx string, index uint32) (*wire.TxOut, error) {
 	}
 }
 
-func addrToPkScript(addr string, network *chaincfg.Params) ([]byte, error) {
+func addressToPkScript(addr string, network *chaincfg.Params) ([]byte, error) {
 	address, err := btcutil.DecodeAddress(addr, network)
 	if err != nil {
 		return nil, err

core/btc/transaction_build_test.go

@@ -12,7 +12,7 @@ func TestTransaction_AddOpReturn(t *testing.T) {
 	require.NoError(t, err)
 	err = txn.AddOpReturn("ComingChat")
 	require.NoError(t, err)
-	require.Equal(t, hex.EncodeToString(txn.outputs[0].PkScript), "6a0a436f6d696e6743686174")
+	require.Equal(t, hex.EncodeToString(txn.msgTx.TxOut[0].PkScript), "6a0a436f6d696e6743686174")
 
 	err = txn.AddOpReturn("len75hellohellohellohellohellohellohellohellohellohellohellohellohellohello")
 	require.NoError(t, err)

core/btc/transaction_decode.go

@@ -5,6 +5,7 @@ import (
 	"strconv"
 
 	"github.com/btcsuite/btcd/blockchain"
+	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/btcutil"
 	"github.com/btcsuite/btcd/chaincfg"
 	"github.com/btcsuite/btcd/txscript"
@@ -93,7 +94,8 @@ func DecodePsbtTransactionDetail(psbtHex string, chainnet string) (d *Transactio
 		return
 	}
 	feeFloat := txFee.ToUnit(btcutil.AmountSatoshi)
-	vSize := virtualSize(packet.UnsignedTx)
+	copyedTx := packet.UnsignedTx.Copy()
+	vSize := virtualSize(ensureSignOrFakeSign(copyedTx, nil))
 	feeRate := feeFloat / float64(vSize)
 
 	inputs := make([]*TxOut, len(packet.Inputs))
@@ -205,3 +207,27 @@ func virtualSize(tx *wire.MsgTx) int64 {
 	weight := (baseSize * (blockchain.WitnessScaleFactor - 1)) + totalSize
 	return (weight + blockchain.WitnessScaleFactor - 1) / blockchain.WitnessScaleFactor
 }
+
+var _fakePrivatekey *btcec.PrivateKey
+
+func ensureSignOrFakeSign(tx *wire.MsgTx, fetcher txscript.PrevOutputFetcher) *wire.MsgTx {
+	if len(tx.TxIn) == 0 || len(tx.TxOut) == 0 {
+		return tx // cannot sign
+	}
+	if len(tx.TxIn[0].SignatureScript) != 0 || len(tx.TxIn[0].Witness) != 0 {
+		return tx // no need sign
+	}
+
+	var err error
+	if _fakePrivatekey == nil {
+		if _fakePrivatekey, err = btcec.NewPrivateKey(); err != nil {
+			return tx // sign failed
+		}
+	}
+	if fetcher == nil {
+		fetcher = txscript.NewCannedPrevOutputFetcher(tx.TxOut[0].PkScript, 100000000)
+	}
+	// fake sign
+	_ = Sign(tx, _fakePrivatekey, fetcher, false)
+	return tx
+}

core/btc/transaction_sign.go

@@ -26,34 +26,20 @@ func (t *Transaction) SignWithAccount(account base.Account) (signedTxn *base.Opt
 }
 
 func (t *Transaction) SignedTransactionWithAccount(account base.Account) (signedTxn base.SignedTransaction, err error) {
-	if len(t.inputs) == 0 || len(t.outputs) == 0 {
-		return nil, errors.New("invalid inputs or outputs")
-	}
-
 	btcAcc, ok := account.(*Account)
 	if !ok {
 		return nil, base.ErrInvalidAccountType
 	}
 
-	tx := wire.NewMsgTx(wire.TxVersion)
-	prevOutFetcher := txscript.NewMultiPrevOutFetcher(nil)
-	for _, input := range t.inputs {
-		txIn := wire.NewTxIn(input.outPoint, nil, nil)
-		tx.TxIn = append(tx.TxIn, txIn)
-		prevOutFetcher.AddPrevOut(*input.outPoint, input.prevOut)
-	}
-	for _, output := range t.outputs {
-		tx.TxOut = append(tx.TxOut, output)
-	}
-
+	copyedTx := t.msgTx.Copy()
 	privateKey := btcAcc.privateKey
 	isComing := btcAcc.addressType == AddressTypeComingTaproot
-	err = Sign(tx, privateKey, prevOutFetcher, isComing)
+	err = Sign(copyedTx, privateKey, t.prevOutFetcher, isComing)
 	if err != nil {
 		return nil, err
 	}
 	return &SignedTransaction{
-		msgTx: tx,
+		msgTx: copyedTx,
 	}, nil
 }
 
@@ -66,7 +52,10 @@ func (t *SignedTransaction) HexString() (res *base.OptionalString, err error) {
 	return base.NewOptionalString(str), nil
 }
 
-func Sign(tx *wire.MsgTx, privKey *btcec.PrivateKey, prevOutFetcher *txscript.MultiPrevOutFetcher, isComing bool) error {
+func Sign(tx *wire.MsgTx, privKey *btcec.PrivateKey, prevOutFetcher txscript.PrevOutputFetcher, isComing bool) error {
+	if len(tx.TxIn) == 0 || len(tx.TxOut) == 0 {
+		return errors.New("invalid inputs or outputs")
+	}
 	for i, in := range tx.TxIn {
 		prevOut := prevOutFetcher.FetchPrevOutput(in.PreviousOutPoint)
 		txSigHashes := txscript.NewTxSigHashes(tx, prevOutFetcher)