transaction.go

package litecoinWallet

import (
	"bytes"
	"encoding/hex"
	"errors"
	"github.com/ltcsuite/ltcd/btcec/v2"
	"github.com/ltcsuite/ltcd/chaincfg"
	"github.com/ltcsuite/ltcd/chaincfg/chainhash"
	"github.com/ltcsuite/ltcd/ltcutil"
	"github.com/ltcsuite/ltcd/txscript"
	"github.com/ltcsuite/ltcd/wire"
	"github.com/ranjbar-dev/litecoin-wallet/blockDaemon"
	"github.com/ranjbar-dev/litecoin-wallet/blockDaemon/response"
	"github.com/ranjbar-dev/litecoin-wallet/enums"
)

func getAddressUTXO(chain *chaincfg.Params, address string) ([]response.UTXO, error) {

	node := enums.MAIN_NODE
	if &chaincfg.TestNet4Params == chain {
		node = enums.TEST_NODE
	}

	bd := blockDaemon.NewBlockDaemonService(node.Config)

	res, err := bd.AddressUTXO(address)
	if err != nil {
		return nil, err
	}

	return res.Data, nil
}

func prepareUTXOForTransaction(chain *chaincfg.Params, address string, amount int64) ([]response.UTXO, int64, error) {

	records, err := getAddressUTXO(chain, address)
	if err != nil {
		return nil, 0, err
	}

	var final []response.UTXO
	var total int64

	for _, record := range records {

		if total >= amount {
			break
		}

		if record.Mined.Confirmations > 2 {

			final = append(final, record)

			total += int64(record.Value)
		}
	}

	return final, total, nil
}

func createTransactionAndSignTransaction(chain *chaincfg.Params, fromAddress string, privateKey *btcec.PrivateKey, toAddress string, amount int64) (*wire.MsgTx, error) {

	fromAddr, err := ltcutil.DecodeAddress(fromAddress, chain)
	if err != nil {
		return nil, errors.New("DecodeAddress fromAddr err " + err.Error())
	}

	fromAddrScriptByte, err := txscript.PayToAddrScript(fromAddr)

	if err != nil {
		return nil, errors.New("fromAddr PayToAddrScript err " + err.Error())
	}

	toAddr, err := ltcutil.DecodeAddress(toAddress, chain)
	if err != nil {
		return nil, errors.New("DecodeAddress destAddrStr err " + err.Error())
	}

	toAddrByte, err := txscript.PayToAddrScript(toAddr)
	if err != nil {
		return nil, errors.New("toAddr PayToAddrScript err " + err.Error())
	}

	fromAddrByte, err := txscript.PayToAddrScript(fromAddr)
	if err != nil {
		return nil, errors.New("fromAddrByte PayToAddrScript err " + err.Error())
	}

	utxoList, totalAmount, err := prepareUTXOForTransaction(chain, fromAddress, amount)
	if err != nil {
		return nil, errors.New("vin err " + err.Error())
	}
	if totalAmount < amount || len(utxoList) == 0 {
		return nil, errors.New("insufficient balance")
	}

	t, err := createTransactionInputsAndSign(chain, privateKey, utxoList, fromAddrByte, fromAddrScriptByte, toAddrByte, totalAmount, amount)
	if err != nil {
		return nil, errors.New("vin err " + err.Error())
	}

	return t, nil
}

func createTransactionInputsAndSign(chain *chaincfg.Params, privateKey *btcec.PrivateKey, utxos []response.UTXO, fromAddressByte []byte, fromAddressScriptByte []byte, toAddressByte []byte, totalAmount int64, amount int64) (*wire.MsgTx, error) {

	node := enums.MAIN_NODE
	if &chaincfg.TestNet4Params == chain {
		node = enums.TEST_NODE
	}

	bd := blockDaemon.NewBlockDaemonService(node.Config)

	res, err := bd.EstimateFee()
	if err != nil {
		return nil, err
	}

	transaction := wire.NewMsgTx(2)

	// vin
	for _, utxo := range utxos {

		hash, err := chainhash.NewHashFromStr(utxo.Mined.TxId)
		if err != nil {
			return nil, err
		}

		txIn := wire.NewTxIn(wire.NewOutPoint(hash, uint32(utxo.Mined.Index)), nil, [][]byte{})
		txIn.Sequence = txIn.Sequence - 2
		transaction.AddTxIn(txIn)
	}

	// vout
	transaction.AddTxOut(wire.NewTxOut(amount, toAddressByte))

	txSize := transaction.SerializeSize()

	fee := int64(txSize * res.EstimatedFees.Slow)

	changeAmount := totalAmount - amount - fee
	if changeAmount > 0 {
		transaction.AddTxOut(wire.NewTxOut(changeAmount, fromAddressByte))
	}

	transaction.LockTime = 0

	signerMap := make(map[wire.OutPoint]*wire.TxOut)
	for _, in := range transaction.TxIn {
		signerMap[in.PreviousOutPoint] = &wire.TxOut{}
	}
	sigHashes := txscript.NewTxSigHashes(transaction)

	// sign
	for index, utxo := range utxos {

		signature, err := txscript.WitnessSignature(transaction, sigHashes, index, int64(utxo.Value), fromAddressScriptByte, txscript.SigHashAll, privateKey, true)
		if err != nil {
			return nil, errors.New("WitnessSignature err " + err.Error())
		}

		transaction.TxIn[index].Witness = signature
	}

	return transaction, nil
}

func getRawTransaction(tx *wire.MsgTx) (string, error) {

	var signedTx bytes.Buffer

	err := tx.Serialize(&signedTx)
	if err != nil {
		return "", err
	}

	return hex.EncodeToString(signedTx.Bytes()), nil
}

func broadcastHex(chain *chaincfg.Params, hex string) (string, error) {

	node := enums.MAIN_NODE
	if &chaincfg.TestNet4Params == chain {
		node = enums.TEST_NODE
	}

	res, err := blockDaemon.NewBlockDaemonService(node.Config).Broadcast(hex)
	if err != nil {
		return "", err
	}

	return res.Id, nil
}

func createSignAndBroadcastTransaction(chain *chaincfg.Params, privateKey *btcec.PrivateKey, fromAddress string, toAddress string, amount int64) (string, error) {

	// signed tx
	tx, err := createTransactionAndSignTransaction(chain, fromAddress, privateKey, toAddress, amount)
	if err != nil {
		return "", err
	}

	// raw
	raw, err := getRawTransaction(tx)
	if err != nil {
		return "", err
	}

	return broadcastHex(chain, raw)
}