// Tests that if an account runs out of funds, any pending and queued transactions // are dropped. func TestTransactionDropping(t *testing.T) { // Create a test account and fund it pool, key := setupTxPool() account, _ := transaction(0, big.NewInt(0), key).From() state, _ := pool.currentState() state.AddBalance(account, big.NewInt(1000)) // Add some pending and some queued transactions var ( tx0 = transaction(0, big.NewInt(100), key) tx1 = transaction(1, big.NewInt(200), key) tx10 = transaction(10, big.NewInt(100), key) tx11 = transaction(11, big.NewInt(200), key) ) pool.promoteTx(account, tx0.Hash(), tx0) pool.promoteTx(account, tx1.Hash(), tx1) pool.enqueueTx(tx10.Hash(), tx10) pool.enqueueTx(tx11.Hash(), tx11) // Check that pre and post validations leave the pool as is if pool.pending[account].Len() != 2 { t.Errorf("pending transaction mismatch: have %d, want %d", pool.pending[account].Len(), 2) } if pool.queue[account].Len() != 2 { t.Errorf("queued transaction mismatch: have %d, want %d", pool.queue[account].Len(), 2) } if len(pool.all) != 4 { t.Errorf("total transaction mismatch: have %d, want %d", len(pool.all), 4) } pool.resetState() if pool.pending[account].Len() != 2 { t.Errorf("pending transaction mismatch: have %d, want %d", pool.pending[account].Len(), 2) } if pool.queue[account].Len() != 2 { t.Errorf("queued transaction mismatch: have %d, want %d", pool.queue[account].Len(), 2) } if len(pool.all) != 4 { t.Errorf("total transaction mismatch: have %d, want %d", len(pool.all), 4) } // Reduce the balance of the account, and check that invalidated transactions are dropped state.AddBalance(account, big.NewInt(-750)) pool.resetState() if _, ok := pool.pending[account].txs.items[tx0.Nonce()]; !ok { t.Errorf("funded pending transaction missing: %v", tx0) } if _, ok := pool.pending[account].txs.items[tx1.Nonce()]; ok { t.Errorf("out-of-fund pending transaction present: %v", tx1) } if _, ok := pool.queue[account].txs.items[tx10.Nonce()]; !ok { t.Errorf("funded queued transaction missing: %v", tx10) } if _, ok := pool.queue[account].txs.items[tx11.Nonce()]; ok { t.Errorf("out-of-fund queued transaction present: %v", tx11) } if len(pool.all) != 2 { t.Errorf("total transaction mismatch: have %d, want %d", len(pool.all), 2) } }
// Tests that if the transaction count belonging to a single account goes above // some threshold, the higher transactions are dropped to prevent DOS attacks. func TestTransactionQueueLimiting(t *testing.T) { // Create a test account and fund it pool, key := setupTxPool() account, _ := transaction(0, big.NewInt(0), key).From() state, _ := pool.currentState() state.AddBalance(account, big.NewInt(1000000)) // Keep queuing up transactions and make sure all above a limit are dropped for i := uint64(1); i <= maxQueued+5; i++ { if err := pool.Add(transaction(i, big.NewInt(100000), key)); err != nil { t.Fatalf("tx %d: failed to add transaction: %v", i, err) } if len(pool.pending) != 0 { t.Errorf("tx %d: pending pool size mismatch: have %d, want %d", i, len(pool.pending), 0) } if i <= maxQueued { if len(pool.queue[account]) != int(i) { t.Errorf("tx %d: queue size mismatch: have %d, want %d", i, len(pool.queue[account]), i) } } else { if len(pool.queue[account]) != maxQueued { t.Errorf("tx %d: queue limit mismatch: have %d, want %d", i, len(pool.queue[account]), maxQueued) } } } }
// Tests that if an account remains idle for a prolonged amount of time, any // non-executable transactions queued up are dropped to prevent wasting resources // on shuffling them around. func TestTransactionQueueTimeLimiting(t *testing.T) { // Reduce the queue limits to shorten test time defer func(old time.Duration) { maxQueuedLifetime = old }(maxQueuedLifetime) defer func(old time.Duration) { evictionInterval = old }(evictionInterval) maxQueuedLifetime = time.Second evictionInterval = time.Second // Create a test account and fund it pool, key := setupTxPool() account, _ := transaction(0, big.NewInt(0), key).From() state, _ := pool.currentState() state.AddBalance(account, big.NewInt(1000000)) // Queue up a batch of transactions for i := uint64(1); i <= maxQueuedPerAccount; i++ { if err := pool.Add(transaction(i, big.NewInt(100000), key)); err != nil { t.Fatalf("tx %d: failed to add transaction: %v", i, err) } } // Wait until at least two expiration cycles hit and make sure the transactions are gone time.Sleep(2 * evictionInterval) if len(pool.queue) > 0 { t.Fatalf("old transactions remained after eviction") } }
func benchmarkCheckQueue(b *testing.B, size int) { // Add a batch of transactions to a pool one by one pool, key := setupTxPool() account, _ := transaction(0, big.NewInt(0), key).From() state, _ := pool.currentState() state.AddBalance(account, big.NewInt(1000000)) for i := 0; i < size; i++ { tx := transaction(uint64(1+i), big.NewInt(100000), key) pool.queueTx(tx.Hash(), tx) } // Benchmark the speed of pool validation b.ResetTimer() for i := 0; i < b.N; i++ { pool.checkQueue() } }
// Benchmarks the speed of iterative transaction insertion. func BenchmarkPoolInsert(b *testing.B) { // Generate a batch of transactions to enqueue into the pool pool, key := setupTxPool() account, _ := transaction(0, big.NewInt(0), key).From() state, _ := pool.currentState() state.AddBalance(account, big.NewInt(1000000)) txs := make(types.Transactions, b.N) for i := 0; i < b.N; i++ { txs[i] = transaction(uint64(i), big.NewInt(100000), key) } // Benchmark importing the transactions into the queue b.ResetTimer() for _, tx := range txs { pool.Add(tx) } }
// Tests that if the transaction count belonging to multiple accounts go above // some threshold, the higher transactions are dropped to prevent DOS attacks. func TestTransactionQueueGlobalLimiting(t *testing.T) { // Reduce the queue limits to shorten test time defer func(old uint64) { maxQueuedInTotal = old }(maxQueuedInTotal) maxQueuedInTotal = maxQueuedPerAccount * 3 // Create the pool to test the limit enforcement with db, _ := ethdb.NewMemDatabase() statedb, _ := state.New(common.Hash{}, db) pool := NewTxPool(testChainConfig(), new(event.TypeMux), func() (*state.StateDB, error) { return statedb, nil }, func() *big.Int { return big.NewInt(1000000) }) pool.resetState() // Create a number of test accounts and fund them state, _ := pool.currentState() keys := make([]*ecdsa.PrivateKey, 5) for i := 0; i < len(keys); i++ { keys[i], _ = crypto.GenerateKey() state.AddBalance(crypto.PubkeyToAddress(keys[i].PublicKey), big.NewInt(1000000)) } // Generate and queue a batch of transactions nonces := make(map[common.Address]uint64) txs := make(types.Transactions, 0, 3*maxQueuedInTotal) for len(txs) < cap(txs) { key := keys[rand.Intn(len(keys))] addr := crypto.PubkeyToAddress(key.PublicKey) txs = append(txs, transaction(nonces[addr]+1, big.NewInt(100000), key)) nonces[addr]++ } // Import the batch and verify that limits have been enforced pool.AddBatch(txs) queued := 0 for addr, list := range pool.queue { if list.Len() > int(maxQueuedPerAccount) { t.Errorf("addr %x: queued accounts overflown allowance: %d > %d", addr, list.Len(), maxQueuedPerAccount) } queued += list.Len() } if queued > int(maxQueuedInTotal) { t.Fatalf("total transactions overflow allowance: %d > %d", queued, maxQueuedInTotal) } }
func benchmarkPoolBatchInsert(b *testing.B, size int) { // Generate a batch of transactions to enqueue into the pool pool, key := setupTxPool() account, _ := transaction(0, big.NewInt(0), key).From() state, _ := pool.currentState() state.AddBalance(account, big.NewInt(1000000)) batches := make([]types.Transactions, b.N) for i := 0; i < b.N; i++ { batches[i] = make(types.Transactions, size) for j := 0; j < size; j++ { batches[i][j] = transaction(uint64(size*i+j), big.NewInt(100000), key) } } // Benchmark importing the transactions into the queue b.ResetTimer() for _, batch := range batches { pool.AddBatch(batch) } }
// Tests that even if the transaction count belonging to a single account goes // above some threshold, as long as the transactions are executable, they are // accepted. func TestTransactionPendingLimiting(t *testing.T) { // Create a test account and fund it pool, key := setupTxPool() account, _ := transaction(0, big.NewInt(0), key).From() state, _ := pool.currentState() state.AddBalance(account, big.NewInt(1000000)) // Keep queuing up transactions and make sure all above a limit are dropped for i := uint64(0); i < maxQueuedPerAccount+5; i++ { if err := pool.Add(transaction(i, big.NewInt(100000), key)); err != nil { t.Fatalf("tx %d: failed to add transaction: %v", i, err) } if pool.pending[account].Len() != int(i)+1 { t.Errorf("tx %d: pending pool size mismatch: have %d, want %d", i, pool.pending[account].Len(), i+1) } if len(pool.queue) != 0 { t.Errorf("tx %d: queue size mismatch: have %d, want %d", i, pool.queue[account].Len(), 0) } } if len(pool.all) != int(maxQueuedPerAccount+5) { t.Errorf("total transaction mismatch: have %d, want %d", len(pool.all), maxQueuedPerAccount+5) } }
// Tests that if a transaction is dropped from the current pending pool (e.g. out // of fund), all consecutive (still valid, but not executable) transactions are // postponed back into the future queue to prevent broadcating them. func TestTransactionPostponing(t *testing.T) { // Create a test account and fund it pool, key := setupTxPool() account, _ := transaction(0, big.NewInt(0), key).From() state, _ := pool.currentState() state.AddBalance(account, big.NewInt(1000)) // Add a batch consecutive pending transactions for validation txns := []*types.Transaction{} for i := 0; i < 100; i++ { var tx *types.Transaction if i%2 == 0 { tx = transaction(uint64(i), big.NewInt(100), key) } else { tx = transaction(uint64(i), big.NewInt(500), key) } pool.addTx(tx.Hash(), account, tx) txns = append(txns, tx) } // Check that pre and post validations leave the pool as is if len(pool.pending) != len(txns) { t.Errorf("pending transaction mismatch: have %d, want %d", len(pool.pending), len(txns)) } if len(pool.queue[account]) != 0 { t.Errorf("queued transaction mismatch: have %d, want %d", len(pool.queue), 0) } pool.resetState() if len(pool.pending) != len(txns) { t.Errorf("pending transaction mismatch: have %d, want %d", len(pool.pending), len(txns)) } if len(pool.queue[account]) != 0 { t.Errorf("queued transaction mismatch: have %d, want %d", len(pool.queue), 0) } // Reduce the balance of the account, and check that transactions are reorganized state.AddBalance(account, big.NewInt(-750)) pool.resetState() if _, ok := pool.pending[txns[0].Hash()]; !ok { t.Errorf("tx %d: valid and funded transaction missing from pending pool: %v", 0, txns[0]) } if _, ok := pool.queue[account][txns[0].Hash()]; ok { t.Errorf("tx %d: valid and funded transaction present in future queue: %v", 0, txns[0]) } for i, tx := range txns[1:] { if i%2 == 1 { if _, ok := pool.pending[tx.Hash()]; ok { t.Errorf("tx %d: valid but future transaction present in pending pool: %v", i+1, tx) } if _, ok := pool.queue[account][tx.Hash()]; !ok { t.Errorf("tx %d: valid but future transaction missing from future queue: %v", i+1, tx) } } else { if _, ok := pool.pending[tx.Hash()]; ok { t.Errorf("tx %d: out-of-fund transaction present in pending pool: %v", i+1, tx) } if _, ok := pool.queue[account][tx.Hash()]; ok { t.Errorf("tx %d: out-of-fund transaction present in future queue: %v", i+1, tx) } } } }