Remove encoding context

Signed-off-by: Gabriel-Trintinalia <gabriel.trintinalia@consensys.net>
pull/7871/head
Gabriel-Trintinalia 3 weeks ago
parent ef9d1ab38e
commit 64b53b4745
  1. 3
      besu/src/main/java/org/hyperledger/besu/cli/subcommands/TxParseSubCommand.java
  2. 3
      ethereum/api/src/main/java/org/hyperledger/besu/ethereum/api/jsonrpc/internal/methods/engine/AbstractEngineNewPayload.java
  3. 13
      ethereum/api/src/main/java/org/hyperledger/besu/ethereum/api/jsonrpc/internal/results/BlockResultFactory.java
  4. 4
      ethereum/api/src/main/java/org/hyperledger/besu/ethereum/api/jsonrpc/internal/results/EngineGetPayloadBodiesResultV1.java
  5. 5
      ethereum/api/src/main/java/org/hyperledger/besu/ethereum/api/jsonrpc/internal/results/TransactionPendingResult.java
  6. 5
      ethereum/api/src/main/java/org/hyperledger/besu/ethereum/api/util/DomainObjectDecodeUtils.java
  7. 7
      ethereum/api/src/test/java/org/hyperledger/besu/ethereum/api/jsonrpc/internal/methods/engine/EngineNewPayloadV3Test.java
  8. 7
      ethereum/api/src/test/java/org/hyperledger/besu/ethereum/api/util/DomainObjectDecodeUtilsTest.java
  9. 10
      ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/Transaction.java
  10. 41
      ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/encoding/EncodingContext.java
  11. 36
      ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/encoding/PooledTransactionDecoder.java
  12. 49
      ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/encoding/PooledTransactionEncoder.java
  13. 42
      ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/encoding/TransactionDecoder.java
  14. 28
      ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/encoding/TransactionEncoder.java
  15. 3
      ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/BodyValidation.java
  16. 10
      ethereum/core/src/test/java/org/hyperledger/besu/ethereum/core/encoding/BlobTransactionEncodingTest.java
  17. 19
      ethereum/core/src/test/java/org/hyperledger/besu/ethereum/core/encoding/TransactionRLPDecoderTest.java
  18. 17
      ethereum/core/src/test/java/org/hyperledger/besu/ethereum/core/encoding/TransactionRLPEncoderTest.java
  19. 5
      ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/manager/EthServer.java
  20. 11
      ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/messages/PooledTransactionsMessage.java
  21. 17
      ethereum/eth/src/test/java/org/hyperledger/besu/ethereum/eth/transactions/PendingTransactionEstimatedMemorySizeTest.java

@ -19,7 +19,6 @@ import static org.hyperledger.besu.cli.subcommands.TxParseSubCommand.COMMAND_NAM
import org.hyperledger.besu.cli.util.VersionProvider; import org.hyperledger.besu.cli.util.VersionProvider;
import org.hyperledger.besu.crypto.SignatureAlgorithmFactory; import org.hyperledger.besu.crypto.SignatureAlgorithmFactory;
import org.hyperledger.besu.ethereum.core.encoding.EncodingContext;
import org.hyperledger.besu.ethereum.core.encoding.TransactionDecoder; import org.hyperledger.besu.ethereum.core.encoding.TransactionDecoder;
import java.io.BufferedReader; import java.io.BufferedReader;
@ -105,7 +104,7 @@ public class TxParseSubCommand implements Runnable {
void dump(final Bytes tx) { void dump(final Bytes tx) {
try { try {
var transaction = TransactionDecoder.decodeOpaqueBytes(tx, EncodingContext.BLOCK_BODY); var transaction = TransactionDecoder.decodeOpaqueBytes(tx);
// https://github.com/hyperledger/besu/blob/5fe49c60b30fe2954c7967e8475c3b3e9afecf35/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetTransactionValidator.java#L252 // https://github.com/hyperledger/besu/blob/5fe49c60b30fe2954c7967e8475c3b3e9afecf35/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetTransactionValidator.java#L252
if (transaction.getChainId().isPresent() && !transaction.getChainId().get().equals(chainId)) { if (transaction.getChainId().isPresent() && !transaction.getChainId().get().equals(chainId)) {

@ -51,7 +51,6 @@ import org.hyperledger.besu.ethereum.core.Difficulty;
import org.hyperledger.besu.ethereum.core.Request; import org.hyperledger.besu.ethereum.core.Request;
import org.hyperledger.besu.ethereum.core.Transaction; import org.hyperledger.besu.ethereum.core.Transaction;
import org.hyperledger.besu.ethereum.core.Withdrawal; import org.hyperledger.besu.ethereum.core.Withdrawal;
import org.hyperledger.besu.ethereum.core.encoding.EncodingContext;
import org.hyperledger.besu.ethereum.core.encoding.TransactionDecoder; import org.hyperledger.besu.ethereum.core.encoding.TransactionDecoder;
import org.hyperledger.besu.ethereum.eth.manager.EthPeers; import org.hyperledger.besu.ethereum.eth.manager.EthPeers;
import org.hyperledger.besu.ethereum.mainnet.BodyValidation; import org.hyperledger.besu.ethereum.mainnet.BodyValidation;
@ -221,7 +220,7 @@ public abstract class AbstractEngineNewPayload extends ExecutionEngineJsonRpcMet
transactions = transactions =
blockParam.getTransactions().stream() blockParam.getTransactions().stream()
.map(Bytes::fromHexString) .map(Bytes::fromHexString)
.map(in -> TransactionDecoder.decodeOpaqueBytes(in, EncodingContext.BLOCK_BODY)) .map(TransactionDecoder::decodeOpaqueBytes)
.collect(Collectors.toList()); .collect(Collectors.toList());
transactions.forEach( transactions.forEach(
transaction -> transaction ->

@ -23,7 +23,6 @@ import org.hyperledger.besu.ethereum.core.Block;
import org.hyperledger.besu.ethereum.core.BlockBody; import org.hyperledger.besu.ethereum.core.BlockBody;
import org.hyperledger.besu.ethereum.core.BlockHeader; import org.hyperledger.besu.ethereum.core.BlockHeader;
import org.hyperledger.besu.ethereum.core.Request; import org.hyperledger.besu.ethereum.core.Request;
import org.hyperledger.besu.ethereum.core.encoding.EncodingContext;
import org.hyperledger.besu.ethereum.core.encoding.TransactionEncoder; import org.hyperledger.besu.ethereum.core.encoding.TransactionEncoder;
import java.util.ArrayList; import java.util.ArrayList;
@ -97,8 +96,7 @@ public class BlockResultFactory {
final List<String> txs = final List<String> txs =
block.getBody().getTransactions().stream() block.getBody().getTransactions().stream()
.map( .map(
transaction -> TransactionEncoder::encodeOpaqueBytes)
TransactionEncoder.encodeOpaqueBytes(transaction, EncodingContext.BLOCK_BODY))
.map(Bytes::toHexString) .map(Bytes::toHexString)
.collect(Collectors.toList()); .collect(Collectors.toList());
@ -110,8 +108,7 @@ public class BlockResultFactory {
final List<String> txs = final List<String> txs =
blockWithReceipts.getBlock().getBody().getTransactions().stream() blockWithReceipts.getBlock().getBody().getTransactions().stream()
.map( .map(
transaction -> TransactionEncoder::encodeOpaqueBytes)
TransactionEncoder.encodeOpaqueBytes(transaction, EncodingContext.BLOCK_BODY))
.map(Bytes::toHexString) .map(Bytes::toHexString)
.collect(Collectors.toList()); .collect(Collectors.toList());
@ -136,8 +133,7 @@ public class BlockResultFactory {
final List<String> txs = final List<String> txs =
blockWithReceipts.getBlock().getBody().getTransactions().stream() blockWithReceipts.getBlock().getBody().getTransactions().stream()
.map( .map(
transaction -> TransactionEncoder::encodeOpaqueBytes)
TransactionEncoder.encodeOpaqueBytes(transaction, EncodingContext.BLOCK_BODY))
.map(Bytes::toHexString) .map(Bytes::toHexString)
.collect(Collectors.toList()); .collect(Collectors.toList());
@ -156,8 +152,7 @@ public class BlockResultFactory {
final List<String> txs = final List<String> txs =
blockWithReceipts.getBlock().getBody().getTransactions().stream() blockWithReceipts.getBlock().getBody().getTransactions().stream()
.map( .map(
transaction -> TransactionEncoder::encodeOpaqueBytes)
TransactionEncoder.encodeOpaqueBytes(transaction, EncodingContext.BLOCK_BODY))
.map(Bytes::toHexString) .map(Bytes::toHexString)
.collect(Collectors.toList()); .collect(Collectors.toList());
final Optional<List<String>> requestsWithoutRequestId = final Optional<List<String>> requestsWithoutRequestId =

@ -16,7 +16,6 @@ package org.hyperledger.besu.ethereum.api.jsonrpc.internal.results;
import org.hyperledger.besu.ethereum.api.jsonrpc.internal.parameters.WithdrawalParameter; import org.hyperledger.besu.ethereum.api.jsonrpc.internal.parameters.WithdrawalParameter;
import org.hyperledger.besu.ethereum.core.BlockBody; import org.hyperledger.besu.ethereum.core.BlockBody;
import org.hyperledger.besu.ethereum.core.encoding.EncodingContext;
import org.hyperledger.besu.ethereum.core.encoding.TransactionEncoder; import org.hyperledger.besu.ethereum.core.encoding.TransactionEncoder;
import java.util.Collections; import java.util.Collections;
@ -54,8 +53,7 @@ public class EngineGetPayloadBodiesResultV1 {
this.transactions = this.transactions =
blockBody.getTransactions().stream() blockBody.getTransactions().stream()
.map( .map(
transaction -> TransactionEncoder::encodeOpaqueBytes)
TransactionEncoder.encodeOpaqueBytes(transaction, EncodingContext.BLOCK_BODY))
.map(Bytes::toHexString) .map(Bytes::toHexString)
.collect(Collectors.toList()); .collect(Collectors.toList());
this.withdrawals = this.withdrawals =

@ -20,8 +20,7 @@ import org.hyperledger.besu.datatypes.TransactionType;
import org.hyperledger.besu.datatypes.VersionedHash; import org.hyperledger.besu.datatypes.VersionedHash;
import org.hyperledger.besu.datatypes.Wei; import org.hyperledger.besu.datatypes.Wei;
import org.hyperledger.besu.ethereum.core.Transaction; import org.hyperledger.besu.ethereum.core.Transaction;
import org.hyperledger.besu.ethereum.core.encoding.EncodingContext; import org.hyperledger.besu.ethereum.core.encoding.PooledTransactionEncoder;
import org.hyperledger.besu.ethereum.core.encoding.TransactionEncoder;
import java.util.List; import java.util.List;
@ -103,7 +102,7 @@ public class TransactionPendingResult implements TransactionResult {
this.nonce = Quantity.create(transaction.getNonce()); this.nonce = Quantity.create(transaction.getNonce());
this.publicKey = transaction.getPublicKey().orElse(null); this.publicKey = transaction.getPublicKey().orElse(null);
this.raw = this.raw =
TransactionEncoder.encodeOpaqueBytes(transaction, EncodingContext.POOLED_TRANSACTION) PooledTransactionEncoder.encodeOpaqueBytes(transaction)
.toString(); .toString();
this.to = transaction.getTo().map(Address::toHexString).orElse(null); this.to = transaction.getTo().map(Address::toHexString).orElse(null);
if (transactionType == TransactionType.FRONTIER) { if (transactionType == TransactionType.FRONTIER) {

@ -17,8 +17,7 @@ package org.hyperledger.besu.ethereum.api.util;
import org.hyperledger.besu.ethereum.api.jsonrpc.internal.exception.InvalidJsonRpcRequestException; import org.hyperledger.besu.ethereum.api.jsonrpc.internal.exception.InvalidJsonRpcRequestException;
import org.hyperledger.besu.ethereum.api.jsonrpc.internal.response.RpcErrorType; import org.hyperledger.besu.ethereum.api.jsonrpc.internal.response.RpcErrorType;
import org.hyperledger.besu.ethereum.core.Transaction; import org.hyperledger.besu.ethereum.core.Transaction;
import org.hyperledger.besu.ethereum.core.encoding.EncodingContext; import org.hyperledger.besu.ethereum.core.encoding.PooledTransactionDecoder;
import org.hyperledger.besu.ethereum.core.encoding.TransactionDecoder;
import org.hyperledger.besu.ethereum.rlp.RLPException; import org.hyperledger.besu.ethereum.rlp.RLPException;
import org.apache.tuweni.bytes.Bytes; import org.apache.tuweni.bytes.Bytes;
@ -29,7 +28,7 @@ public class DomainObjectDecodeUtils {
throws InvalidJsonRpcRequestException { throws InvalidJsonRpcRequestException {
try { try {
Bytes txnBytes = Bytes.fromHexString(rawTransaction); Bytes txnBytes = Bytes.fromHexString(rawTransaction);
return TransactionDecoder.decodeOpaqueBytes(txnBytes, EncodingContext.POOLED_TRANSACTION); return PooledTransactionDecoder.decodeOpaqueBytes(txnBytes);
} catch (final IllegalArgumentException e) { } catch (final IllegalArgumentException e) {
throw new InvalidJsonRpcRequestException( throw new InvalidJsonRpcRequestException(
"Invalid raw transaction hex", RpcErrorType.INVALID_TRANSACTION_PARAMS, e); "Invalid raw transaction hex", RpcErrorType.INVALID_TRANSACTION_PARAMS, e);

@ -48,8 +48,7 @@ import org.hyperledger.besu.ethereum.core.BlockHeaderTestFixture;
import org.hyperledger.besu.ethereum.core.Transaction; import org.hyperledger.besu.ethereum.core.Transaction;
import org.hyperledger.besu.ethereum.core.TransactionTestFixture; import org.hyperledger.besu.ethereum.core.TransactionTestFixture;
import org.hyperledger.besu.ethereum.core.Withdrawal; import org.hyperledger.besu.ethereum.core.Withdrawal;
import org.hyperledger.besu.ethereum.core.encoding.EncodingContext; import org.hyperledger.besu.ethereum.core.encoding.PooledTransactionEncoder;
import org.hyperledger.besu.ethereum.core.encoding.TransactionEncoder;
import org.hyperledger.besu.ethereum.mainnet.BodyValidation; import org.hyperledger.besu.ethereum.mainnet.BodyValidation;
import org.hyperledger.besu.ethereum.mainnet.CancunTargetingGasLimitCalculator; import org.hyperledger.besu.ethereum.mainnet.CancunTargetingGasLimitCalculator;
import org.hyperledger.besu.ethereum.mainnet.ValidationResult; import org.hyperledger.besu.ethereum.mainnet.ValidationResult;
@ -226,8 +225,8 @@ public class EngineNewPayloadV3Test extends EngineNewPayloadV2Test {
public void shouldRejectTransactionsWithFullBlobs() { public void shouldRejectTransactionsWithFullBlobs() {
Bytes transactionWithBlobsBytes = Bytes transactionWithBlobsBytes =
TransactionEncoder.encodeOpaqueBytes( PooledTransactionEncoder.encodeOpaqueBytes(
createTransactionWithBlobs(), EncodingContext.POOLED_TRANSACTION); createTransactionWithBlobs());
List<String> transactions = List.of(transactionWithBlobsBytes.toString()); List<String> transactions = List.of(transactionWithBlobsBytes.toString());

@ -21,8 +21,7 @@ import org.hyperledger.besu.datatypes.Address;
import org.hyperledger.besu.datatypes.Wei; import org.hyperledger.besu.datatypes.Wei;
import org.hyperledger.besu.ethereum.core.BlockDataGenerator; import org.hyperledger.besu.ethereum.core.BlockDataGenerator;
import org.hyperledger.besu.ethereum.core.Transaction; import org.hyperledger.besu.ethereum.core.Transaction;
import org.hyperledger.besu.ethereum.core.encoding.EncodingContext; import org.hyperledger.besu.ethereum.core.encoding.PooledTransactionEncoder;
import org.hyperledger.besu.ethereum.core.encoding.TransactionEncoder;
import org.hyperledger.besu.ethereum.rlp.BytesValueRLPOutput; import org.hyperledger.besu.ethereum.rlp.BytesValueRLPOutput;
import java.math.BigInteger; import java.math.BigInteger;
@ -58,7 +57,7 @@ public class DomainObjectDecodeUtilsTest {
@Test @Test
public void testAccessListRLPSerDes() { public void testAccessListRLPSerDes() {
final BytesValueRLPOutput encoded = new BytesValueRLPOutput(); final BytesValueRLPOutput encoded = new BytesValueRLPOutput();
TransactionEncoder.encodeRLP(accessListTxn, encoded, EncodingContext.POOLED_TRANSACTION); PooledTransactionEncoder.encodeRLP(accessListTxn, encoded);
Transaction decoded = Transaction decoded =
DomainObjectDecodeUtils.decodeRawTransaction(encoded.encoded().toHexString()); DomainObjectDecodeUtils.decodeRawTransaction(encoded.encoded().toHexString());
Assertions.assertThat(decoded.getAccessList().isPresent()).isTrue(); Assertions.assertThat(decoded.getAccessList().isPresent()).isTrue();
@ -68,7 +67,7 @@ public class DomainObjectDecodeUtilsTest {
@Test @Test
public void testAccessList2718OpaqueSerDes() { public void testAccessList2718OpaqueSerDes() {
final Bytes encoded = final Bytes encoded =
TransactionEncoder.encodeOpaqueBytes(accessListTxn, EncodingContext.POOLED_TRANSACTION); PooledTransactionEncoder.encodeOpaqueBytes(accessListTxn);
Transaction decoded = DomainObjectDecodeUtils.decodeRawTransaction(encoded.toString()); Transaction decoded = DomainObjectDecodeUtils.decodeRawTransaction(encoded.toString());
Assertions.assertThat(decoded.getAccessList().isPresent()).isTrue(); Assertions.assertThat(decoded.getAccessList().isPresent()).isTrue();
Assertions.assertThat(decoded.getAccessList().map(List::size).get()).isEqualTo(1); Assertions.assertThat(decoded.getAccessList().map(List::size).get()).isEqualTo(1);

@ -39,7 +39,7 @@ import org.hyperledger.besu.datatypes.Wei;
import org.hyperledger.besu.ethereum.core.encoding.AccessListTransactionEncoder; import org.hyperledger.besu.ethereum.core.encoding.AccessListTransactionEncoder;
import org.hyperledger.besu.ethereum.core.encoding.BlobTransactionEncoder; import org.hyperledger.besu.ethereum.core.encoding.BlobTransactionEncoder;
import org.hyperledger.besu.ethereum.core.encoding.CodeDelegationEncoder; import org.hyperledger.besu.ethereum.core.encoding.CodeDelegationEncoder;
import org.hyperledger.besu.ethereum.core.encoding.EncodingContext; import org.hyperledger.besu.ethereum.core.encoding.PooledTransactionEncoder;
import org.hyperledger.besu.ethereum.core.encoding.TransactionDecoder; import org.hyperledger.besu.ethereum.core.encoding.TransactionDecoder;
import org.hyperledger.besu.ethereum.core.encoding.TransactionEncoder; import org.hyperledger.besu.ethereum.core.encoding.TransactionEncoder;
import org.hyperledger.besu.ethereum.rlp.BytesValueRLPOutput; import org.hyperledger.besu.ethereum.rlp.BytesValueRLPOutput;
@ -135,7 +135,7 @@ public class Transaction
} }
public static Transaction readFrom(final RLPInput rlpInput) { public static Transaction readFrom(final RLPInput rlpInput) {
return TransactionDecoder.decodeRLP(rlpInput, EncodingContext.BLOCK_BODY); return TransactionDecoder.decodeRLP(rlpInput);
} }
/** /**
@ -485,7 +485,7 @@ public class Transaction
* @param out the output to write the transaction to * @param out the output to write the transaction to
*/ */
public void writeTo(final RLPOutput out) { public void writeTo(final RLPOutput out) {
TransactionEncoder.encodeRLP(this, out, EncodingContext.BLOCK_BODY); TransactionEncoder.encodeRLP(this, out);
} }
@Override @Override
@ -556,11 +556,11 @@ public class Transaction
} }
private void memoizeHashAndSize() { private void memoizeHashAndSize() {
final Bytes bytes = TransactionEncoder.encodeOpaqueBytes(this, EncodingContext.BLOCK_BODY); final Bytes bytes = TransactionEncoder.encodeOpaqueBytes(this);
hash = Hash.hash(bytes); hash = Hash.hash(bytes);
if (transactionType.supportsBlob() && getBlobsWithCommitments().isPresent()) { if (transactionType.supportsBlob() && getBlobsWithCommitments().isPresent()) {
final Bytes pooledBytes = final Bytes pooledBytes =
TransactionEncoder.encodeOpaqueBytes(this, EncodingContext.POOLED_TRANSACTION); PooledTransactionEncoder.encodeOpaqueBytes(this);
size = pooledBytes.size(); size = pooledBytes.size();
return; return;
} }

@ -1,41 +0,0 @@
/*
* Copyright contributors to Hyperledger Besu.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
* an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.core.encoding;
/**
* Enum representing the context in which a transaction is being encoded. This context is used to
* determine the appropriate encoding strategy for a transaction.
*
* <p>The context can be one of the following:
*
* <ul>
* <li>{@link #BLOCK_BODY}: The transaction is part of a block body. This context is used when
* encoding transactions for inclusion in a block.
* <li>{@link #POOLED_TRANSACTION}: The transaction is part of a transaction pool. This context is
* used when encoding transactions that are currently in the transaction pool, waiting to be
* included in a block. It is also used when encoding transactions for RPC calls related to
* the transaction pool.
* </ul>
*/
public enum EncodingContext {
/** Represents the context where the transaction is part of a block body. */
BLOCK_BODY,
/**
* Represents the context where the transaction is part of a transaction pool. This context is
* also used when encoding transactions for RPC calls related to the transaction pool.
*/
POOLED_TRANSACTION,
}

@ -0,0 +1,36 @@
package org.hyperledger.besu.ethereum.core.encoding;
import static com.google.common.base.Preconditions.checkNotNull;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.collect.ImmutableMap;
import org.hyperledger.besu.datatypes.TransactionType;
public class PooledTransactionDecoder extends TransactionDecoder{
private static final ImmutableMap<TransactionType, TransactionDecoder.Decoder> POOLED_TRANSACTION_DECODERS =
ImmutableMap.of(
TransactionType.ACCESS_LIST,
AccessListTransactionDecoder::decode,
TransactionType.EIP1559,
EIP1559TransactionDecoder::decode,
TransactionType.BLOB,
BlobPooledTransactionDecoder::decode ,
TransactionType.DELEGATE_CODE,
CodeDelegationTransactionDecoder::decode);
/**
* Gets the decoder for a given transaction type
*
* @param transactionType the transaction type
* @return the decoder
*/
@VisibleForTesting
protected static TransactionDecoder.Decoder getDecoder(
final TransactionType transactionType) {
return checkNotNull(
POOLED_TRANSACTION_DECODERS.get(transactionType),
"Developer Error. A supported transaction type %s has no associated decoding logic",
transactionType);
}
}

@ -0,0 +1,49 @@
/*
* Copyright ConsenSys AG.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
* an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.core.encoding;
import static com.google.common.base.Preconditions.checkNotNull;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.collect.ImmutableMap;
import org.apache.tuweni.bytes.Bytes;
import org.hyperledger.besu.datatypes.TransactionType;
import org.hyperledger.besu.ethereum.core.Transaction;
import org.hyperledger.besu.ethereum.rlp.BytesValueRLPOutput;
import org.hyperledger.besu.ethereum.rlp.RLP;
import org.hyperledger.besu.ethereum.rlp.RLPOutput;
public class PooledTransactionEncoder extends TransactionEncoder {
private static final ImmutableMap<TransactionType, Encoder> POOLED_TRANSACTION_ENCODERS =
ImmutableMap.of(
TransactionType.ACCESS_LIST,
AccessListTransactionEncoder::encode,
TransactionType.EIP1559,
EIP1559TransactionEncoder::encode,
TransactionType.BLOB,
BlobPooledTransactionEncoder::encode,
TransactionType.DELEGATE_CODE,
CodeDelegationEncoder::encode);
@VisibleForTesting
protected static Encoder getEncoder(
final TransactionType transactionType) {
return checkNotNull(
POOLED_TRANSACTION_ENCODERS.get(transactionType),
"Developer Error. A supported transaction type %s has no associated encoding logic",
transactionType);
}
}

@ -16,6 +16,7 @@ package org.hyperledger.besu.ethereum.core.encoding;
import static com.google.common.base.Preconditions.checkNotNull; import static com.google.common.base.Preconditions.checkNotNull;
import com.google.common.annotations.VisibleForTesting;
import org.hyperledger.besu.datatypes.TransactionType; import org.hyperledger.besu.datatypes.TransactionType;
import org.hyperledger.besu.ethereum.core.Transaction; import org.hyperledger.besu.ethereum.core.Transaction;
import org.hyperledger.besu.ethereum.rlp.RLP; import org.hyperledger.besu.ethereum.rlp.RLP;
@ -29,7 +30,7 @@ import org.apache.tuweni.bytes.Bytes;
public class TransactionDecoder { public class TransactionDecoder {
@FunctionalInterface @FunctionalInterface
interface Decoder { protected interface Decoder {
Transaction decode(RLPInput input); Transaction decode(RLPInput input);
} }
@ -44,9 +45,6 @@ public class TransactionDecoder {
TransactionType.DELEGATE_CODE, TransactionType.DELEGATE_CODE,
CodeDelegationTransactionDecoder::decode); CodeDelegationTransactionDecoder::decode);
private static final ImmutableMap<TransactionType, Decoder> POOLED_TRANSACTION_DECODERS =
ImmutableMap.of(TransactionType.BLOB, BlobPooledTransactionDecoder::decode);
/** /**
* Decodes an RLP input into a transaction. If the input represents a typed transaction, it uses * Decodes an RLP input into a transaction. If the input represents a typed transaction, it uses
* the appropriate decoder for that type. Otherwise, it uses the frontier decoder. * the appropriate decoder for that type. Otherwise, it uses the frontier decoder.
@ -55,9 +53,9 @@ public class TransactionDecoder {
* @return the decoded transaction * @return the decoded transaction
*/ */
public static Transaction decodeRLP( public static Transaction decodeRLP(
final RLPInput rlpInput, final EncodingContext encodingContext) { final RLPInput rlpInput) {
if (isTypedTransaction(rlpInput)) { if (isTypedTransaction(rlpInput)) {
return decodeTypedTransaction(rlpInput, encodingContext); return decodeTypedTransaction(rlpInput);
} else { } else {
return FrontierTransactionDecoder.decode(rlpInput); return FrontierTransactionDecoder.decode(rlpInput);
} }
@ -71,7 +69,7 @@ public class TransactionDecoder {
* @return the decoded transaction * @return the decoded transaction
*/ */
private static Transaction decodeTypedTransaction( private static Transaction decodeTypedTransaction(
final RLPInput rlpInput, final EncodingContext context) { final RLPInput rlpInput) {
// Read the typed transaction bytes from the RLP input // Read the typed transaction bytes from the RLP input
final Bytes typedTransactionBytes = rlpInput.readBytes(); final Bytes typedTransactionBytes = rlpInput.readBytes();
@ -79,7 +77,7 @@ public class TransactionDecoder {
TransactionType transactionType = TransactionType transactionType =
getTransactionType(typedTransactionBytes) getTransactionType(typedTransactionBytes)
.orElseThrow((() -> new IllegalArgumentException("Unsupported transaction type"))); .orElseThrow((() -> new IllegalArgumentException("Unsupported transaction type")));
return decodeTypedTransaction(typedTransactionBytes, transactionType, context); return decodeTypedTransaction(typedTransactionBytes, transactionType);
} }
/** /**
@ -89,17 +87,15 @@ public class TransactionDecoder {
* *
* @param transactionBytes the transaction bytes * @param transactionBytes the transaction bytes
* @param transactionType the type of the transaction * @param transactionType the type of the transaction
* @param context the encoding context
* @return the decoded transaction * @return the decoded transaction
*/ */
private static Transaction decodeTypedTransaction( private static Transaction decodeTypedTransaction(
final Bytes transactionBytes, final Bytes transactionBytes,
final TransactionType transactionType, final TransactionType transactionType) {
final EncodingContext context) {
// Slice the transaction bytes to exclude the transaction type and prepare for decoding // Slice the transaction bytes to exclude the transaction type and prepare for decoding
final RLPInput transactionInput = RLP.input(transactionBytes.slice(1)); final RLPInput transactionInput = RLP.input(transactionBytes.slice(1));
// Use the appropriate decoder for the transaction type to decode the remaining bytes // Use the appropriate decoder for the transaction type to decode the remaining bytes
return getDecoder(transactionType, context).decode(transactionInput); return getDecoder(transactionType).decode(transactionInput);
} }
/** /**
@ -108,17 +104,16 @@ public class TransactionDecoder {
* for that type. If the type is not present, it decodes the bytes as an RLP input. * for that type. If the type is not present, it decodes the bytes as an RLP input.
* *
* @param opaqueBytes the opaque bytes * @param opaqueBytes the opaque bytes
* @param context the encoding context
* @return the decoded transaction * @return the decoded transaction
*/ */
public static Transaction decodeOpaqueBytes( public static Transaction decodeOpaqueBytes(
final Bytes opaqueBytes, final EncodingContext context) { final Bytes opaqueBytes) {
var transactionType = getTransactionType(opaqueBytes); var transactionType = getTransactionType(opaqueBytes);
if (transactionType.isPresent()) { if (transactionType.isPresent()) {
return decodeTypedTransaction(opaqueBytes, transactionType.get(), context); return decodeTypedTransaction(opaqueBytes, transactionType.get());
} else { } else {
// If the transaction type is not present, decode the opaque bytes as RLP // If the transaction type is not present, decode the opaque bytes as RLP
return decodeRLP(RLP.input(opaqueBytes), context); return decodeRLP(RLP.input(opaqueBytes));
} }
} }
@ -157,21 +152,14 @@ public class TransactionDecoder {
} }
/** /**
* Gets the decoder for a given transaction type and encoding context. If the context is * Gets the decoder for a given transaction type
* POOLED_TRANSACTION, it uses the network decoder for the type. Otherwise, it uses the typed
* decoder.
* *
* @param transactionType the transaction type * @param transactionType the transaction type
* @param encodingContext the encoding context
* @return the decoder * @return the decoder
*/ */
private static Decoder getDecoder( @VisibleForTesting
final TransactionType transactionType, final EncodingContext encodingContext) { protected static Decoder getDecoder(
if (encodingContext.equals(EncodingContext.POOLED_TRANSACTION)) { final TransactionType transactionType) {
if (POOLED_TRANSACTION_DECODERS.containsKey(transactionType)) {
return POOLED_TRANSACTION_DECODERS.get(transactionType);
}
}
return checkNotNull( return checkNotNull(
TYPED_TRANSACTION_DECODERS.get(transactionType), TYPED_TRANSACTION_DECODERS.get(transactionType),
"Developer Error. A supported transaction type %s has no associated decoding logic", "Developer Error. A supported transaction type %s has no associated decoding logic",

@ -16,6 +16,7 @@ package org.hyperledger.besu.ethereum.core.encoding;
import static com.google.common.base.Preconditions.checkNotNull; import static com.google.common.base.Preconditions.checkNotNull;
import com.google.common.annotations.VisibleForTesting;
import org.hyperledger.besu.datatypes.TransactionType; import org.hyperledger.besu.datatypes.TransactionType;
import org.hyperledger.besu.ethereum.core.Transaction; import org.hyperledger.besu.ethereum.core.Transaction;
import org.hyperledger.besu.ethereum.rlp.BytesValueRLPOutput; import org.hyperledger.besu.ethereum.rlp.BytesValueRLPOutput;
@ -28,7 +29,7 @@ import org.apache.tuweni.bytes.Bytes;
public class TransactionEncoder { public class TransactionEncoder {
@FunctionalInterface @FunctionalInterface
interface Encoder { protected interface Encoder {
void encode(Transaction transaction, RLPOutput output); void encode(Transaction transaction, RLPOutput output);
} }
@ -43,22 +44,17 @@ public class TransactionEncoder {
TransactionType.DELEGATE_CODE, TransactionType.DELEGATE_CODE,
CodeDelegationEncoder::encode); CodeDelegationEncoder::encode);
private static final ImmutableMap<TransactionType, Encoder> POOLED_TRANSACTION_ENCODERS =
ImmutableMap.of(TransactionType.BLOB, BlobPooledTransactionEncoder::encode);
/** /**
* Encodes a transaction into RLP format. * Encodes a transaction into RLP format.
* *
* @param transaction the transaction to encode * @param transaction the transaction to encode
* @param rlpOutput the RLP output stream * @param rlpOutput the RLP output stream
* @param encodingContext the encoding context
*/ */
public static void encodeRLP( public static void encodeRLP(
final Transaction transaction, final Transaction transaction,
final RLPOutput rlpOutput, final RLPOutput rlpOutput) {
final EncodingContext encodingContext) {
final TransactionType transactionType = getTransactionType(transaction); final TransactionType transactionType = getTransactionType(transaction);
Bytes opaqueBytes = encodeOpaqueBytes(transaction, encodingContext); Bytes opaqueBytes = encodeOpaqueBytes(transaction);
encodeRLP(transactionType, opaqueBytes, rlpOutput); encodeRLP(transactionType, opaqueBytes, rlpOutput);
} }
@ -83,16 +79,15 @@ public class TransactionEncoder {
* Encodes a transaction into opaque bytes. * Encodes a transaction into opaque bytes.
* *
* @param transaction the transaction to encode * @param transaction the transaction to encode
* @param encodingContext the encoding context
* @return the encoded transaction as bytes * @return the encoded transaction as bytes
*/ */
public static Bytes encodeOpaqueBytes( public static Bytes encodeOpaqueBytes(
final Transaction transaction, final EncodingContext encodingContext) { final Transaction transaction) {
final TransactionType transactionType = getTransactionType(transaction); final TransactionType transactionType = getTransactionType(transaction);
if (TransactionType.FRONTIER.equals(transactionType)) { if (TransactionType.FRONTIER.equals(transactionType)) {
return RLP.encode(rlpOutput -> FrontierTransactionEncoder.encode(transaction, rlpOutput)); return RLP.encode(rlpOutput -> FrontierTransactionEncoder.encode(transaction, rlpOutput));
} else { } else {
final Encoder encoder = getEncoder(transactionType, encodingContext); final Encoder encoder = getEncoder(transactionType);
final BytesValueRLPOutput out = new BytesValueRLPOutput(); final BytesValueRLPOutput out = new BytesValueRLPOutput();
out.writeByte(transaction.getType().getSerializedType()); out.writeByte(transaction.getType().getSerializedType());
encoder.encode(transaction, out); encoder.encode(transaction, out);
@ -120,14 +115,9 @@ public class TransactionEncoder {
transaction.getType(), "Transaction type for %s was not specified.", transaction); transaction.getType(), "Transaction type for %s was not specified.", transaction);
} }
private static Encoder getEncoder( @VisibleForTesting
final TransactionType transactionType, final EncodingContext encodingContext) { protected static Encoder getEncoder(
final TransactionType transactionType) {
if (encodingContext.equals(EncodingContext.POOLED_TRANSACTION)) {
if (POOLED_TRANSACTION_ENCODERS.containsKey(transactionType)) {
return POOLED_TRANSACTION_ENCODERS.get(transactionType);
}
}
return checkNotNull( return checkNotNull(
TYPED_TRANSACTION_ENCODERS.get(transactionType), TYPED_TRANSACTION_ENCODERS.get(transactionType),
"Developer Error. A supported transaction type %s has no associated encoding logic", "Developer Error. A supported transaction type %s has no associated encoding logic",

@ -23,7 +23,6 @@ import org.hyperledger.besu.ethereum.core.Request;
import org.hyperledger.besu.ethereum.core.Transaction; import org.hyperledger.besu.ethereum.core.Transaction;
import org.hyperledger.besu.ethereum.core.TransactionReceipt; import org.hyperledger.besu.ethereum.core.TransactionReceipt;
import org.hyperledger.besu.ethereum.core.Withdrawal; import org.hyperledger.besu.ethereum.core.Withdrawal;
import org.hyperledger.besu.ethereum.core.encoding.EncodingContext;
import org.hyperledger.besu.ethereum.core.encoding.TransactionEncoder; import org.hyperledger.besu.ethereum.core.encoding.TransactionEncoder;
import org.hyperledger.besu.ethereum.core.encoding.WithdrawalEncoder; import org.hyperledger.besu.ethereum.core.encoding.WithdrawalEncoder;
import org.hyperledger.besu.ethereum.rlp.RLP; import org.hyperledger.besu.ethereum.rlp.RLP;
@ -68,7 +67,7 @@ public final class BodyValidation {
trie.put( trie.put(
indexKey(i), indexKey(i),
TransactionEncoder.encodeOpaqueBytes( TransactionEncoder.encodeOpaqueBytes(
transactions.get(i), EncodingContext.BLOCK_BODY))); transactions.get(i))));
return Hash.wrap(trie.getRootHash()); return Hash.wrap(trie.getRootHash());
} }

@ -58,14 +58,14 @@ public class BlobTransactionEncodingTest {
Bytes bytes = argument.bytes; Bytes bytes = argument.bytes;
// Decode the transaction from the wire using the TransactionDecoder. // Decode the transaction from the wire using the TransactionDecoder.
final Transaction transaction = final Transaction transaction =
TransactionDecoder.decodeOpaqueBytes(bytes, EncodingContext.POOLED_TRANSACTION); PooledTransactionDecoder.decodeOpaqueBytes(bytes);
final BytesValueRLPOutput output = new BytesValueRLPOutput(); final BytesValueRLPOutput output = new BytesValueRLPOutput();
TransactionEncoder.encodeRLP(transaction.getType(), bytes, output); TransactionEncoder.encodeRLP(transaction.getType(), bytes, output);
final BytesValueRLPOutput bytesValueRLPOutput = new BytesValueRLPOutput(); final BytesValueRLPOutput bytesValueRLPOutput = new BytesValueRLPOutput();
TransactionEncoder.encodeRLP( PooledTransactionEncoder.encodeRLP(
transaction, bytesValueRLPOutput, EncodingContext.POOLED_TRANSACTION); transaction, bytesValueRLPOutput);
assertThat(transaction.getSize()).isEqualTo(bytes.size()); assertThat(transaction.getSize()).isEqualTo(bytes.size());
} }
@ -75,10 +75,10 @@ public class BlobTransactionEncodingTest {
Bytes bytes = argument.bytes; Bytes bytes = argument.bytes;
// Decode the transaction from the wire using the TransactionDecoder. // Decode the transaction from the wire using the TransactionDecoder.
final Transaction transaction = final Transaction transaction =
TransactionDecoder.decodeOpaqueBytes(bytes, EncodingContext.BLOCK_BODY); TransactionDecoder.decodeOpaqueBytes(bytes);
// Encode the transaction for wire using the TransactionEncoder. // Encode the transaction for wire using the TransactionEncoder.
Bytes encoded = TransactionEncoder.encodeOpaqueBytes(transaction, EncodingContext.BLOCK_BODY); Bytes encoded = TransactionEncoder.encodeOpaqueBytes(transaction);
// Assert that the encoded transaction matches the original bytes. // Assert that the encoded transaction matches the original bytes.
assertThat(encoded.toHexString()).isEqualTo(bytes.toHexString()); assertThat(encoded.toHexString()).isEqualTo(bytes.toHexString());

@ -15,10 +15,12 @@
package org.hyperledger.besu.ethereum.core.encoding; package org.hyperledger.besu.ethereum.core.encoding;
import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatNoException;
import static org.assertj.core.api.Assertions.assertThatThrownBy; import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.hyperledger.besu.evm.account.Account.MAX_NONCE; import static org.hyperledger.besu.evm.account.Account.MAX_NONCE;
import static org.junit.jupiter.api.Assumptions.assumeTrue; import static org.junit.jupiter.api.Assumptions.assumeTrue;
import org.hyperledger.besu.datatypes.TransactionType;
import org.hyperledger.besu.datatypes.Wei; import org.hyperledger.besu.datatypes.Wei;
import org.hyperledger.besu.ethereum.core.Transaction; import org.hyperledger.besu.ethereum.core.Transaction;
import org.hyperledger.besu.ethereum.rlp.RLP; import org.hyperledger.besu.ethereum.rlp.RLP;
@ -28,6 +30,7 @@ import org.hyperledger.besu.ethereum.rlp.RLPInput;
import java.math.BigInteger; import java.math.BigInteger;
import java.util.Arrays; import java.util.Arrays;
import java.util.Collection; import java.util.Collection;
import java.util.stream.Stream;
import org.apache.tuweni.bytes.Bytes; import org.apache.tuweni.bytes.Bytes;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
@ -67,7 +70,7 @@ class TransactionRLPDecoderTest {
assertThatThrownBy( assertThatThrownBy(
() -> () ->
TransactionDecoder.decodeOpaqueBytes( TransactionDecoder.decodeOpaqueBytes(
Bytes.fromHexString(txWithBigFees), EncodingContext.BLOCK_BODY)) Bytes.fromHexString(txWithBigFees)))
.isInstanceOf(RLPException.class); .isInstanceOf(RLPException.class);
} }
@ -113,7 +116,7 @@ class TransactionRLPDecoderTest {
// Decode bytes into a transaction // Decode bytes into a transaction
final Transaction transaction = decodeRLP(RLP.input(bytes)); final Transaction transaction = decodeRLP(RLP.input(bytes));
Bytes transactionBytes = Bytes transactionBytes =
TransactionEncoder.encodeOpaqueBytes(transaction, EncodingContext.POOLED_TRANSACTION); PooledTransactionEncoder.encodeOpaqueBytes(transaction);
// Bytes size should be equal to transaction size // Bytes size should be equal to transaction size
assertThat(transaction.getSize()).isEqualTo(transactionBytes.size()); assertThat(transaction.getSize()).isEqualTo(transactionBytes.size());
} }
@ -140,7 +143,17 @@ class TransactionRLPDecoderTest {
} }
} }
@Test
void shouldHaveDecodersForAllTransactionTypes(){
Stream.of(TransactionType.values())
.filter(v -> v != TransactionType.FRONTIER).forEach( v -> {
assertThatNoException().isThrownBy(() -> TransactionDecoder.getDecoder(v));
assertThatNoException().isThrownBy(() -> PooledTransactionDecoder.getDecoder(v));
}
);
}
private Transaction decodeRLP(final RLPInput input) { private Transaction decodeRLP(final RLPInput input) {
return TransactionDecoder.decodeRLP(input, EncodingContext.POOLED_TRANSACTION); return PooledTransactionDecoder.decodeRLP(input);
} }
} }

@ -15,7 +15,10 @@
package org.hyperledger.besu.ethereum.core.encoding; package org.hyperledger.besu.ethereum.core.encoding;
import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatNoException;
import java.util.stream.Stream;
import org.hyperledger.besu.datatypes.TransactionType;
import org.hyperledger.besu.ethereum.core.Block; import org.hyperledger.besu.ethereum.core.Block;
import org.hyperledger.besu.ethereum.core.BlockDataGenerator; import org.hyperledger.besu.ethereum.core.BlockDataGenerator;
import org.hyperledger.besu.ethereum.core.Transaction; import org.hyperledger.besu.ethereum.core.Transaction;
@ -75,11 +78,21 @@ class TransactionRLPEncoderTest {
assertThat(output.encoded().toHexString()).isEqualTo(NONCE_64_BIT_MAX_MINUS_2_TX_RLP); assertThat(output.encoded().toHexString()).isEqualTo(NONCE_64_BIT_MAX_MINUS_2_TX_RLP);
} }
@Test
void shouldHaveEncodersForAllTransactionTypes(){
Stream.of(TransactionType.values())
.filter(v -> v != TransactionType.FRONTIER).forEach( v -> {
assertThatNoException().isThrownBy(() -> TransactionEncoder.getEncoder(v));
assertThatNoException().isThrownBy(() -> PooledTransactionEncoder.getEncoder(v));
}
);
}
private Transaction decodeRLP(final RLPInput input) { private Transaction decodeRLP(final RLPInput input) {
return TransactionDecoder.decodeRLP(input, EncodingContext.BLOCK_BODY); return TransactionDecoder.decodeRLP(input);
} }
private void encodeRLP(final Transaction transaction, final BytesValueRLPOutput output) { private void encodeRLP(final Transaction transaction, final BytesValueRLPOutput output) {
TransactionEncoder.encodeRLP(transaction, output, EncodingContext.BLOCK_BODY); TransactionEncoder.encodeRLP(transaction, output);
} }
} }

@ -20,8 +20,7 @@ import org.hyperledger.besu.ethereum.core.BlockBody;
import org.hyperledger.besu.ethereum.core.BlockHeader; import org.hyperledger.besu.ethereum.core.BlockHeader;
import org.hyperledger.besu.ethereum.core.Transaction; import org.hyperledger.besu.ethereum.core.Transaction;
import org.hyperledger.besu.ethereum.core.TransactionReceipt; import org.hyperledger.besu.ethereum.core.TransactionReceipt;
import org.hyperledger.besu.ethereum.core.encoding.EncodingContext; import org.hyperledger.besu.ethereum.core.encoding.PooledTransactionEncoder;
import org.hyperledger.besu.ethereum.core.encoding.TransactionEncoder;
import org.hyperledger.besu.ethereum.eth.EthProtocolConfiguration; import org.hyperledger.besu.ethereum.eth.EthProtocolConfiguration;
import org.hyperledger.besu.ethereum.eth.messages.BlockBodiesMessage; import org.hyperledger.besu.ethereum.eth.messages.BlockBodiesMessage;
import org.hyperledger.besu.ethereum.eth.messages.BlockHeadersMessage; import org.hyperledger.besu.ethereum.eth.messages.BlockHeadersMessage;
@ -273,7 +272,7 @@ class EthServer {
} }
final BytesValueRLPOutput txRlp = new BytesValueRLPOutput(); final BytesValueRLPOutput txRlp = new BytesValueRLPOutput();
TransactionEncoder.encodeRLP(maybeTx.get(), txRlp, EncodingContext.POOLED_TRANSACTION); PooledTransactionEncoder.encodeRLP(maybeTx.get(), txRlp);
final int encodedSize = txRlp.encodedSize(); final int encodedSize = txRlp.encodedSize();
if (responseSizeEstimate + encodedSize > maxMessageSize) { if (responseSizeEstimate + encodedSize > maxMessageSize) {
break; break;

@ -15,9 +15,8 @@
package org.hyperledger.besu.ethereum.eth.messages; package org.hyperledger.besu.ethereum.eth.messages;
import org.hyperledger.besu.ethereum.core.Transaction; import org.hyperledger.besu.ethereum.core.Transaction;
import org.hyperledger.besu.ethereum.core.encoding.EncodingContext; import org.hyperledger.besu.ethereum.core.encoding.PooledTransactionDecoder;
import org.hyperledger.besu.ethereum.core.encoding.TransactionDecoder; import org.hyperledger.besu.ethereum.core.encoding.PooledTransactionEncoder;
import org.hyperledger.besu.ethereum.core.encoding.TransactionEncoder;
import org.hyperledger.besu.ethereum.p2p.rlpx.wire.AbstractMessageData; import org.hyperledger.besu.ethereum.p2p.rlpx.wire.AbstractMessageData;
import org.hyperledger.besu.ethereum.p2p.rlpx.wire.MessageData; import org.hyperledger.besu.ethereum.p2p.rlpx.wire.MessageData;
import org.hyperledger.besu.ethereum.rlp.BytesValueRLPInput; import org.hyperledger.besu.ethereum.rlp.BytesValueRLPInput;
@ -45,9 +44,7 @@ public final class PooledTransactionsMessage extends AbstractMessageData {
final BytesValueRLPOutput out = new BytesValueRLPOutput(); final BytesValueRLPOutput out = new BytesValueRLPOutput();
out.writeList( out.writeList(
transactions, transactions,
(transaction, rlpOutput) -> { PooledTransactionEncoder::encodeRLP);
TransactionEncoder.encodeRLP(transaction, rlpOutput, EncodingContext.POOLED_TRANSACTION);
});
return new PooledTransactionsMessage(out.encoded()); return new PooledTransactionsMessage(out.encoded());
} }
@ -80,7 +77,7 @@ public final class PooledTransactionsMessage extends AbstractMessageData {
final BytesValueRLPInput in = new BytesValueRLPInput(getData(), false); final BytesValueRLPInput in = new BytesValueRLPInput(getData(), false);
pooledTransactions = pooledTransactions =
in.readList( in.readList(
input -> TransactionDecoder.decodeRLP(input, EncodingContext.POOLED_TRANSACTION)); PooledTransactionDecoder::decodeRLP);
} }
return pooledTransactions; return pooledTransactions;
} }

@ -24,9 +24,8 @@ import org.hyperledger.besu.datatypes.TransactionType;
import org.hyperledger.besu.datatypes.Wei; import org.hyperledger.besu.datatypes.Wei;
import org.hyperledger.besu.ethereum.core.Transaction; import org.hyperledger.besu.ethereum.core.Transaction;
import org.hyperledger.besu.ethereum.core.TransactionTestFixture; import org.hyperledger.besu.ethereum.core.TransactionTestFixture;
import org.hyperledger.besu.ethereum.core.encoding.EncodingContext; import org.hyperledger.besu.ethereum.core.encoding.PooledTransactionDecoder;
import org.hyperledger.besu.ethereum.core.encoding.TransactionDecoder; import org.hyperledger.besu.ethereum.core.encoding.PooledTransactionEncoder;
import org.hyperledger.besu.ethereum.core.encoding.TransactionEncoder;
import org.hyperledger.besu.ethereum.eth.transactions.layered.BaseTransactionPoolTest; import org.hyperledger.besu.ethereum.eth.transactions.layered.BaseTransactionPoolTest;
import org.hyperledger.besu.ethereum.rlp.BytesValueRLPInput; import org.hyperledger.besu.ethereum.rlp.BytesValueRLPInput;
import org.hyperledger.besu.ethereum.rlp.BytesValueRLPOutput; import org.hyperledger.besu.ethereum.rlp.BytesValueRLPOutput;
@ -210,11 +209,11 @@ public class PendingTransactionEstimatedMemorySizeTest extends BaseTransactionPo
prepareTransaction(TransactionType.BLOB, 10, Wei.of(500), Wei.of(50), 10, 1); prepareTransaction(TransactionType.BLOB, 10, Wei.of(500), Wei.of(50), 10, 1);
Transaction txBlob = preparedTx.createTransaction(KEYS1); Transaction txBlob = preparedTx.createTransaction(KEYS1);
BytesValueRLPOutput rlpOut = new BytesValueRLPOutput(); BytesValueRLPOutput rlpOut = new BytesValueRLPOutput();
TransactionEncoder.encodeRLP(txBlob, rlpOut, EncodingContext.POOLED_TRANSACTION); PooledTransactionEncoder.encodeRLP(txBlob, rlpOut);
txBlob = txBlob =
TransactionDecoder.decodeRLP( PooledTransactionDecoder.decodeRLP(
new BytesValueRLPInput(rlpOut.encoded(), false), EncodingContext.POOLED_TRANSACTION) new BytesValueRLPInput(rlpOut.encoded(), false))
.detachedCopy(); .detachedCopy();
System.out.println(txBlob.getSender()); System.out.println(txBlob.getSender());
System.out.println(txBlob.getHash()); System.out.println(txBlob.getHash());
@ -242,11 +241,11 @@ public class PendingTransactionEstimatedMemorySizeTest extends BaseTransactionPo
prepareTransaction(TransactionType.BLOB, 10, Wei.of(500), Wei.of(50), 10, 1); prepareTransaction(TransactionType.BLOB, 10, Wei.of(500), Wei.of(50), 10, 1);
Transaction txBlob = preparedTx.createTransaction(KEYS1); Transaction txBlob = preparedTx.createTransaction(KEYS1);
BytesValueRLPOutput rlpOut = new BytesValueRLPOutput(); BytesValueRLPOutput rlpOut = new BytesValueRLPOutput();
TransactionEncoder.encodeRLP(txBlob, rlpOut, EncodingContext.POOLED_TRANSACTION); PooledTransactionEncoder.encodeRLP(txBlob, rlpOut);
txBlob = txBlob =
TransactionDecoder.decodeRLP( PooledTransactionDecoder.decodeRLP(
new BytesValueRLPInput(rlpOut.encoded(), false), EncodingContext.POOLED_TRANSACTION) new BytesValueRLPInput(rlpOut.encoded(), false))
.detachedCopy(); .detachedCopy();
System.out.println(txBlob.getSender()); System.out.println(txBlob.getSender());
System.out.println(txBlob.getHash()); System.out.println(txBlob.getHash());

Loading…
Cancel
Save