kaspad/domain/consensus/model/externalapi/block_equal_clone_test.go
stasatdaglabs d922ee1be2
Add header commitments for DAA score, blue work, and finality points (#1817)
* Add DAAScore, BlueWork, and FinalityPoint to externalapi.BlockHeader.

* Add DAAScore, BlueWork, and FinalityPoint to NewImmutableBlockHeader and fix compilation errors.

* Add DAAScore, BlueWork, and FinalityPoint to protowire header types and fix failing tests.

* Check for header DAA score in validateDifficulty.

* Add DAA score to buildBlock.

* Fix failing tests.

* Add a blue work check in validateDifficultyDAAAndBlueWork.

* Add blue work to buildBlock and fix failing tests.

* Add finality point validation to ValidateHeaderInContext.

* Fix genesis blocks' finality points.

* Add finalityPoint to blockBuilder.

* Fix tests that failed due to missing reachability data.

* Make blockBuilder use VirtualFinalityPoint instead of directly calling FinalityPoint with the virtual hash.

* Don't validate the finality point for blocks with trusted data.

* Add debug logs.

* Skip finality point validation for block whose finality points are the virtual genesis.

* Revert "Add debug logs."

This reverts commit 3c18f519ccbb382f86f63904dbb1c4cd6bc68b00.

* Move checkDAAScore and checkBlueWork to validateBlockHeaderInContext.

* Add checkCoinbaseBlueScore to validateBodyInContext.

* Fix failing tests.

* Add DAAScore, blueWork, and finalityPoint to blocks' hashes.

* Generate new genesis blocks.

* Fix failing tests.

* In BuildUTXOInvalidBlock, get the bits from StageDAADataAndReturnRequiredDifficulty instead of calling RequiredDifficulty separately.
2021-08-12 13:25:00 +03:00

465 lines
16 KiB
Go

package externalapi_test
import (
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/kaspanet/kaspad/domain/consensus/utils/blockheader"
"math/big"
"reflect"
"testing"
)
type blockToCompare struct {
block *externalapi.DomainBlock
expectedResult bool
}
type TestBlockStruct struct {
baseBlock *externalapi.DomainBlock
blocksToCompareTo []blockToCompare
}
func initTestBaseTransactions() []*externalapi.DomainTransaction {
testTx := []*externalapi.DomainTransaction{{
Version: 1,
Inputs: []*externalapi.DomainTransactionInput{},
Outputs: []*externalapi.DomainTransactionOutput{},
LockTime: 1,
SubnetworkID: externalapi.DomainSubnetworkID{0x01},
Gas: 1,
Payload: []byte{0x01},
Fee: 0,
Mass: 1,
ID: externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02}),
}}
return testTx
}
func initTestAnotherTransactions() []*externalapi.DomainTransaction {
testTx := []*externalapi.DomainTransaction{{
Version: 1,
Inputs: []*externalapi.DomainTransactionInput{},
Outputs: []*externalapi.DomainTransactionOutput{},
LockTime: 1,
SubnetworkID: externalapi.DomainSubnetworkID{0x01},
Gas: 1,
Payload: []byte{0x02},
Fee: 0,
Mass: 1,
ID: externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}),
}}
return testTx
}
func initTestTwoTransactions() []*externalapi.DomainTransaction {
testTx := []*externalapi.DomainTransaction{{
Version: 1,
Inputs: []*externalapi.DomainTransactionInput{},
Outputs: []*externalapi.DomainTransactionOutput{},
LockTime: 1,
SubnetworkID: externalapi.DomainSubnetworkID{0x01},
Gas: 1,
Payload: []byte{0x01},
Fee: 0,
Mass: 1,
ID: externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}),
}, {
Version: 1,
Inputs: []*externalapi.DomainTransactionInput{},
Outputs: []*externalapi.DomainTransactionOutput{},
LockTime: 1,
SubnetworkID: externalapi.DomainSubnetworkID{0x01},
Gas: 1,
Payload: []byte{0x01},
Fee: 0,
Mass: 1,
ID: externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}),
}}
return testTx
}
func initTestBlockStructsForClone() []*externalapi.DomainBlock {
tests := []*externalapi.DomainBlock{
{
blockheader.NewImmutableBlockHeader(
0,
[]*externalapi.DomainHash{externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{0})},
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{1}),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{2}),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{3}),
4,
5,
6,
7,
big.NewInt(8),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{9}),
),
initTestBaseTransactions(),
}, {
blockheader.NewImmutableBlockHeader(
0,
[]*externalapi.DomainHash{},
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{1}),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{2}),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{3}),
4,
5,
6,
7,
big.NewInt(8),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{9}),
),
initTestBaseTransactions(),
},
}
return tests
}
func initTestBlockStructsForEqual() *[]TestBlockStruct {
tests := []TestBlockStruct{
{
baseBlock: nil,
blocksToCompareTo: []blockToCompare{
{
block: nil,
expectedResult: true,
},
{
block: &externalapi.DomainBlock{
blockheader.NewImmutableBlockHeader(
0,
[]*externalapi.DomainHash{externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{0})},
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{1}),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{2}),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{3}),
4,
5,
6,
7,
big.NewInt(8),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{9}),
),
initTestBaseTransactions()},
expectedResult: false,
},
},
}, {
baseBlock: &externalapi.DomainBlock{
blockheader.NewImmutableBlockHeader(
0,
[]*externalapi.DomainHash{externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{1})},
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{2}),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{3}),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{4}),
5,
6,
7,
8,
big.NewInt(9),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{10}),
),
initTestBaseTransactions(),
},
blocksToCompareTo: []blockToCompare{
{
block: nil,
expectedResult: false,
},
{
block: &externalapi.DomainBlock{
blockheader.NewImmutableBlockHeader(
0,
[]*externalapi.DomainHash{externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{1})},
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{2}),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{3}),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{4}),
5,
6,
7,
8,
big.NewInt(9),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{10}),
),
initTestAnotherTransactions(),
},
expectedResult: false,
}, {
block: &externalapi.DomainBlock{
blockheader.NewImmutableBlockHeader(
0,
[]*externalapi.DomainHash{externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{1})},
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{2}),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{3}),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{4}),
5,
6,
7,
8,
big.NewInt(9),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{10}),
),
initTestBaseTransactions(),
},
expectedResult: true,
}, {
block: &externalapi.DomainBlock{
blockheader.NewImmutableBlockHeader(
0,
[]*externalapi.DomainHash{
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{1}),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{2}),
},
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{2}),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{3}),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{4}),
5,
6,
7,
8,
big.NewInt(9),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{10}),
),
initTestBaseTransactions(),
},
expectedResult: false,
}, {
block: &externalapi.DomainBlock{
blockheader.NewImmutableBlockHeader(
0,
[]*externalapi.DomainHash{externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{100})}, // Changed
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{2}),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{3}),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{4}),
5,
6,
7,
8,
big.NewInt(9),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{10}),
),
initTestTwoTransactions(),
},
expectedResult: false,
}, {
block: &externalapi.DomainBlock{
blockheader.NewImmutableBlockHeader(
0,
[]*externalapi.DomainHash{externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{1})},
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{100}), // Changed
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{3}),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{4}),
5,
6,
7,
8,
big.NewInt(9),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{10}),
),
initTestBaseTransactions(),
},
expectedResult: false,
}, {
block: &externalapi.DomainBlock{
blockheader.NewImmutableBlockHeader(
0,
[]*externalapi.DomainHash{externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{1})},
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{2}),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{100}), // Changed
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{4}),
5,
6,
7,
8,
big.NewInt(9),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{10}),
),
initTestBaseTransactions(),
},
expectedResult: false,
}, {
block: &externalapi.DomainBlock{
blockheader.NewImmutableBlockHeader(
0,
[]*externalapi.DomainHash{externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{1})},
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{2}),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{3}),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{100}), // Changed
5,
6,
7,
8,
big.NewInt(9),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{10}),
),
initTestBaseTransactions(),
},
expectedResult: false,
}, {
block: &externalapi.DomainBlock{
blockheader.NewImmutableBlockHeader(
0,
[]*externalapi.DomainHash{externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{1})},
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{2}),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{3}),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{4}),
100, // Changed
6,
7,
8,
big.NewInt(9),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{10}),
),
initTestBaseTransactions(),
},
expectedResult: false,
}, {
block: &externalapi.DomainBlock{
blockheader.NewImmutableBlockHeader(
0,
[]*externalapi.DomainHash{externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{1})},
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{2}),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{3}),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{4}),
5,
100, // Changed
7,
8,
big.NewInt(9),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{10}),
),
initTestBaseTransactions(),
},
expectedResult: false,
}, {
block: &externalapi.DomainBlock{
blockheader.NewImmutableBlockHeader(
0,
[]*externalapi.DomainHash{externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{1})},
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{2}),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{3}),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{4}),
5,
6,
100, // Changed
8,
big.NewInt(9),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{10}),
),
initTestBaseTransactions(),
},
expectedResult: false,
}, {
block: &externalapi.DomainBlock{
blockheader.NewImmutableBlockHeader(
0,
[]*externalapi.DomainHash{externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{1})},
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{2}),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{3}),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{4}),
5,
6,
7,
100, // Changed
big.NewInt(9),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{10}),
),
initTestBaseTransactions(),
},
expectedResult: false,
}, {
block: &externalapi.DomainBlock{
blockheader.NewImmutableBlockHeader(
0,
[]*externalapi.DomainHash{externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{1})},
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{2}),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{3}),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{4}),
5,
6,
7,
8,
big.NewInt(100), // Changed
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{10}),
),
initTestBaseTransactions(),
},
expectedResult: false,
}, {
block: &externalapi.DomainBlock{
blockheader.NewImmutableBlockHeader(
0,
[]*externalapi.DomainHash{externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{1})},
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{2}),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{3}),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{4}),
5,
6,
7,
8,
big.NewInt(9),
externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{100}), // Changed
),
initTestBaseTransactions(),
},
expectedResult: false,
},
},
},
}
return &tests
}
func TestDomainBlock_Equal(t *testing.T) {
blockTests := initTestBlockStructsForEqual()
for i, test := range *blockTests {
for j, subTest := range test.blocksToCompareTo {
result1 := test.baseBlock.Equal(subTest.block)
if result1 != subTest.expectedResult {
t.Fatalf("Test #%d:%d: Expected %t but got %t", i, j, subTest.expectedResult, result1)
}
result2 := subTest.block.Equal(test.baseBlock)
if result2 != subTest.expectedResult {
t.Fatalf("Test #%d:%d: Expected %t but got %t", i, j, subTest.expectedResult, result2)
}
}
}
}
func TestDomainBlock_Clone(t *testing.T) {
blocks := initTestBlockStructsForClone()
for i, block := range blocks {
blockClone := block.Clone()
if !blockClone.Equal(block) {
t.Fatalf("Test #%d:[Equal] clone should be equal to the original", i)
}
if !reflect.DeepEqual(block, blockClone) {
t.Fatalf("Test #%d:[DeepEqual] clone should be equal to the original", i)
}
}
}