mirror of
https://github.com/btcsuite/btcd.git
synced 2024-11-19 01:40:07 +01:00
126 lines
3.7 KiB
Go
126 lines
3.7 KiB
Go
package mempool
|
|
|
|
import (
|
|
"time"
|
|
|
|
"github.com/btcsuite/btcd/btcjson"
|
|
"github.com/btcsuite/btcd/btcutil"
|
|
"github.com/btcsuite/btcd/chaincfg/chainhash"
|
|
"github.com/btcsuite/btcd/wire"
|
|
"github.com/stretchr/testify/mock"
|
|
)
|
|
|
|
// MockTxMempool is a mock implementation of the TxMempool interface.
|
|
type MockTxMempool struct {
|
|
mock.Mock
|
|
}
|
|
|
|
// Ensure the MockTxMempool implements the TxMemPool interface.
|
|
var _ TxMempool = (*MockTxMempool)(nil)
|
|
|
|
// LastUpdated returns the last time a transaction was added to or removed from
|
|
// the source pool.
|
|
func (m *MockTxMempool) LastUpdated() time.Time {
|
|
args := m.Called()
|
|
return args.Get(0).(time.Time)
|
|
}
|
|
|
|
// TxDescs returns a slice of descriptors for all the transactions in the pool.
|
|
func (m *MockTxMempool) TxDescs() []*TxDesc {
|
|
args := m.Called()
|
|
return args.Get(0).([]*TxDesc)
|
|
}
|
|
|
|
// RawMempoolVerbose returns all the entries in the mempool as a fully
|
|
// populated btcjson result.
|
|
func (m *MockTxMempool) RawMempoolVerbose() map[string]*btcjson.
|
|
GetRawMempoolVerboseResult {
|
|
|
|
args := m.Called()
|
|
return args.Get(0).(map[string]*btcjson.GetRawMempoolVerboseResult)
|
|
}
|
|
|
|
// Count returns the number of transactions in the main pool. It does not
|
|
// include the orphan pool.
|
|
func (m *MockTxMempool) Count() int {
|
|
args := m.Called()
|
|
return args.Get(0).(int)
|
|
}
|
|
|
|
// FetchTransaction returns the requested transaction from the transaction
|
|
// pool. This only fetches from the main transaction pool and does not include
|
|
// orphans.
|
|
func (m *MockTxMempool) FetchTransaction(
|
|
txHash *chainhash.Hash) (*btcutil.Tx, error) {
|
|
|
|
args := m.Called(txHash)
|
|
|
|
if args.Get(0) == nil {
|
|
return nil, args.Error(1)
|
|
}
|
|
|
|
return args.Get(0).(*btcutil.Tx), args.Error(1)
|
|
}
|
|
|
|
// HaveTransaction returns whether or not the passed transaction already exists
|
|
// in the main pool or in the orphan pool.
|
|
func (m *MockTxMempool) HaveTransaction(hash *chainhash.Hash) bool {
|
|
args := m.Called(hash)
|
|
return args.Get(0).(bool)
|
|
}
|
|
|
|
// ProcessTransaction is the main workhorse for handling insertion of new
|
|
// free-standing transactions into the memory pool. It includes functionality
|
|
// such as rejecting duplicate transactions, ensuring transactions follow all
|
|
// rules, orphan transaction handling, and insertion into the memory pool.
|
|
func (m *MockTxMempool) ProcessTransaction(tx *btcutil.Tx, allowOrphan,
|
|
rateLimit bool, tag Tag) ([]*TxDesc, error) {
|
|
|
|
args := m.Called(tx, allowOrphan, rateLimit, tag)
|
|
|
|
if args.Get(0) == nil {
|
|
return nil, args.Error(1)
|
|
}
|
|
|
|
return args.Get(0).([]*TxDesc), args.Error(1)
|
|
}
|
|
|
|
// RemoveTransaction removes the passed transaction from the mempool. When the
|
|
// removeRedeemers flag is set, any transactions that redeem outputs from the
|
|
// removed transaction will also be removed recursively from the mempool, as
|
|
// they would otherwise become orphans.
|
|
func (m *MockTxMempool) RemoveTransaction(tx *btcutil.Tx,
|
|
removeRedeemers bool) {
|
|
|
|
m.Called(tx, removeRedeemers)
|
|
}
|
|
|
|
// CheckMempoolAcceptance behaves similarly to bitcoind's `testmempoolaccept`
|
|
// RPC method. It will perform a series of checks to decide whether this
|
|
// transaction can be accepted to the mempool. If not, the specific error is
|
|
// returned and the caller needs to take actions based on it.
|
|
func (m *MockTxMempool) CheckMempoolAcceptance(
|
|
tx *btcutil.Tx) (*MempoolAcceptResult, error) {
|
|
|
|
args := m.Called(tx)
|
|
|
|
if args.Get(0) == nil {
|
|
return nil, args.Error(1)
|
|
}
|
|
|
|
return args.Get(0).(*MempoolAcceptResult), args.Error(1)
|
|
}
|
|
|
|
// CheckSpend checks whether the passed outpoint is already spent by a
|
|
// transaction in the mempool. If that's the case the spending transaction will
|
|
// be returned, if not nil will be returned.
|
|
func (m *MockTxMempool) CheckSpend(op wire.OutPoint) *btcutil.Tx {
|
|
args := m.Called(op)
|
|
|
|
if args.Get(0) == nil {
|
|
return nil
|
|
}
|
|
|
|
return args.Get(0).(*btcutil.Tx)
|
|
}
|