Mirroristas/kaspad
2
0
Fork 0
mirror of https://github.com/kaspanet/kaspad.git synced 2025-11-24 14:35:53 +00:00
Code Issues Packages Projects Releases Wiki Activity

address reveiw

Browse Source
This commit is contained in:
D-Stacks 2022-07-22 21:01:26 +02:00
parent 79c934e39c
commit 762ea907c4
14 changed files with 58 additions and 122 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
app/protocol/flows/v5/transactionrelay/handle_requested_transactions.go
View File

@ -30,10 +30,6 @@ func (flow *handleRequestedTransactionsFlow) start() error {
} }
for _, transactionID := range msgRequestTransactions.IDs { for _, transactionID := range msgRequestTransactions.IDs {
//note: below ignores orphan txs that are requested
//find out if this is good or bad practice
//only reference i found to this, is that nodes don't do this in btc
//source: https://arxiv.org/abs/1912.11541 (2nd sentence in abstract)
tx, _, ok := flow.Domain().MiningManager().GetTransaction(transactionID, true, false) tx, _, ok := flow.Domain().MiningManager().GetTransaction(transactionID, true, false)
if !ok { if !ok {

17
app/rpc/rpchandlers/get_mempool_entry.go
View File

@ -6,7 +6,6 @@ import (
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi" "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/kaspanet/kaspad/domain/consensus/utils/transactionid" "github.com/kaspanet/kaspad/domain/consensus/utils/transactionid"
"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router" "github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
"github.com/pkg/errors"
) )
// HandleGetMempoolEntry handles the respectively named RPC command // HandleGetMempoolEntry handles the respectively named RPC command
@ -25,25 +24,15 @@ func HandleGetMempoolEntry(context *rpccontext.Context, _ *router.Router, reques
return errorMessage, nil return errorMessage, nil
} }
transactionPoolTransaction, orphanPoolTransaction, found := context.Domain.MiningManager().GetTransaction(transactionID, !getMempoolEntryRequest.FilterTransactionPool, getMempoolEntryRequest.IncludeOrphanPool) mempoolTransaction, isOrphan, found := context.Domain.MiningManager().GetTransaction(transactionID, !getMempoolEntryRequest.FilterTransactionPool, getMempoolEntryRequest.IncludeOrphanPool)
if !found { if !found || isOrphan && !getMempoolEntryRequest.IncludeOrphanPool || !isOrphan && !getMempoolEntryRequest.FilterTransactionPool {
errorMessage := &appmessage.GetMempoolEntryResponseMessage{} errorMessage := &appmessage.GetMempoolEntryResponseMessage{}
errorMessage.Error = appmessage.RPCErrorf("Transaction %s was not found", transactionID) errorMessage.Error = appmessage.RPCErrorf("Transaction %s was not found", transactionID)
return errorMessage, nil return errorMessage, nil
} }
if transactionPoolTransaction != nil && orphanPoolTransaction != nil { rpcTransaction := appmessage.DomainTransactionToRPCTransaction(mempoolTransaction)
return nil, errors.Errorf("Transaction %s is both an orphan, and not. This should never not happen", transactionID)
} else if transactionPoolTransaction != nil {
transaction = transactionPoolTransaction
isOrphan = false
} else if orphanPoolTransaction != nil {
transaction = orphanPoolTransaction
isOrphan = true
}
rpcTransaction := appmessage.DomainTransactionToRPCTransaction(transaction)
err = context.PopulateTransactionWithVerboseData(rpcTransaction, nil) err = context.PopulateTransactionWithVerboseData(rpcTransaction, nil)
if err != nil { if err != nil {
return nil, err return nil, err

2
domain/miningmanager/factory.go
View File

@ -20,7 +20,7 @@ type factory struct{}
func (f *factory) NewMiningManager(consensusReference consensusreference.ConsensusReference, params *dagconfig.Params, func (f *factory) NewMiningManager(consensusReference consensusreference.ConsensusReference, params *dagconfig.Params,
mempoolConfig *mempoolpkg.Config) MiningManager { mempoolConfig *mempoolpkg.Config) MiningManager {
mempool := mempoolpkg.New(mempoolConfig, params, consensusReference) mempool := mempoolpkg.New(mempoolConfig, consensusReference)
blockTemplateBuilder := blocktemplatebuilder.New(consensusReference, mempool, params.MaxBlockMass, params.CoinbasePayloadScriptPublicKeyMaxLength) blockTemplateBuilder := blocktemplatebuilder.New(consensusReference, mempool, params.MaxBlockMass, params.CoinbasePayloadScriptPublicKeyMaxLength)
return &miningManager{ return &miningManager{

6
domain/miningmanager/mempool/check_transaction_standard_test.go
View File

@ -95,7 +95,7 @@ func TestCalcMinRequiredTxRelayFee(t *testing.T) {
mempoolConfig.MinimumRelayTransactionFee = test.minimumRelayTransactionFee mempoolConfig.MinimumRelayTransactionFee = test.minimumRelayTransactionFee
tcAsConsensus := tc.(externalapi.Consensus) tcAsConsensus := tc.(externalapi.Consensus)
tcAsConsensusPointer := &tcAsConsensus tcAsConsensusPointer := &tcAsConsensus
mempool := New(mempoolConfig, tc.DAGParams(), consensusreference.NewConsensusReference(&tcAsConsensusPointer)).(*mempool) mempool := New(mempoolConfig, consensusreference.NewConsensusReference(&tcAsConsensusPointer)).(*mempool)
got := mempool.minimumRequiredTransactionRelayFee(test.size) got := mempool.minimumRequiredTransactionRelayFee(test.size)
if got != test.want { if got != test.want {
@ -184,7 +184,7 @@ func TestIsTransactionOutputDust(t *testing.T) {
mempoolConfig.MinimumRelayTransactionFee = test.minimumRelayTransactionFee mempoolConfig.MinimumRelayTransactionFee = test.minimumRelayTransactionFee
tcAsConsensus := tc.(externalapi.Consensus) tcAsConsensus := tc.(externalapi.Consensus)
tcAsConsensusPointer := &tcAsConsensus tcAsConsensusPointer := &tcAsConsensus
mempool := New(mempoolConfig, tc.DAGParams(), consensusreference.NewConsensusReference(&tcAsConsensusPointer)).(*mempool) mempool := New(mempoolConfig, consensusreference.NewConsensusReference(&tcAsConsensusPointer)).(*mempool)
res := mempool.IsTransactionOutputDust(&test.txOut) res := mempool.IsTransactionOutputDust(&test.txOut)
if res != test.isDust { if res != test.isDust {
@ -306,7 +306,7 @@ func TestCheckTransactionStandardInIsolation(t *testing.T) {
tcAsConsensus := tc.(externalapi.Consensus) tcAsConsensus := tc.(externalapi.Consensus)
tcAsConsensusPointer := &tcAsConsensus tcAsConsensusPointer := &tcAsConsensus
consensusReference := consensusreference.NewConsensusReference(&tcAsConsensusPointer) consensusReference := consensusreference.NewConsensusReference(&tcAsConsensusPointer)
mempool := New(mempoolConfig, tc.DAGParams(), consensusReference).(*mempool) mempool := New(mempoolConfig, consensusReference).(*mempool)
// Ensure standardness is as expected. // Ensure standardness is as expected.
err := mempool.checkTransactionStandardInIsolation(test.tx) err := mempool.checkTransactionStandardInIsolation(test.tx)

4
domain/miningmanager/mempool/handle_new_block_transactions.go
View File

@ -6,7 +6,7 @@ import (
"github.com/kaspanet/kaspad/domain/consensus/utils/transactionhelper" "github.com/kaspanet/kaspad/domain/consensus/utils/transactionhelper"
) )
func (mp *mempool) handleNewBlockTransactions(blockTransactions []*externalapi.DomainTransaction, clone bool) ( func (mp *mempool) handleNewBlockTransactions(blockTransactions []*externalapi.DomainTransaction,) (
[]*externalapi.DomainTransaction, error) { []*externalapi.DomainTransaction, error) {
// Skip the coinbase transaction // Skip the coinbase transaction
@ -30,7 +30,7 @@ func (mp *mempool) handleNewBlockTransactions(blockTransactions []*externalapi.D
return nil, err return nil, err
} }
acceptedOrphansFromThisTransaction, err := mp.orphansPool.processOrphansAfterAcceptedTransaction(transaction, clone) acceptedOrphansFromThisTransaction, err := mp.orphansPool.processOrphansAfterAcceptedTransaction(transaction)
if err != nil { if err != nil {
return nil, err return nil, err
} }

36
domain/miningmanager/mempool/mempool.go
View File

@ -4,7 +4,6 @@ import (
"sync" "sync"
"github.com/kaspanet/kaspad/domain/consensusreference" "github.com/kaspanet/kaspad/domain/consensusreference"
"github.com/kaspanet/kaspad/domain/dagconfig"
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi" "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
miningmanagermodel "github.com/kaspanet/kaspad/domain/miningmanager/model" miningmanagermodel "github.com/kaspanet/kaspad/domain/miningmanager/model"
@ -14,7 +13,6 @@ type mempool struct {
mtx sync.RWMutex mtx sync.RWMutex
config *Config config *Config
params *dagconfig.Params
consensusReference consensusreference.ConsensusReference consensusReference consensusreference.ConsensusReference
mempoolUTXOSet *mempoolUTXOSet mempoolUTXOSet *mempoolUTXOSet
@ -23,10 +21,9 @@ type mempool struct {
} }
// New constructs a new mempool // New constructs a new mempool
func New(config *Config, params *dagconfig.Params, consensusReference consensusreference.ConsensusReference) miningmanagermodel.Mempool { func New(config *Config, consensusReference consensusreference.ConsensusReference) miningmanagermodel.Mempool {
mp := &mempool{ mp := &mempool{
config: config, config: config,
params: params,
consensusReference: consensusReference, consensusReference: consensusReference,
} }
@ -43,30 +40,31 @@ func (mp *mempool) ValidateAndInsertTransaction(transaction *externalapi.DomainT
mp.mtx.Lock() mp.mtx.Lock()
defer mp.mtx.Unlock() defer mp.mtx.Unlock()
return mp.validateAndInsertTransaction(transaction, isHighPriority, allowOrphan, true) return mp.validateAndInsertTransaction(transaction, isHighPriority, allowOrphan)
} }
func (mp *mempool) GetTransaction(transactionID *externalapi.DomainTransactionID, func (mp *mempool) GetTransaction(transactionID *externalapi.DomainTransactionID,
includeTransactionPool bool, includeTransactionPool bool,
includeOrphanPool bool) ( includeOrphanPool bool) (
transactionPoolTransaction *externalapi.DomainTransaction, transaction *externalapi.DomainTransaction,
orphanPoolTransaction *externalapi.DomainTransaction, isOrphan bool,
found bool) { found bool) {
mp.mtx.RLock() mp.mtx.RLock()
defer mp.mtx.RUnlock() defer mp.mtx.RUnlock()
var transactionfound bool var transactionfound bool
var orphanTransactionFound bool isOrphan = false
if includeTransactionPool { if includeTransactionPool {
transactionPoolTransaction, transactionfound = mp.transactionsPool.getTransaction(transactionID, true) transaction, transactionfound = mp.transactionsPool.getTransaction(transactionID, true)
} }
if includeOrphanPool { if !transactionfound && includeOrphanPool {
orphanPoolTransaction, orphanTransactionFound = mp.orphansPool.getOrphanTransaction(transactionID, true) transaction, transactionfound = mp.orphansPool.getOrphanTransaction(transactionID)
isOrphan = true
} }
return transactionPoolTransaction, orphanPoolTransaction, transactionfound || orphanTransactionFound return transaction, isOrphan, transactionfound
} }
func (mp *mempool) GetTransactionsByAddresses(includeTransactionPool bool, includeOrphanPool bool) ( func (mp *mempool) GetTransactionsByAddresses(includeTransactionPool bool, includeOrphanPool bool) (
@ -79,14 +77,14 @@ func (mp *mempool) GetTransactionsByAddresses(includeTransactionPool bool, inclu
defer mp.mtx.RUnlock() defer mp.mtx.RUnlock()
if includeTransactionPool { if includeTransactionPool {
sendingInTransactionPool, receivingInTransactionPool, err = mp.transactionsPool.getTransactionsByAddresses(true) sendingInTransactionPool, receivingInTransactionPool, err = mp.transactionsPool.getTransactionsByAddresses()
if err != nil { if err != nil {
return nil, nil, nil, nil, err return nil, nil, nil, nil, err
} }
} }
if includeOrphanPool { if includeOrphanPool {
sendingInTransactionPool, receivingInOrphanPool, err = mp.orphansPool.getOrphanTransactionsByAddresses(true) sendingInTransactionPool, receivingInOrphanPool, err = mp.orphansPool.getOrphanTransactionsByAddresses()
if err != nil { if err != nil {
return nil, nil, nil, nil, err return nil, nil, nil, nil, err
} }
@ -103,11 +101,11 @@ func (mp *mempool) AllTransactions(includeTransactionPool bool, includeOrphanPoo
defer mp.mtx.RUnlock() defer mp.mtx.RUnlock()
if includeTransactionPool { if includeTransactionPool {
transactionPoolTransactions = mp.transactionsPool.getAllTransactions(true) transactionPoolTransactions = mp.transactionsPool.getAllTransactions()
} }
if includeOrphanPool { if includeOrphanPool {
orphanPoolTransactions = mp.orphansPool.getAllOrphanTransactions(true) orphanPoolTransactions = mp.orphansPool.getAllOrphanTransactions()
} }
return transactionPoolTransactions, orphanPoolTransactions return transactionPoolTransactions, orphanPoolTransactions
@ -135,21 +133,21 @@ func (mp *mempool) HandleNewBlockTransactions(transactions []*externalapi.Domain
mp.mtx.Lock() mp.mtx.Lock()
defer mp.mtx.Unlock() defer mp.mtx.Unlock()
return mp.handleNewBlockTransactions(transactions, true) return mp.handleNewBlockTransactions(transactions)
} }
func (mp *mempool) BlockCandidateTransactions() []*externalapi.DomainTransaction { func (mp *mempool) BlockCandidateTransactions() []*externalapi.DomainTransaction {
mp.mtx.RLock() mp.mtx.RLock()
defer mp.mtx.RUnlock() defer mp.mtx.RUnlock()
return mp.transactionsPool.allReadyTransactions(true) return mp.transactionsPool.allReadyTransactions()
} }
func (mp *mempool) RevalidateHighPriorityTransactions() (validTransactions []*externalapi.DomainTransaction, err error) { func (mp *mempool) RevalidateHighPriorityTransactions() (validTransactions []*externalapi.DomainTransaction, err error) {
mp.mtx.Lock() mp.mtx.Lock()
defer mp.mtx.Unlock() defer mp.mtx.Unlock()
return mp.revalidateHighPriorityTransactions(true) return mp.revalidateHighPriorityTransactions()
} }
func (mp *mempool) RemoveTransactions(transactions []*externalapi.DomainTransaction, removeRedeemers bool) error { func (mp *mempool) RemoveTransactions(transactions []*externalapi.DomainTransaction, removeRedeemers bool) error {

31
domain/miningmanager/mempool/orphan_pool.go
View File

@ -134,7 +134,7 @@ func (op *orphansPool) addOrphan(transaction *externalapi.DomainTransaction, isH
return nil return nil
} }
func (op *orphansPool) processOrphansAfterAcceptedTransaction(acceptedTransaction *externalapi.DomainTransaction, clone bool) ( func (op *orphansPool) processOrphansAfterAcceptedTransaction(acceptedTransaction *externalapi.DomainTransaction) (
acceptedOrphans []*externalapi.DomainTransaction, err error) { acceptedOrphans []*externalapi.DomainTransaction, err error) {
acceptedOrphans = []*externalapi.DomainTransaction{} acceptedOrphans = []*externalapi.DomainTransaction{}
@ -169,11 +169,7 @@ func (op *orphansPool) processOrphansAfterAcceptedTransaction(acceptedTransactio
} }
return nil, err return nil, err
} }
if clone { acceptedOrphans = append(acceptedOrphans, orphan.Transaction().Clone()) //these pointers leave the mempool, hence the clone
acceptedOrphans = append(acceptedOrphans, orphan.Transaction().Clone())
} else {
acceptedOrphans = append(acceptedOrphans, orphan.Transaction())
}
} }
} }
} }
@ -333,17 +329,14 @@ func (op *orphansPool) randomNonHighPriorityOrphan() *model.OrphanTransaction {
return nil return nil
} }
func (op *orphansPool) getOrphanTransaction(transactionID *externalapi.DomainTransactionID, clone bool) (*externalapi.DomainTransaction, bool) { func (op *orphansPool) getOrphanTransaction(transactionID *externalapi.DomainTransactionID) (*externalapi.DomainTransaction, bool) {
if orphanTransaction, ok := op.allOrphans[*transactionID]; ok { if orphanTransaction, ok := op.allOrphans[*transactionID]; ok {
if clone { return orphanTransaction.Transaction().Clone(), true //this pointer leaves the mempool, hence we clone.
return orphanTransaction.Transaction().Clone(), true
}
return orphanTransaction.Transaction(), true
} }
return nil, false return nil, false
} }
func (op *orphansPool) getOrphanTransactionsByAddresses(clone bool) ( func (op *orphansPool) getOrphanTransactionsByAddresses() (
sending model.ScriptPublicKeyStringToDomainTransaction, sending model.ScriptPublicKeyStringToDomainTransaction,
receiving model.ScriptPublicKeyStringToDomainTransaction, receiving model.ScriptPublicKeyStringToDomainTransaction,
err error) { err error) {
@ -351,11 +344,7 @@ func (op *orphansPool) getOrphanTransactionsByAddresses(clone bool) (
receiving = make(model.ScriptPublicKeyStringToDomainTransaction) receiving = make(model.ScriptPublicKeyStringToDomainTransaction)
var transaction *externalapi.DomainTransaction var transaction *externalapi.DomainTransaction
for _, mempoolTransaction := range op.allOrphans { for _, mempoolTransaction := range op.allOrphans {
if clone { transaction = mempoolTransaction.Transaction().Clone() //these pointers leave the mempool, hence we clone.
transaction = mempoolTransaction.Transaction().Clone()
} else {
transaction = mempoolTransaction.Transaction()
}
for _, input := range transaction.Inputs { for _, input := range transaction.Inputs {
if input.UTXOEntry == nil { //this is not a bug, but a valid state of orphan transactions with missing outpoints. if input.UTXOEntry == nil { //this is not a bug, but a valid state of orphan transactions with missing outpoints.
continue continue
@ -371,15 +360,11 @@ func (op *orphansPool) getOrphanTransactionsByAddresses(clone bool) (
return sending, receiving, nil return sending, receiving, nil
} }
func (op *orphansPool) getAllOrphanTransactions(clone bool) []*externalapi.DomainTransaction { func (op *orphansPool) getAllOrphanTransactions() []*externalapi.DomainTransaction {
allOrphanTransactions := make([]*externalapi.DomainTransaction, len(op.allOrphans)) allOrphanTransactions := make([]*externalapi.DomainTransaction, len(op.allOrphans))
i := 0 i := 0
for _, mempoolTransaction := range op.allOrphans { for _, mempoolTransaction := range op.allOrphans {
if clone { allOrphanTransactions[i] = mempoolTransaction.Transaction().Clone() //these pointers leave the mempool, hence we clone.
allOrphanTransactions[i] = mempoolTransaction.Transaction().Clone()
} else {
allOrphanTransactions[i] = mempoolTransaction.Transaction()
}
i++ i++
} }
return allOrphanTransactions return allOrphanTransactions

32
domain/miningmanager/mempool/revalidate_high_priority_transactions.go
View File

@ -6,35 +6,21 @@ import (
"github.com/kaspanet/kaspad/infrastructure/logger" "github.com/kaspanet/kaspad/infrastructure/logger"
) )
func (mp *mempool) revalidateHighPriorityTransactions(clone bool) ([]*externalapi.DomainTransaction, error) { func (mp *mempool) revalidateHighPriorityTransactions() ([]*externalapi.DomainTransaction, error) {
onEnd := logger.LogAndMeasureExecutionTime(log, "revalidateHighPriorityTransactions") onEnd := logger.LogAndMeasureExecutionTime(log, "revalidateHighPriorityTransactions")
defer onEnd() defer onEnd()
validTransactions := []*externalapi.DomainTransaction{} validTransactions := []*externalapi.DomainTransaction{}
if !clone { for _, transaction := range mp.transactionsPool.highPriorityTransactions {
for _, transaction := range mp.transactionsPool.highPriorityTransactions { isValid, err := mp.revalidateTransaction(transaction)
isValid, err := mp.revalidateTransaction(transaction) if err != nil {
if err != nil { return nil, err
return nil, err
}
if !isValid {
continue
}
validTransactions = append(validTransactions, transaction.Transaction())
} }
} else { if !isValid {
for _, transaction := range mp.transactionsPool.highPriorityTransactions { continue
isValid, err := mp.revalidateTransaction(transaction)
if err != nil {
return nil, err
}
if !isValid {
continue
}
validTransactions = append(validTransactions, transaction.Transaction().Clone())
} }
validTransactions = append(validTransactions, transaction.Transaction().Clone())
} }
return validTransactions, nil return validTransactions, nil

26
domain/miningmanager/mempool/transactions_pool.go
View File

@ -131,16 +131,12 @@ func (tp *transactionsPool) expireOldTransactions() error {
return nil return nil
} }
func (tp *transactionsPool) allReadyTransactions(clone bool) []*externalapi.DomainTransaction { func (tp *transactionsPool) allReadyTransactions() []*externalapi.DomainTransaction {
result := []*externalapi.DomainTransaction{} result := []*externalapi.DomainTransaction{}
for _, mempoolTransaction := range tp.allTransactions { for _, mempoolTransaction := range tp.allTransactions {
if len(mempoolTransaction.ParentTransactionsInPool()) == 0 { if len(mempoolTransaction.ParentTransactionsInPool()) == 0 {
if clone { result = append(result, mempoolTransaction.Transaction().Clone())
result = append(result, mempoolTransaction.Transaction().Clone())
} else {
result = append(result, mempoolTransaction.Transaction())
}
} }
} }
@ -219,7 +215,7 @@ func (tp *transactionsPool) getTransaction(transactionID *externalapi.DomainTran
return nil, false return nil, false
} }
func (tp *transactionsPool) getTransactionsByAddresses(clone bool) ( func (tp *transactionsPool) getTransactionsByAddresses() (
sending model.ScriptPublicKeyStringToDomainTransaction, sending model.ScriptPublicKeyStringToDomainTransaction,
receiving model.ScriptPublicKeyStringToDomainTransaction, receiving model.ScriptPublicKeyStringToDomainTransaction,
err error) { err error) {
@ -227,13 +223,9 @@ func (tp *transactionsPool) getTransactionsByAddresses(clone bool) (
receiving = make(model.ScriptPublicKeyStringToDomainTransaction) receiving = make(model.ScriptPublicKeyStringToDomainTransaction)
var transaction *externalapi.DomainTransaction var transaction *externalapi.DomainTransaction
for _, mempoolTransaction := range tp.allTransactions { for _, mempoolTransaction := range tp.allTransactions {
if clone { transaction = mempoolTransaction.Transaction().Clone()
transaction = mempoolTransaction.Transaction().Clone()
} else {
transaction = mempoolTransaction.Transaction()
}
for _, input := range transaction.Inputs { for _, input := range transaction.Inputs {
if input.UTXOEntry == nil { //this should be fixed if input.UTXOEntry == nil {
return nil, nil, errors.Errorf("Mempool transaction %s is missing an UTXOEntry. This should be fixed, and not happen", consensushashing.TransactionID(transaction).String()) return nil, nil, errors.Errorf("Mempool transaction %s is missing an UTXOEntry. This should be fixed, and not happen", consensushashing.TransactionID(transaction).String())
} }
sending[input.UTXOEntry.ScriptPublicKey().String()] = transaction sending[input.UTXOEntry.ScriptPublicKey().String()] = transaction
@ -245,15 +237,11 @@ func (tp *transactionsPool) getTransactionsByAddresses(clone bool) (
return sending, receiving, nil return sending, receiving, nil
} }
func (tp *transactionsPool) getAllTransactions(clone bool) []*externalapi.DomainTransaction { func (tp *transactionsPool) getAllTransactions() []*externalapi.DomainTransaction {
allTransactions := make([]*externalapi.DomainTransaction, len(tp.allTransactions)) allTransactions := make([]*externalapi.DomainTransaction, len(tp.allTransactions))
i := 0 i := 0
for _, mempoolTransaction := range tp.allTransactions { for _, mempoolTransaction := range tp.allTransactions {
if clone { allTransactions[i] = mempoolTransaction.Transaction().Clone()
allTransactions[i] = mempoolTransaction.Transaction().Clone()
} else {
allTransactions[i] = mempoolTransaction.Transaction()
}
i++ i++
} }
return allTransactions return allTransactions

10
domain/miningmanager/mempool/validate_and_insert_transaction.go
View File

@ -10,7 +10,7 @@ import (
) )
func (mp *mempool) validateAndInsertTransaction(transaction *externalapi.DomainTransaction, isHighPriority bool, func (mp *mempool) validateAndInsertTransaction(transaction *externalapi.DomainTransaction, isHighPriority bool,
allowOrphan bool, clone bool) (acceptedTransactions []*externalapi.DomainTransaction, err error) { allowOrphan bool) (acceptedTransactions []*externalapi.DomainTransaction, err error) {
onEnd := logger.LogAndMeasureExecutionTime(log, onEnd := logger.LogAndMeasureExecutionTime(log,
fmt.Sprintf("validateAndInsertTransaction %s", consensushashing.TransactionID(transaction))) fmt.Sprintf("validateAndInsertTransaction %s", consensushashing.TransactionID(transaction)))
@ -49,16 +49,12 @@ func (mp *mempool) validateAndInsertTransaction(transaction *externalapi.DomainT
return nil, err return nil, err
} }
acceptedOrphans, err := mp.orphansPool.processOrphansAfterAcceptedTransaction(mempoolTransaction.Transaction(), clone) acceptedOrphans, err := mp.orphansPool.processOrphansAfterAcceptedTransaction(mempoolTransaction.Transaction(),)
if err != nil { if err != nil {
return nil, err return nil, err
} }
if clone { acceptedTransactions = append([]*externalapi.DomainTransaction{transaction.Clone()}, acceptedOrphans...)
acceptedTransactions = append([]*externalapi.DomainTransaction{transaction.Clone()}, acceptedOrphans...)
} else {
acceptedTransactions = append([]*externalapi.DomainTransaction{transaction}, acceptedOrphans...)
}
err = mp.transactionsPool.limitTransactionCount() err = mp.transactionsPool.limitTransactionCount()
if err != nil { if err != nil {

4
domain/miningmanager/miningmanager.go
View File

@ -17,7 +17,7 @@ type MiningManager interface {
GetBlockTemplateBuilder() miningmanagermodel.BlockTemplateBuilder GetBlockTemplateBuilder() miningmanagermodel.BlockTemplateBuilder
GetTransaction(transactionID *externalapi.DomainTransactionID, includeTransactionPool bool, includeOrphanPool bool) ( GetTransaction(transactionID *externalapi.DomainTransactionID, includeTransactionPool bool, includeOrphanPool bool) (
transactionPoolTransaction *externalapi.DomainTransaction, transactionPoolTransaction *externalapi.DomainTransaction,
orphanPoolTransaction *externalapi.DomainTransaction, isOrphan bool,
found bool) found bool)
GetTransactionsByAddresses(includeTransactionPool bool, includeOrphanPool bool) ( GetTransactionsByAddresses(includeTransactionPool bool, includeOrphanPool bool) (
sendingInTransactionPool map[string]*externalapi.DomainTransaction, sendingInTransactionPool map[string]*externalapi.DomainTransaction,
@ -122,7 +122,7 @@ func (mm *miningManager) GetTransaction(
includeTransactionPool bool, includeTransactionPool bool,
includeOrphanPool bool) ( includeOrphanPool bool) (
transactionPoolTransaction *externalapi.DomainTransaction, transactionPoolTransaction *externalapi.DomainTransaction,
orphanPoolTransaction *externalapi.DomainTransaction, isOrphan bool,
found bool) { found bool) {
return mm.mempool.GetTransaction(transactionID, includeTransactionPool, includeOrphanPool) return mm.mempool.GetTransaction(transactionID, includeTransactionPool, includeOrphanPool)

5
domain/miningmanager/miningmanager_test.go
View File

@ -227,7 +227,6 @@ func TestHandleNewBlockTransactions(t *testing.T) {
} }
mempoolTransactions, _ = miningManager.AllTransactions(true, false) mempoolTransactions, _ = miningManager.AllTransactions(true, false)
if len(mempoolTransactions) != 0 { if len(mempoolTransactions) != 0 {
mempoolTransactions, _ = miningManager.AllTransactions(true, false)
blockIDs := domainBlocksToBlockIds(mempoolTransactions) blockIDs := domainBlocksToBlockIds(mempoolTransactions)
t.Fatalf("The mempool contains unexpected transactions: %s", blockIDs) t.Fatalf("The mempool contains unexpected transactions: %s", blockIDs)
} }
@ -608,7 +607,7 @@ func TestModifyBlockTemplate(t *testing.T) {
t.Fatalf("ValidateAndInsertTransaction: %v", err) t.Fatalf("ValidateAndInsertTransaction: %v", err)
} }
} }
transactionsMempool, _ := miningManager.AllTransactions(true, true) transactionsMempool, _ := miningManager.AllTransactions(true, false)
for _, transaction := range transactionsMempool { for _, transaction := range transactionsMempool {
if contains(transaction, childTransactions) { if contains(transaction, childTransactions) {
t.Fatalf("Error: an orphan transaction is exist in the mempool") t.Fatalf("Error: an orphan transaction is exist in the mempool")
@ -657,7 +656,7 @@ func TestModifyBlockTemplate(t *testing.T) {
if err != nil { if err != nil {
t.Fatalf("HandleNewBlockTransactions: %+v", err) t.Fatalf("HandleNewBlockTransactions: %+v", err)
} }
transactionsMempool, _ = miningManager.AllTransactions(true, true) transactionsMempool, _ = miningManager.AllTransactions(true, false)
if len(transactionsMempool) != len(childTransactions) { if len(transactionsMempool) != len(childTransactions) {
t.Fatalf("Expected %d transactions in the mempool but got %d", len(childTransactions), len(transactionsMempool)) t.Fatalf("Expected %d transactions in the mempool but got %d", len(childTransactions), len(transactionsMempool))
} }

2
domain/miningmanager/model/interface_mempool.go
View File

@ -18,7 +18,7 @@ type Mempool interface {
includeOrphanPool bool, includeOrphanPool bool,
) ( ) (
transactionPoolTransaction *externalapi.DomainTransaction, transactionPoolTransaction *externalapi.DomainTransaction,
orphanPoolTransaction *externalapi.DomainTransaction, isOrphan bool,
found bool) found bool)
GetTransactionsByAddresses( GetTransactionsByAddresses(
includeTransactionPool bool, includeTransactionPool bool,

1
testing/integration/tx_relay_test.go
View File

@ -103,7 +103,6 @@ func TestTxRelay(t *testing.T) {
t.Fatal("Error payer is reciving") t.Fatal("Error payer is reciving")
} }
} }
for _, mempoolEntry := range mempoolEntryByAddress.Receiving { for _, mempoolEntry := range mempoolEntryByAddress.Receiving {
if mempoolEntry.IsOrphan { if mempoolEntry.IsOrphan {
t.Fatalf("transaction %s is an orphan, although it shouldn't be", mempoolEntry.Transaction.VerboseData.TransactionID) t.Fatalf("transaction %s is an orphan, although it shouldn't be", mempoolEntry.Transaction.VerboseData.TransactionID)