diff --git a/app/protocol/flows/blockrelay/ibd.go b/app/protocol/flows/blockrelay/ibd.go index b697a8af4..34f994b44 100644 --- a/app/protocol/flows/blockrelay/ibd.go +++ b/app/protocol/flows/blockrelay/ibd.go @@ -59,8 +59,8 @@ func (flow *handleRelayInvsFlow) runIBDIfNotRunning(highHash *externalapi.Domain } if !isValid { - log.Infof("The suggested pruning point is incompatible to this node DAG, so stopping IBD with this" + - " peer") + log.Infof("The suggested pruning point %s is incompatible to this node DAG, so stopping IBD with this"+ + " peer", msgIBDRootHash.Hash) return nil } @@ -91,40 +91,6 @@ func (flow *handleRelayInvsFlow) runIBDIfNotRunning(highHash *externalapi.Domain return nil } -func (flow *handleRelayInvsFlow) fetchUTXOSetIfMissing() (bool, error) { - err := flow.outgoingRoute.Enqueue(appmessage.NewMsgRequestIBDRootHash()) - if err != nil { - return false, err - } - - message, err := flow.dequeueIncomingMessageAndSkipInvs(common.DefaultTimeout) - if err != nil { - return false, err - } - - msgIBDRootHash, ok := message.(*appmessage.MsgIBDRootHash) - if !ok { - return false, protocolerrors.Errorf(true, "received unexpected message type. "+ - "expected: %s, got: %s", appmessage.CmdIBDRootHash, message.Command()) - } - - isValid, err := flow.Domain().Consensus().IsValidPruningPoint(msgIBDRootHash.Hash) - if err != nil { - return false, err - } - - if !isValid { - return false, nil - } - - found, err := flow.fetchMissingUTXOSet(msgIBDRootHash.Hash) - if err != nil { - return false, err - } - - return found, nil -} - func (flow *handleRelayInvsFlow) syncHeaders(highHash *externalapi.DomainHash) error { log.Debugf("Trying to find highest shared chain block with peer %s with high hash %s", flow.peer, highHash) highestSharedBlockHash, err := flow.findHighestSharedBlockHash(highHash) diff --git a/domain/consensus/model/externalapi/transaction.go b/domain/consensus/model/externalapi/transaction.go index 0dec46d5a..781da21bf 100644 --- a/domain/consensus/model/externalapi/transaction.go +++ b/domain/consensus/model/externalapi/transaction.go @@ -117,12 +117,12 @@ func (tx *DomainTransaction) Equal(other *DomainTransaction) bool { return false } - if tx.Fee != other.Fee { - return false + if tx.Fee != 0 && other.Fee != 0 && tx.Fee != other.Fee { + panic(errors.New("identical transactions should always have the same fee")) } - if tx.Mass != other.Mass { - return false + if tx.Mass != 0 && other.Mass != 0 && tx.Mass != other.Mass { + panic(errors.New("identical transactions should always have the same mass")) } if tx.ID != nil && other.ID != nil && !tx.ID.Equal(other.ID) { @@ -163,8 +163,8 @@ func (input *DomainTransactionInput) Equal(other *DomainTransactionInput) bool { return false } - if !input.UTXOEntry.Equal(other.UTXOEntry) { - return false + if input.UTXOEntry != nil && other.UTXOEntry != nil && !input.UTXOEntry.Equal(other.UTXOEntry) { + panic(errors.New("identical inputs should always have the same UTXO entry")) } return true diff --git a/domain/consensus/model/externalapi/transaction_equal_clone_test.go b/domain/consensus/model/externalapi/transaction_equal_clone_test.go index 43f3d3d8d..48065b0fa 100644 --- a/domain/consensus/model/externalapi/transaction_equal_clone_test.go +++ b/domain/consensus/model/externalapi/transaction_equal_clone_test.go @@ -25,6 +25,7 @@ type testDomainTransactionStruct struct { type transactionInputToCompare struct { tx *externalapi.DomainTransactionInput expectedResult bool + expectsPanic bool } type testDomainTransactionInputStruct struct { @@ -291,7 +292,7 @@ func initTestTransactionToCompare() []*transactionToCompare { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02}), }, - expectedResult: false, + expectedResult: true, }, { tx: &externalapi.DomainTransaction{ 2, //Changed @@ -317,7 +318,7 @@ func initTestTransactionToCompare() []*transactionToCompare { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02}), - }, //6 + }, expectedResult: false, }, { tx: &externalapi.DomainTransaction{ @@ -344,8 +345,8 @@ func initTestTransactionToCompare() []*transactionToCompare { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}), - }, //7 - expectedResult: false, + }, + expectsPanic: true, }, { tx: &externalapi.DomainTransaction{ 1, @@ -463,8 +464,8 @@ func initTestTransactionToCompare() []*transactionToCompare { []*externalapi.DomainTransactionInput{{externalapi.DomainOutpoint{ *externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{0x01}), 0xFFFF}, []byte{1, 2, 3}, - uint64(0xFFFFFFFF), - utxo.NewUTXOEntry(1, []byte{0, 1, 2, 3, 4}, true, 2)}}, + uint64(0xFFFFFFF0), // Changed sequence + utxo.NewUTXOEntry(1, []byte{0, 1, 2, 3}, true, 2)}}, []*externalapi.DomainTransactionOutput{{uint64(0xFFFF), []byte{1, 2}}, {uint64(0xFFFF), []byte{1, 3}}}, @@ -485,6 +486,35 @@ func initTestTransactionToCompare() []*transactionToCompare { }, expectedResult: false, }, + { + tx: &externalapi.DomainTransaction{ + 1, + []*externalapi.DomainTransactionInput{{externalapi.DomainOutpoint{ + *externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{0x01}), 0xFFFF}, + []byte{1, 2, 3}, + uint64(0xFFFFFFFF), + utxo.NewUTXOEntry(1, []byte{0, 1, 2, 3}, true, 2)}}, + []*externalapi.DomainTransactionOutput{{uint64(0xFFFF), + []byte{1, 2}}, + {uint64(0xFFFF), + []byte{1, 3}}}, + 1, + externalapi.DomainSubnetworkID{0x01}, + 2, // Changed + *externalapi.NewDomainHashFromByteArray(&[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, 0x00}), + []byte{0x01}, + 0, + 1, + 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}), + }, + expectedResult: false, + }, } return testTx } @@ -583,7 +613,7 @@ func initTestDomainTransactionForEqual() []testDomainTransactionStruct { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}), []byte{0x01}, - 0, + 1, 1, externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, @@ -606,7 +636,7 @@ func initTestDomainTransactionForEqual() []testDomainTransactionStruct { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}), []byte{0x01}, - 0, + 1, 1, nil, }, @@ -624,11 +654,29 @@ func initTestDomainTransactionForEqual() []testDomainTransactionStruct { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}), []byte{0x01}, - 0, + 1, 1, nil, }, expectedResult: true, + }, { + tx: &externalapi.DomainTransaction{ + 1, + []*externalapi.DomainTransactionInput{}, + []*externalapi.DomainTransactionOutput{}, + 1, + externalapi.DomainSubnetworkID{0x01}, + 1, + *externalapi.NewDomainHashFromByteArray(&[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, 0x00}), + []byte{0x01}, + 2, // Changed fee + 1, + nil, + }, + expectsPanic: true, }}, }, } @@ -661,7 +709,15 @@ func initTestDomainTxInputToCompare() []*transactionInputToCompare { uint64(0xFFFFFFFF), utxo.NewUTXOEntry(1, []byte{0, 1, 2, 3}, false, 2), // Changed }, - expectedResult: false, + expectsPanic: true, + }, { + tx: &externalapi.DomainTransactionInput{ + externalapi.DomainOutpoint{*externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{0x01}), 0xFFFF}, + []byte{1, 2, 3}, + uint64(0xFFFFFFFF), + nil, // Changed + }, + expectedResult: true, }, { tx: &externalapi.DomainTransactionInput{ externalapi.DomainOutpoint{*externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{0x01}), 0xFFFF}, @@ -682,7 +738,7 @@ func initTestDomainTxInputToCompare() []*transactionInputToCompare { tx: &externalapi.DomainTransactionInput{ externalapi.DomainOutpoint{*externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{0x01, 0x02}), 0xFFFF}, // Changed []byte{1, 2, 3}, - uint64(0xFFFFFFF0), // Changed + uint64(0xFFFFFFFF), utxo.NewUTXOEntry(1, []byte{0, 1, 2, 3}, true, 2), }, expectedResult: false, @@ -690,7 +746,7 @@ func initTestDomainTxInputToCompare() []*transactionInputToCompare { tx: &externalapi.DomainTransactionInput{ externalapi.DomainOutpoint{*externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{0x01, 0x02}), 0xFFFF}, // Changed []byte{1, 2, 3}, - uint64(0xFFFFFFF0), // Changed + uint64(0xFFFFFFFF), utxo.NewUTXOEntry(2 /* Changed */, []byte{0, 1, 2, 3}, true, 2), // Changed }, expectedResult: false, @@ -698,7 +754,7 @@ func initTestDomainTxInputToCompare() []*transactionInputToCompare { tx: &externalapi.DomainTransactionInput{ externalapi.DomainOutpoint{*externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{0x01, 0x02}), 0xFFFF}, // Changed []byte{1, 2, 3}, - uint64(0xFFFFFFF0), // Changed + uint64(0xFFFFFFFF), utxo.NewUTXOEntry(3 /* Changed */, []byte{0, 1, 2, 3}, true, 3), // Changed }, expectedResult: false, @@ -852,7 +908,7 @@ func TestDomainTransaction_Equal(t *testing.T) { r := recover() panicked := r != nil if panicked != subTest.expectsPanic { - t.Fatalf("panicked expected to be %t but got %t", subTest.expectsPanic, panicked) + t.Fatalf("Test #%d:%d: panicked expected to be %t but got %t: %s", i, j, subTest.expectsPanic, panicked, r) } }() result1 := test.baseTx.Equal(subTest.tx) @@ -865,7 +921,7 @@ func TestDomainTransaction_Equal(t *testing.T) { r := recover() panicked := r != nil if panicked != subTest.expectsPanic { - t.Fatalf("panicked expected to be %t but got %t", subTest.expectsPanic, panicked) + t.Fatalf("Test #%d:%d: panicked expected to be %t but got %t: %s", i, j, subTest.expectsPanic, panicked, r) } }() result2 := subTest.tx.Equal(test.baseTx) @@ -896,14 +952,32 @@ func TestDomainTransactionInput_Equal(t *testing.T) { txTests := initTestDomainTransactionInputForEqual() for i, test := range txTests { for j, subTest := range test.transactionInputToCompareTo { - result1 := test.baseTx.Equal(subTest.tx) - if result1 != subTest.expectedResult { - t.Fatalf("Test #%d:%d: Expected %t but got %t", i, j, subTest.expectedResult, result1) - } - result2 := subTest.tx.Equal(test.baseTx) - if result2 != subTest.expectedResult { - t.Fatalf("Test #%d:%d: Expected %t but got %t", i, j, subTest.expectedResult, result2) - } + func() { + defer func() { + r := recover() + panicked := r != nil + if panicked != subTest.expectsPanic { + t.Fatalf("Test #%d:%d: panicked expected to be %t but got %t: %s", i, j, subTest.expectsPanic, panicked, r) + } + }() + result1 := test.baseTx.Equal(subTest.tx) + if result1 != subTest.expectedResult { + t.Fatalf("Test #%d:%d: Expected %t but got %t", i, j, subTest.expectedResult, result1) + } + }() + func() { + defer func() { + r := recover() + panicked := r != nil + if panicked != subTest.expectsPanic { + t.Fatalf("Test #%d:%d: panicked expected to be %t but got %t: %s", i, j, subTest.expectsPanic, panicked, r) + } + }() + result2 := subTest.tx.Equal(test.baseTx) + if result2 != subTest.expectedResult { + t.Fatalf("Test #%d:%d: Expected %t but got %t", i, j, subTest.expectedResult, result2) + } + }() } } } diff --git a/domain/consensus/model/ghostdag.go b/domain/consensus/model/ghostdag.go index d4967df71..efe5be5c9 100644 --- a/domain/consensus/model/ghostdag.go +++ b/domain/consensus/model/ghostdag.go @@ -13,6 +13,7 @@ type BlockGHOSTDAGData interface { SelectedParent() *externalapi.DomainHash MergeSetBlues() []*externalapi.DomainHash MergeSetReds() []*externalapi.DomainHash + MergeSet() []*externalapi.DomainHash BluesAnticoneSizes() map[externalapi.DomainHash]KType } diff --git a/domain/consensus/processes/consensusstatemanager/calculate_past_utxo.go b/domain/consensus/processes/consensusstatemanager/calculate_past_utxo.go index 3b6c3c419..407449dc5 100644 --- a/domain/consensus/processes/consensusstatemanager/calculate_past_utxo.go +++ b/domain/consensus/processes/consensusstatemanager/calculate_past_utxo.go @@ -37,7 +37,7 @@ func (csm *consensusStateManager) CalculatePastUTXOAndAcceptanceData(blockHash * } log.Tracef("Applying blue blocks to the selected parent past UTXO of block %s", blockHash) - acceptanceData, utxoDiff, err := csm.applyBlueBlocks(blockHash, selectedParentPastUTXO, blockGHOSTDAGData) + acceptanceData, utxoDiff, err := csm.applyMergeSetBlocks(blockHash, selectedParentPastUTXO, blockGHOSTDAGData) if err != nil { return nil, nil, nil, err } @@ -107,14 +107,14 @@ func (csm *consensusStateManager) restorePastUTXO(blockHash *externalapi.DomainH return accumulatedDiff, nil } -func (csm *consensusStateManager) applyBlueBlocks(blockHash *externalapi.DomainHash, +func (csm *consensusStateManager) applyMergeSetBlocks(blockHash *externalapi.DomainHash, selectedParentPastUTXODiff model.MutableUTXODiff, ghostdagData model.BlockGHOSTDAGData) ( externalapi.AcceptanceData, model.MutableUTXODiff, error) { - log.Tracef("applyBlueBlocks start for block %s", blockHash) - defer log.Tracef("applyBlueBlocks end for block %s", blockHash) + log.Tracef("applyMergeSetBlocks start for block %s", blockHash) + defer log.Tracef("applyMergeSetBlocks end for block %s", blockHash) - blueBlocks, err := csm.blockStore.Blocks(csm.databaseContext, ghostdagData.MergeSetBlues()) + mergeSetBlocks, err := csm.blockStore.Blocks(csm.databaseContext, ghostdagData.MergeSet()) if err != nil { return nil, nil, err } @@ -125,26 +125,26 @@ func (csm *consensusStateManager) applyBlueBlocks(blockHash *externalapi.DomainH } log.Tracef("The past median time for block %s is: %d", blockHash, selectedParentMedianTime) - multiblockAcceptanceData := make(externalapi.AcceptanceData, len(blueBlocks)) + multiblockAcceptanceData := make(externalapi.AcceptanceData, len(mergeSetBlocks)) accumulatedUTXODiff := selectedParentPastUTXODiff accumulatedMass := uint64(0) - for i, blueBlock := range blueBlocks { - blueBlockHash := consensushashing.BlockHash(blueBlock) - log.Tracef("Applying blue block %s", blueBlockHash) + for i, mergeSetBlock := range mergeSetBlocks { + mergeSetBlockHash := consensushashing.BlockHash(mergeSetBlock) + log.Tracef("Applying merge set block %s", mergeSetBlockHash) blockAcceptanceData := &externalapi.BlockAcceptanceData{ - BlockHash: blueBlockHash, - TransactionAcceptanceData: make([]*externalapi.TransactionAcceptanceData, len(blueBlock.Transactions)), + BlockHash: mergeSetBlockHash, + TransactionAcceptanceData: make([]*externalapi.TransactionAcceptanceData, len(mergeSetBlock.Transactions)), } isSelectedParent := i == 0 - log.Tracef("Is blue block %s the selected parent: %t", blueBlockHash, isSelectedParent) + log.Tracef("Is merge set block %s the selected parent: %t", mergeSetBlockHash, isSelectedParent) - for j, transaction := range blueBlock.Transactions { + for j, transaction := range mergeSetBlock.Transactions { var isAccepted bool transactionID := consensushashing.TransactionID(transaction) log.Tracef("Attempting to accept transaction %s in block %s", - transactionID, blueBlockHash) + transactionID, mergeSetBlockHash) isAccepted, accumulatedMass, err = csm.maybeAcceptTransaction(transaction, blockHash, isSelectedParent, accumulatedUTXODiff, accumulatedMass, selectedParentMedianTime, ghostdagData.BlueScore()) @@ -152,7 +152,7 @@ func (csm *consensusStateManager) applyBlueBlocks(blockHash *externalapi.DomainH return nil, nil, err } log.Tracef("Transaction %s in block %s isAccepted: %t, fee: %d", - transactionID, blueBlockHash, isAccepted, transaction.Fee) + transactionID, mergeSetBlockHash, isAccepted, transaction.Fee) blockAcceptanceData.TransactionAcceptanceData[j] = &externalapi.TransactionAcceptanceData{ Transaction: transaction, diff --git a/domain/consensus/processes/consensusstatemanager/resolve_block_status_test.go b/domain/consensus/processes/consensusstatemanager/resolve_block_status_test.go index 77f038e27..9b5511fd5 100644 --- a/domain/consensus/processes/consensusstatemanager/resolve_block_status_test.go +++ b/domain/consensus/processes/consensusstatemanager/resolve_block_status_test.go @@ -2,6 +2,9 @@ package consensusstatemanager_test import ( "errors" + "github.com/kaspanet/kaspad/domain/consensus/model" + "github.com/kaspanet/kaspad/domain/consensus/utils/constants" + "github.com/kaspanet/kaspad/domain/consensus/utils/subnetworks" "testing" "github.com/kaspanet/kaspad/domain/consensus/ruleerrors" @@ -151,6 +154,215 @@ func TestDoubleSpends(t *testing.T) { }) } +// TestTransactionAcceptance checks that blue blocks transactions are favoured above +// red blocks transactions, and that the block reward is paid only for blue blocks. +func TestTransactionAcceptance(t *testing.T) { + testutils.ForAllNets(t, true, func(t *testing.T, params *dagconfig.Params) { + params.BlockCoinbaseMaturity = 0 + + factory := consensus.NewFactory() + testConsensus, teardown, err := factory.NewTestConsensus(params, "TestTransactionAcceptance") + if err != nil { + t.Fatalf("Error setting up testConsensus: %+v", err) + } + defer teardown(false) + + fundingBlock1Hash, _, err := testConsensus.AddBlock([]*externalapi.DomainHash{params.GenesisHash}, nil, nil) + if err != nil { + t.Fatalf("Error creating fundingBlock1: %+v", err) + } + + fundingBlock2Hash, _, err := testConsensus.AddBlock([]*externalapi.DomainHash{fundingBlock1Hash}, nil, nil) + if err != nil { + t.Fatalf("Error creating fundingBlock2: %+v", err) + } + + // Generate fundingBlock3 to pay for fundingBlock2 + fundingBlock3Hash, _, err := testConsensus.AddBlock([]*externalapi.DomainHash{fundingBlock2Hash}, nil, nil) + if err != nil { + t.Fatalf("Error creating fundingBlock3: %+v", err) + } + + // Add a chain of K blocks above fundingBlock3 so we'll + // be able to mine a red block on top of it. + tipHash := fundingBlock3Hash + for i := model.KType(0); i < params.K; i++ { + var err error + tipHash, _, err = testConsensus.AddBlock([]*externalapi.DomainHash{tipHash}, nil, nil) + if err != nil { + t.Fatalf("Error creating fundingBlock1: %+v", err) + } + } + + fundingBlock2, err := testConsensus.GetBlock(fundingBlock2Hash) + if err != nil { + t.Fatalf("Error getting fundingBlock: %+v", err) + } + + fundingTransaction1 := fundingBlock2.Transactions[transactionhelper.CoinbaseTransactionIndex] + + fundingBlock3, err := testConsensus.GetBlock(fundingBlock3Hash) + if err != nil { + t.Fatalf("Error getting fundingBlock: %+v", err) + } + + fundingTransaction2 := fundingBlock3.Transactions[transactionhelper.CoinbaseTransactionIndex] + + spendingTransaction1, err := testutils.CreateTransaction(fundingTransaction1) + if err != nil { + t.Fatalf("Error creating spendingTransaction1: %+v", err) + } + + spendingTransaction2, err := testutils.CreateTransaction(fundingTransaction2) + if err != nil { + t.Fatalf("Error creating spendingTransaction1: %+v", err) + } + + redHash, _, err := testConsensus.AddBlock([]*externalapi.DomainHash{fundingBlock3Hash}, nil, + []*externalapi.DomainTransaction{spendingTransaction1, spendingTransaction2}) + if err != nil { + t.Fatalf("Error creating redBlock: %+v", err) + } + + blueScriptPublicKey := []byte{1} + blueHash, _, err := testConsensus.AddBlock([]*externalapi.DomainHash{tipHash}, &externalapi.DomainCoinbaseData{ + ScriptPublicKey: blueScriptPublicKey, + ExtraData: nil, + }, + []*externalapi.DomainTransaction{spendingTransaction1}) + if err != nil { + t.Fatalf("Error creating blue: %+v", err) + } + + // Mining two blocks so tipHash will definitely be the selected tip. + tipHash, _, err = testConsensus.AddBlock([]*externalapi.DomainHash{tipHash}, nil, nil) + if err != nil { + t.Fatalf("Error creating tip: %+v", err) + } + + finalTipSelectedParentScriptPublicKey := []byte{3} + finalTipSelectedParentHash, _, err := testConsensus.AddBlock([]*externalapi.DomainHash{tipHash}, + &externalapi.DomainCoinbaseData{ + ScriptPublicKey: finalTipSelectedParentScriptPublicKey, + ExtraData: nil, + }, nil) + if err != nil { + t.Fatalf("Error creating tip: %+v", err) + } + + finalTipHash, _, err := testConsensus.AddBlock([]*externalapi.DomainHash{finalTipSelectedParentHash, redHash, blueHash}, nil, + nil) + if err != nil { + t.Fatalf("Error creating finalTip: %+v", err) + } + + acceptanceData, err := testConsensus.AcceptanceDataStore().Get(testConsensus.DatabaseContext(), finalTipHash) + if err != nil { + t.Fatalf("Error getting acceptance data: %+v", err) + } + + finalTipSelectedParent, err := testConsensus.GetBlock(finalTipSelectedParentHash) + if err != nil { + t.Fatalf("Error getting finalTipSelectedParent: %+v", err) + } + + blue, err := testConsensus.GetBlock(blueHash) + if err != nil { + t.Fatalf("Error getting blue: %+v", err) + } + + red, err := testConsensus.GetBlock(redHash) + if err != nil { + t.Fatalf("Error getting red: %+v", err) + } + + // We expect spendingTransaction1 to be accepted by the blue block and not by the red one, because + // blue blocks in the merge set should always be ordered before red blocks in the merge set. + // We also expect spendingTransaction2 to be accepted by the red because nothing conflicts it. + expectedAcceptanceData := externalapi.AcceptanceData{ + { + BlockHash: finalTipSelectedParentHash, + TransactionAcceptanceData: []*externalapi.TransactionAcceptanceData{ + { + Transaction: finalTipSelectedParent.Transactions[0], + Fee: 0, + IsAccepted: true, + }, + }, + }, + { + BlockHash: blueHash, + TransactionAcceptanceData: []*externalapi.TransactionAcceptanceData{ + { + Transaction: blue.Transactions[0], + Fee: 0, + IsAccepted: false, + }, + { + Transaction: spendingTransaction1, + Fee: 1, + IsAccepted: true, + }, + }, + }, + { + BlockHash: redHash, + TransactionAcceptanceData: []*externalapi.TransactionAcceptanceData{ + { + Transaction: red.Transactions[0], + Fee: 0, + IsAccepted: false, + }, + { + Transaction: spendingTransaction1, + Fee: 0, + IsAccepted: false, + }, + { + Transaction: spendingTransaction2, + Fee: 1, + IsAccepted: true, + }, + }, + }, + } + + if !acceptanceData.Equal(expectedAcceptanceData) { + t.Fatalf("The acceptance data is not the expected acceptance data") + } + + finalTip, err := testConsensus.GetBlock(finalTipHash) + if err != nil { + t.Fatalf("Error getting finalTip: %+v", err) + } + + // We expect the coinbase transaction to pay reward for the selected parent, the + // blue block, and not for the red block. + expectedCoinbase := &externalapi.DomainTransaction{ + Version: constants.TransactionVersion, + Inputs: nil, + Outputs: []*externalapi.DomainTransactionOutput{ + { + Value: 50 * constants.SompiPerKaspa, + ScriptPublicKey: finalTipSelectedParentScriptPublicKey, + }, + { + Value: 50*constants.SompiPerKaspa + 1, // testutils.CreateTransaction pays a fee of 1 sompi + ScriptPublicKey: blueScriptPublicKey, + }, + }, + LockTime: 0, + SubnetworkID: subnetworks.SubnetworkIDCoinbase, + Gas: 0, + PayloadHash: finalTip.Transactions[0].PayloadHash, + Payload: finalTip.Transactions[0].Payload, + } + if !finalTip.Transactions[transactionhelper.CoinbaseTransactionIndex].Equal(expectedCoinbase) { + t.Fatalf("Unexpected coinbase transaction") + } + }) +} + func TestResolveBlockStatusSanity(t *testing.T) { testutils.ForAllNets(t, true, func(t *testing.T, params *dagconfig.Params) { consensus, teardown, err := consensus.NewFactory().NewTestConsensus(params, "TestResolveBlockStatusSanity") diff --git a/domain/consensus/processes/ghostdagmanager/ghostdag_data.go b/domain/consensus/processes/ghostdagmanager/ghostdag_data.go index a488542c0..49fc39090 100644 --- a/domain/consensus/processes/ghostdagmanager/ghostdag_data.go +++ b/domain/consensus/processes/ghostdagmanager/ghostdag_data.go @@ -57,3 +57,13 @@ func (bgd *blockGHOSTDAGData) MergeSetReds() []*externalapi.DomainHash { func (bgd *blockGHOSTDAGData) BluesAnticoneSizes() map[externalapi.DomainHash]model.KType { return bgd.bluesAnticoneSizes } + +func (bgd *blockGHOSTDAGData) MergeSet() []*externalapi.DomainHash { + mergeSet := make([]*externalapi.DomainHash, len(bgd.mergeSetBlues)+len(bgd.mergeSetReds)) + copy(mergeSet, bgd.mergeSetBlues) + if len(bgd.mergeSetReds) > 0 { + copy(mergeSet[len(bgd.mergeSetBlues):], bgd.mergeSetReds) + } + + return mergeSet +} diff --git a/util/address.go b/util/address.go index 9ac4a0a37..5162cfe1c 100644 --- a/util/address.go +++ b/util/address.go @@ -135,7 +135,8 @@ func DecodeAddress(addr string, expectedPrefix Bech32Prefix) (Address, error) { return nil, errors.Errorf("decoded address's prefix could not be parsed: %s", err) } if expectedPrefix != Bech32PrefixUnknown && expectedPrefix != prefix { - return nil, errors.Errorf("decoded address is of wrong network: %s", err) + return nil, errors.Errorf("decoded address is of wrong network. Expected %s but got %s", expectedPrefix, + prefix) } // Switch on decoded length to determine the type.