Hey, need some help

[ramzesisi]

package main

import (
	"bytes"
	"encoding/hex"
	"fmt"
	"log"
	"sort"

	"github.com/btcsuite/btcd/btcutil"
	"github.com/btcsuite/btcd/chaincfg"
	"github.com/btcsuite/btcd/chaincfg/chainhash"
	"github.com/btcsuite/btcd/txscript"
	"github.com/btcsuite/btcd/wire"
)

type UTXOByValue []UTXO

func (a UTXOByValue) Len() int           { return len(a) }
func (a UTXOByValue) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a UTXOByValue) Less(i, j int) bool { return a[i].Value > a[j].Value }

type UTXOFetcher struct {
	UTXOs map[wire.OutPoint]*wire.TxOut
}

// This method needs to exactly match the interface's requirement.
func (f *UTXOFetcher) FetchPrevOutput(outpoint *wire.OutPoint) wire.TxOut {
	if utxo, exists := f.UTXOs[*outpoint]; exists {
		return *utxo
	}
	return wire.TxOut{} // Return an empty TxOut if not found
}

func estimateFee(txSize int, feePerByte int64) int64 {
	//fmt.Printf("TxSize: %d, FeePerByte: %d", txSize, feePerByte)
	return int64(txSize) * feePerByte
}

func transferBtc(privKey, sender, destination string, amount float32, feePerByte int64) []byte {

	sort.Sort(UTXOByValue(UTXOlist))

	params := &chaincfg.TestNet3Params

	tx := wire.NewMsgTx(2)
	wif, err := btcutil.DecodeWIF(privKey)
	if err != nil {
		log.Fatal(err)
	}
	amountSats := int64(amount * 1e8)
	var totalInput int64

	var usedUTXOs []UTXO

	for _, utxo := range UTXOlist {
		if totalInput >= amountSats {
			break
		}
		totalInput += utxo.Value
		hash, err := chainhash.NewHashFromStr(utxo.Txid)
		if err != nil {
			log.Fatal(err)
		}
		outPoint := wire.NewOutPoint(hash, uint32(utxo.Vout))
		txIn := wire.NewTxIn(outPoint, nil, nil)
		tx.AddTxIn(txIn)
		usedUTXOs = append(usedUTXOs, utxo)
	}

	if totalInput < amountSats {
		log.Fatal("Insufficient funds")
	}

	destinationAddress, err := btcutil.DecodeAddress(destination, params)
	if err != nil {
		log.Fatal(err)
	}
	pkScriptDestination, err := txscript.PayToAddrScript(destinationAddress)
	if err != nil {
		log.Fatal(err)
	}
	tx.AddTxOut(wire.NewTxOut(amountSats, pkScriptDestination))

	senderAddress, err := btcutil.DecodeAddress(sender, params)
	if err != nil {
		log.Fatal(err)
	}
	pkScriptSender, err := txscript.PayToAddrScript(senderAddress)
	if err != nil {
		log.Fatal(err)
	}
	change := totalInput - amountSats - feePerByte*300
	tx.AddTxOut(wire.NewTxOut(change, pkScriptSender))

	prevOuts := make(map[wire.OutPoint]*wire.TxOut)
	for _, utxo := range usedUTXOs {
		hash, err := chainhash.NewHashFromStr(utxo.Txid)
		if err != nil {
			log.Fatal(err)
		}
		outPoint := wire.NewOutPoint(hash, uint32(utxo.Vout))
		prevOut := wire.NewTxOut(utxo.Value, utxo.PkScript)
		prevOuts[*outPoint] = prevOut
	}

	fetcher := txscript.NewMultiPrevOutFetcher(prevOuts)

	txSigHashes := txscript.NewTxSigHashes(tx, fetcher)

	for i, utxo := range usedUTXOs {
		if txscript.IsWitnessProgram(utxo.PkScript) {
			hexString := hex.EncodeToString(utxo.PkScript)

			// Print the hexadecimal string
			fmt.Println(hexString) // Output: 48656c6c6f
			//fmt.Printf("UTXO is being used as witness\n%s\n", utxo.PkScript)
			// For witness transactions, use WitnessSignature
			witness, err := txscript.WitnessSignature(tx, txSigHashes, i, utxo.Value, utxo.PkScript, txscript.SigHashAll, wif.PrivKey, true)
			if err != nil {
				log.Fatal(err)
			}
			tx.TxIn[i].Witness = witness
		} else {
			fmt.Println("UTXO is being used as NONwitness", utxo)
			// For non-witness transactions, use SignatureScript
			signatureScript, err := txscript.SignatureScript(tx, i, utxo.PkScript, txscript.SigHashAll, wif.PrivKey, true)
			if err != nil {
				log.Fatal(err)
			}
			tx.TxIn[i].SignatureScript = signatureScript
		}
	}

	// Set sequence number for RBF if necessary
	// for i := range tx.TxIn {
	//     tx.TxIn[i].Sequence = wire.MaxTxInSequenceNum - 2
	// }

	var buf bytes.Buffer
	tx.Serialize(&buf)
	return buf.Bytes()
}

package main

import (
	"encoding/hex"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
)

type UTXOresponse struct {
	Txid   string `json:"txid"`
	Vout   int    `json:"vout"`
	Status struct {
		Confirmed   bool   `json:"confirmed"`
		BlockHeight int    `json:"block_height"`
		BlockHash   string `json:"block_hash"`
		BlockTime   int    `json:"block_time"`
	} `json:"status"`
	Value int `json:"value"`
}

type TransactionResponse struct {
	Txid     string `json:"txid"`
	Version  int    `json:"version"`
	Locktime int    `json:"locktime"`
	Vin      []struct {
		Txid    string `json:"txid"`
		Vout    int    `json:"vout"`
		Prevout struct {
			Scriptpubkey        string `json:"scriptpubkey"`
			ScriptpubkeyAsm     string `json:"scriptpubkey_asm"`
			ScriptpubkeyType    string `json:"scriptpubkey_type"`
			ScriptpubkeyAddress string `json:"scriptpubkey_address"`
			Value               int64  `json:"value"`
		} `json:"prevout"`
		Scriptsig    string   `json:"scriptsig"`
		ScriptsigAsm string   `json:"scriptsig_asm"`
		Witness      []string `json:"witness"`
		IsCoinbase   bool     `json:"is_coinbase"`
		Sequence     int64    `json:"sequence"`
	} `json:"vin"`
	Vout []struct {
		Scriptpubkey        string `json:"scriptpubkey"`
		ScriptpubkeyAsm     string `json:"scriptpubkey_asm"`
		ScriptpubkeyType    string `json:"scriptpubkey_type"`
		ScriptpubkeyAddress string `json:"scriptpubkey_address"`
		Value               int64  `json:"value"`
	} `json:"vout"`
	Size   int `json:"size"`
	Weight int `json:"weight"`
	Sigops int `json:"sigops"`
	Fee    int `json:"fee"`
	Status struct {
		Confirmed   bool   `json:"confirmed"`
		BlockHeight int    `json:"block_height"`
		BlockHash   string `json:"block_hash"`
		BlockTime   int    `json:"block_time"`
	} `json:"status"`
}

type UTXO struct {
	Txid     string
	Vout     int
	Value    int64
	PkScript []byte // Adding PkScript field
}

var (
	UTXOlist []UTXO
)

func UTXOrequest() {
	client := &http.Client{}
	req, _ := http.NewRequest("GET", "https://mempool.space/testnet/api/address/tb1p9w23qkjd8yk8hhuakt2sg46cptxaqpyfllg0k7jad3gpr4fr4uzqy4a08h/utxo", nil)
	resp, _ := client.Do(req)
	defer resp.Body.Close()
	bodyText, _ := io.ReadAll(resp.Body)

	var utxoResponses []UTXOresponse
	json.Unmarshal(bodyText, &utxoResponses)

	for _, utxoResp := range utxoResponses {
		transaction := GetTxRequest(utxoResp.Txid)
		pkScriptHex := transaction.Vout[utxoResp.Vout].Scriptpubkey
		pkScript, err := hex.DecodeString(pkScriptHex)
		if err != nil {
			log.Fatal(err)
		}
		UTXOlist = append(UTXOlist, UTXO{
			Txid:     utxoResp.Txid,
			Vout:     utxoResp.Vout,
			Value:    int64(utxoResp.Value),
			PkScript: pkScript,
		})
	}
}

func GetTxRequest(txHash string) TransactionResponse {
	client := &http.Client{}
	url := fmt.Sprintf("https://mempool.space/testnet/api/tx/%s", txHash)
	req, _ := http.NewRequest("GET", url, nil)
	resp, _ := client.Do(req)
	defer resp.Body.Close()
	bodyText, _ := io.ReadAll(resp.Body)
	//fmt.Printf("%s\n", bodyText)
	var transaction TransactionResponse
	json.Unmarshal(bodyText, &transaction)
	return transaction
}

package main

import (
	"encoding/hex"
	"fmt"
)

func main() {

	UTXOrequest()
	fmt.Println(UTXOlist)
	privKey := "cVSUxyMMqdUVUrre2RT2VZf5tLpL1w9eCqfYsWJnmSdnvv7yFKn7"
	senderAddress := "tb1p9w23qkjd8yk8hhuakt2sg46cptxaqpyfllg0k7jad3gpr4fr4uzqy4a08h"
	destinationAddress := "tb1p9w23qkjd8yk8hhuakt2sg46cptxaqpyfllg0k7jad3gpr4fr4uzqy4a08h"
	btcAmount := 0.0004
	rawSignedTx := transferBtc(privKey, senderAddress, destinationAddress, float32(btcAmount), int64(1))
	signedTxHex := hex.EncodeToString(rawSignedTx)
	fmt.Println(signedTxHex)
}

trying to send small amount from my wallet address to my wallet address trough import signed messagee in electrum (also tried to broadcast trough api) and its not working

Any one know how to fix it? I guess that ill have really stupid error

[ramzesisi]

btw it looks like transaction is will work, but its now working

[guggero]

So you completely changed the whole code and are doing Taproot signing now? Let me know when you're done changing the code so I don't have to look at all versions of it.

[ramzesisi]

It is already done

Im trying to send small amount from taproot to taproot

tried with segwit - got the same problem

changed the whole code - because sent you more information and all my code

[guggero]

Taproot requires different signing methods/functions, see

btcd/txscript/sign.go

Line 70 in f6e8292

func RawTxInTaprootSignature(tx *wire.MsgTx, sigHashes *TxSigHashes, idx int,

.

[ramzesisi]

Hey, did your impovements

got this trouble
i need to get tapScriptRootHash i guess but idk how to generate it from mine inputs/outputs.

[guggero]

#2041