[4844] Add encodingContext to TransactionEncoder and TransactionDecoder

ethereum/api/src/main/java/org/hyperledger/besu/ethereum/api/jsonrpc/internal/methods/engine/AbstractEngineNewPayload.java

@@ -50,6 +50,7 @@
 import org.hyperledger.besu.ethereum.core.Difficulty;
 import org.hyperledger.besu.ethereum.core.Transaction;
 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.eth.manager.EthPeers;
 import org.hyperledger.besu.ethereum.mainnet.BodyValidation;
@@ -170,7 +171,7 @@ public JsonRpcResponse syncResponse(final JsonRpcRequestContext requestContext)
       transactions =
           blockParam.getTransactions().stream()
               .map(Bytes::fromHexString)
-              .map(TransactionDecoder::decodeOpaqueBytes)
+              .map(in -> TransactionDecoder.decodeOpaqueBytes(in, EncodingContext.BLOCK_BODY))
               .collect(Collectors.toList());
     } catch (final RLPException | IllegalArgumentException e) {
       return respondWithInvalid(

ethereum/api/src/main/java/org/hyperledger/besu/ethereum/api/jsonrpc/internal/results/BlockResultFactory.java

@@ -24,6 +24,7 @@
 import org.hyperledger.besu.ethereum.core.BlockHeader;
 import org.hyperledger.besu.ethereum.core.BlockValueCalculator;
 import org.hyperledger.besu.ethereum.core.BlockWithReceipts;
+import org.hyperledger.besu.ethereum.core.encoding.EncodingContext;
 import org.hyperledger.besu.ethereum.core.encoding.TransactionEncoder;
 
 import java.util.ArrayList;
@@ -95,7 +96,9 @@ public BlockResult transactionComplete(final Block block) {
   public EngineGetPayloadResultV1 payloadTransactionCompleteV1(final Block block) {
     final List<String> txs =
         block.getBody().getTransactions().stream()
-            .map(TransactionEncoder::encodeOpaqueBytes)
+            .map(
+                transaction ->
+                    TransactionEncoder.encodeOpaqueBytes(transaction, EncodingContext.BLOCK_BODY))
             .map(Bytes::toHexString)
             .collect(Collectors.toList());
 
@@ -106,7 +109,9 @@ public EngineGetPayloadResultV2 payloadTransactionCompleteV2(
       final BlockWithReceipts blockWithReceipts) {
     final List<String> txs =
         blockWithReceipts.getBlock().getBody().getTransactions().stream()
-            .map(TransactionEncoder::encodeOpaqueBytes)
+            .map(
+                transaction ->
+                    TransactionEncoder.encodeOpaqueBytes(transaction, EncodingContext.BLOCK_BODY))
             .map(Bytes::toHexString)
             .collect(Collectors.toList());
 
@@ -132,7 +137,9 @@ public EngineGetPayloadResultV3 payloadTransactionCompleteV3(
       final BlockWithReceipts blockWithReceipts) {
     final List<String> txs =
         blockWithReceipts.getBlock().getBody().getTransactions().stream()
-            .map(TransactionEncoder::encodeOpaqueBytes)
+            .map(
+                transaction ->
+                    TransactionEncoder.encodeOpaqueBytes(transaction, EncodingContext.BLOCK_BODY))
             .map(Bytes::toHexString)
             .collect(Collectors.toList());
 

ethereum/api/src/main/java/org/hyperledger/besu/ethereum/api/jsonrpc/internal/results/EngineGetPayloadBodiesResultV1.java

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

ethereum/api/src/main/java/org/hyperledger/besu/ethereum/api/jsonrpc/internal/results/TransactionPendingResult.java

@@ -20,6 +20,7 @@
 import org.hyperledger.besu.datatypes.VersionedHash;
 import org.hyperledger.besu.datatypes.Wei;
 import org.hyperledger.besu.ethereum.core.Transaction;
+import org.hyperledger.besu.ethereum.core.encoding.EncodingContext;
 import org.hyperledger.besu.ethereum.core.encoding.TransactionEncoder;
 
 import java.util.List;
@@ -99,7 +100,9 @@ public TransactionPendingResult(final Transaction transaction) {
     this.input = transaction.getPayload().toString();
     this.nonce = Quantity.create(transaction.getNonce());
     this.publicKey = transaction.getPublicKey().orElse(null);
-    this.raw = TransactionEncoder.encodeOpaqueBytes(transaction).toString();
+    this.raw =
+        TransactionEncoder.encodeOpaqueBytes(transaction, EncodingContext.POOLED_TRANSACTION)
+            .toString();
     this.to = transaction.getTo().map(Address::toHexString).orElse(null);
     this.type =
         transactionType.equals(TransactionType.FRONTIER)

ethereum/api/src/main/java/org/hyperledger/besu/ethereum/api/util/DomainObjectDecodeUtils.java

@@ -16,6 +16,7 @@
 
 import org.hyperledger.besu.ethereum.api.jsonrpc.internal.exception.InvalidJsonRpcRequestException;
 import org.hyperledger.besu.ethereum.core.Transaction;
+import org.hyperledger.besu.ethereum.core.encoding.EncodingContext;
 import org.hyperledger.besu.ethereum.core.encoding.TransactionDecoder;
 import org.hyperledger.besu.ethereum.rlp.RLPException;
 
@@ -27,7 +28,7 @@ public static Transaction decodeRawTransaction(final String rawTransaction)
       throws InvalidJsonRpcRequestException {
     try {
       Bytes txnBytes = Bytes.fromHexString(rawTransaction);
-      return TransactionDecoder.decodeOpaqueBytes(txnBytes);
+      return TransactionDecoder.decodeOpaqueBytes(txnBytes, EncodingContext.POOLED_TRANSACTION);
     } catch (final IllegalArgumentException e) {
       throw new InvalidJsonRpcRequestException("Invalid raw transaction hex", e);
     } catch (final RLPException r) {

ethereum/api/src/test/java/org/hyperledger/besu/ethereum/api/jsonrpc/internal/methods/engine/EngineNewPayloadV3Test.java

@@ -23,7 +23,13 @@
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
+import org.hyperledger.besu.crypto.KeyPair;
+import org.hyperledger.besu.crypto.SignatureAlgorithm;
+import org.hyperledger.besu.crypto.SignatureAlgorithmFactory;
+import org.hyperledger.besu.datatypes.Address;
 import org.hyperledger.besu.datatypes.BlobGas;
+import org.hyperledger.besu.datatypes.BlobsWithCommitments;
+import org.hyperledger.besu.datatypes.TransactionType;
 import org.hyperledger.besu.datatypes.Wei;
 import org.hyperledger.besu.ethereum.BlockProcessingOutputs;
 import org.hyperledger.besu.ethereum.BlockProcessingResult;
@@ -35,18 +41,26 @@
 import org.hyperledger.besu.ethereum.api.jsonrpc.internal.response.JsonRpcResponse;
 import org.hyperledger.besu.ethereum.api.jsonrpc.internal.response.RpcErrorType;
 import org.hyperledger.besu.ethereum.api.jsonrpc.internal.results.EnginePayloadStatusResult;
+import org.hyperledger.besu.ethereum.core.BlobTestFixture;
 import org.hyperledger.besu.ethereum.core.BlockHeader;
 import org.hyperledger.besu.ethereum.core.BlockHeaderTestFixture;
 import org.hyperledger.besu.ethereum.core.Deposit;
+import org.hyperledger.besu.ethereum.core.Transaction;
+import org.hyperledger.besu.ethereum.core.TransactionTestFixture;
 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.mainnet.BodyValidation;
 import org.hyperledger.besu.ethereum.mainnet.ValidationResult;
 import org.hyperledger.besu.evm.gascalculator.CancunGasCalculator;
 
+import java.math.BigInteger;
 import java.util.Collections;
 import java.util.List;
 import java.util.Optional;
+import java.util.function.Supplier;
 
+import com.google.common.base.Suppliers;
 import org.apache.tuweni.bytes.Bytes;
 import org.apache.tuweni.bytes.Bytes32;
 import org.junit.jupiter.api.BeforeEach;
@@ -56,6 +70,9 @@
 
 @ExtendWith(MockitoExtension.class)
 public class EngineNewPayloadV3Test extends EngineNewPayloadV2Test {
+  private static final Supplier<SignatureAlgorithm> SIGNATURE_ALGORITHM =
+      Suppliers.memoize(SignatureAlgorithmFactory::getInstance);
+  protected static final KeyPair senderKeys = SIGNATURE_ALGORITHM.get().generateKeyPair();
 
   public EngineNewPayloadV3Test() {}
 
@@ -194,4 +211,42 @@ public void shouldValidateExcessBlobGasCorrectly() {
     assertThat(jsonRpcError.getData()).isEqualTo("Missing blob gas fields");
     verify(engineCallListener, times(1)).executionEngineCalled();
   }
+
+  @Test
+  public void shouldRejectTransactionsWithFullBlob() {
+
+    Bytes transactionWithBlobsBytes =
+        TransactionEncoder.encodeOpaqueBytes(
+            createTransactionWithBlobs(), EncodingContext.POOLED_TRANSACTION);
+
+    List<String> transactions = List.of(transactionWithBlobsBytes.toString());
+
+    BlockHeader mockHeader =
+        setupValidPayload(
+            new BlockProcessingResult(Optional.of(new BlockProcessingOutputs(null, List.of()))),
+            Optional.empty(),
+            Optional.empty());
+    var resp = resp(mockEnginePayload(mockHeader, transactions));
+
+    EnginePayloadStatusResult res = fromSuccessResp(resp);
+    assertThat(res.getStatusAsString()).isEqualTo(INVALID.name());
+    assertThat(res.getError()).isEqualTo("Failed to decode transactions from block parameter");
+    verify(engineCallListener, times(1)).executionEngineCalled();
+  }
+
+  private Transaction createTransactionWithBlobs() {
+    BlobTestFixture blobTestFixture = new BlobTestFixture();
+    BlobsWithCommitments bwc = blobTestFixture.createBlobsWithCommitments(1);
+
+    return new TransactionTestFixture()
+        .to(Optional.of(Address.fromHexString("0xDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF")))
+        .type(TransactionType.BLOB)
+        .chainId(Optional.of(BigInteger.ONE))
+        .maxFeePerGas(Optional.of(Wei.of(15)))
+        .maxFeePerBlobGas(Optional.of(Wei.of(128)))
+        .maxPriorityFeePerGas(Optional.of(Wei.of(1)))
+        .blobsWithCommitments(Optional.of(bwc))
+        .versionedHashes(Optional.of(bwc.getVersionedHashes()))
+        .createTransaction(senderKeys);
+  }
 }

ethereum/api/src/test/java/org/hyperledger/besu/ethereum/api/util/DomainObjectDecodeUtilsTest.java

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

ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/Transaction.java

@@ -35,7 +35,9 @@
 import org.hyperledger.besu.datatypes.TransactionType;
 import org.hyperledger.besu.datatypes.VersionedHash;
 import org.hyperledger.besu.datatypes.Wei;
+import org.hyperledger.besu.ethereum.core.encoding.AccessListTransactionEncoder;
 import org.hyperledger.besu.ethereum.core.encoding.BlobTransactionEncoder;
+import org.hyperledger.besu.ethereum.core.encoding.EncodingContext;
 import org.hyperledger.besu.ethereum.core.encoding.TransactionDecoder;
 import org.hyperledger.besu.ethereum.core.encoding.TransactionEncoder;
 import org.hyperledger.besu.ethereum.rlp.BytesValueRLPOutput;
@@ -126,7 +128,7 @@ public static Transaction readFrom(final Bytes rlpBytes) {
   }
 
   public static Transaction readFrom(final RLPInput rlpInput) {
-    return TransactionDecoder.decodeForWire(rlpInput);
+    return TransactionDecoder.decodeRLP(rlpInput, EncodingContext.BLOCK_BODY);
   }
 
   /**
@@ -613,7 +615,7 @@ private Bytes32 getOrComputeSenderRecoveryHash() {
    * @param out the output to write the transaction to
    */
   public void writeTo(final RLPOutput out) {
-    TransactionEncoder.encodeForWire(this, out);
+    TransactionEncoder.encodeRLP(this, out, EncodingContext.BLOCK_BODY);
   }
 
   @Override
@@ -676,17 +678,19 @@ public int getSize() {
   }
 
   private void memoizeHashAndSize() {
-    final Bytes bytes = TransactionEncoder.encodeOpaqueBytes(this);
+    final Bytes bytes = TransactionEncoder.encodeOpaqueBytes(this, EncodingContext.BLOCK_BODY);
     hash = Hash.hash(bytes);
 
     if (transactionType.supportsBlob()) {
       if (getBlobsWithCommitments().isPresent()) {
-        size = bytes.size();
+        final BytesValueRLPOutput rlpOutput = new BytesValueRLPOutput();
+        TransactionEncoder.encodeRLP(this, rlpOutput, EncodingContext.POOLED_TRANSACTION);
+        size = rlpOutput.encodedSize();
         return;
       }
     }
     final BytesValueRLPOutput rlpOutput = new BytesValueRLPOutput();
-    TransactionEncoder.encodeForWire(transactionType, bytes, rlpOutput);
+    TransactionEncoder.encodeRLP(transactionType, bytes, rlpOutput);
     size = rlpOutput.encodedSize();
   }
 
@@ -968,7 +972,7 @@ private static void eip1559PreimageFields(
     rlpOutput.writeBytes(to.map(Bytes::copy).orElse(Bytes.EMPTY));
     rlpOutput.writeUInt256Scalar(value);
     rlpOutput.writeBytes(payload);
-    TransactionEncoder.writeAccessList(rlpOutput, accessList);
+    AccessListTransactionEncoder.writeAccessList(rlpOutput, accessList);
   }
 
   private static Bytes blobPreimage(
@@ -1019,7 +1023,7 @@ private static Bytes accessListPreimage(
         RLP.encode(
             rlpOutput -> {
               rlpOutput.startList();
-              TransactionEncoder.encodeAccessListInner(
+              AccessListTransactionEncoder.encodeAccessListInner(
                   chainId, nonce, gasPrice, gasLimit, to, value, payload, accessList, rlpOutput);
               rlpOutput.endList();
             });

ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/encoding/AccessListTransactionDecoder.java

@@ -0,0 +1,74 @@
+/*
+ * Copyright Hyperledger Besu Contributors.
+ *
+ * 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 org.hyperledger.besu.crypto.SignatureAlgorithm;
+import org.hyperledger.besu.crypto.SignatureAlgorithmFactory;
+import org.hyperledger.besu.datatypes.AccessListEntry;
+import org.hyperledger.besu.datatypes.Address;
+import org.hyperledger.besu.datatypes.TransactionType;
+import org.hyperledger.besu.datatypes.Wei;
+import org.hyperledger.besu.ethereum.core.Transaction;
+import org.hyperledger.besu.ethereum.rlp.RLPInput;
+
+import java.math.BigInteger;
+import java.util.function.Supplier;
+
+import com.google.common.base.Suppliers;
+
+class AccessListTransactionDecoder {
+  private static final Supplier<SignatureAlgorithm> SIGNATURE_ALGORITHM =
+      Suppliers.memoize(SignatureAlgorithmFactory::getInstance);
+
+  public static Transaction decode(final RLPInput rlpInput) {
+    rlpInput.enterList();
+    final Transaction.Builder preSignatureTransactionBuilder =
+        Transaction.builder()
+            .type(TransactionType.ACCESS_LIST)
+            .chainId(BigInteger.valueOf(rlpInput.readLongScalar()))
+            .nonce(rlpInput.readLongScalar())
+            .gasPrice(Wei.of(rlpInput.readUInt256Scalar()))
+            .gasLimit(rlpInput.readLongScalar())
+            .to(
+                rlpInput.readBytes(
+                    addressBytes -> addressBytes.size() == 0 ? null : Address.wrap(addressBytes)))
+            .value(Wei.of(rlpInput.readUInt256Scalar()))
+            .payload(rlpInput.readBytes())
+            .accessList(
+                rlpInput.readList(
+                    accessListEntryRLPInput -> {
+                      accessListEntryRLPInput.enterList();
+                      final AccessListEntry accessListEntry =
+                          new AccessListEntry(
+                              Address.wrap(accessListEntryRLPInput.readBytes()),
+                              accessListEntryRLPInput.readList(RLPInput::readBytes32));
+                      accessListEntryRLPInput.leaveList();
+                      return accessListEntry;
+                    }));
+    final byte recId = (byte) rlpInput.readIntScalar();
+    final Transaction transaction =
+        preSignatureTransactionBuilder
+            .signature(
+                SIGNATURE_ALGORITHM
+                    .get()
+                    .createSignature(
+                        rlpInput.readUInt256Scalar().toUnsignedBigInteger(),
+                        rlpInput.readUInt256Scalar().toUnsignedBigInteger(),
+                        recId))
+            .build();
+    rlpInput.leaveList();
+    return transaction;
+  }
+}