Skip to content

Commit 7e15f44

Browse files
benaadamsbenaadams
authored
Reduce guard checks and interface calls when using ArrayPoolList (#7960)
1 parent 4bb25cd commit 7e15f44

22 files changed

+111
-158
lines changed

‎src/Nethermind/Nethermind.Crypto/KeccakRlpStream.cs

-5
Original file line numberDiff line numberDiff line change
@@ -30,11 +30,6 @@ public override void Write(ReadOnlySpan<byte> bytesToWrite)
3030
_keccakHash.Update(bytesToWrite);
3131
}
3232

33-
public override void Write(IReadOnlyList<byte> bytesToWrite)
34-
{
35-
_keccakHash.Update(bytesToWrite.ToArray());
36-
}
37-
3833
public override void WriteByte(byte byteToWrite)
3934
{
4035
_keccakHash.Update(MemoryMarshal.CreateSpan(ref byteToWrite, 1));

‎src/Nethermind/Nethermind.JsonRpc/Modules/Eth/FeeHistory/FeeHistoryOracle.cs

+2-1
Original file line numberDiff line numberDiff line change
@@ -254,10 +254,11 @@ static IEnumerable<long> CalculateGasUsed(TxReceipt[] txReceipts)
254254
: txs.Select(static tx => tx.GasLimit));
255255

256256
List<RewardInfo> rewardInfos = new(txs.Length);
257+
Span<long> gasUsedSpan = gasUsed.AsSpan();
257258
for (int i = 0; i < txs.Length; i++)
258259
{
259260
txs[i].TryCalculatePremiumPerGas(block.BaseFeePerGas, out UInt256 premiumPerGas);
260-
rewardInfos.Add(new RewardInfo(gasUsed[i], premiumPerGas));
261+
rewardInfos.Add(new RewardInfo(gasUsedSpan[i], premiumPerGas));
261262
}
262263

263264
rewardInfos.Sort(static (i1, i2) => i1.PremiumPerGas.CompareTo(i2.PremiumPerGas));

‎src/Nethermind/Nethermind.Network.Test/P2P/SerializerTester.cs

+1
Original file line numberDiff line numberDiff line change
@@ -50,6 +50,7 @@ public static void TestZero<T>(IZeroMessageSerializer<T> serializer, T message,
5050
{
5151
buffer.Release();
5252
buffer2.Release();
53+
message.TryDispose();
5354
}
5455
}
5556
}

‎src/Nethermind/Nethermind.Network.Test/P2P/Subprotocols/Eth/V65/Eth65ProtocolHandlerTests.cs

+2-1
Original file line numberDiff line numberDiff line change
@@ -10,6 +10,7 @@
1010
using FluentAssertions;
1111
using Nethermind.Consensus;
1212
using Nethermind.Core;
13+
using Nethermind.Core.Collections;
1314
using Nethermind.Core.Crypto;
1415
using Nethermind.Core.Extensions;
1516
using Nethermind.Core.Specs;
@@ -196,7 +197,7 @@ public void should_handle_NewPooledTransactionHashesMessage([Values(true, false)
196197
HandleIncomingStatusMessage();
197198
HandleZeroMessage(msg, Eth65MessageCode.NewPooledTransactionHashes);
198199

199-
_pooledTxsRequestor.Received(canGossipTransactions ? 1 : 0).RequestTransactions(Arg.Any<Action<GetPooledTransactionsMessage>>(), Arg.Any<IReadOnlyList<Hash256>>());
200+
_pooledTxsRequestor.Received(canGossipTransactions ? 1 : 0).RequestTransactions(Arg.Any<Action<GetPooledTransactionsMessage>>(), Arg.Any<IOwnedReadOnlyList<Hash256>>());
200201
}
201202

202203
private void HandleZeroMessage<T>(T msg, int messageCode) where T : MessageBase

‎src/Nethermind/Nethermind.Network.Test/P2P/Subprotocols/Eth/V65/PooledTxsRequestorTests.cs

+34-26
Original file line numberDiff line numberDiff line change
@@ -12,6 +12,9 @@
1212
using Nethermind.TxPool;
1313
using NSubstitute;
1414
using NUnit.Framework;
15+
using System.Runtime.InteropServices;
16+
using Nethermind.Core.Collections;
17+
using Nethermind.Core.Extensions;
1518

1619
namespace Nethermind.Network.Test.P2P.Subprotocols.Eth.V65
1720
{
@@ -20,74 +23,79 @@ public class PooledTxsRequestorTests
2023
private readonly ITxPool _txPool = Substitute.For<ITxPool>();
2124
private readonly Action<GetPooledTransactionsMessage> _doNothing = static msg => msg.Dispose();
2225
private IPooledTxsRequestor _requestor;
23-
private IReadOnlyList<Hash256> _request;
24-
private IList<Hash256> _expected;
25-
private IReadOnlyList<Hash256> _response;
26+
private ArrayPoolList<Hash256> _response;
2627

28+
[TearDown]
29+
public void TearDown()
30+
{
31+
_response?.Dispose();
32+
}
2733

2834
[Test]
2935
public void filter_properly_newPooledTxHashes()
3036
{
31-
_response = new List<Hash256>();
3237
_requestor = new PooledTxsRequestor(_txPool, new TxPoolConfig());
33-
_requestor.RequestTransactions(_doNothing, new List<Hash256> { TestItem.KeccakA, TestItem.KeccakD });
38+
using var skipped = new ArrayPoolList<Hash256>(2) { TestItem.KeccakA, TestItem.KeccakD };
39+
_requestor.RequestTransactions(_doNothing, skipped);
3440

35-
_request = new List<Hash256> { TestItem.KeccakA, TestItem.KeccakB, TestItem.KeccakC };
36-
_expected = new List<Hash256> { TestItem.KeccakB, TestItem.KeccakC };
37-
_requestor.RequestTransactions(Send, _request);
38-
_response.Should().BeEquivalentTo(_expected);
41+
using var request = new ArrayPoolList<Hash256>(3) { TestItem.KeccakA, TestItem.KeccakB, TestItem.KeccakC };
42+
using var expected = new ArrayPoolList<Hash256>(3) { TestItem.KeccakB, TestItem.KeccakC };
43+
_requestor.RequestTransactions(Send, request);
44+
_response.Should().BeEquivalentTo(expected);
3945
}
4046

4147
[Test]
4248
public void filter_properly_already_pending_hashes()
4349
{
44-
_response = new List<Hash256>();
4550
_requestor = new PooledTxsRequestor(_txPool, new TxPoolConfig());
46-
_requestor.RequestTransactions(_doNothing, new List<Hash256> { TestItem.KeccakA, TestItem.KeccakB, TestItem.KeccakC });
51+
using var skipped = new ArrayPoolList<Hash256>(3) { TestItem.KeccakA, TestItem.KeccakB, TestItem.KeccakC };
52+
_requestor.RequestTransactions(_doNothing, skipped);
4753

48-
_request = new List<Hash256> { TestItem.KeccakA, TestItem.KeccakB, TestItem.KeccakC };
49-
_requestor.RequestTransactions(Send, _request);
54+
using var request = new ArrayPoolList<Hash256>(3) { TestItem.KeccakA, TestItem.KeccakB, TestItem.KeccakC };
55+
_requestor.RequestTransactions(Send, request);
5056
_response.Should().BeEmpty();
5157
}
5258

5359
[Test]
5460
public void filter_properly_discovered_hashes()
5561
{
56-
_response = new List<Hash256>();
5762
_requestor = new PooledTxsRequestor(_txPool, new TxPoolConfig());
5863

59-
_request = new List<Hash256> { TestItem.KeccakA, TestItem.KeccakB, TestItem.KeccakC };
60-
_expected = new List<Hash256> { TestItem.KeccakA, TestItem.KeccakB, TestItem.KeccakC };
61-
_requestor.RequestTransactions(Send, _request);
62-
_response.Should().BeEquivalentTo(_expected);
64+
using var request = new ArrayPoolList<Hash256>(3) { TestItem.KeccakA, TestItem.KeccakB, TestItem.KeccakC };
65+
using var expected = new ArrayPoolList<Hash256>(3) { TestItem.KeccakA, TestItem.KeccakB, TestItem.KeccakC };
66+
_requestor.RequestTransactions(Send, request);
67+
_response.Should().BeEquivalentTo(expected);
6368
}
6469

6570
[Test]
6671
public void can_handle_empty_argument()
6772
{
68-
_response = new List<Hash256>();
6973
_requestor = new PooledTxsRequestor(_txPool, new TxPoolConfig());
70-
_requestor.RequestTransactions(Send, new List<Hash256>());
74+
using var skipped = new ArrayPoolList<Hash256>(0);
75+
_requestor.RequestTransactions(Send, skipped);
7176
_response.Should().BeEmpty();
7277
}
7378

7479
[Test]
7580
public void filter_properly_hashes_present_in_hashCache()
7681
{
77-
_response = new List<Hash256>();
7882
ITxPool txPool = Substitute.For<ITxPool>();
7983
txPool.IsKnown(Arg.Any<Hash256>()).Returns(true);
8084
_requestor = new PooledTxsRequestor(txPool, new TxPoolConfig());
8185

82-
_request = new List<Hash256> { TestItem.KeccakA, TestItem.KeccakB };
83-
_expected = new List<Hash256> { };
84-
_requestor.RequestTransactions(Send, _request);
85-
_response.Should().BeEquivalentTo(_expected);
86+
using var request = new ArrayPoolList<Hash256>(2) { TestItem.KeccakA, TestItem.KeccakB };
87+
using var expected = new ArrayPoolList<Hash256>(0) { };
88+
_requestor.RequestTransactions(Send, request);
89+
_response.Should().BeEquivalentTo(expected);
8690
}
8791

8892
private void Send(GetPooledTransactionsMessage msg)
8993
{
90-
using (msg) _response = msg.Hashes.ToList();
94+
_response?.Dispose();
95+
using (msg)
96+
{
97+
_response = msg.Hashes.ToPooledList();
98+
}
9199
}
92100
}
93101
}

‎src/Nethermind/Nethermind.Network.Test/P2P/Subprotocols/Eth/V68/Eth68ProtocolHandlerTests.cs

+2-2
Original file line numberDiff line numberDiff line change
@@ -125,7 +125,7 @@ public void Can_handle_NewPooledTransactions_message([Values(0, 1, 2, 100)] int
125125
HandleZeroMessage(msg, Eth68MessageCode.NewPooledTransactionHashes);
126126

127127
_pooledTxsRequestor.Received(canGossipTransactions ? 1 : 0).RequestTransactionsEth68(Arg.Any<Action<GetPooledTransactionsMessage>>(),
128-
Arg.Any<IReadOnlyList<Hash256>>(), Arg.Any<IReadOnlyList<int>>(), Arg.Any<IReadOnlyList<byte>>());
128+
Arg.Any<IOwnedReadOnlyList<Hash256>>(), Arg.Any<IOwnedReadOnlyList<int>>(), Arg.Any<IOwnedReadOnlyList<byte>>());
129129
}
130130

131131
[TestCase(true)]
@@ -163,7 +163,7 @@ public void Should_process_huge_transaction()
163163
HandleZeroMessage(msg, Eth68MessageCode.NewPooledTransactionHashes);
164164

165165
_pooledTxsRequestor.Received(1).RequestTransactionsEth68(Arg.Any<Action<GetPooledTransactionsMessage>>(),
166-
Arg.Any<IReadOnlyList<Hash256>>(), Arg.Any<IReadOnlyList<int>>(), Arg.Any<IReadOnlyList<byte>>());
166+
Arg.Any<IOwnedReadOnlyList<Hash256>>(), Arg.Any<IOwnedReadOnlyList<int>>(), Arg.Any<IOwnedReadOnlyList<byte>>());
167167
}
168168

169169
[TestCase(1)]

‎src/Nethermind/Nethermind.Network.Test/P2P/Subprotocols/NodeData/GetNodeDataMessageTests.cs

+3-3
Original file line numberDiff line numberDiff line change
@@ -21,7 +21,7 @@ public class GetNodeDataMessageTests
2121
public void Sets_values_from_constructor_argument()
2222
{
2323
Hash256[] keys = { TestItem.KeccakA, TestItem.KeccakB };
24-
GetNodeDataMessage message = new(keys.ToPooledList());
24+
using GetNodeDataMessage message = new(keys.ToPooledList());
2525
keys.Should().BeEquivalentTo(message.Hashes);
2626
}
2727

@@ -34,15 +34,15 @@ public void Throws_on_null_argument()
3434
[Test]
3535
public void To_string()
3636
{
37-
GetNodeDataMessage message = new(ArrayPoolList<Hash256>.Empty());
37+
using GetNodeDataMessage message = new(ArrayPoolList<Hash256>.Empty());
3838
_ = message.ToString();
3939
}
4040

4141
[Test]
4242
public void Packet_type_and_protocol_are_correct()
4343
{
4444
Hash256[] keys = { TestItem.KeccakA, TestItem.KeccakB };
45-
GetNodeDataMessage message = new(keys.ToPooledList());
45+
using GetNodeDataMessage message = new(keys.ToPooledList());
4646

4747
message.PacketType.Should().Be(NodeDataMessageCode.GetNodeData);
4848
message.Protocol.Should().Be(Protocol.NodeData);

‎src/Nethermind/Nethermind.Network.Test/P2P/Subprotocols/Snap/Messages/GetStorageRangesMessageSerializerTests.cs

+2-2
Original file line numberDiff line numberDiff line change
@@ -22,7 +22,7 @@ public void Roundtrip_Many()
2222
GetStorageRangeMessage msg = new()
2323
{
2424
RequestId = MessageConstants.Random.NextLong(),
25-
StoragetRange = new()
25+
StorageRange = new()
2626
{
2727
RootHash = TestItem.KeccakA,
2828
Accounts = TestItem.Keccaks.Select(static k => new PathWithAccount(k, null)).ToPooledList(TestItem.Keccaks.Length),
@@ -43,7 +43,7 @@ public void Roundtrip_Empty()
4343
GetStorageRangeMessage msg = new()
4444
{
4545
RequestId = MessageConstants.Random.NextLong(),
46-
StoragetRange = new()
46+
StorageRange = new()
4747
{
4848
RootHash = Keccak.OfAnEmptyString,
4949
Accounts = ArrayPoolList<PathWithAccount>.Empty(),

‎src/Nethermind/Nethermind.Network.Test/P2P/Subprotocols/Snap/Messages/GetTrieNodesMessageSerializerTests.cs

+1-1
Original file line numberDiff line numberDiff line change
@@ -98,7 +98,7 @@ public void NullPathGroup()
9898

9999
GetTrieNodesMessageSerializer serializer = new();
100100

101-
GetTrieNodesMessage? msg = serializer.Deserialize(data);
101+
using GetTrieNodesMessage? msg = serializer.Deserialize(data);
102102
byte[] recode = serializer.Serialize(msg);
103103

104104
recode.Should().BeEquivalentTo(data);

‎src/Nethermind/Nethermind.Network.Test/P2P/Subprotocols/Snap/Messages/TrieNodesMessageSerializerTests.cs

+2-2
Original file line numberDiff line numberDiff line change
@@ -15,7 +15,7 @@ public class TrieNodesMessageSerializerTests
1515
[Test]
1616
public void Roundtrip()
1717
{
18-
ArrayPoolList<byte[]> data = new(2) { new byte[] { 0xde, 0xad, 0xc0, 0xde }, new byte[] { 0xfe, 0xed } };
18+
using ArrayPoolList<byte[]> data = new(2) { new byte[] { 0xde, 0xad, 0xc0, 0xde }, new byte[] { 0xfe, 0xed } };
1919

2020
TrieNodesMessage message = new(data);
2121

@@ -27,7 +27,7 @@ public void Roundtrip()
2727
[Test]
2828
public void RoundtripWithCorrectLength()
2929
{
30-
ArrayPoolList<byte[]> data = new(2) { new byte[] { 0xde, 0xad, 0xc0, 0xde }, new byte[] { 0xfe, 0xed } };
30+
using ArrayPoolList<byte[]> data = new(2) { new byte[] { 0xde, 0xad, 0xc0, 0xde }, new byte[] { 0xfe, 0xed } };
3131

3232
TrieNodesMessage message = new(data);
3333
message.RequestId = 1;

‎src/Nethermind/Nethermind.Network/P2P/Subprotocols/Eth/HashesMessageSerializer.cs

+2-2
Original file line numberDiff line numberDiff line change
@@ -40,9 +40,9 @@ public void Serialize(IByteBuffer byteBuffer, T message)
4040
RlpStream rlpStream = new NettyRlpStream(byteBuffer);
4141

4242
rlpStream.StartSequence(contentLength);
43-
for (int i = 0; i < message.Hashes.Count; i++)
43+
foreach (Hash256 hash in message.Hashes.AsSpan())
4444
{
45-
rlpStream.Encode(message.Hashes[i]);
45+
rlpStream.Encode(hash);
4646
}
4747
}
4848

‎src/Nethermind/Nethermind.Network/P2P/Subprotocols/Eth/IPooledTxsRequestor.cs

+4-4
Original file line numberDiff line numberDiff line change
@@ -2,16 +2,16 @@
22
// SPDX-License-Identifier: LGPL-3.0-only
33

44
using System;
5-
using System.Collections.Generic;
5+
using Nethermind.Core.Collections;
66
using Nethermind.Core.Crypto;
77
using Nethermind.Network.P2P.Subprotocols.Eth.V65.Messages;
88

99
namespace Nethermind.Network.P2P.Subprotocols.Eth
1010
{
1111
public interface IPooledTxsRequestor
1212
{
13-
void RequestTransactions(Action<GetPooledTransactionsMessage> send, IReadOnlyList<Hash256> hashes);
14-
void RequestTransactionsEth66(Action<V66.Messages.GetPooledTransactionsMessage> send, IReadOnlyList<Hash256> hashes);
15-
void RequestTransactionsEth68(Action<V66.Messages.GetPooledTransactionsMessage> send, IReadOnlyList<Hash256> hashes, IReadOnlyList<int> sizes, IReadOnlyList<byte> types);
13+
void RequestTransactions(Action<GetPooledTransactionsMessage> send, IOwnedReadOnlyList<Hash256> hashes);
14+
void RequestTransactionsEth66(Action<V66.Messages.GetPooledTransactionsMessage> send, IOwnedReadOnlyList<Hash256> hashes);
15+
void RequestTransactionsEth68(Action<V66.Messages.GetPooledTransactionsMessage> send, IOwnedReadOnlyList<Hash256> hashes, IOwnedReadOnlyList<int> sizes, IOwnedReadOnlyList<byte> types);
1616
}
1717
}

‎src/Nethermind/Nethermind.Network/P2P/Subprotocols/Eth/PooledTxsRequestor.cs

+23-28
Original file line numberDiff line numberDiff line change
@@ -27,15 +27,15 @@ public PooledTxsRequestor(ITxPool txPool, ITxPoolConfig txPoolConfig)
2727
_blobSupportEnabled = txPoolConfig.BlobsSupport.IsEnabled();
2828
}
2929

30-
public void RequestTransactions(Action<GetPooledTransactionsMessage> send, IReadOnlyList<Hash256> hashes)
30+
public void RequestTransactions(Action<GetPooledTransactionsMessage> send, IOwnedReadOnlyList<Hash256> hashes)
3131
{
32-
ArrayPoolList<Hash256> discoveredTxHashes = AddMarkUnknownHashes(hashes);
32+
ArrayPoolList<Hash256> discoveredTxHashes = AddMarkUnknownHashes(hashes.AsSpan());
3333
RequestPooledTransactions(send, discoveredTxHashes);
3434
}
3535

36-
public void RequestTransactionsEth66(Action<V66.Messages.GetPooledTransactionsMessage> send, IReadOnlyList<Hash256> hashes)
36+
public void RequestTransactionsEth66(Action<V66.Messages.GetPooledTransactionsMessage> send, IOwnedReadOnlyList<Hash256> hashes)
3737
{
38-
ArrayPoolList<Hash256> discoveredTxHashes = AddMarkUnknownHashes(hashes);
38+
ArrayPoolList<Hash256> discoveredTxHashes = AddMarkUnknownHashes(hashes.AsSpan());
3939

4040
if (discoveredTxHashes.Count <= MaxNumberOfTxsInOneMsg)
4141
{
@@ -56,41 +56,44 @@ public void RequestTransactionsEth66(Action<V66.Messages.GetPooledTransactionsMe
5656
}
5757
}
5858

59-
public void RequestTransactionsEth68(Action<V66.Messages.GetPooledTransactionsMessage> send, IReadOnlyList<Hash256> hashes, IReadOnlyList<int> sizes, IReadOnlyList<byte> types)
59+
public void RequestTransactionsEth68(Action<V66.Messages.GetPooledTransactionsMessage> send, IOwnedReadOnlyList<Hash256> hashes, IOwnedReadOnlyList<int> sizes, IOwnedReadOnlyList<byte> types)
6060
{
61-
using ArrayPoolList<(Hash256 Hash, byte Type, int Size)> discoveredTxHashesAndSizes = AddMarkUnknownHashesEth68(hashes, sizes, types);
61+
using ArrayPoolList<(Hash256 Hash, byte Type, int Size)> discoveredTxHashesAndSizes = AddMarkUnknownHashesEth68(hashes.AsSpan(), sizes.AsSpan(), types.AsSpan());
6262
if (discoveredTxHashesAndSizes.Count == 0) return;
6363

6464
int packetSizeLeft = TransactionsMessage.MaxPacketSize;
6565
ArrayPoolList<Hash256> hashesToRequest = new(discoveredTxHashesAndSizes.Count);
6666

67-
for (int i = 0; i < discoveredTxHashesAndSizes.Count; i++)
67+
var discoveredCount = discoveredTxHashesAndSizes.Count;
68+
var toRequestCount = 0;
69+
foreach ((Hash256 hash, byte type, int size) in discoveredTxHashesAndSizes.AsSpan())
6870
{
69-
int txSize = discoveredTxHashesAndSizes[i].Size;
70-
TxType txType = (TxType)discoveredTxHashesAndSizes[i].Type;
71+
int txSize = size;
72+
TxType txType = (TxType)type;
7173

72-
if (txSize > packetSizeLeft && hashesToRequest.Count > 0)
74+
if (txSize > packetSizeLeft && toRequestCount > 0)
7375
{
7476
RequestPooledTransactionsEth66(send, hashesToRequest);
75-
hashesToRequest = new ArrayPoolList<Hash256>(discoveredTxHashesAndSizes.Count);
77+
hashesToRequest = new ArrayPoolList<Hash256>(discoveredCount);
7678
packetSizeLeft = TransactionsMessage.MaxPacketSize;
79+
toRequestCount = 0;
7780
}
7881

7982
if (_blobSupportEnabled || txType != TxType.Blob)
8083
{
81-
hashesToRequest.Add(discoveredTxHashesAndSizes[i].Hash);
84+
hashesToRequest.Add(hash);
8285
packetSizeLeft -= txSize;
86+
toRequestCount++;
8387
}
8488
}
8589

8690
RequestPooledTransactionsEth66(send, hashesToRequest);
8791
}
8892

89-
private ArrayPoolList<Hash256> AddMarkUnknownHashes(IReadOnlyList<Hash256> hashes)
93+
private ArrayPoolList<Hash256> AddMarkUnknownHashes(ReadOnlySpan<Hash256> hashes)
9094
{
91-
int count = hashes.Count;
92-
ArrayPoolList<Hash256> discoveredTxHashes = new ArrayPoolList<Hash256>(count);
93-
for (int i = 0; i < count; i++)
95+
ArrayPoolList<Hash256> discoveredTxHashes = new ArrayPoolList<Hash256>(hashes.Length);
96+
for (int i = 0; i < hashes.Length; i++)
9497
{
9598
Hash256 hash = hashes[i];
9699
if (!_txPool.IsKnown(hash) && _pendingHashes.Set(hash))
@@ -102,11 +105,10 @@ private ArrayPoolList<Hash256> AddMarkUnknownHashes(IReadOnlyList<Hash256> hashe
102105
return discoveredTxHashes;
103106
}
104107

105-
private ArrayPoolList<(Hash256, byte, int)> AddMarkUnknownHashesEth68(IReadOnlyList<Hash256> hashes, IReadOnlyList<int> sizes, IReadOnlyList<byte> types)
108+
private ArrayPoolList<(Hash256, byte, int)> AddMarkUnknownHashesEth68(ReadOnlySpan<Hash256> hashes, ReadOnlySpan<int> sizes, ReadOnlySpan<byte> types)
106109
{
107-
int count = hashes.Count;
108-
ArrayPoolList<(Hash256, byte, int)> discoveredTxHashesAndSizes = new(count);
109-
for (int i = 0; i < count; i++)
110+
ArrayPoolList<(Hash256, byte, int)> discoveredTxHashesAndSizes = new(hashes.Length);
111+
for (int i = 0; i < hashes.Length; i++)
110112
{
111113
Hash256 hash = hashes[i];
112114
if (!_txPool.IsKnown(hash) && !_txPool.ContainsTx(hash, (TxType)types[i]) && _pendingHashes.Set(hash))
@@ -120,14 +122,7 @@ private ArrayPoolList<Hash256> AddMarkUnknownHashes(IReadOnlyList<Hash256> hashe
120122

121123
private static void RequestPooledTransactions(Action<GetPooledTransactionsMessage> send, IOwnedReadOnlyList<Hash256> hashesToRequest)
122124
{
123-
if (hashesToRequest.Count > 0)
124-
{
125-
send(new(hashesToRequest));
126-
}
127-
else
128-
{
129-
hashesToRequest.Dispose();
130-
}
125+
send(new(hashesToRequest));
131126
}
132127

133128
private static void RequestPooledTransactionsEth66(Action<V66.Messages.GetPooledTransactionsMessage> send, IOwnedReadOnlyList<Hash256> hashesToRequest)

0 commit comments

Comments
 (0)