eth_config prototype

A prototype for eth_cofig, sharing operational client configuration data
 via RPC.

Signed-off-by: Danno Ferrin <danno@numisight.com>

Author: shemnon

consensus/merge/src/main/java/org/hyperledger/besu/consensus/merge/TransitionProtocolSchedule.java

@@ -244,4 +244,9 @@ public void setPublicWorldStateArchiveForPrivacyBlockProcessor(
   public void setProtocolContext(final ProtocolContext protocolContext) {
     this.protocolContext = protocolContext;
   }
+
+  @Override
+  public Optional<ProtocolSpec> getNextProtocolSpec(final ProtocolSpec currentProtocolSpec) {
+    return getPostMergeSchedule().getNextProtocolSpec(currentProtocolSpec);
+  }
 }

ethereum/api/src/main/java/org/hyperledger/besu/ethereum/api/jsonrpc/RpcMethod.java

@@ -98,6 +98,7 @@ public enum RpcMethod {
   ETH_CALL("eth_call"),
   ETH_CHAIN_ID("eth_chainId"),
   ETH_COINBASE("eth_coinbase"),
+  ETH_CONFIG("eth_config"),
   ETH_ESTIMATE_GAS("eth_estimateGas"),
   ETH_CREATE_ACCESS_LIST("eth_createAccessList"),
   ETH_FEE_HISTORY("eth_feeHistory"),

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

@@ -0,0 +1,119 @@
+/*
+ * 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.api.jsonrpc.internal.methods;
+
+import org.hyperledger.besu.ethereum.api.jsonrpc.RpcMethod;
+import org.hyperledger.besu.ethereum.api.jsonrpc.internal.JsonRpcRequestContext;
+import org.hyperledger.besu.ethereum.api.jsonrpc.internal.response.JsonRpcResponse;
+import org.hyperledger.besu.ethereum.api.jsonrpc.internal.response.JsonRpcSuccessResponse;
+import org.hyperledger.besu.ethereum.api.query.BlockchainQueries;
+import org.hyperledger.besu.ethereum.mainnet.ProtocolSchedule;
+import org.hyperledger.besu.ethereum.mainnet.ProtocolSpec;
+import org.hyperledger.besu.ethereum.mainnet.requests.RequestProcessorCoordinator;
+import org.hyperledger.besu.evm.precompile.PrecompileContractRegistry;
+
+import java.nio.charset.StandardCharsets;
+import java.util.Map;
+import java.util.TreeMap;
+import java.util.function.Supplier;
+import java.util.zip.CRC32;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import com.google.common.base.Suppliers;
+
+public class EthConfig implements JsonRpcMethod {
+
+  private static final Supplier<ObjectMapper> mapperSupplier = Suppliers.memoize(ObjectMapper::new);
+
+  private final BlockchainQueries blockchain;
+  private final ProtocolSchedule protocolSchedule;
+
+  public EthConfig(final BlockchainQueries blockchain, final ProtocolSchedule protocolSchedule) {
+    this.blockchain = blockchain;
+    this.protocolSchedule = protocolSchedule;
+  }
+
+  @Override
+  public String getName() {
+    return RpcMethod.ETH_CONFIG.getMethodName();
+  }
+
+  @Override
+  public JsonRpcResponse response(final JsonRpcRequestContext requestContext) {
+    var header = blockchain.getBlockchain().getChainHeadHeader();
+    var current = protocolSchedule.getForNextBlockHeader(header, System.currentTimeMillis() / 1000);
+    var next = protocolSchedule.getNextProtocolSpec(current);
+
+    var currentConfig = generateConfig(current);
+    var nextConfig = next.map(this::generateConfig).orElse(null);
+
+    ObjectNode result = mapperSupplier.get().createObjectNode();
+    result.put("current", currentConfig);
+    result.put("currentHash", configHash(currentConfig));
+    result.put("next", nextConfig);
+    result.put("nextHash", configHash(nextConfig));
+
+    return new JsonRpcSuccessResponse(requestContext.getRequest().getId(), result);
+  }
+
+  JsonNode generateConfig(final ProtocolSpec spec) {
+    var result = mapperSupplier.get().createObjectNode();
+    var forkId = protocolSchedule.hardforkFor(x -> x.spec() == spec).orElseThrow();
+
+    result.put("activation", forkId.milestone());
+
+    var blobs = result.putObject("blobs");
+    blobs.put(
+        "baseFeeUpdateFraction", spec.getFeeMarket().getBaseFeeUpdateFraction().longValueExact());
+    blobs.put("max", spec.getGasLimitCalculator().currentBlobGasLimit() / (128 * 1024));
+    blobs.put("target", spec.getGasCalculator().getBlobTarget());
+
+    result.put(
+        "chainId", protocolSchedule.getChainId().map(c -> "0x" + c.toString(16)).orElse(null));
+
+    var contracts =
+        new TreeMap<>(
+            spec.getRequestProcessorCoordinator()
+                .map(RequestProcessorCoordinator::getContractConfigs)
+                .orElse(Map.of()));
+    spec.getBlockHashProcessor()
+        .getHistoryContract()
+        .ifPresent(a -> contracts.put("HISTORY", a.toHexString()));
+    if (!contracts.isEmpty()) {
+      var jsonContracts = result.putObject("contracts");
+      contracts.forEach(jsonContracts::put);
+    }
+
+    PrecompileContractRegistry registry = spec.getPrecompileContractRegistry();
+    var precompiles = result.putObject("precompiles");
+    registry.getPrecompileAddresses().stream()
+        .sorted()
+        .forEach(a -> precompiles.put(a.toHexString(), registry.get(a).getName()));
+
+    return result;
+  }
+
+  String configHash(final JsonNode node) {
+    if (node == null) {
+      return null;
+    } else {
+      final CRC32 crc = new CRC32();
+      crc.update(node.toString().getBytes(StandardCharsets.UTF_8));
+      return Long.toHexString(crc.getValue());
+    }
+  }
+}

ethereum/api/src/main/java/org/hyperledger/besu/ethereum/api/jsonrpc/methods/EthJsonRpcMethods.java

@@ -23,6 +23,7 @@
 import org.hyperledger.besu.ethereum.api.jsonrpc.internal.methods.EthCall;
 import org.hyperledger.besu.ethereum.api.jsonrpc.internal.methods.EthChainId;
 import org.hyperledger.besu.ethereum.api.jsonrpc.internal.methods.EthCoinbase;
+import org.hyperledger.besu.ethereum.api.jsonrpc.internal.methods.EthConfig;
 import org.hyperledger.besu.ethereum.api.jsonrpc.internal.methods.EthCreateAccessList;
 import org.hyperledger.besu.ethereum.api.jsonrpc.internal.methods.EthEstimateGas;
 import org.hyperledger.besu.ethereum.api.jsonrpc.internal.methods.EthFeeHistory;
@@ -156,6 +157,7 @@ protected Map<String, JsonRpcMethod> create() {
         new EthCreateAccessList(blockchainQueries, transactionSimulator),
         new EthMining(miningCoordinator),
         new EthCoinbase(miningCoordinator),
+        new EthConfig(blockchainQueries, protocolSchedule),
         new EthProtocolVersion(supportedCapabilities),
         new EthGasPrice(blockchainQueries, apiConfiguration),
         new EthGetWork(miningCoordinator),

ethereum/api/src/test/resources/org/hyperledger/besu/ethereum/api/jsonrpc/eth/eth_chainId.json

@@ -0,0 +1,39 @@
+{
+  "request": {
+    "id": 8,
+    "jsonrpc": "2.0",
+    "method": "eth_config",
+    "params": []
+  },
+  "response": {
+    "jsonrpc": "2.0",
+    "id": 8,
+    "result": {
+      "current": {
+        "activation": 1444660040,
+        "blobs": {
+          "baseFeeUpdateFraction": 3338477,
+          "max": 6,
+          "target": 3
+        },
+        "chainId": "0x1",
+        "precompiles": {
+          "0x0000000000000000000000000000000000000001": "ECREC",
+          "0x0000000000000000000000000000000000000002": "SHA256",
+          "0x0000000000000000000000000000000000000003": "RIPEMD160",
+          "0x0000000000000000000000000000000000000004": "ID",
+          "0x0000000000000000000000000000000000000005": "EXPMOD",
+          "0x0000000000000000000000000000000000000006": "BN256_ADD",
+          "0x0000000000000000000000000000000000000007": "BN256_MUL",
+          "0x0000000000000000000000000000000000000008": "BN256_PAIRING",
+          "0x0000000000000000000000000000000000000009": "BLAKE2F",
+          "0x000000000000000000000000000000000000000a": "KZG_POINT_EVALUATION"
+        }
+      },
+      "currentHash": "1b5fbed",
+      "next": null,
+      "nextHash": null
+    }
+  },
+  "statusCode": 200
+}

ethereum/api/src/test/resources/org/hyperledger/besu/ethereum/api/jsonrpc/eth/eth_config.json

@@ -74,6 +74,30 @@ public ProtocolSpec getByBlockHeader(final ProcessableBlockHeader blockHeader) {
     return null;
   }
 
+  @Override
+  public Optional<ProtocolSpec> getNextProtocolSpec(final ProtocolSpec currentProtocolSpec) {
+    checkArgument(
+        !protocolSpecs.isEmpty(), "At least 1 milestone must be provided to the protocol schedule");
+    checkArgument(
+        protocolSpecs.last().fork().milestone() == 0,
+        "There must be a milestone starting from block 0");
+
+    // protocolSpecs is sorted in descending block order, so the first one we find that's lower than
+    // the requested level will be the most appropriate spec
+    ScheduledProtocolSpec priorProtocolSpec = null;
+    for (final ScheduledProtocolSpec spec : protocolSpecs) {
+      if (spec.spec() == currentProtocolSpec) {
+        if (priorProtocolSpec == null) {
+          return Optional.empty();
+        } else {
+          return Optional.of(priorProtocolSpec.spec());
+        }
+      }
+      priorProtocolSpec = spec;
+    }
+    return Optional.empty();
+  }
+
   @Override
   public Optional<BigInteger> getChainId() {
     return chainId;

ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/DefaultProtocolSchedule.java

@@ -40,6 +40,8 @@ default ProtocolSpec getForNextBlockHeader(
     return getByBlockHeader(nextBlockHeader);
   }
 
+  Optional<ProtocolSpec> getNextProtocolSpec(final ProtocolSpec currentProtocolSpec);
+
   Optional<BigInteger> getChainId();
 
   String listMilestones();

ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/ProtocolSchedule.java

@@ -14,13 +14,20 @@
  */
 package org.hyperledger.besu.ethereum.mainnet.blockhash;
 
+import org.hyperledger.besu.datatypes.Address;
 import org.hyperledger.besu.ethereum.chain.Blockchain;
 import org.hyperledger.besu.ethereum.core.ProcessableBlockHeader;
 import org.hyperledger.besu.ethereum.mainnet.systemcall.BlockContextProcessor;
 import org.hyperledger.besu.ethereum.mainnet.systemcall.BlockProcessingContext;
 import org.hyperledger.besu.evm.blockhash.BlockHashLookup;
 
+import java.util.Optional;
+
 public interface BlockHashProcessor extends BlockContextProcessor<Void, BlockProcessingContext> {
 
   BlockHashLookup createBlockHashLookup(Blockchain blockchain, ProcessableBlockHeader blockHeader);
+
+  default Optional<Address> getHistoryContract() {
+    return Optional.empty();
+  }
 }

ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/blockhash/BlockHashProcessor.java

@@ -18,6 +18,8 @@
 import org.hyperledger.besu.ethereum.mainnet.systemcall.BlockProcessingContext;
 import org.hyperledger.besu.ethereum.mainnet.systemcall.SystemCallProcessor;
 
+import java.util.Optional;
+
 import com.google.common.annotations.VisibleForTesting;
 import org.apache.tuweni.bytes.Bytes;
 
@@ -58,4 +60,9 @@ public Void process(final BlockProcessingContext context) {
     processor.process(historyStorageAddress, context, inputData);
     return null;
   }
+
+  @Override
+  public Optional<Address> getHistoryContract() {
+    return Optional.of(historyStorageAddress);
+  }
 }