chore: cherry pick #13479 - redirectForAccount proxy contract support (#13668)

Signed-off-by: lukelee-sl <[email protected]>

Author: lukelee-sl

hedera-node/configuration/preprod/application.properties

@@ -1,2 +1,3 @@
 contracts.chainId=298
 contracts.precompile.atomicCryptoTransfer.enabled=true
+contracts.systemContract.accountService.enabled=true

hedera-node/configuration/previewnet/application.properties

@@ -7,4 +7,5 @@
 bootstrap.genesisPublicKey=c249a323c878f5b5e2daccda6d731e6fdc32f870228d1cd4fae559d947dbc36c
 contracts.chainId=297
 contracts.precompile.atomicCryptoTransfer.enabled=true
+contracts.systemContract.accountService.enabled=true
 ledger.id=0x02

hedera-node/hedera-app/build.gradle.kts

@@ -115,6 +115,7 @@ xtestModuleInfo {
     requires("org.mockito")
     requires("org.mockito.junit.jupiter")
     requires("tuweni.bytes")
+    requires("tuweni.units")
     runtimeOnly("io.netty.transport.epoll.linux.x86_64")
     runtimeOnly("io.netty.transport.epoll.linux.aarch_64")
 }

hedera-node/hedera-app/src/xtest/java/contract/AbstractContractXTest.java

@@ -57,6 +57,8 @@
 import com.hedera.node.app.service.contract.impl.exec.scope.VerificationStrategies;
 import com.hedera.node.app.service.contract.impl.exec.systemcontracts.common.Call;
 import com.hedera.node.app.service.contract.impl.exec.systemcontracts.common.CallAddressChecks;
+import com.hedera.node.app.service.contract.impl.exec.systemcontracts.has.HasCallAttempt;
+import com.hedera.node.app.service.contract.impl.exec.systemcontracts.has.HasCallFactory;
 import com.hedera.node.app.service.contract.impl.exec.systemcontracts.hts.HtsCallAttempt;
 import com.hedera.node.app.service.contract.impl.exec.systemcontracts.hts.HtsCallFactory;
 import com.hedera.node.app.service.contract.impl.exec.systemcontracts.hts.SyntheticIds;
@@ -86,9 +88,11 @@
 import java.util.Map;
 import java.util.Optional;
 import java.util.function.Consumer;
+import org.apache.tuweni.units.bigints.UInt256;
 import org.hyperledger.besu.datatypes.Wei;
 import org.hyperledger.besu.evm.frame.MessageFrame;
 import org.hyperledger.besu.evm.precompile.PrecompiledContract;
+import org.jetbrains.annotations.NotNull;
 import org.junit.jupiter.api.BeforeEach;
 import org.mockito.Mock;
 import org.mockito.Mockito;
@@ -114,15 +118,24 @@ public abstract class AbstractContractXTest extends AbstractXTest {
     @Mock
     private CallAddressChecks addressChecks;
 
-    private HtsCallFactory callAttemptFactory;
+    private HtsCallFactory callHtsAttemptFactory;
+
+    private HasCallFactory callHasAttemptFactory;
 
     protected ContractScaffoldingComponent component;
 
+    public enum SystemContractCallType {
+        HTS_CALL,
+        HAS_CALL
+    }
+
     @BeforeEach
     void setUp() {
         component = DaggerContractScaffoldingComponent.factory().create(metrics, configuration(), storeMetricsService);
-        callAttemptFactory = new HtsCallFactory(
+        callHtsAttemptFactory = new HtsCallFactory(
                 LIVE_SYNTHETIC_IDS, addressChecks, LIVE_VERIFICATION_STRATEGIES, component.callHtsTranslators());
+        callHasAttemptFactory = new HasCallFactory(
+                LIVE_SYNTHETIC_IDS, addressChecks, LIVE_VERIFICATION_STRATEGIES, component.callHasTranslators());
     }
 
     protected Configuration configuration() {
@@ -196,13 +209,18 @@ private void runHtsCallAndExpectOnSuccess(
             @NonNull final org.apache.tuweni.bytes.Bytes input,
             @NonNull final Consumer<org.apache.tuweni.bytes.Bytes> outputAssertions,
             @Nullable final String context) {
-        runHtsCallAndExpect(requiresDelegatePermission, sender, input, resultOnlyAssertion(result -> {
-            assertEquals(
-                    MessageFrame.State.COMPLETED_SUCCESS,
-                    result.getState(),
-                    Optional.ofNullable(context).orElse("An unspecified operation") + " should have succeeded");
-            outputAssertions.accept(result.getOutput());
-        }));
+        runCallAndExpect(
+                requiresDelegatePermission,
+                SystemContractCallType.HTS_CALL,
+                sender,
+                input,
+                resultOnlyAssertion(result -> {
+                    assertEquals(
+                            MessageFrame.State.COMPLETED_SUCCESS,
+                            result.getState(),
+                            Optional.ofNullable(context).orElse("An unspecified operation") + " should have succeeded");
+                    outputAssertions.accept(result.getOutput());
+                }));
     }
 
     protected void runHtsCallAndExpectRevert(
@@ -233,7 +251,7 @@ private void internalRunHtsCallAndExpectRevert(
             @NonNull final org.apache.tuweni.bytes.Bytes input,
             @NonNull final ResponseCodeEnum status,
             @Nullable final String context) {
-        runHtsCallAndExpect(false, sender, input, resultOnlyAssertion(result -> {
+        runCallAndExpect(false, SystemContractCallType.HTS_CALL, sender, input, resultOnlyAssertion(result -> {
             assertEquals(
                     MessageFrame.State.REVERT,
                     result.getState(),
@@ -248,8 +266,59 @@ private void internalRunHtsCallAndExpectRevert(
         }));
     }
 
-    private void runHtsCallAndExpect(
+    protected void runHasCallAndExpectOnSuccess(
+            @NonNull final org.hyperledger.besu.datatypes.Address sender,
+            @NonNull final org.apache.tuweni.bytes.Bytes input,
+            @NonNull final Consumer<org.apache.tuweni.bytes.Bytes> outputAssertions,
+            @Nullable final String context) {
+        runCallAndExpect(false, SystemContractCallType.HAS_CALL, sender, input, resultOnlyAssertion(result -> {
+            assertEquals(
+                    MessageFrame.State.COMPLETED_SUCCESS,
+                    result.getState(),
+                    Optional.ofNullable(context).orElse("An unspecified operation") + " should have succeeded");
+            outputAssertions.accept(result.getOutput());
+        }));
+    }
+
+    protected void runHasCallAndExpectRevert(
+            @NonNull final org.hyperledger.besu.datatypes.Address sender,
+            @NonNull final org.apache.tuweni.bytes.Bytes input,
+            @NonNull final ResponseCodeEnum status,
+            @NonNull final String context,
+            final boolean useOrdinal) {
+        internalRunHasCallAndExpectRevert(sender, input, status, context, useOrdinal);
+    }
+
+    private void internalRunHasCallAndExpectRevert(
+            @NonNull final org.hyperledger.besu.datatypes.Address sender,
+            @NonNull final org.apache.tuweni.bytes.Bytes input,
+            @NonNull final ResponseCodeEnum status,
+            @Nullable final String context,
+            final boolean useOrdinal) {
+        runCallAndExpect(false, SystemContractCallType.HAS_CALL, sender, input, resultOnlyAssertion(result -> {
+            assertEquals(
+                    MessageFrame.State.REVERT,
+                    result.getState(),
+                    Optional.ofNullable(context).orElse("An unspecified operation") + " should have reverted");
+            ResponseCodeEnum actualReason;
+            if (useOrdinal) {
+                actualReason = ResponseCodeEnum.fromProtobufOrdinal(
+                        UInt256.fromBytes(result.getOutput()).intValue());
+            } else {
+                actualReason = ResponseCodeEnum.fromString(
+                        new String(result.getOutput().toArrayUnsafe()));
+            }
+            assertEquals(
+                    status,
+                    actualReason,
+                    "'" + Optional.ofNullable(context).orElse("An unspecified operation")
+                            + "' should have reverted with " + status + " but instead reverted with " + actualReason);
+        }));
+    }
+
+    private void runCallAndExpect(
             final boolean requiresDelegatePermission,
+            @NonNull final SystemContractCallType callType,
             @NonNull final org.hyperledger.besu.datatypes.Address sender,
             @NonNull final org.apache.tuweni.bytes.Bytes input,
             @NonNull final Consumer<Call.PricedResult> resultAssertions) {
@@ -288,15 +357,39 @@ private void runHtsCallAndExpect(
         given(addressChecks.hasParentDelegateCall(frame)).willReturn(requiresDelegatePermission);
         Mockito.lenient().when(frame.getValue()).thenReturn(Wei.MAX_WEI);
 
-        final var attempt = callAttemptFactory.createCallAttemptFrom(input, DIRECT_OR_PROXY_REDIRECT, frame);
-        final var call = attempt.asExecutableCall();
+        Call.PricedResult pricedResult =
+                switch (callType) {
+                    case HTS_CALL -> {
+                        yield getHtsPricedResult(input);
+                    }
+                    case HAS_CALL -> {
+                        yield getHasPricedResult(input);
+                    }
+                };
 
-        final var pricedResult = requireNonNull(call).execute(frame);
         resultAssertions.accept(pricedResult);
         // Note that committing a reverted calls should have no effect on state
         ((SavepointStackImpl) context.savepointStack()).commitFullStack();
     }
 
+    @NotNull
+    private Call.PricedResult getHtsPricedResult(@NonNull org.apache.tuweni.bytes.Bytes input) {
+        final var attempt = callHtsAttemptFactory.createCallAttemptFrom(input, DIRECT_OR_PROXY_REDIRECT, frame);
+        final var call = attempt.asExecutableCall();
+
+        final var pricedResult = requireNonNull(call).execute(frame);
+        return pricedResult;
+    }
+
+    @NotNull
+    private Call.PricedResult getHasPricedResult(@NonNull org.apache.tuweni.bytes.Bytes input) {
+        final var attempt = callHasAttemptFactory.createCallAttemptFrom(input, DIRECT_OR_PROXY_REDIRECT, frame);
+        final var call = attempt.asExecutableCall();
+
+        final var pricedResult = requireNonNull(call).execute(frame);
+        return pricedResult;
+    }
+
     protected TransactionBody createCallTransactionBody(
             final AccountID payer,
             final long value,
@@ -379,6 +472,23 @@ public static org.apache.tuweni.bytes.Bytes bytesForRedirect(
                 org.apache.tuweni.bytes.Bytes.of(subSelector));
     }
 
+    //
+    // Encode given a ByteBuffer and accountId input bytes for a call to a given contract.
+    // Largely, this is used to encode the call to redirectToAccount() proxy contract for testing purposes.
+    // Copied here from TestHelpers as that class is not available in this package.
+    public static org.apache.tuweni.bytes.Bytes bytesForRedirectForAccount(
+            final ByteBuffer encodedErcCall, final AccountID accountID) {
+        return bytesForRedirectForAccount(encodedErcCall.array(), asLongZeroAddress(accountID.accountNum()));
+    }
+
+    public static org.apache.tuweni.bytes.Bytes bytesForRedirectForAccount(
+            final byte[] subSelector, final org.hyperledger.besu.datatypes.Address accountAddress) {
+        return org.apache.tuweni.bytes.Bytes.concatenate(
+                org.apache.tuweni.bytes.Bytes.wrap(HasCallAttempt.REDIRECT_FOR_ACCOUNT.selector()),
+                accountAddress,
+                org.apache.tuweni.bytes.Bytes.of(subSelector));
+    }
+
     public static org.apache.tuweni.bytes.Bytes asBytesResult(final ByteBuffer encoded) {
         return org.apache.tuweni.bytes.Bytes.wrap(encoded.array());
     }

hedera-node/hedera-app/src/xtest/java/contract/HbarAllowanceXTest.java

@@ -0,0 +1,119 @@
+/*
+ * Copyright (C) 2023-2024 Hedera Hashgraph, LLC
+ *
+ * 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.
+ */
+
+package contract;
+
+import static com.hedera.hapi.node.base.ResponseCodeEnum.INVALID_ALLOWANCE_OWNER_ID;
+import static com.hederahashgraph.api.proto.java.ResponseCodeEnum.SUCCESS;
+import static contract.HtsErc721TransferXTestConstants.APPROVED_ADDRESS;
+import static contract.HtsErc721TransferXTestConstants.APPROVED_BESU_ADDRESS;
+import static contract.HtsErc721TransferXTestConstants.APPROVED_HEADLONG_ADDRESS;
+import static contract.HtsErc721TransferXTestConstants.APPROVED_ID;
+import static contract.XTestConstants.INVALID_ID;
+import static contract.XTestConstants.OWNER_ADDRESS;
+import static contract.XTestConstants.OWNER_HEADLONG_ADDRESS;
+import static contract.XTestConstants.OWNER_ID;
+import static contract.XTestConstants.SENDER_CONTRACT_ID_KEY;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import com.esaulpaugh.headlong.abi.Tuple;
+import com.hedera.hapi.node.base.AccountID;
+import com.hedera.hapi.node.state.primitives.ProtoBytes;
+import com.hedera.hapi.node.state.token.Account;
+import com.hedera.hapi.node.state.token.AccountCryptoAllowance;
+import com.hedera.node.app.service.contract.impl.exec.systemcontracts.has.hbarallowance.HbarAllowanceTranslator;
+import java.math.BigInteger;
+import java.util.HashMap;
+import java.util.Map;
+import org.apache.tuweni.bytes.Bytes;
+
+/**
+ * Exercises hbar allowance for a token via the following steps relative to an {@code OWNER} and {@code SENDER} accounts:
+ * <ol>
+ *     <li>Get Hbar Allowance of OWNER for SPENDER via {@link HbarAllowanceTranslator#HBAR_ALLOWANCE_PROXY}.</li>
+ *     <li>Get Hbar Allowance of OWNER for SPENDER via {@link HbarAllowanceTranslator#HBAR_ALLOWANCE}.</li>
+ *     <li>Fail Hbar Allowance if OWNER is not found.</li>
+ * </ol>
+ */
+public class HbarAllowanceXTest extends AbstractContractXTest {
+    @Override
+    protected void doScenarioOperations() {
+        runHasCallAndExpectOnSuccess(
+                APPROVED_BESU_ADDRESS,
+                bytesForRedirectForAccount(
+                        HbarAllowanceTranslator.HBAR_ALLOWANCE_PROXY.encodeCallWithArgs(APPROVED_HEADLONG_ADDRESS),
+                        OWNER_ID),
+                output -> assertEquals(
+                        asBytesResult(HbarAllowanceTranslator.HBAR_ALLOWANCE_PROXY
+                                .getOutputs()
+                                .encodeElements((long) SUCCESS.getNumber(), BigInteger.valueOf(1_000L))),
+                        output),
+                "Successful execution of hbarAllowance for SENDER by OWNER.");
+        runHasCallAndExpectOnSuccess(
+                APPROVED_BESU_ADDRESS,
+                Bytes.wrapByteBuffer(HbarAllowanceTranslator.HBAR_ALLOWANCE.encodeCall(
+                        Tuple.of(OWNER_HEADLONG_ADDRESS, APPROVED_HEADLONG_ADDRESS))),
+                output -> assertEquals(
+                        asBytesResult(HbarAllowanceTranslator.HBAR_ALLOWANCE_PROXY
+                                .getOutputs()
+                                .encodeElements((long) SUCCESS.getNumber(), BigInteger.valueOf(1_000L))),
+                        output),
+                "Successful execution of hbarAllowance for SENDER by OWNER.");
+        runHasCallAndExpectRevert(
+                APPROVED_BESU_ADDRESS,
+                bytesForRedirectForAccount(
+                        HbarAllowanceTranslator.HBAR_ALLOWANCE_PROXY.encodeCallWithArgs(APPROVED_HEADLONG_ADDRESS),
+                        INVALID_ID),
+                INVALID_ALLOWANCE_OWNER_ID,
+                "Failed execution of hbarAllowance when OWNER is not found.",
+                false);
+    }
+
+    @Override
+    protected Map<ProtoBytes, AccountID> initialAliases() {
+        return new HashMap<>() {
+            {
+                put(ProtoBytes.newBuilder().value(OWNER_ADDRESS).build(), OWNER_ID);
+                put(ProtoBytes.newBuilder().value(APPROVED_ADDRESS).build(), APPROVED_ID);
+            }
+        };
+    }
+
+    @Override
+    protected Map<AccountID, Account> initialAccounts() {
+        return new HashMap<>() {
+            {
+                put(
+                        OWNER_ID,
+                        Account.newBuilder()
+                                .accountId(OWNER_ID)
+                                .alias(OWNER_ADDRESS)
+                                .key(SENDER_CONTRACT_ID_KEY)
+                                .cryptoAllowances(AccountCryptoAllowance.newBuilder()
+                                        .amount(1_000L)
+                                        .spenderId(APPROVED_ID)
+                                        .build())
+                                .build());
+                put(
+                        APPROVED_ID,
+                        Account.newBuilder()
+                                .accountId(APPROVED_ID)
+                                .alias(APPROVED_ADDRESS)
+                                .build());
+            }
+        };
+    }
+}