EIP 7702

CHANGELOG.md

@@ -12,6 +12,7 @@
 - `privacy-nonce-always-increments` option enables private transactions to always increment the nonce, even if the transaction is invalid [#6593](https://github.com/hyperledger/besu/pull/6593)
 - Add `block-test` subcommand to the evmtool which runs blockchain reference tests [#7310](https://github.com/hyperledger/besu/pull/7310)
 - Implement gnark-crypto for eip-2537 [#7316](https://github.com/hyperledger/besu/pull/7316)
+- Added EIP-7702 [#7237](https://github.com/hyperledger/besu/pull/7237)
 
 ### Bug fixes
 - Fix `eth_call` deserialization to correctly ignore unknown fields in the transaction object. [#7323](https://github.com/hyperledger/besu/pull/7323)

acceptance-tests/tests/src/test/java/org/hyperledger/besu/tests/acceptance/ethereum/PragueAcceptanceTestService.java

@@ -0,0 +1,193 @@
+/*
+ * 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.tests.acceptance.ethereum;
+
+import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
+
+import org.hyperledger.besu.tests.acceptance.dsl.node.BesuNode;
+import org.hyperledger.besu.tests.acceptance.dsl.transaction.eth.EthTransactions;
+
+import java.io.IOException;
+import java.util.Optional;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import okhttp3.Call;
+import okhttp3.MediaType;
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import okhttp3.RequestBody;
+import okhttp3.Response;
+import org.web3j.protocol.core.methods.response.EthBlock;
+
+public class PragueAcceptanceTestService {
+  protected static final MediaType MEDIA_TYPE_JSON =
+      MediaType.parse("application/json; charset=utf-8");
+
+  private final OkHttpClient httpClient;
+  private final ObjectMapper mapper;
+  private final BesuNode besuNode;
+  private final EthTransactions ethTransactions;
+
+  private long blockTimeStamp = 0;
+
+  PragueAcceptanceTestService(final BesuNode besuNode, final EthTransactions ethTransactions) {
+    this.besuNode = besuNode;
+    this.ethTransactions = ethTransactions;
+    httpClient = new OkHttpClient();
+    mapper = new ObjectMapper();
+  }
+
+  public void buildNewBlock() throws IOException {
+    final EthBlock.Block block = besuNode.execute(ethTransactions.block());
+
+    blockTimeStamp += 1;
+    final Call buildBlockRequest =
+        createEngineCall(createForkChoiceRequest(block.getHash(), blockTimeStamp));
+
+    final String payloadId;
+    try (final Response buildBlockResponse = buildBlockRequest.execute()) {
+      payloadId =
+          mapper
+              .readTree(buildBlockResponse.body().string())
+              .get("result")
+              .get("payloadId")
+              .asText();
+
+      assertThat(payloadId).isNotEmpty();
+    }
+
+    waitFor(500);
+
+    final Call getPayloadRequest = createEngineCall(createGetPayloadRequest(payloadId));
+
+    final ObjectNode executionPayload;
+    final String newBlockHash;
+    final String parentBeaconBlockRoot;
+    try (final Response getPayloadResponse = getPayloadRequest.execute()) {
+      assertThat(getPayloadResponse.code()).isEqualTo(200);
+
+      executionPayload =
+          (ObjectNode)
+              mapper
+                  .readTree(getPayloadResponse.body().string())
+                  .get("result")
+                  .get("executionPayload");
+
+      newBlockHash = executionPayload.get("blockHash").asText();
+      parentBeaconBlockRoot = executionPayload.remove("parentBeaconBlockRoot").asText();
+
+      assertThat(newBlockHash).isNotEmpty();
+    }
+
+    final Call newPayloadRequest =
+        createEngineCall(
+            createNewPayloadRequest(executionPayload.toString(), parentBeaconBlockRoot));
+    try (final Response newPayloadResponse = newPayloadRequest.execute()) {
+      assertThat(newPayloadResponse.code()).isEqualTo(200);
+    }
+
+    final Call moveChainAheadRequest = createEngineCall(createForkChoiceRequest(newBlockHash));
+
+    try (final Response moveChainAheadResponse = moveChainAheadRequest.execute()) {
+      assertThat(moveChainAheadResponse.code()).isEqualTo(200);
+    }
+  }
+
+  private Call createEngineCall(final String request) {
+    return httpClient.newCall(
+        new Request.Builder()
+            .url(besuNode.engineRpcUrl().get())
+            .post(RequestBody.create(request, MEDIA_TYPE_JSON))
+            .build());
+  }
+
+  private String createForkChoiceRequest(final String blockHash) {
+    return createForkChoiceRequest(blockHash, null);
+  }
+
+  private String createForkChoiceRequest(final String parentBlockHash, final Long timeStamp) {
+    final Optional<Long> maybeTimeStamp = Optional.ofNullable(timeStamp);
+
+    String forkChoiceRequest =
+        "{"
+            + "  \"jsonrpc\": \"2.0\","
+            + "  \"method\": \"engine_forkchoiceUpdatedV3\","
+            + "  \"params\": ["
+            + "    {"
+            + "      \"headBlockHash\": \""
+            + parentBlockHash
+            + "\","
+            + "      \"safeBlockHash\": \""
+            + parentBlockHash
+            + "\","
+            + "      \"finalizedBlockHash\": \""
+            + parentBlockHash
+            + "\""
+            + "    }";
+
+    if (maybeTimeStamp.isPresent()) {
+      forkChoiceRequest +=
+          "    ,{"
+              + "      \"timestamp\": \""
+              + Long.toHexString(maybeTimeStamp.get())
+              + "\","
+              + "      \"prevRandao\": \"0x0000000000000000000000000000000000000000000000000000000000000000\","
+              + "      \"suggestedFeeRecipient\": \"0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b\","
+              + "      \"withdrawals\": [],"
+              + "      \"parentBeaconBlockRoot\": \"0x0000000000000000000000000000000000000000000000000000000000000000\""
+              + "    }";
+    }
+
+    forkChoiceRequest += "  ]," + "  \"id\": 67" + "}";
+
+    return forkChoiceRequest;
+  }
+
+  private String createGetPayloadRequest(final String payloadId) {
+    return "{"
+        + "  \"jsonrpc\": \"2.0\","
+        + "  \"method\": \"engine_getPayloadV4\","
+        + "  \"params\": [\""
+        + payloadId
+        + "\"],"
+        + "  \"id\": 67"
+        + "}";
+  }
+
+  private String createNewPayloadRequest(
+      final String executionPayload, final String parentBeaconBlockRoot) {
+    return "{"
+        + "  \"jsonrpc\": \"2.0\","
+        + "  \"method\": \"engine_newPayloadV4\","
+        + "  \"params\": ["
+        + executionPayload
+        + ",[],"
+        + "\""
+        + parentBeaconBlockRoot
+        + "\""
+        + "],"
+        + "  \"id\": 67"
+        + "}";
+  }
+
+  private static void waitFor(final long durationMilliSeconds) {
+    try {
+      Thread.sleep(durationMilliSeconds);
+    } catch (InterruptedException e) {
+      throw new RuntimeException(e);
+    }
+  }
+}

acceptance-tests/tests/src/test/java/org/hyperledger/besu/tests/acceptance/ethereum/SetCodeTransactionAcceptanceTest.java

@@ -0,0 +1,125 @@
+/*
+ * 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.tests.acceptance.ethereum;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.hyperledger.besu.crypto.SECP256K1;
+import org.hyperledger.besu.datatypes.Address;
+import org.hyperledger.besu.datatypes.TransactionType;
+import org.hyperledger.besu.datatypes.Wei;
+import org.hyperledger.besu.ethereum.core.SetCodeAuthorization;
+import org.hyperledger.besu.ethereum.core.Transaction;
+import org.hyperledger.besu.tests.acceptance.dsl.AcceptanceTestBase;
+import org.hyperledger.besu.tests.acceptance.dsl.account.Account;
+import org.hyperledger.besu.tests.acceptance.dsl.node.BesuNode;
+
+import java.io.IOException;
+import java.math.BigInteger;
+import java.util.List;
+import java.util.Optional;
+
+import org.apache.tuweni.bytes.Bytes;
+import org.apache.tuweni.bytes.Bytes32;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.web3j.protocol.core.methods.response.TransactionReceipt;
+
+public class SetCodeTransactionAcceptanceTest extends AcceptanceTestBase {
+  private static final String GENESIS_FILE = "/dev/dev_prague.json";
+  private static final SECP256K1 secp256k1 = new SECP256K1();
+
+  public static final Address SEND_ALL_ETH_CONTRACT_ADDRESS =
+      Address.fromHexStringStrict("0000000000000000000000000000000000009999");
+
+  private final Account authorizer =
+      accounts.createAccount(
+          Address.fromHexStringStrict("8da48afC965480220a3dB9244771bd3afcB5d895"));
+  public static final Bytes AUTHORIZER_PRIVATE_KEY =
+      Bytes.fromHexString("11f2e7b6a734ab03fa682450e0d4681d18a944f8b83c99bf7b9b4de6c0f35ea1");
+
+  private final Account transactionSponsor =
+      accounts.createAccount(
+          Address.fromHexStringStrict("a05b21E5186Ce93d2a226722b85D6e550Ac7D6E3"));
+  public static final Bytes TRANSACTION_SPONSOR_PRIVATE_KEY =
+      Bytes.fromHexString("3a4ff6d22d7502ef2452368165422861c01a0f72f851793b372b87888dc3c453");
+
+  private BesuNode besuNode;
+  private PragueAcceptanceTestService testService;
+
+  @BeforeEach
+  void setUp() throws IOException {
+    besuNode = besu.createExecutionEngineGenesisNode("besuNode", GENESIS_FILE);
+    cluster.start(besuNode);
+
+    testService = new PragueAcceptanceTestService(besuNode, ethTransactions);
+  }
+
+  /**
+   * At the beginning of the test both the authorizer and the transaction sponsor have a balance of
+   * 90000 ETH. The authorizer creates an authorization for a contract that send all its ETH to any
+   * given address. The transaction sponsor created a 7702 transaction with it and sends all the ETH
+   * from the authorizer to itself. The authorizer balance should be 0 and the transaction sponsor
+   * balance should be greater than 170000 ETH.
+   */
+  @Test
+  public void shouldTransferAllEthOfAuthorizerToSponsor() throws IOException {
+
+    // 7702 transaction
+    final org.hyperledger.besu.datatypes.SetCodeAuthorization authorization =
+        SetCodeAuthorization.builder()
+            .chainId(BigInteger.valueOf(20211))
+            .address(SEND_ALL_ETH_CONTRACT_ADDRESS)
+            .signAndBuild(
+                secp256k1.createKeyPair(
+                    secp256k1.createPrivateKey(AUTHORIZER_PRIVATE_KEY.toUnsignedBigInteger())));
+
+    final Transaction tx =
+        Transaction.builder()
+            .type(TransactionType.SET_CODE)
+            .chainId(BigInteger.valueOf(20211))
+            .nonce(0)
+            .maxPriorityFeePerGas(Wei.of(1000000000))
+            .maxFeePerGas(Wei.fromHexString("0x02540BE400"))
+            .gasLimit(1000000)
+            .to(Address.fromHexStringStrict(authorizer.getAddress()))
+            .value(Wei.ZERO)
+            .payload(Bytes32.leftPad(Bytes.fromHexString(transactionSponsor.getAddress())))
+            .accessList(List.of())
+            .setCodeTransactionPayloads(List.of(authorization))
+            .signAndBuild(
+                secp256k1.createKeyPair(
+                    secp256k1.createPrivateKey(
+                        TRANSACTION_SPONSOR_PRIVATE_KEY.toUnsignedBigInteger())));
+
+    final String txHash =
+        besuNode.execute(ethTransactions.sendRawTransaction(tx.encoded().toHexString()));
+    testService.buildNewBlock();
+
+    cluster.verify(authorizer.balanceEquals(0));
+
+    final BigInteger transactionSponsorBalance =
+        besuNode.execute(ethTransactions.getBalance(transactionSponsor));
+
+    // The transaction sponsor balance should be greater than 170000 ETH. We don't do an exact
+    // balance check to avoid
+    // having to calculate the exact amount of gas used.
+    assertThat(transactionSponsorBalance).isGreaterThan(new BigInteger("170000000000000000000000"));
+
+    Optional<TransactionReceipt> maybeTransactionReceipt =
+        besuNode.execute(ethTransactions.getTransactionReceipt(txHash));
+    assertThat(maybeTransactionReceipt).isPresent();
+  }
+}

besu/src/test/java/org/hyperledger/besu/cli/options/TransactionPoolOptionsTest.java

@@ -413,7 +413,7 @@ public void maxPrioritizedTxsPerTypeConfigFile() throws IOException {
   @Test
   public void maxPrioritizedTxsPerTypeWrongTxType() {
     internalTestFailure(
-        "Invalid value for option '--tx-pool-max-prioritized-by-type' (MAP<TYPE,INTEGER>): expected one of [FRONTIER, ACCESS_LIST, EIP1559, BLOB] (case-insensitive) but was 'WRONG_TYPE'",
+        "Invalid value for option '--tx-pool-max-prioritized-by-type' (MAP<TYPE,INTEGER>): expected one of [FRONTIER, ACCESS_LIST, EIP1559, BLOB, SET_CODE] (case-insensitive) but was 'WRONG_TYPE'",
         "--tx-pool-max-prioritized-by-type",
         "WRONG_TYPE=1");
   }