Merge remote-tracking branch 'origin/fix/optimize-inputs'

rohenaz · rohenaz · commit 118d07677c91 · 2024-09-09T21:42:39.000-04:00
diff --git a/script/interpreter/operations.go b/script/interpreter/operations.go
@@ -2016,9 +2016,9 @@ func opcodeCheckSig(op *ParsedOpcode, t *thread) error {
 		return err
 	}
 
-	txCopy := t.tx.Clone()
-	txCopy.Inputs[t.inputIdx].SourceTransaction.Outputs[txCopy.Inputs[t.inputIdx].SourceTxOutIndex].LockingScript = up
-	// txCopy.Inputs[t.inputIdx].SourceTxScript = up
+	txCopy := t.tx.ShallowClone()
+	sourceTxOut := txCopy.Inputs[t.inputIdx].SourceTxOutput()
+	sourceTxOut.LockingScript = up
 
 	hash, err = txCopy.CalcInputSignatureHash(uint32(t.inputIdx), shf)
 	if err != nil {
@@ -2282,9 +2282,12 @@ func opcodeCheckMultiSig(op *ParsedOpcode, t *thread) error {
 		}
 
 		// Generate the signature hash based on the signature hash type.
-		txCopy := t.tx.Clone()
+		txCopy := t.tx.ShallowClone()
 		input := txCopy.Inputs[t.inputIdx]
-		input.SourceTransaction.Outputs[input.SourceTxOutIndex].LockingScript = up
+		sourceOut := input.SourceTxOutput()
+		if sourceOut != nil {
+			sourceOut.LockingScript = up
+		}
 
 		signatureHash, err := txCopy.CalcInputSignatureHash(uint32(t.inputIdx), shf)
 		if err != nil {
diff --git a/script/interpreter/reference_test.go b/script/interpreter/reference_test.go
@@ -323,7 +323,7 @@ func createSpendingTx(sigScript, pkScript *script.Script, outputValue int64) *tr
 			LockingScript: script.NewFromBytes([]byte{}),
 		}},
 	}
-	spendingTx.Inputs[0].SetSourceTxFromOutput(&transaction.TransactionOutput{
+	spendingTx.Inputs[0].SetSourceTxOutput(&transaction.TransactionOutput{
 		LockingScript: pkScript,
 	})
 
@@ -612,7 +612,7 @@ testloop:
 
 		for k, txin := range tx.Inputs {
 			prevOut, ok := prevOuts[txIOKey{id: txin.SourceTXID.String(), idx: txin.SourceTxOutIndex}]
-			txin.SetSourceTxFromOutput(prevOut)
+			txin.SetSourceTxOutput(prevOut)
 			if !ok {
 				t.Errorf("bad test (missing %dth input) %d:%v",
 					k, i, test)
@@ -762,7 +762,7 @@ testloop:
 
 		for k, txin := range tx.Inputs {
 			prevOut, ok := prevOuts[txIOKey{id: txin.SourceTXID.String(), idx: txin.SourceTxOutIndex}]
-			txin.SetSourceTxFromOutput(prevOut)
+			txin.SetSourceTxOutput(prevOut)
 			if !ok {
 				t.Errorf("bad test (missing %dth input) %d:%v",
 					k, i, test)
diff --git a/script/interpreter/thread.go b/script/interpreter/thread.go
@@ -352,7 +352,7 @@ func (t *thread) apply(opts *execOpts) error {
 	t.astack = newStack(t.cfg, t.hasFlag(scriptflag.VerifyMinimalData))
 
 	if t.tx != nil {
-		t.tx.Inputs[t.inputIdx].SetSourceTxFromOutput(&transaction.TransactionOutput{
+		t.tx.Inputs[t.inputIdx].SetSourceTxOutput(&transaction.TransactionOutput{
 			LockingScript: t.prevOutput.LockingScript,
 			Satoshis:      t.prevOutput.Satoshis,
 		})
diff --git a/script/script.go b/script/script.go
@@ -127,6 +127,11 @@ func (s *Script) AppendOpcodes(oo ...uint8) error {
 	return nil
 }
 
+// Bytes implements the Byte interface and returns the byte slice of script.
+func (s *Script) Bytes() []byte {
+	return *s
+}
+
 // String implements the stringer interface and returns the hex string of script.
 func (s *Script) String() string {
 	return hex.EncodeToString(*s)
diff --git a/transaction/broadcaster/arc.go b/transaction/broadcaster/arc.go
@@ -67,7 +67,7 @@ func (f *ArcResponse) Scan(value interface{}) error {
 func (a *Arc) Broadcast(t *transaction.Transaction) (*transaction.BroadcastSuccess, *transaction.BroadcastFailure) {
 	var buf *bytes.Buffer
 	for _, input := range t.Inputs {
-		if input.SourceTransaction == nil {
+		if input.SourceTxOutput() == nil {
 			buf = bytes.NewBuffer(t.Bytes())
 			break
 		}
diff --git a/transaction/fees.go b/transaction/fees.go
@@ -24,10 +24,11 @@ func (tx *Transaction) Fee(f FeeModel, changeDistribution ChangeDistribution) er
 	}
 	satsIn := uint64(0)
 	for _, i := range tx.Inputs {
-		if i.SourceTransaction == nil {
+		sourceSats := i.SourceTxSatoshis()
+		if sourceSats == nil {
 			return ErrEmptyPreviousTx
 		}
-		satsIn += *i.SourceTxSatoshis()
+		satsIn += *sourceSats
 	}
 	satsOut := uint64(0)
 	changeOuts := uint64(0)
diff --git a/transaction/input.go b/transaction/input.go
@@ -35,21 +35,31 @@ type TransactionInput struct {
 	SourceTxOutIndex        uint32
 	SequenceNumber          uint32
 	SourceTransaction       *Transaction
+	sourceOutput            *TransactionOutput
 	UnlockingScriptTemplate UnlockingScriptTemplate
 }
 
+func (i *TransactionInput) SourceTxOutput() *TransactionOutput {
+	if i.SourceTransaction != nil {
+		return i.SourceTransaction.Outputs[i.SourceTxOutIndex]
+	}
+	return i.sourceOutput
+}
+
 func (i *TransactionInput) SourceTxScript() *script.Script {
-	if i.SourceTransaction == nil {
-		return nil
+	sourceTxOut := i.SourceTxOutput()
+	if sourceTxOut != nil {
+		return sourceTxOut.LockingScript
 	}
-	return i.SourceTransaction.Outputs[i.SourceTxOutIndex].LockingScript
+	return nil
 }
 
 func (i *TransactionInput) SourceTxSatoshis() *uint64 {
-	if i.SourceTransaction == nil {
-		return nil
+	sourceTxOut := i.SourceTxOutput()
+	if sourceTxOut != nil {
+		return &sourceTxOut.Satoshis
 	}
-	return &i.SourceTransaction.Outputs[i.SourceTxOutIndex].Satoshis
+	return nil
 }
 
 // ReadFrom reads from the `io.Reader` into the `transaction.TransactionInput`.
@@ -132,7 +142,7 @@ func (i *TransactionInput) readFrom(r io.Reader, extended bool) (int64, error) {
 			return bytesRead, errors.Wrapf(err, "script(%d): got %d bytes", scriptLen.Length(), n)
 		}
 
-		i.SetSourceTxFromOutput(&TransactionOutput{
+		i.SetSourceTxOutput(&TransactionOutput{
 			Satoshis:      binary.LittleEndian.Uint64(prevSatoshis),
 			LockingScript: script.NewFromBytes(scriptBytes),
 		})
@@ -179,9 +189,6 @@ func (i *TransactionInput) Bytes(clear bool) []byte {
 	return append(h, util.LittleEndianBytes(i.SequenceNumber, 4)...)
 }
 
-func (i *TransactionInput) SetSourceTxFromOutput(txo *TransactionOutput) {
-	prevTx := &Transaction{}
-	prevTx.Outputs = make([]*TransactionOutput, i.SourceTxOutIndex+1)
-	prevTx.Outputs[i.SourceTxOutIndex] = txo
-	i.SourceTransaction = prevTx
+func (i *TransactionInput) SetSourceTxOutput(txo *TransactionOutput) {
+	i.sourceOutput = txo
 }
diff --git a/transaction/signaturehash.go b/transaction/signaturehash.go
@@ -67,7 +67,7 @@ func (tx *Transaction) CalcInputPreimage(inputNumber uint32, sigHashFlag sighash
 	if len(in.SourceTXID) == 0 {
 		return nil, ErrEmptyPreviousTxID
 	}
-	if in.SourceTransaction == nil {
+	if in.SourceTxOutput() == nil {
 		return nil, ErrEmptyPreviousTx
 	}
 
@@ -95,7 +95,7 @@ func (tx *Transaction) CalcInputPreimage(inputNumber uint32, sigHashFlag sighash
 		hashOutputs = tx.OutputsHash(int32(inputNumber))
 	}
 
-	buf := make([]byte, 0)
+	buf := make([]byte, 0, 256)
 
 	// Version
 	v := make([]byte, 4)
@@ -160,7 +160,7 @@ func (tx *Transaction) CalcInputPreimageLegacy(inputNumber uint32, shf sighash.F
 	if len(in.SourceTXID) == 0 {
 		return nil, ErrEmptyPreviousTxID
 	}
-	if in.SourceTransaction == nil {
+	if in.SourceTxOutput() == nil {
 		return nil, ErrEmptyPreviousTx
 	}
 
@@ -188,14 +188,14 @@ func (tx *Transaction) CalcInputPreimageLegacy(inputNumber uint32, shf sighash.F
 		return defaultHex, nil
 	}
 
-	txCopy := tx.Clone()
+	txCopy := tx.ShallowClone()
 
 	for i := range txCopy.Inputs {
 		if i == int(inputNumber) {
-			txCopy.Inputs[i].SourceTransaction = tx.Inputs[inputNumber].SourceTransaction
+			txCopy.Inputs[i].sourceOutput = in.SourceTxOutput()
 		} else {
 			txCopy.Inputs[i].UnlockingScript = &script.Script{}
-			txCopy.Inputs[i].SetSourceTxFromOutput(&TransactionOutput{})
+			txCopy.Inputs[i].sourceOutput = &TransactionOutput{}
 		}
 	}
 
diff --git a/transaction/signaturehash_test.go b/transaction/signaturehash_test.go
@@ -63,7 +63,7 @@ func TestTx_CalcInputPreimage(t *testing.T) {
 			// Add the UTXO amount and script (PreviousTx already in unsigned tx)
 			prevScript, err := script.NewFromHex(test.SourceTxScript)
 			require.NoError(t, err)
-			tx.InputIdx(test.index).SetSourceTxFromOutput(&transaction.TransactionOutput{
+			tx.InputIdx(test.index).SetSourceTxOutput(&transaction.TransactionOutput{
 				LockingScript: prevScript,
 				Satoshis:      test.previousTxSatoshis,
 			})
@@ -156,7 +156,7 @@ func TestTx_CalcInputSignatureHash(t *testing.T) {
 			// Add the UTXO amount and script (PreviousTx already in unsigned tx)
 			prevScript, err := script.NewFromHex(test.SourceTxScript)
 			require.NoError(t, err)
-			tx.Inputs[test.index].SetSourceTxFromOutput(&transaction.TransactionOutput{
+			tx.Inputs[test.index].SetSourceTxOutput(&transaction.TransactionOutput{
 				LockingScript: prevScript,
 				Satoshis:      test.previousTxSatoshis,
 			})
@@ -222,7 +222,7 @@ func TestTx_CalcInputPreimageLegacy(t *testing.T) {
 			// Add the UTXO amount and script (PreviousTx already in unsigned tx)
 			prevScript, err := script.NewFromHex(test.SourceTxScript)
 			require.NoError(t, err)
-			tx.Inputs[test.index].SetSourceTxFromOutput(&transaction.TransactionOutput{
+			tx.Inputs[test.index].SetSourceTxOutput(&transaction.TransactionOutput{
 				LockingScript: prevScript,
 				Satoshis:      test.previousTxSatoshis,
 			})
diff --git a/transaction/template/p2pkh/p2pkh.go b/transaction/template/p2pkh/p2pkh.go
@@ -47,7 +47,7 @@ type P2PKH struct {
 }
 
 func (p *P2PKH) Sign(tx *transaction.Transaction, inputIndex uint32) (*script.Script, error) {
-	if tx.Inputs[inputIndex].SourceTransaction == nil {
+	if tx.Inputs[inputIndex].SourceTxOutput() == nil {
 		return nil, transaction.ErrEmptyPreviousTx
 	}
 
diff --git a/transaction/transaction.go b/transaction/transaction.go
@@ -10,6 +10,7 @@ import (
 
 	"github.com/bitcoin-sv/go-sdk/chainhash"
 	crypto "github.com/bitcoin-sv/go-sdk/primitives/hash"
+	"github.com/bitcoin-sv/go-sdk/script"
 	"github.com/bitcoin-sv/go-sdk/util"
 )
 
@@ -291,7 +292,7 @@ func (tx *Transaction) Bytes() []byte {
 // (with PreviousTxSatoshis and SourceTxScript included)
 func (tx *Transaction) EF() ([]byte, error) {
 	for _, in := range tx.Inputs {
-		if in.SourceTransaction == nil {
+		if in.SourceTransaction == nil && in.sourceOutput == nil {
 			return nil, ErrEmptyPreviousTx
 		}
 	}
@@ -321,10 +322,52 @@ func (tx *Transaction) Clone() *Transaction {
 	}
 
 	for i, input := range tx.Inputs {
-		// if input.SourceTransaction != nil {
-		// 	clone.Inputs[i].SourceTransaction = input.SourceTransaction.Clone()
-		// }
-		clone.Inputs[i].SourceTransaction = input.SourceTransaction
+		if input.SourceTransaction != nil {
+			clone.Inputs[i].SourceTransaction = input.SourceTransaction.Clone()
+		}
+		// clone.Inputs[i].SourceTransaction = input.SourceTransaction
+		clone.Inputs[i].sourceOutput = input.sourceOutput
+	}
+
+	return clone
+}
+
+func (tx *Transaction) ShallowClone() *Transaction {
+	// Creating a new Tx from scratch is much faster than cloning from bytes
+	// ~ 420ns/op vs 2200ns/op of the above function in benchmarking
+	// this matters as we clone txs a couple of times when verifying signatures
+	clone := &Transaction{
+		Version:  tx.Version,
+		LockTime: tx.LockTime,
+		Inputs:   make([]*TransactionInput, len(tx.Inputs)),
+		Outputs:  make([]*TransactionOutput, len(tx.Outputs)),
+	}
+
+	for i, input := range tx.Inputs {
+		clone.Inputs[i] = &TransactionInput{
+			SourceTXID:       (*chainhash.Hash)(input.SourceTXID[:]),
+			SourceTxOutIndex: input.SourceTxOutIndex,
+			SequenceNumber:   input.SequenceNumber,
+		}
+		if input.UnlockingScript != nil {
+			clone.Inputs[i].UnlockingScript = input.UnlockingScript
+		}
+		sourceTxOut := input.SourceTxOutput()
+		if sourceTxOut != nil {
+			clone.Inputs[i].sourceOutput = &TransactionOutput{
+				Satoshis:      sourceTxOut.Satoshis,
+				LockingScript: script.NewFromBytes(*sourceTxOut.LockingScript),
+			}
+		}
+	}
+
+	for i, output := range tx.Outputs {
+		clone.Outputs[i] = &TransactionOutput{
+			Satoshis: output.Satoshis,
+		}
+		if output.LockingScript != nil {
+			clone.Outputs[i].LockingScript = output.LockingScript
+		}
 	}
 
 	return clone
@@ -352,19 +395,16 @@ func (tx *Transaction) toBytesHelper(index int, lockingScript []byte, extended b
 
 		if extended {
 			b := make([]byte, 8)
-			prevSats := uint64(0)
-			if in.SourceTxSatoshis() != nil {
-				prevSats = *in.SourceTxSatoshis()
-			}
-			binary.LittleEndian.PutUint64(b, prevSats)
-			h = append(h, b...)
-
-			prevScript := in.SourceTxScript()
-			if prevScript != nil {
-				l := uint64(len(*prevScript))
+			sourceTxOut := in.SourceTxOutput()
+			if sourceTxOut != nil {
+				binary.LittleEndian.PutUint64(b, sourceTxOut.Satoshis)
+				h = append(h, b...)
+				l := uint64(len(*sourceTxOut.LockingScript))
 				h = append(h, VarInt(l).Bytes()...)
-				h = append(h, *prevScript...)
+				h = append(h, *sourceTxOut.LockingScript...)
 			} else {
+				binary.LittleEndian.PutUint64(b, 0)
+				h = append(h, b...)
 				h = append(h, 0x00) // The length of the script is zero
 			}
 		}
diff --git a/transaction/transaction_test.go b/transaction/transaction_test.go
@@ -78,3 +78,14 @@ func TestEF(t *testing.T) {
 		require.Equal(t, "010000000000000000ef01ac4e164f5bc16746bb0868404292ac8318bbac3800e4aad13a014da427adce3e000000006a47304402203a61a2e931612b4bda08d541cfb980885173b8dcf64a3471238ae7abcd368d6402204cbf24f04b9aa2256d8901f0ed97866603d2be8324c2bfb7a37bf8fc90edd5b441210263e2dee22b1ddc5e11f6fab8bcd2378bdd19580d640501ea956ec0e786f93e76ffffffff3e660000000000001976a9146bfd5c7fbe21529d45803dbcf0c87dd3c71efbc288ac013c660000000000001976a9146bfd5c7fbe21529d45803dbcf0c87dd3c71efbc288ac00000000", ef)
 	})
 }
+
+func Benchmark_ShallowClone(b *testing.B) {
+	tx, _ := transaction.NewTransactionFromHex("0200000003a9bc457fdc6a54d99300fb137b23714d860c350a9d19ff0f571e694a419ff3a0010000006b48304502210086c83beb2b2663e4709a583d261d75be538aedcafa7766bd983e5c8db2f8b2fc02201a88b178624ab0ad1748b37c875f885930166237c88f5af78ee4e61d337f935f412103e8be830d98bb3b007a0343ee5c36daa48796ae8bb57946b1e87378ad6e8a090dfeffffff0092bb9a47e27bf64fc98f557c530c04d9ac25e2f2a8b600e92a0b1ae7c89c20010000006b483045022100f06b3db1c0a11af348401f9cebe10ae2659d6e766a9dcd9e3a04690ba10a160f02203f7fbd7dfcfc70863aface1a306fcc91bbadf6bc884c21a55ef0d32bd6b088c8412103e8be830d98bb3b007a0343ee5c36daa48796ae8bb57946b1e87378ad6e8a090dfeffffff9d0d4554fa692420a0830ca614b6c60f1bf8eaaa21afca4aa8c99fb052d9f398000000006b483045022100d920f2290548e92a6235f8b2513b7f693a64a0d3fa699f81a034f4b4608ff82f0220767d7d98025aff3c7bd5f2a66aab6a824f5990392e6489aae1e1ae3472d8dffb412103e8be830d98bb3b007a0343ee5c36daa48796ae8bb57946b1e87378ad6e8a090dfeffffff02807c814a000000001976a9143a6bf34ebfcf30e8541bbb33a7882845e5a29cb488ac76b0e60e000000001976a914bd492b67f90cb85918494767ebb23102c4f06b7088ac67000000")
+
+	b.Run("clone", func(b *testing.B) {
+		for i := 0; i < b.N; i++ {
+			clone := tx.ShallowClone()
+			_ = clone
+		}
+	})
+}
diff --git a/transaction/txinput.go b/transaction/txinput.go

Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ func (f *ArcResponse) Scan(value interface{}) error {`
`67`	`67`	`func (a Arc) Broadcast(t transaction.Transaction) (transaction.BroadcastSuccess, transaction.BroadcastFailure) {`
`68`	`68`	`var buf *bytes.Buffer`
`69`	`69`	`for _, input := range t.Inputs {`
`70`		`- if input.SourceTransaction == nil {`
	`70`	`+ if input.SourceTxOutput() == nil {`
`71`	`71`	`buf = bytes.NewBuffer(t.Bytes())`
`72`	`72`	`break`
`73`	`73`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,10 +24,11 @@ func (tx *Transaction) Fee(f FeeModel, changeDistribution ChangeDistribution) er`
`24`	`24`	`}`
`25`	`25`	`satsIn := uint64(0)`
`26`	`26`	`for _, i := range tx.Inputs {`
`27`		`- if i.SourceTransaction == nil {`
	`27`	`+ sourceSats := i.SourceTxSatoshis()`
	`28`	`+ if sourceSats == nil {`
`28`	`29`	`return ErrEmptyPreviousTx`
`29`	`30`	`}`
`30`		`- satsIn += *i.SourceTxSatoshis()`
	`31`	`+ satsIn += *sourceSats`
`31`	`32`	`}`
`32`	`33`	`satsOut := uint64(0)`
`33`	`34`	`changeOuts := uint64(0)`
Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ func (tx *Transaction) CalcInputPreimage(inputNumber uint32, sigHashFlag sighash`
`67`	`67`	`if len(in.SourceTXID) == 0 {`
`68`	`68`	`return nil, ErrEmptyPreviousTxID`
`69`	`69`	`}`
`70`		`- if in.SourceTransaction == nil {`
	`70`	`+ if in.SourceTxOutput() == nil {`
`71`	`71`	`return nil, ErrEmptyPreviousTx`
`72`	`72`	`}`
`73`	`73`
`@@ -95,7 +95,7 @@ func (tx *Transaction) CalcInputPreimage(inputNumber uint32, sigHashFlag sighash`
`95`	`95`	`hashOutputs = tx.OutputsHash(int32(inputNumber))`
`96`	`96`	`}`
`97`	`97`
`98`		`- buf := make([]byte, 0)`
	`98`	`+ buf := make([]byte, 0, 256)`
`99`	`99`
`100`	`100`	`// Version`
`101`	`101`	`v := make([]byte, 4)`
`@@ -160,7 +160,7 @@ func (tx *Transaction) CalcInputPreimageLegacy(inputNumber uint32, shf sighash.F`
`160`	`160`	`if len(in.SourceTXID) == 0 {`
`161`	`161`	`return nil, ErrEmptyPreviousTxID`
`162`	`162`	`}`
`163`		`- if in.SourceTransaction == nil {`
	`163`	`+ if in.SourceTxOutput() == nil {`
`164`	`164`	`return nil, ErrEmptyPreviousTx`
`165`	`165`	`}`
`166`	`166`
`@@ -188,14 +188,14 @@ func (tx *Transaction) CalcInputPreimageLegacy(inputNumber uint32, shf sighash.F`
`188`	`188`	`return defaultHex, nil`
`189`	`189`	`}`
`190`	`190`
`191`		`- txCopy := tx.Clone()`
	`191`	`+ txCopy := tx.ShallowClone()`
`192`	`192`
`193`	`193`	`for i := range txCopy.Inputs {`
`194`	`194`	`if i == int(inputNumber) {`
`195`		`- txCopy.Inputs[i].SourceTransaction = tx.Inputs[inputNumber].SourceTransaction`
	`195`	`+ txCopy.Inputs[i].sourceOutput = in.SourceTxOutput()`
`196`	`196`	`} else {`
`197`	`197`	`txCopy.Inputs[i].UnlockingScript = &script.Script{}`
`198`		`- txCopy.Inputs[i].SetSourceTxFromOutput(&TransactionOutput{})`
	`198`	`+ txCopy.Inputs[i].sourceOutput = &TransactionOutput{}`
`199`	`199`	`}`
`200`	`200`	`}`
`201`	`201`
Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,7 @@ type P2PKH struct {`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`func (p P2PKH) Sign(tx transaction.Transaction, inputIndex uint32) (*script.Script, error) {`
`50`		`- if tx.Inputs[inputIndex].SourceTransaction == nil {`
	`50`	`+ if tx.Inputs[inputIndex].SourceTxOutput() == nil {`
`51`	`51`	`return nil, transaction.ErrEmptyPreviousTx`
`52`	`52`	`}`
`53`	`53`