Handle EIP-7702 code delgation

Signed-off-by: Lukasz Gasior <[email protected]>

Author: lukasz-hashgraph

hedera-node/hedera-config/src/main/java/com/hedera/node/config/data/ContractsConfig.java

@@ -101,7 +101,7 @@ public record ContractsConfig(
         @ConfigProperty(value = "evm.nativeLibVerification.halt.enabled", defaultValue = "false") @NetworkProperty
                 boolean nativeLibVerificationHaltEnabled,
         @ConfigProperty(value = "evm.pectra.enabled", defaultValue = "true") @NetworkProperty boolean evmPectraEnabled,
-        @ConfigProperty(value = "metrics.smartContract.primary.enabled", defaultValue = "false") @NetworkProperty
+        @ConfigProperty(value = "metrics.smartContract.primary.enabled", defaultValue = "true") @NetworkProperty
                 boolean metricsSmartContractPrimaryEnabled,
         @ConfigProperty(value = "metrics.smartContract.secondary.enabled", defaultValue = "true") @NetworkProperty
                 boolean metricsSmartContractSecondaryEnabled) {}

hedera-node/hedera-smart-contract-service-impl/build.gradle.kts

@@ -5,7 +5,7 @@ description = "Default Hedera Smart Contract Service Implementation"
 
 // Remove the following line to enable all 'javac' lint checks that we have turned on by default
 // and then fix the reported issues.
-// TODO: bring back .add("-Xlint:-exports")
+// TODO(Pectra): restore to `options.compilerArgs.add("-Xlint:-exports")`
 tasks.withType<JavaCompile>().configureEach { options.compilerArgs.clear() }
 
 mainModuleInfo { annotationProcessor("dagger.compiler") }

hedera-node/hedera-smart-contract-service-impl/src/main/java/com/hedera/node/app/service/contract/impl/exec/delegation/CodeDelegationProcessor.java

@@ -2,6 +2,7 @@
 package com.hedera.node.app.service.contract.impl.exec.delegation;
 
 import static org.hyperledger.besu.evm.account.Account.MAX_NONCE;
+import static org.hyperledger.besu.evm.worldstate.CodeDelegationHelper.CODE_DELEGATION_PREFIX;
 
 import com.hedera.node.app.hapi.utils.ethereum.CodeDelegation;
 import com.hedera.node.app.hapi.utils.ethereum.EthTxSigs;
@@ -28,8 +29,6 @@ public record CodeDelegationProcessor(long chainId) {
 
     private static final int MAX_Y_PARITY = 2 ^ 8;
 
-    public static final Bytes CODE_DELEGATION_PREFIX = Bytes.fromHexString("ef0100");
-
     /** The size of the delegated code */
     public static final int DELEGATED_CODE_SIZE = CODE_DELEGATION_PREFIX.size() + Address.SIZE;
 

hedera-node/hedera-smart-contract-service-impl/src/main/java/com/hedera/node/app/service/contract/impl/exec/operations/CustomDelegateCallOperation.java

@@ -79,6 +79,8 @@ public OperationResult execute(@NonNull final MessageFrame frame, @NonNull final
     private boolean isRedirectFromNativeEntity(@NonNull final MessageFrame frame) {
         final var updater = (ProxyWorldUpdater) frame.getWorldUpdater();
         final var recipient = requireNonNull(updater.getHederaAccount(frame.getRecipientAddress()));
+        // TODO(Pectra): update the condition below. Specifically recipient.isRegularAccount() no longer holds.
+        // Consider adding a frame variable (e.g. isFacadeExecution) or a different mechanism.
         return recipient.isTokenFacade() || recipient.isScheduleTxnFacade() || recipient.isRegularAccount();
     }
 }

hedera-node/hedera-smart-contract-service-impl/src/main/java/com/hedera/node/app/service/contract/impl/exec/processors/CustomMessageCallProcessor.java

@@ -157,7 +157,7 @@ && isPayloadEligibleForAccountServiceRedirect(frame.getInputData())) {
             // disable precompile if so configured.
             evmPrecompile = null;
         }
-        // TODO(Pectra): revisit this?
+        // TODO(Pectra): double check all corner cases for the below condition
         // Check to see if the code address is a system account and possibly halt
         // Note that we allow calls to the allowance hook address(0x16d) if the call is part of
         // a hook dispatch; in that case, the allowance hook is being treated as a normal
@@ -398,9 +398,6 @@ private void doHalt(
     }
 
     private static boolean isPayloadEligibleForAccountServiceRedirect(Bytes payload) {
-        // The compiled binary uses an ABI-compatible function dispatch, so we expect
-        // the first 4 bytes of the payload to be the selector of the function.
-        // We check that against a fixed list of selectors.
         final int prefix = payload.size() >= FUNCTION_SELECTOR_LENGTH ? payload.getInt(0) : 0;
         return ACCOUNT_PROXY_ELIGIBLE_CALL_DATA_PREFIXES.contains(prefix);
     }

hedera-node/hedera-smart-contract-service-impl/src/main/java/com/hedera/node/app/service/contract/impl/exec/systemcontracts/common/AbstractCallAttempt.java

@@ -17,10 +17,10 @@
 import com.swirlds.config.api.Configuration;
 import edu.umd.cs.findbugs.annotations.NonNull;
 import edu.umd.cs.findbugs.annotations.Nullable;
-
 import java.nio.BufferUnderflowException;
 import java.util.Arrays;
 import java.util.Optional;
+import java.util.Set;
 import org.apache.tuweni.bytes.Bytes;
 import org.hyperledger.besu.datatypes.Address;
 
@@ -35,8 +35,12 @@ public abstract class AbstractCallAttempt<T extends AbstractCallAttempt<T>> {
     protected final AccountID senderId;
     protected final Bytes input;
     protected final byte[] selector;
+    protected final Optional<Address> maybeRedirectAddress;
 
-    protected final Optional<Address> legacyRedirectAddress;
+    private boolean matchesFnSelector(Function fn, Bytes input) {
+        final var selector = fn.selector();
+        return Arrays.equals(input.toArrayUnsafe(), 0, selector.length, selector, 0, selector.length);
+    }
 
     /**
      * @param input the input in bytes
@@ -46,29 +50,37 @@ public AbstractCallAttempt(
             // we are keeping the 'input' out of the 'options' for not duplicate and keep close to related params
             @NonNull final Bytes input,
             @NonNull final CallAttemptOptions<T> options,
-            Function redirectFunction) {
+            Set<Address> systemContractAddresses,
+            Function legacyRedirectFunction) {
         requireNonNull(input);
         this.options = requireNonNull(options);
         this.senderId = options.addressIdConverter().convertSender(options.senderAddress());
 
-        final var redirectFnSelector = redirectFunction.selector();
-        final var matchesRedirectSelector = Arrays.equals(input.toArrayUnsafe(), 0, redirectFnSelector.length, redirectFnSelector, 0, redirectFnSelector.length);
-        if (matchesRedirectSelector) {
+        // If the recipient address of this call doesn't match the system contract address
+        // it means we're running an EIP-7702 delegation (i.e. a facade/redirect call).
+        final var isDelegationRedirect = !systemContractAddresses.contains(options.recipientAddress());
+        if (isDelegationRedirect) {
+            this.maybeRedirectAddress = Optional.of(options.recipientAddress());
+            this.input = input;
+        } else if (matchesFnSelector(legacyRedirectFunction, input)) {
             Tuple abiCall = null;
             try {
-                abiCall = redirectFunction.decodeCall(input.toArrayUnsafe());
+                abiCall = legacyRedirectFunction.decodeCall(input.toArrayUnsafe());
             } catch (IllegalArgumentException | BufferUnderflowException | IndexOutOfBoundsException ignore) {
                 // no-op
             }
             if (abiCall != null) {
-                this.legacyRedirectAddress = Optional.of(Address.fromHexString(abiCall.get(0).toString()));
+                this.maybeRedirectAddress =
+                        Optional.of(Address.fromHexString(abiCall.get(0).toString()));
                 this.input = Bytes.wrap((byte[]) abiCall.get(1));
             } else {
-                this.legacyRedirectAddress = Optional.empty();
-                this.input = input;
+                // TODO(Pectra): consider dropping support for proxy calls that don't confirm to ABI
+                this.maybeRedirectAddress = Optional.of(Address.wrap(input.slice(4, 20)));
+                this.input = input.slice(24);
             }
         } else {
-            this.legacyRedirectAddress = Optional.empty();
+            // A regular call; neither EIP-7702 redirect nor legacy redirect function. Process as-is.
+            this.maybeRedirectAddress = Optional.empty();
             this.input = input;
         }
 
@@ -211,7 +223,7 @@ public boolean isStaticCall() {
      * @return whether the current call attempt is redirected to a system contract address
      */
     public boolean isRedirect() {
-        return this.legacyRedirectAddress.isPresent() || options.maybeRedirectAddress().isPresent();
+        return this.maybeRedirectAddress.isPresent();
     }
 
     /**

hedera-node/hedera-smart-contract-service-impl/src/main/java/com/hedera/node/app/service/contract/impl/exec/systemcontracts/common/CallAttemptOptions.java

@@ -13,13 +13,12 @@
 import com.swirlds.config.api.Configuration;
 import edu.umd.cs.findbugs.annotations.NonNull;
 import java.util.List;
-import java.util.Optional;
 import org.hyperledger.besu.datatypes.Address;
 
 public record CallAttemptOptions<T extends AbstractCallAttempt<T>>(
         @NonNull ContractID contractID,
         @NonNull Address senderAddress,
-        @NonNull Optional<Address> maybeRedirectAddress,
+        @NonNull Address recipientAddress,
         @NonNull Address authorizingAddress,
         boolean onlyDelegatableContractKeysActive,
         @NonNull HederaWorldUpdater.Enhancement enhancement,
@@ -34,6 +33,7 @@ public record CallAttemptOptions<T extends AbstractCallAttempt<T>>(
     /**
      * @param contractID the target system contract ID
      * @param senderAddress the address of the sender of this call
+     * @param recipientAddress the recipient address of this call
      * @param authorizingAddress the contract whose keys are to be activated
      * @param onlyDelegatableContractKeysActive whether the strategy should require a delegatable contract id key
      * @param enhancement the enhancement to get the native operations to look up the contract's number
@@ -48,7 +48,7 @@ public record CallAttemptOptions<T extends AbstractCallAttempt<T>>(
     public CallAttemptOptions(
             @NonNull final ContractID contractID,
             @NonNull final Address senderAddress,
-            @NonNull final Optional<Address> maybeRedirectAddress,
+            @NonNull final Address recipientAddress,
             @NonNull final Address authorizingAddress,
             final boolean onlyDelegatableContractKeysActive,
             @NonNull final Enhancement enhancement,
@@ -61,7 +61,7 @@ public CallAttemptOptions(
             final boolean isStaticCall) {
         this.contractID = requireNonNull(contractID);
         this.senderAddress = requireNonNull(senderAddress);
-        this.maybeRedirectAddress = requireNonNull(maybeRedirectAddress);
+        this.recipientAddress = requireNonNull(recipientAddress);
         this.authorizingAddress = requireNonNull(authorizingAddress);
         this.onlyDelegatableContractKeysActive = onlyDelegatableContractKeysActive;
         this.enhancement = requireNonNull(enhancement);

hedera-node/hedera-smart-contract-service-impl/src/main/java/com/hedera/node/app/service/contract/impl/exec/systemcontracts/has/HasCallAttempt.java

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 package com.hedera.node.app.service.contract.impl.exec.systemcontracts.has;
 
+import static com.hedera.node.app.service.contract.impl.exec.systemcontracts.HasSystemContract.HAS_EVM_ADDRESS;
 import static com.hedera.node.app.service.contract.impl.utils.ConversionUtils.isLongZero;
 import static com.hedera.node.app.service.contract.impl.utils.ConversionUtils.numberOfLongZero;
 import static java.util.Objects.requireNonNull;
@@ -17,6 +18,7 @@
 import com.hedera.node.config.data.HederaConfig;
 import edu.umd.cs.findbugs.annotations.NonNull;
 import edu.umd.cs.findbugs.annotations.Nullable;
+import java.util.Set;
 import org.apache.tuweni.bytes.Bytes;
 import org.hyperledger.besu.datatypes.Address;
 
@@ -26,8 +28,9 @@
  * everything it will need to execute.
  */
 public class HasCallAttempt extends AbstractCallAttempt<HasCallAttempt> {
-    public static final Function LEGACY_REDIRECT_FOR_ACCOUNT =
-            new Function("redirectForAccount(address,bytes)");
+    private static final Set<Address> HAS_ADDRESSES = Set.of(Address.fromHexString(HAS_EVM_ADDRESS));
+
+    public static final Function LEGACY_REDIRECT_FOR_ACCOUNT = new Function("redirectForAccount(address,bytes)");
 
     @Nullable
     private final Account redirectAccount;
@@ -39,13 +42,10 @@ public HasCallAttempt(
             @NonNull final Bytes input,
             @NonNull final CallAttemptOptions<HasCallAttempt> options,
             @NonNull final SignatureVerifier signatureVerifier) {
-        super(input, options, LEGACY_REDIRECT_FOR_ACCOUNT);
+        super(input, options, HAS_ADDRESSES, LEGACY_REDIRECT_FOR_ACCOUNT);
 
         this.redirectAccount =
-            this.legacyRedirectAddress
-                .or(options::maybeRedirectAddress)
-                .map(this::linkedAccount)
-                .orElse(null);
+                this.maybeRedirectAddress.map(this::linkedAccount).orElse(null);
 
         this.signatureVerifier = requireNonNull(signatureVerifier);
     }

hedera-node/hedera-smart-contract-service-impl/src/main/java/com/hedera/node/app/service/contract/impl/exec/systemcontracts/has/HasCallFactory.java

@@ -84,7 +84,7 @@ public HasCallFactory(
                 new CallAttemptOptions<>(
                         contractID,
                         frame.getSenderAddress(),
-                        maybeRedirectAddress,
+                        frame.getRecipientAddress(),
                         frame.getSenderAddress(),
                         addressChecks.hasParentDelegateCall(frame),
                         enhancement,

hedera-node/hedera-smart-contract-service-impl/src/main/java/com/hedera/node/app/service/contract/impl/exec/systemcontracts/hss/HssCallAttempt.java

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 package com.hedera.node.app.service.contract.impl.exec.systemcontracts.hss;
 
+import static com.hedera.node.app.service.contract.impl.exec.systemcontracts.HssSystemContract.HSS_EVM_ADDRESS;
 import static com.hedera.node.app.service.contract.impl.utils.ConversionUtils.isLongZero;
 import static com.hedera.node.app.service.contract.impl.utils.ConversionUtils.maybeMissingNumberOf;
 import static com.hedera.node.app.service.contract.impl.utils.ConversionUtils.numberOfLongZero;
@@ -28,8 +29,10 @@
  * everything it will need to execute.
  */
 public class HssCallAttempt extends AbstractCallAttempt<HssCallAttempt> {
-    public static final Function LEGACY_REDIRECT_FOR_SCHEDULE =
-            new Function("redirectForSchedule(address,bytes)");
+    private static final Set<Address> HSS_ADDRESSES = Set.of(Address.fromHexString(HSS_EVM_ADDRESS));
+
+    public static final Function LEGACY_REDIRECT_FOR_SCHEDULE_TXN =
+            new Function("redirectForScheduleTxn(address,bytes)");
 
     @Nullable
     private final Schedule redirectScheduleTxn;
@@ -41,13 +44,10 @@ public HssCallAttempt(
             @NonNull final Bytes input,
             @NonNull final CallAttemptOptions<HssCallAttempt> options,
             @NonNull final SignatureVerifier signatureVerifier) {
-        super(input, options, LEGACY_REDIRECT_FOR_SCHEDULE);
+        super(input, options, HSS_ADDRESSES, LEGACY_REDIRECT_FOR_SCHEDULE_TXN);
 
         this.redirectScheduleTxn =
-            this.legacyRedirectAddress
-                .or(options::maybeRedirectAddress)
-                .map(this::linkedSchedule)
-                .orElse(null);
+                this.maybeRedirectAddress.map(this::linkedSchedule).orElse(null);
 
         this.signatureVerifier = signatureVerifier;
     }