RPC: include orphans into mempool entries (#2046)

* RPC: include orphans into mempool entries

* no need for + 1

* give request option to choose mempool pool(s)

* add to wallet, fix bg

* use orphanpool rpc to test for orphans

* fix fmt

* fix crash when quering orphan pool in get_mempool_entries

* pass the tests, fix fromAppMessage bug

* Update config_test.go

don't think this is needed

* needed for tests to pass

* inverse to transactionpoolfilter, cut down code to two ifs.

* fmt

* update test to true false, forgot one includetransactionpool renaming

* update and simplyfiy get_mempool_entry handler

* comment outdated

* i think we usually use make instead of var.

* Fix some leftovers of includeTransactionPool

Co-authored-by: Ori Newman <orinewman1@gmail.com>

app/appmessage/rpc_get_mempool_entries.go

@@ -4,6 +4,8 @@ package appmessage
 // its respective RPC message
 type GetMempoolEntriesRequestMessage struct {
 	baseMessage
+	IncludeOrphanPool     bool
+	FilterTransactionPool bool
 }
 
 // Command returns the protocol command string for the message
@@ -12,8 +14,11 @@ func (msg *GetMempoolEntriesRequestMessage) Command() MessageCommand {
 }
 
 // NewGetMempoolEntriesRequestMessage returns a instance of the message
-func NewGetMempoolEntriesRequestMessage() *GetMempoolEntriesRequestMessage {
-	return &GetMempoolEntriesRequestMessage{}
+func NewGetMempoolEntriesRequestMessage(includeOrphanPool bool, filterTransactionPool bool) *GetMempoolEntriesRequestMessage {
+	return &GetMempoolEntriesRequestMessage{
+		IncludeOrphanPool:     includeOrphanPool,
+		FilterTransactionPool: filterTransactionPool,
+	}
 }
 
 // GetMempoolEntriesResponseMessage is an appmessage corresponding to

app/appmessage/rpc_get_mempool_entries_by_addresses.go

@@ -11,7 +11,9 @@ type MempoolEntryByAddress struct {
 // its respective RPC message
 type GetMempoolEntriesByAddressesRequestMessage struct {
 	baseMessage
-	Addresses []string
+	Addresses             []string
+	IncludeOrphanPool     bool
+	FilterTransactionPool bool
 }
 
 // Command returns the protocol command string for the message
@@ -20,9 +22,11 @@ func (msg *GetMempoolEntriesByAddressesRequestMessage) Command() MessageCommand
 }
 
 // NewGetMempoolEntriesByAddressesRequestMessage returns a instance of the message
-func NewGetMempoolEntriesByAddressesRequestMessage(addresses []string) *GetMempoolEntriesByAddressesRequestMessage {
+func NewGetMempoolEntriesByAddressesRequestMessage(addresses []string, includeOrphanPool bool, filterTransactionPool bool) *GetMempoolEntriesByAddressesRequestMessage {
 	return &GetMempoolEntriesByAddressesRequestMessage{
-		Addresses: addresses,
+		Addresses:             addresses,
+		IncludeOrphanPool:     includeOrphanPool,
+		FilterTransactionPool: filterTransactionPool,
 	}
 }
 

app/appmessage/rpc_get_mempool_entry.go

@@ -4,7 +4,9 @@ package appmessage
 // its respective RPC message
 type GetMempoolEntryRequestMessage struct {
 	baseMessage
-	TxID string
+	TxID                  string
+	IncludeOrphanPool     bool
+	FilterTransactionPool bool
 }
 
 // Command returns the protocol command string for the message
@@ -13,8 +15,12 @@ func (msg *GetMempoolEntryRequestMessage) Command() MessageCommand {
 }
 
 // NewGetMempoolEntryRequestMessage returns a instance of the message
-func NewGetMempoolEntryRequestMessage(txID string) *GetMempoolEntryRequestMessage {
-	return &GetMempoolEntryRequestMessage{TxID: txID}
+func NewGetMempoolEntryRequestMessage(txID string, includeOrphanPool bool, filterTransactionPool bool) *GetMempoolEntryRequestMessage {
+	return &GetMempoolEntryRequestMessage{
+		TxID:                  txID,
+		IncludeOrphanPool:     includeOrphanPool,
+		FilterTransactionPool: filterTransactionPool,
+	}
 }
 
 // GetMempoolEntryResponseMessage is an appmessage corresponding to
@@ -30,6 +36,7 @@ type GetMempoolEntryResponseMessage struct {
 type MempoolEntry struct {
 	Fee         uint64
 	Transaction *RPCTransaction
+	IsOrphan    bool
 }
 
 // Command returns the protocol command string for the message
@@ -38,11 +45,12 @@ func (msg *GetMempoolEntryResponseMessage) Command() MessageCommand {
 }
 
 // NewGetMempoolEntryResponseMessage returns a instance of the message
-func NewGetMempoolEntryResponseMessage(fee uint64, transaction *RPCTransaction) *GetMempoolEntryResponseMessage {
+func NewGetMempoolEntryResponseMessage(fee uint64, transaction *RPCTransaction, isOrphan bool) *GetMempoolEntryResponseMessage {
 	return &GetMempoolEntryResponseMessage{
 		Entry: &MempoolEntry{
 			Fee:         fee,
 			Transaction: transaction,
+			IsOrphan:    isOrphan,
 		},
 	}
 }

app/rpc/rpchandlers/get_mempool_entries.go

@@ -7,7 +7,32 @@ import (
 )
 
 // HandleGetMempoolEntries handles the respectively named RPC command
-func HandleGetMempoolEntries(context *rpccontext.Context, _ *router.Router, _ appmessage.Message) (appmessage.Message, error) {
+func HandleGetMempoolEntries(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
+	getMempoolEntriesRequest := request.(*appmessage.GetMempoolEntriesRequestMessage)
+
+	entries := make([]*appmessage.MempoolEntry, 0)
+
+	if !getMempoolEntriesRequest.FilterTransactionPool {
+		transactionPoolEntries, err := getTransactionPoolMempoolEntries(context)
+		if err != nil {
+			return nil, err
+		}
+
+		entries = append(entries, transactionPoolEntries...)
+	}
+
+	if getMempoolEntriesRequest.IncludeOrphanPool {
+		orphanPoolEntries, err := getOrphanPoolMempoolEntries(context)
+		if err != nil {
+			return nil, err
+		}
+		entries = append(entries, orphanPoolEntries...)
+	}
+
+	return appmessage.NewGetMempoolEntriesResponseMessage(entries), nil
+}
+
+func getTransactionPoolMempoolEntries(context *rpccontext.Context) ([]*appmessage.MempoolEntry, error) {
 	transactions := context.Domain.MiningManager().AllTransactions()
 	entries := make([]*appmessage.MempoolEntry, 0, len(transactions))
 	for _, transaction := range transactions {
@@ -19,8 +44,26 @@ func HandleGetMempoolEntries(context *rpccontext.Context, _ *router.Router, _ ap
 		entries = append(entries, &appmessage.MempoolEntry{
 			Fee:         transaction.Fee,
 			Transaction: rpcTransaction,
+			IsOrphan:    false,
 		})
 	}
-
-	return appmessage.NewGetMempoolEntriesResponseMessage(entries), nil
+	return entries, nil
+}
+
+func getOrphanPoolMempoolEntries(context *rpccontext.Context) ([]*appmessage.MempoolEntry, error) {
+	orphanTransactions := context.Domain.MiningManager().AllOrphanTransactions()
+	entries := make([]*appmessage.MempoolEntry, 0, len(orphanTransactions))
+	for _, orphanTransaction := range orphanTransactions {
+		rpcTransaction := appmessage.DomainTransactionToRPCTransaction(orphanTransaction)
+		err := context.PopulateTransactionWithVerboseData(rpcTransaction, nil)
+		if err != nil {
+			return nil, err
+		}
+		entries = append(entries, &appmessage.MempoolEntry{
+			Fee:         orphanTransaction.Fee,
+			Transaction: rpcTransaction,
+			IsOrphan:    true,
+		})
+	}
+	return entries, nil
 }

app/rpc/rpchandlers/get_mempool_entries_by_addresses.go

@@ -1,8 +1,12 @@
 package rpchandlers
 
 import (
+	"errors"
+
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
+
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
 	"github.com/kaspanet/kaspad/domain/consensus/utils/txscript"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
@@ -12,17 +16,62 @@ import (
 // HandleGetMempoolEntriesByAddresses handles the respectively named RPC command
 func HandleGetMempoolEntriesByAddresses(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
 
-	transactions := context.Domain.MiningManager().AllTransactions()
 	getMempoolEntriesByAddressesRequest := request.(*appmessage.GetMempoolEntriesByAddressesRequestMessage)
+
 	mempoolEntriesByAddresses := make([]*appmessage.MempoolEntryByAddress, 0)
 
-	for _, addressString := range getMempoolEntriesByAddressesRequest.Addresses {
+	if !getMempoolEntriesByAddressesRequest.FilterTransactionPool {
+		transactionPoolTransactions := context.Domain.MiningManager().AllTransactions()
+		transactionPoolEntriesByAddresses, err := extractMempoolEntriesByAddressesFromTransactions(
+			context,
+			getMempoolEntriesByAddressesRequest.Addresses,
+			transactionPoolTransactions,
+			false,
+		)
+		if err != nil {
+			rpcError := &appmessage.RPCError{}
+			if !errors.As(err, &rpcError) {
+				return nil, err
+			}
+			errorMessage := &appmessage.GetUTXOsByAddressesResponseMessage{}
+			errorMessage.Error = rpcError
+			return errorMessage, nil
+		}
+		mempoolEntriesByAddresses = append(mempoolEntriesByAddresses, transactionPoolEntriesByAddresses...)
+	}
 
+	if getMempoolEntriesByAddressesRequest.IncludeOrphanPool {
+
+		orphanPoolTransactions := context.Domain.MiningManager().AllOrphanTransactions()
+		orphanPoolEntriesByAddresse, err := extractMempoolEntriesByAddressesFromTransactions(
+			context,
+			getMempoolEntriesByAddressesRequest.Addresses,
+			orphanPoolTransactions,
+			true,
+		)
+		if err != nil {
+			rpcError := &appmessage.RPCError{}
+			if !errors.As(err, &rpcError) {
+				return nil, err
+			}
+			errorMessage := &appmessage.GetUTXOsByAddressesResponseMessage{}
+			errorMessage.Error = rpcError
+			return errorMessage, nil
+		}
+
+		mempoolEntriesByAddresses = append(mempoolEntriesByAddresses, orphanPoolEntriesByAddresse...)
+	}
+
+	return appmessage.NewGetMempoolEntriesByAddressesResponseMessage(mempoolEntriesByAddresses), nil
+}
+
+//TO DO: optimize extractMempoolEntriesByAddressesFromTransactions
+func extractMempoolEntriesByAddressesFromTransactions(context *rpccontext.Context, addresses []string, transactions []*externalapi.DomainTransaction, areOrphans bool) ([]*appmessage.MempoolEntryByAddress, error) {
+	mempoolEntriesByAddresses := make([]*appmessage.MempoolEntryByAddress, 0)
+	for _, addressString := range addresses {
 		_, err := util.DecodeAddress(addressString, context.Config.ActiveNetParams.Prefix)
 		if err != nil {
-			errorMessage := &appmessage.GetUTXOsByAddressesResponseMessage{}
-			errorMessage.Error = appmessage.RPCErrorf("Could not decode address '%s': %s", addressString, err)
-			return errorMessage, nil
+			return nil, appmessage.RPCErrorf("Could not decode address '%s': %s", addressString, err)
 		}
 
 		sending := make([]*appmessage.MempoolEntry, 0)
@@ -50,6 +99,7 @@ func HandleGetMempoolEntriesByAddresses(context *rpccontext.Context, _ *router.R
 						&appmessage.MempoolEntry{
 							Fee:         transaction.Fee,
 							Transaction: rpcTransaction,
+							IsOrphan:    areOrphans,
 						},
 					)
 					break //one input is enough
@@ -71,6 +121,7 @@ func HandleGetMempoolEntriesByAddresses(context *rpccontext.Context, _ *router.R
 						&appmessage.MempoolEntry{
 							Fee:         transaction.Fee,
 							Transaction: rpcTransaction,
+							IsOrphan:    areOrphans,
 						},
 					)
 					break //one output is enough
@@ -89,9 +140,8 @@ func HandleGetMempoolEntriesByAddresses(context *rpccontext.Context, _ *router.R
 					},
 				)
 			}
-
 		}
-	}
 
-	return appmessage.NewGetMempoolEntriesByAddressesResponseMessage(mempoolEntriesByAddresses), nil
+	}
+	return mempoolEntriesByAddresses, nil
 }

app/rpc/rpchandlers/get_mempool_entry.go

@@ -3,12 +3,18 @@ package rpchandlers
 import (
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"github.com/kaspanet/kaspad/domain/consensus/utils/transactionid"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
 )
 
 // HandleGetMempoolEntry handles the respectively named RPC command
 func HandleGetMempoolEntry(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
+
+	transaction := &externalapi.DomainTransaction{}
+	var found bool
+	var isOrphan bool
+
 	getMempoolEntryRequest := request.(*appmessage.GetMempoolEntryRequestMessage)
 
 	transactionID, err := transactionid.FromString(getMempoolEntryRequest.TxID)
@@ -18,17 +24,25 @@ func HandleGetMempoolEntry(context *rpccontext.Context, _ *router.Router, reques
 		return errorMessage, nil
 	}
 
-	transaction, ok := context.Domain.MiningManager().GetTransaction(transactionID)
-	if !ok {
+	if !getMempoolEntryRequest.FilterTransactionPool {
+		transaction, found = context.Domain.MiningManager().GetTransaction(transactionID)
+	}
+
+	if getMempoolEntryRequest.IncludeOrphanPool && !found {
+		transaction, found = context.Domain.MiningManager().GetOrphanTransaction(transactionID)
+		isOrphan = true
+	}
+
+	if !found {
 		errorMessage := &appmessage.GetMempoolEntryResponseMessage{}
 		errorMessage.Error = appmessage.RPCErrorf("Transaction %s was not found", transactionID)
 		return errorMessage, nil
 	}
+
 	rpcTransaction := appmessage.DomainTransactionToRPCTransaction(transaction)
 	err = context.PopulateTransactionWithVerboseData(rpcTransaction, nil)
 	if err != nil {
 		return nil, err
 	}
-
-	return appmessage.NewGetMempoolEntryResponseMessage(transaction.Fee, rpcTransaction), nil
+	return appmessage.NewGetMempoolEntryResponseMessage(transaction.Fee, rpcTransaction, isOrphan), nil
 }

cmd/kaspawallet/daemon/server/sync.go

@@ -267,7 +267,7 @@ func (s *server) refreshUTXOs() error {
 	// and not in consensus, and between the calls its spending transaction will be
 	// added to consensus and removed from the mempool, so `getUTXOsByAddressesResponse`
 	// will include an obsolete output.
-	mempoolEntriesByAddresses, err := s.rpcClient.GetMempoolEntriesByAddresses(s.addressSet.strings())
+	mempoolEntriesByAddresses, err := s.rpcClient.GetMempoolEntriesByAddresses(s.addressSet.strings(), true, true)
 	if err != nil {
 		return err
 	}

domain/miningmanager/mempool/mempool.go

@@ -56,6 +56,20 @@ func (mp *mempool) AllTransactions() []*externalapi.DomainTransaction {
 	return mp.transactionsPool.getAllTransactions()
 }
 
+func (mp *mempool) GetOrphanTransaction(transactionID *externalapi.DomainTransactionID) (*externalapi.DomainTransaction, bool) {
+	mp.mtx.RLock()
+	defer mp.mtx.RUnlock()
+
+	return mp.orphansPool.getOrphanTransaction(transactionID)
+}
+
+func (mp *mempool) AllOrphanTransactions() []*externalapi.DomainTransaction {
+	mp.mtx.RLock()
+	defer mp.mtx.RUnlock()
+
+	return mp.orphansPool.getAllOrphanTransactions()
+}
+
 func (mp *mempool) TransactionCount() int {
 	mp.mtx.RLock()
 	defer mp.mtx.RUnlock()

domain/miningmanager/mempool/orphan_pool.go

@@ -328,3 +328,18 @@ func (op *orphansPool) randomNonHighPriorityOrphan() *model.OrphanTransaction {
 
 	return nil
 }
+
+func (op *orphansPool) getOrphanTransaction(transactionID *externalapi.DomainTransactionID) (*externalapi.DomainTransaction, bool) {
+	if orphanTransaction, ok := op.allOrphans[*transactionID]; ok {
+		return orphanTransaction.Transaction(), true
+	}
+	return nil, false
+}
+
+func (op *orphansPool) getAllOrphanTransactions() []*externalapi.DomainTransaction {
+	allOrphanTransactions := make([]*externalapi.DomainTransaction, 0, len(op.allOrphans))
+	for _, mempoolTransaction := range op.allOrphans {
+		allOrphanTransactions = append(allOrphanTransactions, mempoolTransaction.Transaction())
+	}
+	return allOrphanTransactions
+}

domain/miningmanager/miningmanager.go

@@ -1,11 +1,12 @@
 package miningmanager
 
 import (
+	"sync"
+	"time"
+
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"github.com/kaspanet/kaspad/domain/consensusreference"
 	miningmanagermodel "github.com/kaspanet/kaspad/domain/miningmanager/model"
-	"sync"
-	"time"
 )
 
 // MiningManager creates block templates for mining as well as maintaining
@@ -16,6 +17,8 @@ type MiningManager interface {
 	GetBlockTemplateBuilder() miningmanagermodel.BlockTemplateBuilder
 	GetTransaction(transactionID *externalapi.DomainTransactionID) (*externalapi.DomainTransaction, bool)
 	AllTransactions() []*externalapi.DomainTransaction
+	GetOrphanTransaction(transactionID *externalapi.DomainTransactionID) (*externalapi.DomainTransaction, bool)
+	AllOrphanTransactions() []*externalapi.DomainTransaction
 	TransactionCount() int
 	HandleNewBlockTransactions(txs []*externalapi.DomainTransaction) ([]*externalapi.DomainTransaction, error)
 	ValidateAndInsertTransaction(transaction *externalapi.DomainTransaction, isHighPriority bool, allowOrphan bool) (
@@ -115,6 +118,17 @@ func (mm *miningManager) AllTransactions() []*externalapi.DomainTransaction {
 	return mm.mempool.AllTransactions()
 }
 
+func (mm *miningManager) GetOrphanTransaction(
+	transactionID *externalapi.DomainTransactionID) (*externalapi.DomainTransaction, bool) {
+
+	return mm.mempool.GetOrphanTransaction(transactionID)
+}
+
+func (mm *miningManager) AllOrphanTransactions() []*externalapi.DomainTransaction {
+
+	return mm.mempool.AllOrphanTransactions()
+}
+
 func (mm *miningManager) TransactionCount() int {
 	return mm.mempool.TransactionCount()
 }

domain/miningmanager/model/interface_mempool.go

@@ -14,6 +14,8 @@ type Mempool interface {
 	RemoveTransactions(txs []*externalapi.DomainTransaction, removeRedeemers bool) error
 	GetTransaction(transactionID *externalapi.DomainTransactionID) (*externalapi.DomainTransaction, bool)
 	AllTransactions() []*externalapi.DomainTransaction
+	GetOrphanTransaction(transactionID *externalapi.DomainTransactionID) (*externalapi.DomainTransaction, bool)
+	AllOrphanTransactions() []*externalapi.DomainTransaction
 	TransactionCount() int
 	RevalidateHighPriorityTransactions() (validTransactions []*externalapi.DomainTransaction, err error)
 	IsTransactionOutputDust(output *externalapi.DomainTransactionOutput) bool

infrastructure/network/netadapter/server/grpcserver/protowire/rpc.md

@@ -609,6 +609,8 @@ in the mempool.
 | Field | Type | Label | Description |
 | ----- | ---- | ----- | ----------- |
 | txId | [string](#string) |  | The transaction's TransactionID. |
+| includeOrphanPool | [bool](#bool) |  |  |
+| filterTransactionPool | [bool](#bool) |  |  |
 
 
 
@@ -638,6 +640,12 @@ GetMempoolEntriesRequestMessage requests information about all the transactions
 currently in the mempool.
 
 
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| includeOrphanPool | [bool](#bool) |  |  |
+| filterTransactionPool | [bool](#bool) |  |  |
+
+
 
 
 
@@ -668,6 +676,7 @@ currently in the mempool.
 | ----- | ---- | ----- | ----------- |
 | fee | [uint64](#uint64) |  |  |
 | transaction | [RpcTransaction](#protowire.RpcTransaction) |  |  |
+| isOrphan | [bool](#bool) |  |  |
 
 
 
@@ -1798,6 +1807,8 @@ See NotifyNewBlockTemplateRequestMessage
 | Field | Type | Label | Description |
 | ----- | ---- | ----- | ----------- |
 | addresses | [string](#string) | repeated |  |
+| includeOrphanPool | [bool](#bool) |  |  |
+| filterTransactionPool | [bool](#bool) |  |  |
 
 
 

infrastructure/network/netadapter/server/grpcserver/protowire/rpc.proto

@@ -215,6 +215,8 @@ message GetSelectedTipHashResponseMessage{
 message GetMempoolEntryRequestMessage{
   // The transaction's TransactionID.
   string txId = 1;
+  bool includeOrphanPool = 2;
+  bool filterTransactionPool = 3;
 }
 
 message GetMempoolEntryResponseMessage{
@@ -226,6 +228,8 @@ message GetMempoolEntryResponseMessage{
 // GetMempoolEntriesRequestMessage requests information about all the transactions
 // currently in the mempool.
 message GetMempoolEntriesRequestMessage{
+        bool includeOrphanPool = 1;
+        bool filterTransactionPool = 2;
 }
 
 message GetMempoolEntriesResponseMessage{
@@ -237,6 +241,7 @@ message GetMempoolEntriesResponseMessage{
 message MempoolEntry{
   uint64 fee = 1;
   RpcTransaction transaction = 3;
+  bool isOrphan = 4;
 }
 
 // GetConnectedPeerInfoRequestMessage requests information about all the p2p peers
@@ -697,6 +702,8 @@ message MempoolEntryByAddress{
 
 message GetMempoolEntriesByAddressesRequestMessage{
   repeated string addresses = 1;
+  bool includeOrphanPool = 2;
+  bool filterTransactionPool = 3;
 }
 
 message  GetMempoolEntriesByAddressesResponseMessage{

infrastructure/network/netadapter/server/grpcserver/protowire/rpc_get_mempool_entries.go

@@ -9,14 +9,27 @@ func (x *KaspadMessage_GetMempoolEntriesRequest) toAppMessage() (appmessage.Mess
 	if x == nil {
 		return nil, errors.Wrapf(errorNil, "KaspadMessage_GetMempoolEntriesRequest is nil")
 	}
-	return &appmessage.GetMempoolEntriesRequestMessage{}, nil
+	return x.GetMempoolEntriesRequest.toAppMessage()
 }
 
-func (x *KaspadMessage_GetMempoolEntriesRequest) fromAppMessage(_ *appmessage.GetMempoolEntriesRequestMessage) error {
-	x.GetMempoolEntriesRequest = &GetMempoolEntriesRequestMessage{}
+func (x *KaspadMessage_GetMempoolEntriesRequest) fromAppMessage(message *appmessage.GetMempoolEntriesRequestMessage) error {
+	x.GetMempoolEntriesRequest = &GetMempoolEntriesRequestMessage{
+		IncludeOrphanPool:     message.IncludeOrphanPool,
+		FilterTransactionPool: message.FilterTransactionPool,
+	}
 	return nil
 }
 
+func (x *GetMempoolEntriesRequestMessage) toAppMessage() (appmessage.Message, error) {
+	if x == nil {
+		return nil, errors.Wrapf(errorNil, "GetMempoolEntryRequestMessage is nil")
+	}
+	return &appmessage.GetMempoolEntriesRequestMessage{
+		IncludeOrphanPool:     x.IncludeOrphanPool,
+		FilterTransactionPool: x.FilterTransactionPool,
+	}, nil
+}
+
 func (x *KaspadMessage_GetMempoolEntriesResponse) toAppMessage() (appmessage.Message, error) {
 	if x == nil {
 		return nil, errors.Wrapf(errorNil, "KaspadMessage_GetMempoolEntriesResponse is nil")

infrastructure/network/netadapter/server/grpcserver/protowire/rpc_get_mempool_entries_by_addresses.go

@@ -7,14 +7,16 @@ import (
 
 func (x *KaspadMessage_GetMempoolEntriesByAddressesRequest) toAppMessage() (appmessage.Message, error) {
 	if x == nil {
-		return nil, errors.Wrapf(errorNil, "KaspadMessage_GetMempoolEntriesRequest is nil")
+		return nil, errors.Wrapf(errorNil, "KaspadMessage_KaspadMessage_GetMempoolEntriesByAddressesRequest is nil")
 	}
 	return x.GetMempoolEntriesByAddressesRequest.toAppMessage()
 }
 
 func (x *KaspadMessage_GetMempoolEntriesByAddressesRequest) fromAppMessage(message *appmessage.GetMempoolEntriesByAddressesRequestMessage) error {
 	x.GetMempoolEntriesByAddressesRequest = &GetMempoolEntriesByAddressesRequestMessage{
-		Addresses: message.Addresses,
+		Addresses:             message.Addresses,
+		IncludeOrphanPool:     message.IncludeOrphanPool,
+		FilterTransactionPool: message.FilterTransactionPool,
 	}
 	return nil
 }
@@ -24,7 +26,9 @@ func (x *GetMempoolEntriesByAddressesRequestMessage) toAppMessage() (appmessage.
 		return nil, errors.Wrapf(errorNil, "KaspadMessage_GetMempoolEntriesRequest is nil")
 	}
 	return &appmessage.GetMempoolEntriesByAddressesRequestMessage{
-		Addresses: x.Addresses,
+		Addresses:             x.Addresses,
+		IncludeOrphanPool:     x.IncludeOrphanPool,
+		FilterTransactionPool: x.FilterTransactionPool,
 	}, nil
 }
 

infrastructure/network/netadapter/server/grpcserver/protowire/rpc_get_mempool_entry.go

@@ -14,7 +14,9 @@ func (x *KaspadMessage_GetMempoolEntryRequest) toAppMessage() (appmessage.Messag
 
 func (x *KaspadMessage_GetMempoolEntryRequest) fromAppMessage(message *appmessage.GetMempoolEntryRequestMessage) error {
 	x.GetMempoolEntryRequest = &GetMempoolEntryRequestMessage{
-		TxId: message.TxID,
+		TxId:                  message.TxID,
+		IncludeOrphanPool:     message.IncludeOrphanPool,
+		FilterTransactionPool: message.FilterTransactionPool,
 	}
 	return nil
 }
@@ -24,7 +26,9 @@ func (x *GetMempoolEntryRequestMessage) toAppMessage() (appmessage.Message, erro
 		return nil, errors.Wrapf(errorNil, "GetMempoolEntryRequestMessage is nil")
 	}
 	return &appmessage.GetMempoolEntryRequestMessage{
-		TxID: x.TxId,
+		TxID:                  x.TxId,
+		IncludeOrphanPool:     x.IncludeOrphanPool,
+		FilterTransactionPool: x.FilterTransactionPool,
 	}, nil
 }
 
@@ -91,6 +95,7 @@ func (x *MempoolEntry) toAppMessage() (*appmessage.MempoolEntry, error) {
 	return &appmessage.MempoolEntry{
 		Fee:         x.Fee,
 		Transaction: transaction,
+		IsOrphan:    x.IsOrphan,
 	}, nil
 }
 
@@ -103,6 +108,7 @@ func (x *MempoolEntry) fromAppMessage(message *appmessage.MempoolEntry) error {
 	*x = MempoolEntry{
 		Fee:         message.Fee,
 		Transaction: transaction,
+		IsOrphan:    message.IsOrphan,
 	}
 	return nil
 }

infrastructure/network/rpcclient/rpc_get_mempool_entries.go

@@ -3,8 +3,8 @@ package rpcclient
 import "github.com/kaspanet/kaspad/app/appmessage"
 
 // GetMempoolEntries sends an RPC request respective to the function's name and returns the RPC server's response
-func (c *RPCClient) GetMempoolEntries() (*appmessage.GetMempoolEntriesResponseMessage, error) {
-	err := c.rpcRouter.outgoingRoute().Enqueue(appmessage.NewGetMempoolEntriesRequestMessage())
+func (c *RPCClient) GetMempoolEntries(includeOrphanPool bool, filterTransactionPool bool) (*appmessage.GetMempoolEntriesResponseMessage, error) {
+	err := c.rpcRouter.outgoingRoute().Enqueue(appmessage.NewGetMempoolEntriesRequestMessage(includeOrphanPool, filterTransactionPool))
 	if err != nil {
 		return nil, err
 	}

infrastructure/network/rpcclient/rpc_get_mempool_entries_by_address.go

@@ -3,8 +3,8 @@ package rpcclient
 import "github.com/kaspanet/kaspad/app/appmessage"
 
 // GetMempoolEntriesByAddresses sends an RPC request respective to the function's name and returns the RPC server's response
-func (c *RPCClient) GetMempoolEntriesByAddresses(addresses []string) (*appmessage.GetMempoolEntriesByAddressesResponseMessage, error) {
-	err := c.rpcRouter.outgoingRoute().Enqueue(appmessage.NewGetMempoolEntriesByAddressesRequestMessage(addresses))
+func (c *RPCClient) GetMempoolEntriesByAddresses(addresses []string, includeOrphanPool bool, filterTransactionPool bool) (*appmessage.GetMempoolEntriesByAddressesResponseMessage, error) {
+	err := c.rpcRouter.outgoingRoute().Enqueue(appmessage.NewGetMempoolEntriesByAddressesRequestMessage(addresses, includeOrphanPool, filterTransactionPool))
 	if err != nil {
 		return nil, err
 	}

infrastructure/network/rpcclient/rpc_get_mempool_entry.go

@@ -3,8 +3,8 @@ package rpcclient
 import "github.com/kaspanet/kaspad/app/appmessage"
 
 // GetMempoolEntry sends an RPC request respective to the function's name and returns the RPC server's response
-func (c *RPCClient) GetMempoolEntry(txID string) (*appmessage.GetMempoolEntryResponseMessage, error) {
-	err := c.rpcRouter.outgoingRoute().Enqueue(appmessage.NewGetMempoolEntryRequestMessage(txID))
+func (c *RPCClient) GetMempoolEntry(txID string, includeOrphanPool bool, filterTransactionPool bool) (*appmessage.GetMempoolEntryResponseMessage, error) {
+	err := c.rpcRouter.outgoingRoute().Enqueue(appmessage.NewGetMempoolEntryRequestMessage(txID, includeOrphanPool, filterTransactionPool))
 	if err != nil {
 		return nil, err
 	}

testing/integration/config_test.go

@@ -31,7 +31,7 @@ const (
 	miningAddress3           = "kaspasim:qqq754f2gdcjcnykwuwwr60c82rh5u6mxxe7yqxljnrxz9fu0h95kduq9ezng"
 	miningAddress3PrivateKey = "f6c8f31fd359cbb97007034780bc4021f6ad01c6bc10499b79849efd4cc7ca39"
 
-	defaultTimeout = 10 * time.Second
+	defaultTimeout = 30 * time.Second
 )
 
 func setConfig(t *testing.T, harness *appHarness, protocolVersion uint32) {

testing/integration/tx_relay_test.go

@@ -69,7 +69,7 @@ func TestTxRelay(t *testing.T) {
 
 		for range ticker.C {
 
-			_, err := payee.rpcClient.GetMempoolEntry(txID)
+			getMempoolEntryResponse, err := payee.rpcClient.GetMempoolEntry(txID, true, false)
 			if err != nil {
 				if strings.Contains(err.Error(), "not found") {
 					continue
@@ -77,12 +77,16 @@ func TestTxRelay(t *testing.T) {
 
 				t.Fatalf("Error getting mempool entry: %+v", err)
 			}
+			mempoolEntry := getMempoolEntryResponse.Entry
+			if mempoolEntry.IsOrphan {
+				t.Fatalf("transaction %s is an orphan, although it shouldn't be", mempoolEntry.Transaction.VerboseData.TransactionID)
+			}
 
-			mempoolEntriesByAddresses, err := payee.rpcClient.GetMempoolEntriesByAddresses(mempoolAddressQuery)
+			getMempoolEntriesByAddressesResponse, err := payee.rpcClient.GetMempoolEntriesByAddresses(mempoolAddressQuery, true, false)
 			if err != nil {
 				t.Fatalf("Error getting mempool entry: %+v", err)
 			}
-			for _, mempoolEntryByAddress := range mempoolEntriesByAddresses.Entries {
+			for _, mempoolEntryByAddress := range getMempoolEntriesByAddressesResponse.Entries {
 				if payee.miningAddress == mempoolEntryByAddress.Address {
 					if len(mempoolEntryByAddress.Sending) > 1 {
 						t.Fatal("Error payee is sending")
@@ -99,7 +103,16 @@ func TestTxRelay(t *testing.T) {
 						t.Fatal("Error payer is reciving")
 					}
 				}
-				continue
+				for _, mempoolEntry := range mempoolEntryByAddress.Receiving {
+					if mempoolEntry.IsOrphan {
+						t.Fatalf("transaction %s is an orphan, although it shouldn't be", mempoolEntry.Transaction.VerboseData.TransactionID)
+					}
+				}
+				for _, mempoolEntry := range mempoolEntryByAddress.Sending {
+					if mempoolEntry.IsOrphan {
+						t.Fatalf("transaction %s is an orphan, although it shouldn't be", mempoolEntry.Transaction.VerboseData.TransactionID)
+					}
+				}
 			}
 
 			close(txAddedToMempoolChan)