Merge pull request #53 from gaze-network/develop

Release v0.4.2

common/bitcoin.go

@@ -1,4 +0,0 @@
-package common
-
-// HalvingInterval is the number of blocks between each halving event.
-const HalvingInterval = 210_000

common/network.go

@@ -1,6 +1,9 @@
 package common
 
-import "github.com/btcsuite/btcd/chaincfg"
+import (
+	"github.com/btcsuite/btcd/chaincfg"
+	"github.com/gaze-network/indexer-network/pkg/logger"
+)
 
 type Network string
 
@@ -37,3 +40,15 @@ func (n Network) ChainParams() *chaincfg.Params {
 func (n Network) String() string {
 	return string(n)
 }
+
+func (n Network) HalvingInterval() uint64 {
+	switch n {
+	case NetworkMainnet, NetworkTestnet:
+		return 210_000
+	case NetworkFractalMainnet, NetworkFractalTestnet:
+		return 2_100_000
+	default:
+		logger.Panic("invalid network")
+		return 0
+	}
+}

modules/runes/constants/constants.go

@@ -1,10 +1,13 @@
 package constants
 
 import (
+	"fmt"
+
 	"github.com/Cleverse/go-utilities/utils"
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/gaze-network/indexer-network/common"
 	"github.com/gaze-network/indexer-network/core/types"
+	"github.com/gaze-network/indexer-network/pkg/logger"
 )
 
 const (
@@ -15,13 +18,31 @@ const (
 
 var StartingBlockHeader = map[common.Network]types.BlockHeader{
 	common.NetworkMainnet: {
-		Height:    839999,
-		Hash:      *utils.Must(chainhash.NewHashFromStr("0000000000000000000172014ba58d66455762add0512355ad651207918494ab")),
-		PrevBlock: *utils.Must(chainhash.NewHashFromStr("00000000000000000001dcce6ce7c8a45872cafd1fb04732b447a14a91832591")),
+		Height: 839999,
+		Hash:   *utils.Must(chainhash.NewHashFromStr("0000000000000000000172014ba58d66455762add0512355ad651207918494ab")),
 	},
 	common.NetworkTestnet: {
-		Height:    2583200,
-		Hash:      *utils.Must(chainhash.NewHashFromStr("000000000006c5f0dfcd9e0e81f27f97a87aef82087ffe69cd3c390325bb6541")),
-		PrevBlock: *utils.Must(chainhash.NewHashFromStr("00000000000668f3bafac992f53424774515440cb47e1cb9e73af3f496139e28")),
+		Height: 2519999,
+		Hash:   *utils.Must(chainhash.NewHashFromStr("000000000006f45c16402f05d9075db49d3571cf5273cf4cbeaa2aa295f7c833")),
+	},
+	common.NetworkFractalMainnet: {
+		Height: 83999,
+		Hash:   *utils.Must(chainhash.NewHashFromStr("0000000000000000000000000000000000000000000000000000000000000000")), // TODO: Update this to match real hash
+	},
+	common.NetworkFractalTestnet: {
+		Height: 83999,
+		Hash:   *utils.Must(chainhash.NewHashFromStr("00000000000000613ddfbdd1778b17cea3818febcbbf82762eafaa9461038343")),
 	},
 }
+
+func NetworkHasGenesisRune(network common.Network) bool {
+	switch network {
+	case common.NetworkMainnet, common.NetworkFractalMainnet, common.NetworkFractalTestnet:
+		return true
+	case common.NetworkTestnet:
+		return false
+	default:
+		logger.Panic(fmt.Sprintf("unsupported network: %s", network))
+		return false
+	}
+}

modules/runes/processor.go

@@ -69,8 +69,8 @@ func (p *Processor) VerifyStates(ctx context.Context) error {
 	if err := p.ensureValidState(ctx); err != nil {
 		return errors.Wrap(err, "error during ensureValidState")
 	}
-	if p.network == common.NetworkMainnet {
-		if err := p.ensureGenesisRune(ctx); err != nil {
+	if constants.NetworkHasGenesisRune(p.network) {
+		if err := p.ensureGenesisRune(ctx, p.network); err != nil {
 			return errors.Wrap(err, "error during ensureGenesisRune")
 		}
 	}
@@ -122,7 +122,7 @@ func (p *Processor) ensureValidState(ctx context.Context) error {
 
 var genesisRuneId = runes.RuneId{BlockHeight: 1, TxIndex: 0}
 
-func (p *Processor) ensureGenesisRune(ctx context.Context) error {
+func (p *Processor) ensureGenesisRune(ctx context.Context, network common.Network) error {
 	_, err := p.runesDg.GetRuneEntryByRuneId(ctx, genesisRuneId)
 	if err != nil && !errors.Is(err, errs.NotFound) {
 		return errors.Wrap(err, "failed to get genesis rune entry")
@@ -138,8 +138,8 @@ func (p *Processor) ensureGenesisRune(ctx context.Context) error {
 			Terms: &runes.Terms{
 				Amount:      lo.ToPtr(uint128.From64(1)),
 				Cap:         &uint128.Max,
-				HeightStart: lo.ToPtr(uint64(common.HalvingInterval * 4)),
-				HeightEnd:   lo.ToPtr(uint64(common.HalvingInterval * 5)),
+				HeightStart: lo.ToPtr(network.HalvingInterval() * 4),
+				HeightEnd:   lo.ToPtr(network.HalvingInterval() * 5),
 				OffsetStart: nil,
 				OffsetEnd:   nil,
 			},

modules/runes/runes/flag.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/cockroachdb/errors"
 	"github.com/gaze-network/indexer-network/common/errs"
+	"github.com/gaze-network/indexer-network/pkg/logger"
 	"github.com/gaze-network/uint128"
 )
 
@@ -58,7 +59,8 @@ func ParseFlags(input interface{}) (Flags, error) {
 		}
 		return Flags(u128), nil
 	default:
-		panic("invalid flags input type")
+		logger.Panic("invalid flags input type")
+		return Flags{}, nil
 	}
 }
 

modules/runes/runes/rune.go

@@ -1,11 +1,13 @@
 package runes
 
 import (
+	"fmt"
 	"slices"
 
 	"github.com/Cleverse/go-utilities/utils"
 	"github.com/cockroachdb/errors"
 	"github.com/gaze-network/indexer-network/common"
+	"github.com/gaze-network/indexer-network/pkg/logger"
 	"github.com/gaze-network/uint128"
 )
 
@@ -119,24 +121,25 @@ func (r Rune) Cmp(other Rune) int {
 func FirstRuneHeight(network common.Network) uint64 {
 	switch network {
 	case common.NetworkMainnet:
-		return common.HalvingInterval * 4
+		return 840_000
 	case common.NetworkTestnet:
-		return common.HalvingInterval * 12
+		return 2_520_000
 	case common.NetworkFractalMainnet:
-		return 84000
+		return 84_000
 	case common.NetworkFractalTestnet:
-		return 84000
+		return 84_000
 	}
-	panic("invalid network")
+	logger.Panic(fmt.Sprintf("invalid network: %s", network))
+	return 0
 }
 
 func MinimumRuneAtHeight(network common.Network, height uint64) Rune {
 	offset := height + 1
-	interval := common.HalvingInterval / 12
+	interval := network.HalvingInterval() / 12
 
 	// runes are gradually unlocked from rune activation height until the next halving
 	start := FirstRuneHeight(network)
-	end := start + common.HalvingInterval
+	end := start + network.HalvingInterval()
 
 	if offset < start {
 		return (Rune)(unlockSteps[12])

modules/runes/runes/rune_test.go

@@ -92,8 +92,8 @@ func TestMinimumRuneAtHeightMainnet(t *testing.T) {
 	}
 
 	start := FirstRuneHeight(common.NetworkMainnet)
-	end := start + common.HalvingInterval
-	interval := uint64(common.HalvingInterval / 12)
+	end := start + common.NetworkMainnet.HalvingInterval()
+	interval := uint64(common.NetworkMainnet.HalvingInterval() / 12)
 
 	test(0, "AAAAAAAAAAAAA")
 	test(start/2, "AAAAAAAAAAAAA")

modules/runes/runes/tag.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/cockroachdb/errors"
 	"github.com/gaze-network/indexer-network/common/errs"
+	"github.com/gaze-network/indexer-network/pkg/logger"
 	"github.com/gaze-network/uint128"
 )
 
@@ -102,6 +103,7 @@ func ParseTag(input interface{}) (Tag, error) {
 		}
 		return Tag(u128), nil
 	default:
-		panic("invalid tag input type")
+		logger.Panic("invalid tag input type")
+		return Tag{}, nil
 	}
 }

pkg/btcutils/address.go

@@ -150,6 +150,18 @@ func (a Address) Equal(b Address) bool {
 	return a.encoded == b.encoded
 }
 
+// DustLimit returns the output dust limit (lowest possible satoshis in a UTXO) for the address type.
+func (a Address) DustLimit() int64 {
+	switch a.encodedType {
+	case AddressP2TR:
+		return 330
+	case AddressP2WPKH:
+		return 294
+	default:
+		return 546
+	}
+}
+
 // MarshalText implements the encoding.TextMarshaler interface.
 func (a Address) MarshalText() ([]byte, error) {
 	return []byte(a.encoded), nil

pkg/btcutils/address_test.go

@@ -447,3 +447,72 @@ func TestAddressPkScript(t *testing.T) {
 		})
 	}
 }
+
+func TestAddressDustLimit(t *testing.T) {
+	type Spec struct {
+		Address           string
+		DefaultNet        *chaincfg.Params
+		ExpectedDustLimit int64
+	}
+
+	specs := []Spec{
+		{
+			Address:           "bc1qfpgdxtpl7kz5qdus2pmexyjaza99c28q8uyczh",
+			DefaultNet:        &chaincfg.MainNetParams,
+			ExpectedDustLimit: 294,
+		},
+		{
+			Address:           "tb1qfpgdxtpl7kz5qdus2pmexyjaza99c28qd6ltey",
+			DefaultNet:        &chaincfg.MainNetParams,
+			ExpectedDustLimit: 294,
+		},
+		{
+			Address:           "bc1p7h87kqsmpzatddzhdhuy9gmxdpvn5kvar6hhqlgau8d2ffa0pa3qvz5d38",
+			DefaultNet:        &chaincfg.MainNetParams,
+			ExpectedDustLimit: 330,
+		},
+		{
+			Address:           "tb1p7h87kqsmpzatddzhdhuy9gmxdpvn5kvar6hhqlgau8d2ffa0pa3qm2zztg",
+			DefaultNet:        &chaincfg.MainNetParams,
+			ExpectedDustLimit: 330,
+		},
+		{
+			Address:           "3Ccte7SJz71tcssLPZy3TdWz5DTPeNRbPw",
+			DefaultNet:        &chaincfg.MainNetParams,
+			ExpectedDustLimit: 546,
+		},
+		{
+			Address:           "1KrRZSShVkdc8J71CtY4wdw46Rx3BRLKyH",
+			DefaultNet:        &chaincfg.MainNetParams,
+			ExpectedDustLimit: 546,
+		},
+		{
+			Address:           "bc1qeklep85ntjz4605drds6aww9u0qr46qzrv5xswd35uhjuj8ahfcqgf6hak",
+			DefaultNet:        &chaincfg.MainNetParams,
+			ExpectedDustLimit: 546,
+		},
+		{
+			Address:           "migbBPcDajPfffrhoLpYFTQNXQFbWbhpz3",
+			DefaultNet:        &chaincfg.TestNet3Params,
+			ExpectedDustLimit: 546,
+		},
+		{
+			Address:           "tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3q0sl5k7",
+			DefaultNet:        &chaincfg.MainNetParams,
+			ExpectedDustLimit: 546,
+		},
+		{
+			Address:           "2NCxMvHPTduZcCuUeAiWUpuwHga7Y66y9XJ",
+			DefaultNet:        &chaincfg.TestNet3Params,
+			ExpectedDustLimit: 546,
+		},
+	}
+
+	for _, spec := range specs {
+		t.Run(spec.Address, func(t *testing.T) {
+			addr, err := btcutils.SafeNewAddress(spec.Address, spec.DefaultNet)
+			require.NoError(t, err)
+			assert.Equal(t, spec.ExpectedDustLimit, addr.DustLimit())
+		})
+	}
+}

pkg/btcutils/fee.go

@@ -0,0 +1,56 @@
+package btcutils
+
+import (
+	"github.com/btcsuite/btcd/blockchain"
+	"github.com/btcsuite/btcd/btcec/v2"
+	"github.com/btcsuite/btcd/btcutil"
+	"github.com/btcsuite/btcd/wire"
+	"github.com/cockroachdb/errors"
+	"github.com/gaze-network/indexer-network/common/errs"
+)
+
+// EstimateSignedTxNetworkFee estimates the network fee for the given transaction. "prevTxOuts" should be list of all outputs used as inputs in the transaction.
+// If the transaction has unsigned inputs, the fee will be calculated as if those inputs were signed.
+func EstimateSignedTxNetworkFee(tx *wire.MsgTx, prevTxOuts []*wire.TxOut, feeRate int64) (int64, error) {
+	if len(tx.TxIn) != len(prevTxOuts) {
+		return 0, errors.Wrapf(errs.InvalidArgument, "tx.TxIn length (%d) must match prevTxOuts length (%d)", len(tx.TxIn), len(prevTxOuts))
+	}
+	tx = tx.Copy()
+	mockPrivateKey, _ := btcec.NewPrivateKey()
+	for i := range tx.TxIn {
+		if len(tx.TxIn[i].SignatureScript) > 0 || (len(tx.TxIn[i].Witness) > 0 && len(tx.TxIn[i].Witness[0]) > 0) {
+			// already signed, skip
+			continue
+		}
+		address, err := ExtractAddressFromPkScript(prevTxOuts[i].PkScript)
+		if err != nil {
+			return 0, errors.Wrapf(err, "failed to extract address from pkScript %d", i)
+		}
+		// if the input is a taproot script-path spend, we need to sign it with the tapscript
+		if address.Type() == AddressTaproot && len(tx.TxIn[i].Witness) == 3 {
+			tx, err = SignTxInputTapScript(tx, mockPrivateKey, prevTxOuts[i], i)
+			if err != nil {
+				return 0, errors.Wrapf(err, "failed to sign tx input %d (tapscript)", i)
+			}
+		} else {
+			tx, err = SignTxInput(tx, mockPrivateKey, prevTxOuts[i], i)
+			if err != nil {
+				return 0, errors.Wrapf(err, "failed to sign tx input %d", i)
+			}
+		}
+	}
+	txWeight := blockchain.GetTransactionWeight(btcutil.NewTx(tx))
+	txVBytes := calVBytes(txWeight)
+
+	fee := txVBytes * feeRate
+	return fee, nil
+}
+
+func calVBytes(txWeight int64) int64 {
+	// VBytes = txWeight/4, a fraction of Vbyte uses 1 Vbyte.
+	txVBytes := txWeight / 4
+	if txWeight%4 > 0 {
+		txVBytes += 1
+	}
+	return txVBytes
+}

pkg/btcutils/signature.go

@@ -3,8 +3,12 @@ package btcutils
 import (
 	"github.com/Cleverse/go-utilities/utils"
 	verifier "github.com/bitonicnl/verify-signed-message/pkg"
+	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/chaincfg"
+	"github.com/btcsuite/btcd/txscript"
+	"github.com/btcsuite/btcd/wire"
 	"github.com/cockroachdb/errors"
+	"github.com/gaze-network/indexer-network/common/errs"
 )
 
 func VerifySignature(address string, message string, sigBase64 string, defaultNet ...*chaincfg.Params) error {
@@ -19,3 +23,121 @@ func VerifySignature(address string, message string, sigBase64 string, defaultNe
 	}
 	return nil
 }
+
+func SignTxInput(tx *wire.MsgTx, privateKey *btcec.PrivateKey, prevTxOut *wire.TxOut, inputIndex int) (*wire.MsgTx, error) {
+	if privateKey == nil {
+		return nil, errors.Wrap(errs.InvalidArgument, "PrivateKey is required")
+	}
+	if tx == nil {
+		return nil, errors.Wrap(errs.InvalidArgument, "Tx is required")
+	}
+	if prevTxOut == nil {
+		return nil, errors.Wrap(errs.InvalidArgument, "PrevTxOut is required")
+	}
+
+	prevOutFetcher := txscript.NewCannedPrevOutputFetcher(prevTxOut.PkScript, prevTxOut.Value)
+	sigHashes := txscript.NewTxSigHashes(tx, prevOutFetcher)
+	if len(tx.TxIn) <= inputIndex {
+		return nil, errors.Errorf("input to sign (%d) is out of range", inputIndex)
+	}
+	address, err := ExtractAddressFromPkScript(prevTxOut.PkScript)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to extract address")
+	}
+
+	switch address.Type() {
+	case AddressP2TR:
+		witness, err := txscript.TaprootWitnessSignature(
+			tx,
+			sigHashes,
+			inputIndex,
+			prevTxOut.Value,
+			prevTxOut.PkScript,
+			txscript.SigHashAll|txscript.SigHashAnyOneCanPay,
+			privateKey)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to sign")
+		}
+		tx.TxIn[inputIndex].Witness = witness
+	case AddressP2WPKH:
+		witness, err := txscript.WitnessSignature(
+			tx,
+			sigHashes,
+			inputIndex,
+			prevTxOut.Value,
+			prevTxOut.PkScript,
+			txscript.SigHashAll|txscript.SigHashAnyOneCanPay,
+			privateKey,
+			true,
+		)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to sign")
+		}
+		tx.TxIn[inputIndex].Witness = witness
+	case AddressP2PKH:
+		sigScript, err := txscript.SignatureScript(
+			tx,
+			inputIndex,
+			prevTxOut.PkScript,
+			txscript.SigHashAll|txscript.SigHashAnyOneCanPay,
+			privateKey,
+			true,
+		)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to sign")
+		}
+		tx.TxIn[inputIndex].SignatureScript = sigScript
+	default:
+		return nil, errors.Wrapf(errs.NotSupported, "unsupported input address type %s", address.Type())
+	}
+
+	return tx, nil
+}
+
+func SignTxInputTapScript(tx *wire.MsgTx, privateKey *btcec.PrivateKey, prevTxOut *wire.TxOut, inputIndex int) (*wire.MsgTx, error) {
+	if privateKey == nil {
+		return nil, errors.Wrap(errs.InvalidArgument, "PrivateKey is required")
+	}
+	if tx == nil {
+		return nil, errors.Wrap(errs.InvalidArgument, "Tx is required")
+	}
+	if prevTxOut == nil {
+		return nil, errors.Wrap(errs.InvalidArgument, "PrevTxOut is required")
+	}
+
+	prevOutFetcher := txscript.NewCannedPrevOutputFetcher(prevTxOut.PkScript, prevTxOut.Value)
+	sigHashes := txscript.NewTxSigHashes(tx, prevOutFetcher)
+	if len(tx.TxIn) <= inputIndex {
+		return nil, errors.Errorf("input to sign (%d) is out of range", inputIndex)
+	}
+	address, err := ExtractAddressFromPkScript(prevTxOut.PkScript)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to extract address")
+	}
+
+	if address.Type() != AddressTaproot {
+		return nil, errors.Errorf("input type must be %s", AddressTaproot)
+	}
+
+	witness := tx.TxIn[inputIndex].Witness
+	if len(witness) != 3 {
+		return nil, errors.Wrapf(errs.InvalidArgument, "invalid witness length: expected 3, got %d", len(witness))
+	}
+
+	tapLeaf := txscript.NewBaseTapLeaf(witness[1])
+	signature, err := txscript.RawTxInTapscriptSignature(
+		tx,
+		sigHashes,
+		inputIndex,
+		prevTxOut.Value,
+		prevTxOut.PkScript,
+		tapLeaf,
+		txscript.SigHashAll|txscript.SigHashAnyOneCanPay,
+		privateKey)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to sign")
+	}
+	tx.TxIn[inputIndex].Witness[0] = signature
+
+	return tx, nil
+}

pkg/btcutils/signature_test.go

@@ -3,8 +3,14 @@ package btcutils
 import (
 	"testing"
 
+	"github.com/btcsuite/btcd/btcec/v2"
+	"github.com/btcsuite/btcd/btcec/v2/schnorr"
+	"github.com/btcsuite/btcd/btcutil"
 	"github.com/btcsuite/btcd/chaincfg"
+	"github.com/btcsuite/btcd/txscript"
+	"github.com/btcsuite/btcd/wire"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestVerifySignature(t *testing.T) {
@@ -67,3 +73,115 @@ func TestVerifySignature(t *testing.T) {
 		assert.Error(t, err)
 	}
 }
+
+func TestSignTxInput(t *testing.T) {
+	generateTxAndPrevTxOutFromPkScript := func(pkScript []byte) (*wire.MsgTx, *wire.TxOut) {
+		tx := wire.NewMsgTx(wire.TxVersion)
+		tx.AddTxIn(&wire.TxIn{
+			PreviousOutPoint: wire.OutPoint{
+				Index: 1,
+			},
+		})
+		txOut := &wire.TxOut{
+			Value: 1e8, PkScript: pkScript,
+		}
+		tx.AddTxOut(txOut)
+		// using same value and pkScript as input for simplicity
+		return tx, txOut
+	}
+	verifySignedTx := func(t *testing.T, signedTx *wire.MsgTx, prevTxOut *wire.TxOut) {
+		t.Helper()
+
+		prevOutFetcher := txscript.NewCannedPrevOutputFetcher(prevTxOut.PkScript, prevTxOut.Value)
+		sigHashes := txscript.NewTxSigHashes(signedTx, prevOutFetcher)
+		vm, err := txscript.NewEngine(
+			prevTxOut.PkScript, signedTx, 0, txscript.StandardVerifyFlags,
+			nil, sigHashes, prevTxOut.Value, prevOutFetcher,
+		)
+		require.NoError(t, err)
+		require.NoError(t, vm.Execute(), "error during signature verification") // no error means success
+	}
+
+	privKey, _ := btcec.NewPrivateKey()
+	t.Run("P2TR input", func(t *testing.T) {
+		taprootKey := txscript.ComputeTaprootKeyNoScript(privKey.PubKey())
+
+		pkScript, err := txscript.PayToTaprootScript(taprootKey)
+		require.NoError(t, err)
+
+		tx, prevTxOut := generateTxAndPrevTxOutFromPkScript(pkScript)
+		signedTx, err := SignTxInput(
+			tx, privKey, prevTxOut, 0,
+		)
+		require.NoError(t, err)
+		verifySignedTx(t, signedTx, prevTxOut)
+	})
+	t.Run("tapscript input", func(t *testing.T) {
+		internalKey := privKey.PubKey()
+
+		// Our script will be a simple OP_CHECKSIG as the sole leaf of a
+		// tapscript tree.
+		builder := txscript.NewScriptBuilder()
+		builder.AddData(schnorr.SerializePubKey(internalKey))
+		builder.AddOp(txscript.OP_CHECKSIG)
+		tapScript, err := builder.Script()
+		require.NoError(t, err)
+
+		tapLeaf := txscript.NewBaseTapLeaf(tapScript)
+		tapScriptTree := txscript.AssembleTaprootScriptTree(tapLeaf)
+
+		controlBlock := tapScriptTree.LeafMerkleProofs[0].ToControlBlock(
+			internalKey,
+		)
+		controlBlockBytes, err := controlBlock.ToBytes()
+		require.NoError(t, err)
+
+		tapScriptRootHash := tapScriptTree.RootNode.TapHash()
+		outputKey := txscript.ComputeTaprootOutputKey(
+			internalKey, tapScriptRootHash[:],
+		)
+		p2trScript, err := txscript.PayToTaprootScript(outputKey)
+		require.NoError(t, err)
+
+		tx, prevTxOut := generateTxAndPrevTxOutFromPkScript(p2trScript)
+		tx.TxIn[0].Witness = wire.TxWitness{
+			{},
+			tapScript,
+			controlBlockBytes,
+		}
+		signedTx, err := SignTxInputTapScript(
+			tx, privKey, prevTxOut, 0,
+		)
+		require.NoError(t, err)
+		verifySignedTx(t, signedTx, prevTxOut)
+	})
+	t.Run("P2WPKH input", func(t *testing.T) {
+		pubKey := privKey.PubKey()
+		pubKeyHash := btcutil.Hash160(pubKey.SerializeCompressed())
+
+		pkScript, err := txscript.NewScriptBuilder().
+			AddOp(txscript.OP_0).
+			AddData(pubKeyHash).
+			Script()
+
+		tx, prevTxOut := generateTxAndPrevTxOutFromPkScript(pkScript)
+		signedTx, err := SignTxInput(
+			tx, privKey, prevTxOut, 0,
+		)
+		require.NoError(t, err)
+		verifySignedTx(t, signedTx, prevTxOut)
+	})
+	t.Run("P2PKH input", func(t *testing.T) {
+		pubKey := privKey.PubKey()
+		pubKeyHash := btcutil.Hash160(pubKey.SerializeCompressed())
+		address, err := btcutil.NewAddressPubKeyHash(pubKeyHash, &chaincfg.MainNetParams)
+		pkScript, err := txscript.PayToAddrScript(address)
+
+		tx, prevTxOut := generateTxAndPrevTxOutFromPkScript(pkScript)
+		signedTx, err := SignTxInput(
+			tx, privKey, prevTxOut, 0,
+		)
+		require.NoError(t, err)
+		verifySignedTx(t, signedTx, prevTxOut)
+	})
+}