mirror of
https://github.com/kaspanet/kaspad.git
synced 2025-05-20 13:56:45 +00:00
7390651072
* Remove HF1 activation code * Remove test with an overflow * Fix "max sompi amount is never dust" * Remove estimatedHeaderUpperBound logic
353 lines
11 KiB
Go
353 lines
11 KiB
Go
// Copyright (c) 2013-2016 The btcsuite developers
|
|
// Use of this source code is governed by an ISC
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package mempool
|
|
|
|
import (
|
|
"bytes"
|
|
"math"
|
|
"testing"
|
|
|
|
"github.com/kaspanet/kaspad/domain/consensusreference"
|
|
|
|
"github.com/kaspanet/kaspad/domain/consensus/utils/testutils"
|
|
|
|
"github.com/kaspanet/kaspad/domain/consensus"
|
|
|
|
"github.com/kaspanet/kaspad/domain/consensus/utils/constants"
|
|
|
|
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
|
|
"github.com/kaspanet/kaspad/domain/consensus/utils/txscript"
|
|
"github.com/kaspanet/kaspad/util"
|
|
"github.com/pkg/errors"
|
|
)
|
|
|
|
func TestCalcMinRequiredTxRelayFee(t *testing.T) {
|
|
tests := []struct {
|
|
name string // test description.
|
|
size uint64 // Transaction size in bytes.
|
|
minimumRelayTransactionFee util.Amount // minimum relay transaction fee.
|
|
want uint64 // Expected fee.
|
|
}{
|
|
{
|
|
// Ensure combination of size and fee that are less than 1000
|
|
// produce a non-zero fee.
|
|
"250 bytes with relay fee of 3",
|
|
250,
|
|
3,
|
|
3,
|
|
},
|
|
{
|
|
"100 bytes with default minimum relay fee",
|
|
100,
|
|
defaultMinimumRelayTransactionFee,
|
|
100,
|
|
},
|
|
{
|
|
"max standard tx size with default minimum relay fee",
|
|
MaximumStandardTransactionMass,
|
|
defaultMinimumRelayTransactionFee,
|
|
100000,
|
|
},
|
|
{
|
|
"1500 bytes with 5000 relay fee",
|
|
1500,
|
|
5000,
|
|
7500,
|
|
},
|
|
{
|
|
"1500 bytes with 3000 relay fee",
|
|
1500,
|
|
3000,
|
|
4500,
|
|
},
|
|
{
|
|
"782 bytes with 5000 relay fee",
|
|
782,
|
|
5000,
|
|
3910,
|
|
},
|
|
{
|
|
"782 bytes with 3000 relay fee",
|
|
782,
|
|
3000,
|
|
2346,
|
|
},
|
|
{
|
|
"782 bytes with 2550 relay fee",
|
|
782,
|
|
2550,
|
|
1994,
|
|
},
|
|
}
|
|
|
|
testutils.ForAllNets(t, true, func(t *testing.T, consensusConfig *consensus.Config) {
|
|
factory := consensus.NewFactory()
|
|
tc, teardown, err := factory.NewTestConsensus(consensusConfig, "TestCalcMinRequiredTxRelayFee")
|
|
if err != nil {
|
|
t.Fatalf("Error setting up consensus: %+v", err)
|
|
}
|
|
defer teardown(false)
|
|
|
|
for _, test := range tests {
|
|
mempoolConfig := DefaultConfig(tc.DAGParams())
|
|
mempoolConfig.MinimumRelayTransactionFee = test.minimumRelayTransactionFee
|
|
tcAsConsensus := tc.(externalapi.Consensus)
|
|
tcAsConsensusPointer := &tcAsConsensus
|
|
mempool := New(mempoolConfig, consensusreference.NewConsensusReference(&tcAsConsensusPointer)).(*mempool)
|
|
|
|
got := mempool.minimumRequiredTransactionRelayFee(test.size)
|
|
if got != test.want {
|
|
t.Errorf("TestCalcMinRequiredTxRelayFee test '%s' "+
|
|
"failed: got %v want %v", test.name, got,
|
|
test.want)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestIsTransactionOutputDust(t *testing.T) {
|
|
scriptPublicKey := &externalapi.ScriptPublicKey{
|
|
[]byte{0x76, 0xa9, 0x21, 0x03, 0x2f, 0x7e, 0x43,
|
|
0x0a, 0xa4, 0xc9, 0xd1, 0x59, 0x43, 0x7e, 0x84, 0xb9,
|
|
0x75, 0xdc, 0x76, 0xd9, 0x00, 0x3b, 0xf0, 0x92, 0x2c,
|
|
0xf3, 0xaa, 0x45, 0x28, 0x46, 0x4b, 0xab, 0x78, 0x0d,
|
|
0xba, 0x5e}, 0}
|
|
|
|
tests := []struct {
|
|
name string // test description
|
|
txOut externalapi.DomainTransactionOutput
|
|
minimumRelayTransactionFee util.Amount // minimum relay transaction fee.
|
|
isDust bool
|
|
}{
|
|
{
|
|
// Any value is allowed with a zero relay fee.
|
|
"zero value with zero relay fee",
|
|
externalapi.DomainTransactionOutput{Value: 0, ScriptPublicKey: scriptPublicKey},
|
|
0,
|
|
false,
|
|
},
|
|
{
|
|
// Zero value is dust with any relay fee"
|
|
"zero value with very small tx fee",
|
|
externalapi.DomainTransactionOutput{Value: 0, ScriptPublicKey: scriptPublicKey},
|
|
1,
|
|
true,
|
|
},
|
|
{
|
|
"36 byte public key script with value 605",
|
|
externalapi.DomainTransactionOutput{Value: 605, ScriptPublicKey: scriptPublicKey},
|
|
1000,
|
|
true,
|
|
},
|
|
{
|
|
"36 byte public key script with value 606",
|
|
externalapi.DomainTransactionOutput{Value: 606, ScriptPublicKey: scriptPublicKey},
|
|
1000,
|
|
false,
|
|
},
|
|
{
|
|
// Maximum allowed value is never dust.
|
|
"max sompi amount is never dust",
|
|
externalapi.DomainTransactionOutput{Value: constants.MaxSompi, ScriptPublicKey: scriptPublicKey},
|
|
util.Amount(1000),
|
|
false,
|
|
},
|
|
{
|
|
// Maximum uint64 value causes overflow.
|
|
"maximum uint64 value",
|
|
externalapi.DomainTransactionOutput{Value: math.MaxUint64, ScriptPublicKey: scriptPublicKey},
|
|
math.MaxUint64,
|
|
true,
|
|
},
|
|
{
|
|
// Unspendable ScriptPublicKey due to an invalid public key
|
|
// script.
|
|
"unspendable ScriptPublicKey",
|
|
externalapi.DomainTransactionOutput{Value: 5000, ScriptPublicKey: &externalapi.ScriptPublicKey{[]byte{0x01}, 0}},
|
|
0, // no relay fee
|
|
true,
|
|
},
|
|
}
|
|
|
|
testutils.ForAllNets(t, true, func(t *testing.T, consensusConfig *consensus.Config) {
|
|
factory := consensus.NewFactory()
|
|
tc, teardown, err := factory.NewTestConsensus(consensusConfig, "TestIsTransactionOutputDust")
|
|
if err != nil {
|
|
t.Fatalf("Error setting up consensus: %+v", err)
|
|
}
|
|
defer teardown(false)
|
|
|
|
for _, test := range tests {
|
|
mempoolConfig := DefaultConfig(tc.DAGParams())
|
|
mempoolConfig.MinimumRelayTransactionFee = test.minimumRelayTransactionFee
|
|
tcAsConsensus := tc.(externalapi.Consensus)
|
|
tcAsConsensusPointer := &tcAsConsensus
|
|
mempool := New(mempoolConfig, consensusreference.NewConsensusReference(&tcAsConsensusPointer)).(*mempool)
|
|
|
|
res := mempool.IsTransactionOutputDust(&test.txOut)
|
|
if res != test.isDust {
|
|
t.Errorf("Dust test '%s' failed: want %v got %v",
|
|
test.name, test.isDust, res)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestCheckTransactionStandardInIsolation(t *testing.T) {
|
|
// Create some dummy, but otherwise standard, data for transactions.
|
|
prevOutTxID := &externalapi.DomainTransactionID{}
|
|
dummyPrevOut := externalapi.DomainOutpoint{TransactionID: *prevOutTxID, Index: 1}
|
|
dummySigScript := bytes.Repeat([]byte{0x00}, 65)
|
|
dummyTxIn := externalapi.DomainTransactionInput{
|
|
PreviousOutpoint: dummyPrevOut,
|
|
SignatureScript: dummySigScript,
|
|
Sequence: constants.MaxTxInSequenceNum,
|
|
}
|
|
addrHash := [32]byte{0x01}
|
|
addr, err := util.NewAddressPublicKey(addrHash[:], util.Bech32PrefixKaspaTest)
|
|
if err != nil {
|
|
t.Fatalf("NewAddressPublicKey: unexpected error: %v", err)
|
|
}
|
|
dummyScriptPublicKey, err := txscript.PayToAddrScript(addr)
|
|
if err != nil {
|
|
t.Fatalf("PayToAddrScript: unexpected error: %v", err)
|
|
}
|
|
dummyTxOut := externalapi.DomainTransactionOutput{
|
|
Value: 100000000, // 1 KAS
|
|
ScriptPublicKey: dummyScriptPublicKey,
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
tx *externalapi.DomainTransaction
|
|
height uint64
|
|
isStandard bool
|
|
code RejectCode
|
|
}{
|
|
{
|
|
name: "Typical pay-to-pubkey transaction",
|
|
tx: &externalapi.DomainTransaction{Version: 0, Inputs: []*externalapi.DomainTransactionInput{&dummyTxIn}, Outputs: []*externalapi.DomainTransactionOutput{&dummyTxOut}},
|
|
height: 300000,
|
|
isStandard: true,
|
|
},
|
|
{
|
|
name: "Transaction version too high",
|
|
tx: &externalapi.DomainTransaction{Version: constants.MaxTransactionVersion + 1, Inputs: []*externalapi.DomainTransactionInput{&dummyTxIn}, Outputs: []*externalapi.DomainTransactionOutput{&dummyTxOut}},
|
|
height: 300000,
|
|
isStandard: false,
|
|
code: RejectNonstandard,
|
|
},
|
|
|
|
{
|
|
name: "Transaction size is too large",
|
|
tx: &externalapi.DomainTransaction{Version: 0, Inputs: []*externalapi.DomainTransactionInput{&dummyTxIn}, Outputs: []*externalapi.DomainTransactionOutput{{
|
|
Value: 0,
|
|
ScriptPublicKey: &externalapi.ScriptPublicKey{bytes.Repeat([]byte{0x00}, MaximumStandardTransactionMass+1), 0},
|
|
}}},
|
|
height: 300000,
|
|
isStandard: false,
|
|
code: RejectNonstandard,
|
|
},
|
|
{
|
|
name: "Signature script size is too large",
|
|
tx: &externalapi.DomainTransaction{Version: 0, Inputs: []*externalapi.DomainTransactionInput{{
|
|
PreviousOutpoint: dummyPrevOut,
|
|
SignatureScript: bytes.Repeat([]byte{0x00}, maximumStandardSignatureScriptSize+1),
|
|
Sequence: constants.MaxTxInSequenceNum,
|
|
}}, Outputs: []*externalapi.DomainTransactionOutput{&dummyTxOut}},
|
|
height: 300000,
|
|
isStandard: false,
|
|
code: RejectNonstandard,
|
|
},
|
|
{
|
|
name: "Valid but non standard public key script",
|
|
tx: &externalapi.DomainTransaction{Version: 0, Inputs: []*externalapi.DomainTransactionInput{&dummyTxIn}, Outputs: []*externalapi.DomainTransactionOutput{{
|
|
Value: 100000000,
|
|
ScriptPublicKey: &externalapi.ScriptPublicKey{[]byte{txscript.OpTrue}, 0},
|
|
}}},
|
|
height: 300000,
|
|
isStandard: false,
|
|
code: RejectNonstandard,
|
|
},
|
|
{ //Todo : check on ScriptPublicKey type.
|
|
name: "Dust output",
|
|
tx: &externalapi.DomainTransaction{Version: 0, Inputs: []*externalapi.DomainTransactionInput{&dummyTxIn}, Outputs: []*externalapi.DomainTransactionOutput{{
|
|
Value: 0,
|
|
ScriptPublicKey: dummyScriptPublicKey,
|
|
}}},
|
|
height: 300000,
|
|
isStandard: false,
|
|
code: RejectDust,
|
|
},
|
|
{
|
|
name: "Nulldata transaction",
|
|
tx: &externalapi.DomainTransaction{Version: 0, Inputs: []*externalapi.DomainTransactionInput{&dummyTxIn}, Outputs: []*externalapi.DomainTransactionOutput{{
|
|
Value: 0,
|
|
ScriptPublicKey: &externalapi.ScriptPublicKey{[]byte{txscript.OpReturn}, 0},
|
|
}}},
|
|
height: 300000,
|
|
isStandard: false,
|
|
code: RejectNonstandard,
|
|
},
|
|
}
|
|
|
|
testutils.ForAllNets(t, true, func(t *testing.T, consensusConfig *consensus.Config) {
|
|
factory := consensus.NewFactory()
|
|
tc, teardown, err := factory.NewTestConsensus(consensusConfig, "TestCheckTransactionStandardInIsolation")
|
|
if err != nil {
|
|
t.Fatalf("Error setting up consensus: %+v", err)
|
|
}
|
|
defer teardown(false)
|
|
|
|
for _, test := range tests {
|
|
mempoolConfig := DefaultConfig(tc.DAGParams())
|
|
tcAsConsensus := tc.(externalapi.Consensus)
|
|
tcAsConsensusPointer := &tcAsConsensus
|
|
consensusReference := consensusreference.NewConsensusReference(&tcAsConsensusPointer)
|
|
mempool := New(mempoolConfig, consensusReference).(*mempool)
|
|
|
|
// Ensure standardness is as expected.
|
|
err := mempool.checkTransactionStandardInIsolation(test.tx)
|
|
if err == nil && test.isStandard {
|
|
// Test passes since function returned standard for a
|
|
// transaction which is intended to be standard.
|
|
continue
|
|
}
|
|
if err == nil && !test.isStandard {
|
|
t.Errorf("checkTransactionStandardInIsolation (%s): standard when "+
|
|
"it should not be", test.name)
|
|
continue
|
|
}
|
|
if err != nil && test.isStandard {
|
|
t.Errorf("checkTransactionStandardInIsolation (%s): nonstandard "+
|
|
"when it should not be: %v", test.name, err)
|
|
continue
|
|
}
|
|
|
|
// Ensure error type is a TxRuleError inside of a RuleError.
|
|
var ruleErr RuleError
|
|
if !errors.As(err, &ruleErr) {
|
|
t.Errorf("checkTransactionStandardInIsolation (%s): unexpected "+
|
|
"error type - got %T", test.name, err)
|
|
continue
|
|
}
|
|
txRuleErr, ok := ruleErr.Err.(TxRuleError)
|
|
if !ok {
|
|
t.Errorf("checkTransactionStandardInIsolation (%s): unexpected "+
|
|
"error type - got %T", test.name, ruleErr.Err)
|
|
continue
|
|
}
|
|
|
|
// Ensure the reject code is the expected one.
|
|
if txRuleErr.RejectCode != test.code {
|
|
t.Errorf("checkTransactionStandardInIsolation (%s): unexpected "+
|
|
"error code - got %v, want %v", test.name,
|
|
txRuleErr.RejectCode, test.code)
|
|
continue
|
|
}
|
|
}
|
|
})
|
|
}
|