V2.1.0

fix issue #5

Author: mrtnetwork

CHANGELOG.md

@@ -1,7 +1,12 @@
+## 2.1.0
+
+* fix issue [#5](https://github.com/mrtnetwork/bitcoin/issues/5)
+
 ## 2.0.0
- - Updated golang.org/x/crypto to the latest version v0.18.0
- - Resolved issue with Multisignature address
+
+* Updated golang.org/x/crypto to the latest version v0.18.0
+* Resolved issue with Multisignature address
 
 ## 1.0.0
 
-* Release.
+* Release.

README.md

@@ -2,4 +2,4 @@ module github.com/mrtnetwork/bitcoin
 
 go 1.21
 
-require golang.org/x/crypto v0.18.0
+require golang.org/x/crypto v0.22.0

go.mod

@@ -2,3 +2,5 @@ golang.org/x/crypto v0.13.0 h1:mvySKfSWJ+UKUii46M40LOvyWfN0s2U+46/jDd0e6Ck=
 golang.org/x/crypto v0.13.0/go.mod h1:y6Z2r+Rw4iayiXXAIxJIDAJ1zMW4yaTpebo8fPOliYc=
 golang.org/x/crypto v0.18.0 h1:PGVlW0xEltQnzFZ55hkuX5+KLyrMYhHld1YHO4AKcdc=
 golang.org/x/crypto v0.18.0/go.mod h1:R0j02AL6hcrfOiy9T4ZYp/rcWeMxM3L6QYxlOuEG1mg=
+golang.org/x/crypto v0.22.0 h1:g1v0xeRhjcugydODzvb3mEM9SQ0HGp9s/nh3COQ/C30=
+golang.org/x/crypto v0.22.0/go.mod h1:vr6Su+7cTlO45qkww3VDJlzDn0ctJvRgYbC2NvXHt+M=

go.sum

@@ -84,7 +84,7 @@ func (builder *BitcoinTransactionBuilder) HasTaproot() bool {
 // It is used to make the appropriate scriptSig
 func buildInputScriptPubKeys(utxo UtxoWithOwner, isTaproot bool) (*scripts.Script, error) {
 	if utxo.IsMultiSig() {
-		script, e := scripts.ScriptFromRaw(utxo.OwnerDetails.MultiSigAddress.ScriptDetails, true)
+		script, e := scripts.ScriptFromRaw(formating.HexToBytes(utxo.OwnerDetails.MultiSigAddress.ScriptDetails), true)
 		if e != nil {
 			return nil, e
 		}
@@ -205,7 +205,7 @@ func buildP2shSegwitRedeemScriptSig(utx UtxoWithOwner) ([]string, error) {
 	if utx.IsMultiSig() {
 		switch utx.OwnerDetails.MultiSigAddress.Address.GetType() {
 		case address.P2WSHInP2SH:
-			script, e := scripts.ScriptFromRaw(utx.OwnerDetails.MultiSigAddress.ScriptDetails, true)
+			script, e := scripts.ScriptFromRaw(formating.HexToBytes(utx.OwnerDetails.MultiSigAddress.ScriptDetails), true)
 			if e != nil {
 				return nil, e
 			}

provider/transction_builder.go

@@ -52,46 +52,41 @@ func (s *Script) ToP2shScriptPubKey() *Script {
 }
 
 // Imports a Script commands list from raw hexadecimal data
-func ScriptFromRaw(hexData string, hasSegwit bool) (*Script, error) {
+func ScriptFromRaw(scriptBytes []byte, hasSegwit bool) (*Script, error) {
 	var commands []interface{}
 	index := 0
-	scriptraw, err := formating.HexToBytesCatch(hexData)
-	if err != nil {
-		return nil, fmt.Errorf("invalid script bytes")
-	}
-
-	for index < len(scriptraw) {
-		b := int(scriptraw[index])
+	for index < len(scriptBytes) {
+		b := int(scriptBytes[index])
 		if constant.CODE_OPS[b] != "" {
 			commands = append(commands, constant.CODE_OPS[b])
 			index++
 		} else if !hasSegwit && b == 0x4c {
-			bytesToRead := int(scriptraw[index+1])
+			bytesToRead := int(scriptBytes[index+1])
 			index++
-			data := scriptraw[index : index+bytesToRead]
+			data := scriptBytes[index : index+bytesToRead]
 			commands = append(commands, hex.EncodeToString(data))
 			index += bytesToRead
 		} else if !hasSegwit && b == 0x4d {
-			bytesToRead := int(binary.LittleEndian.Uint16(scriptraw[index+1 : index+3]))
+			bytesToRead := int(binary.LittleEndian.Uint16(scriptBytes[index+1 : index+3]))
 			index += 3
-			data := scriptraw[index : index+bytesToRead]
+			data := scriptBytes[index : index+bytesToRead]
 			commands = append(commands, hex.EncodeToString(data))
 			index += bytesToRead
 		} else if !hasSegwit && b == 0x4e {
-			bytesToRead := int(binary.LittleEndian.Uint32(scriptraw[index+1 : index+5]))
+			bytesToRead := int(binary.LittleEndian.Uint32(scriptBytes[index+1 : index+5]))
 			index += 5
-			data := scriptraw[index : index+bytesToRead]
+			data := scriptBytes[index : index+bytesToRead]
 			commands = append(commands, hex.EncodeToString(data))
 			index += bytesToRead
 		} else {
-			vi, size := formating.ViToInt(scriptraw[index:])
+			vi, size := formating.ViToInt(scriptBytes[index:])
 			dataSize := vi
 			// size := size
 			lastIndex := index + size + dataSize
-			if lastIndex > len(scriptraw) {
-				lastIndex = len(scriptraw)
+			if lastIndex > len(scriptBytes) {
+				lastIndex = len(scriptBytes)
 			}
-			commands = append(commands, hex.EncodeToString(scriptraw[index+size:lastIndex]))
+			commands = append(commands, hex.EncodeToString(scriptBytes[index+size:lastIndex]))
 			index += dataSize + size
 		}
 	}
@@ -100,8 +95,9 @@ func ScriptFromRaw(hexData string, hasSegwit bool) (*Script, error) {
 
 // GetScriptType determines the script type based on the provided hash and whether it has
 // SegWit data. It returns the identified ScriptType.
-func GetScriptType(hash string, hasSegwit bool) (ScriptType, error) {
-	s, err := ScriptFromRaw(hash, hasSegwit)
+func GetScriptType(scriptBytes []byte, hasSegwit bool) (ScriptType, error) {
+
+	s, err := ScriptFromRaw(scriptBytes, hasSegwit)
 	if err != nil {
 		return -1, err
 	}

scripts/script.go

@@ -1,10 +1,11 @@
 package scripts
 
 import (
+	"math/big"
+
 	"github.com/mrtnetwork/bitcoin/constant"
 	"github.com/mrtnetwork/bitcoin/digest"
 	"github.com/mrtnetwork/bitcoin/formating"
-	"math/big"
 )
 
 // Define BtcTransaction struct
@@ -95,37 +96,37 @@ func (tx *BtcTransaction) Copy() *BtcTransaction {
 	}
 }
 func BtcTransactionFromRaw(raw string) (*BtcTransaction, error) {
-	rawtx := formating.HexToBytes(raw)
+	txBytes := formating.HexToBytes(raw)
 	cursor := 4
 	var flag []byte
 	hasSegwit := false
 
-	if rawtx[4] == 0 {
-		flag = rawtx[5:6]
+	if txBytes[4] == 0 {
+		flag = txBytes[5:6]
 		if flag[0] == 1 {
 			hasSegwit = true
 		}
 		cursor += 2
 	}
 
-	vi, viCursor := formating.ViToInt(rawtx[cursor:])
+	vi, viCursor := formating.ViToInt(txBytes[cursor:])
 	cursor += viCursor
 
 	inputs := make([]*TxInput, vi)
 	for index := 0; index < len(inputs); index++ {
-		inp, inpCursor, err := TxInputFromRaw(raw, cursor, hasSegwit)
+		inp, inpCursor, err := TxInputFromRaw(txBytes, cursor, hasSegwit)
 		if err != nil {
 			return nil, err
 		}
 		inputs[index] = inp
 		cursor = inpCursor
 	}
-	viOut, viOutCursor := formating.ViToInt(rawtx[cursor:])
+	viOut, viOutCursor := formating.ViToInt(txBytes[cursor:])
 	cursor += viOutCursor
 
 	outputs := make([]*TxOutput, viOut)
 	for index := 0; index < len(outputs); index++ {
-		out, outCursor, err := TxOutputFromRaw(raw, cursor, hasSegwit)
+		out, outCursor, err := TxOutputFromRaw(txBytes, cursor, hasSegwit)
 		if err != nil {
 			return nil, err
 		}
@@ -135,14 +136,14 @@ func BtcTransactionFromRaw(raw string) (*BtcTransaction, error) {
 	witnesses := make([]TxWitnessInput, len(inputs))
 	if hasSegwit {
 		for n := 0; n < len(inputs); n++ {
-			wVi, wViCursor := formating.ViToInt(rawtx[cursor:])
+			wVi, wViCursor := formating.ViToInt(txBytes[cursor:])
 			cursor += wViCursor
 			witnessesTmp := make([]string, wVi)
 			for m := 0; m < len(witnessesTmp); m++ {
 				var witness []byte
-				wtVi, wtViCursor := formating.ViToInt(rawtx[cursor:])
+				wtVi, wtViCursor := formating.ViToInt(txBytes[cursor:])
 				if wtVi != 0 {
-					witness = rawtx[cursor+wtViCursor : cursor+wtViCursor+wtVi]
+					witness = txBytes[cursor+wtViCursor : cursor+wtViCursor+wtVi]
 				}
 				cursor += wtViCursor + wtVi
 				witnessesTmp[m] = formating.BytesToHex(witness)

scripts/transaction.go

@@ -4,6 +4,7 @@ import (
 	"encoding/binary"
 	"encoding/hex"
 	"fmt"
+
 	"github.com/mrtnetwork/bitcoin/constant"
 	"github.com/mrtnetwork/bitcoin/formating"
 )
@@ -81,45 +82,41 @@ func (ti *TxInput) ToBytes() []byte {
 }
 
 // FromRaw parses a raw transaction input string into a TxInput
-func TxInputFromRaw(raw string, cursor int, hasSegwit bool) (*TxInput, int, error) {
-	txInputRaw, err := formating.HexToBytesCatch(raw)
-	if err != nil {
-		return nil, cursor, err
-	}
+func TxInputFromRaw(inputBytes []byte, cursor int, hasSegwit bool) (*TxInput, int, error) {
 
-	if cursor+32 >= len(txInputRaw) {
+	if cursor+32 >= len(inputBytes) {
 		return nil, cursor, fmt.Errorf("input transaction hash not found. Probably malformed raw transaction")
 	}
 
 	inpHash := make([]byte, 32)
-	copy(inpHash, formating.ReverseBytes(txInputRaw[cursor:cursor+32]))
+	copy(inpHash, formating.ReverseBytes(inputBytes[cursor:cursor+32]))
 	cursor += 32
 
-	if cursor+4 >= len(txInputRaw) {
+	if cursor+4 >= len(inputBytes) {
 		return nil, cursor, fmt.Errorf("output number not found. Probably malformed raw transaction")
 	}
 
-	outputN := binary.LittleEndian.Uint32(formating.ReverseBytes(txInputRaw[cursor : cursor+4]))
+	outputN := binary.LittleEndian.Uint32(inputBytes[cursor : cursor+4])
 	cursor += 4
 
-	vi, viSize := formating.ViToInt(txInputRaw[cursor:])
+	vi, viSize := formating.ViToInt(inputBytes[cursor:])
 	cursor += viSize
 
-	if cursor+vi > len(txInputRaw) {
+	if cursor+vi > len(inputBytes) {
 		return nil, cursor, fmt.Errorf("unlocking script length exceeds available data. Probably malformed raw transaction")
 	}
 
-	unlockingScript := txInputRaw[cursor : cursor+vi]
+	unlockingScript := inputBytes[cursor : cursor+vi]
 	cursor += vi
 
-	if cursor+4 > len(txInputRaw) {
+	if cursor+4 > len(inputBytes) {
 		return nil, cursor, fmt.Errorf("Sequence number not found. Probably malformed raw transaction")
 	}
 
-	sequenceNumberData := txInputRaw[cursor : cursor+4]
+	sequenceNumberData := inputBytes[cursor : cursor+4]
 	cursor += 4
 
-	script, err := ScriptFromRaw(formating.BytesToHex(unlockingScript), hasSegwit)
+	script, err := ScriptFromRaw(unlockingScript, hasSegwit)
 	if err != nil {
 		return nil, cursor, err
 	}

scripts/tx_input.go

@@ -2,8 +2,9 @@ package scripts
 
 import (
 	"encoding/binary"
-	"github.com/mrtnetwork/bitcoin/formating"
 	"math/big"
+
+	"github.com/mrtnetwork/bitcoin/formating"
 )
 
 type TxOutput struct {
@@ -42,19 +43,19 @@ func (txOutput *TxOutput) ToBytes() []byte {
 // raw The hexadecimal raw string of the Transaction
 // The cursor of which the algorithm will start to read the data
 // hasSegwit  Is the Tx Output segwit or not
-func TxOutputFromRaw(raw string, cursor int, hasSegwit bool) (*TxOutput, int, error) {
-	rawBytes := formating.HexToBytes(raw)
+func TxOutputFromRaw(outputBytes []byte, cursor int, hasSegwit bool) (*TxOutput, int, error) {
+
 	// Parse TxOutput from raw bytes
-	value := int64(binary.LittleEndian.Uint64(rawBytes[cursor : cursor+8]))
+	value := int64(binary.LittleEndian.Uint64(outputBytes[cursor : cursor+8]))
 	cursor += 8
 
-	vi, viSize := formating.ViToInt(rawBytes[cursor:])
+	vi, viSize := formating.ViToInt(outputBytes[cursor:])
 	cursor += viSize
 
-	lockScript := rawBytes[cursor : cursor+vi]
+	lockScript := outputBytes[cursor : cursor+vi]
 	cursor += vi
 
-	scriptPubKey, err := ScriptFromRaw(formating.BytesToHex(lockScript), hasSegwit)
+	scriptPubKey, err := ScriptFromRaw(lockScript, hasSegwit)
 	if err != nil {
 		return nil, cursor, err
 	}

scripts/tx_output.go

@@ -1,10 +1,9 @@
 package test
 
 import (
-	"fmt"
-	"github.com/mrtnetwork/bitcoin/bip39"
-	"github.com/mrtnetwork/bitcoin/formating"
 	"testing"
+
+	"github.com/mrtnetwork/bitcoin/bip39"
 )
 
 func TestBip39(t *testing.T) {
@@ -26,13 +25,11 @@ func TestBip39(t *testing.T) {
 
 	// Select the desired number of words. 12(Words12), 15(Words15), 18(Words18), 21(Words21) or 24(Words24) words
 	mnemonic, err := bip.GenerateMnemonic(bip39.Words24)
-	fmt.Println("mnemonic: ", mnemonic)
 	if err != nil {
 		t.Errorf(err.Error())
 	}
 	// passphrase: An optional passphrase used for seed derivation. Can be an empty string.
-	toSeed := bip39.ToSeed(mnemonic, "PASSPHRASE")
-	fmt.Println("seed: ", formating.BytesToHex(toSeed))
+	_ = bip39.ToSeed(mnemonic, "PASSPHRASE")
 
 	toEntropy, err := bip.MnemonicToEntropy(mnemonic)
 	if err != nil {

test/bip_39_test.go

@@ -1,10 +1,10 @@
 package test
 
 import (
-	"fmt"
+	"testing"
+
 	"github.com/mrtnetwork/bitcoin/address"
 	hdwallet "github.com/mrtnetwork/bitcoin/hd_wallet"
-	"testing"
 )
 
 func TestHDWallet(t *testing.T) {
@@ -72,7 +72,6 @@ func TestHDWallet(t *testing.T) {
 		}
 
 		p2wsh := publicKey.ToP2WSHAddress().Show(network)
-		fmt.Println("p2wsh: ", p2wsh)
 		if p2wsh != p2wshPublicWallet {
 			t.Errorf("Expected %v, but got %v", p2wshPublicWallet, p2wsh)
 		}

test/hd_wallet_test.go

@@ -102,7 +102,7 @@ func TestP2pkhAddresses(t *testing.T) {
 		if err == nil {
 			fmt.Println(tx.Program().Hash160 == hash160)
 		} else {
-			print(err.Error())
+			t.Errorf(err.Error())
 		}
 
 	})
@@ -234,7 +234,6 @@ func TestP2trAddresses(t *testing.T) {
 	t.Run("t7", func(t *testing.T) {
 		pub := privOdd.GetPublic()
 		program := pub.ToTaprootAddress().Program().Program
-		fmt.Println("program: ", program)
 		if !strings.EqualFold(program, correctOddTweakedPk) {
 			t.Errorf("Expected %v, but got %v", correctOddTweakedPk, program)
 		}