04632 Fuzzing test for LazyCreate through precompiles

hedera-node/test-clients/src/main/java/com/hedera/services/bdd/spec/infrastructure/providers/ops/precompile/RandomERC20TransferLazyCreate.java

@@ -0,0 +1,97 @@
+/*
+ * Copyright (C) 2023 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 com.hedera.services.bdd.spec.infrastructure.providers.ops.precompile;
+
+import static com.hedera.node.app.service.evm.utils.EthSigsUtils.recoverAddressFromPubKey;
+import static com.hedera.services.bdd.spec.keys.TrieSigMapGenerator.uniqueWithFullPrefixesFor;
+import static com.hedera.services.bdd.spec.queries.QueryVerbs.getTxnRecord;
+import static com.hedera.services.bdd.spec.transactions.TxnVerbs.*;
+import static com.hedera.services.bdd.spec.utilops.CustomSpecAssert.allRunFor;
+import static com.hedera.services.bdd.spec.utilops.UtilVerbs.withOpContext;
+import static com.hedera.services.bdd.suites.HapiSuite.GENESIS;
+import static com.hedera.services.bdd.suites.contract.Utils.asAddress;
+import static com.hedera.services.bdd.suites.crypto.AutoCreateUtils.updateSpecFor;
+import static com.hedera.services.bdd.suites.regression.factories.IdFuzzingProviderFactory.*;
+import static com.hedera.services.bdd.suites.utils.ECDSAKeysUtils.getEvmAddressFromString;
+import static com.hederahashgraph.api.proto.java.ResponseCodeEnum.SUCCESS;
+
+import com.hedera.services.bdd.spec.HapiSpecOperation;
+import com.hedera.services.bdd.spec.infrastructure.EntityNameProvider;
+import com.hedera.services.bdd.spec.infrastructure.HapiSpecRegistry;
+import com.hedera.services.bdd.spec.infrastructure.OpProvider;
+import com.hedera.services.bdd.spec.queries.meta.HapiGetTxnRecord;
+import com.hedera.services.bdd.spec.transactions.contract.HapiParserUtil;
+import com.hederahashgraph.api.proto.java.Key;
+import java.math.BigInteger;
+import java.util.Optional;
+
+public class RandomERC20TransferLazyCreate implements OpProvider {
+    private final HapiSpecRegistry registry;
+    private static final long GAS_TO_OFFER = 5_000_000L;
+    private static final String TRANSFER = "transfer";
+    private static final String TRANSFER_TXN = "transferTxn";
+    private final EntityNameProvider<Key> keys;
+
+    public RandomERC20TransferLazyCreate(HapiSpecRegistry registry, EntityNameProvider<Key> keys) {
+        this.registry = registry;
+        this.keys = keys;
+    }
+
+    private Optional<String> randomKey() {
+        return keys.getQualifying().filter(k -> !k.isEmpty());
+    }
+
+    @Override
+    public Optional<HapiSpecOperation> get() {
+        return randomKey().map(this::generateLazyCreateTransferOfERC20);
+    }
+
+    private HapiSpecOperation generateLazyCreateTransferOfERC20(String evmAddressRecipient) {
+        final var addressBytes = recoverAddressFromPubKey(getEvmAddressFromString(registry, evmAddressRecipient));
+        return withOpContext((spec, opLog) -> {
+            final var opContractCall = contractCall(
+                            ERC_20_CONTRACT,
+                            TRANSFER,
+                            HapiParserUtil.asHeadlongAddress(asAddress(registry.getTokenID(ERC_FUNGIBLE_TOKEN))),
+                            HapiParserUtil.asHeadlongAddress(addressBytes),
+                            BigInteger.valueOf(2))
+                    .via(TRANSFER_TXN)
+                    .gas(GAS_TO_OFFER)
+                    .hasKnownStatus(SUCCESS);
+
+            final HapiGetTxnRecord hapiGetTxnRecord =
+                    getTxnRecord(TRANSFER_TXN).andAllChildRecords().assertingNothingAboutHashes();
+
+            allRunFor(spec, opContractCall, hapiGetTxnRecord);
+
+            if (!hapiGetTxnRecord.getChildRecords().isEmpty()) {
+
+                updateSpecFor(spec, evmAddressRecipient);
+                final var opUpdate = cryptoUpdateAliased(evmAddressRecipient)
+                        .maxAutomaticAssociations(1000000000)
+                        .payingWith(GENESIS)
+                        .signedBy(evmAddressRecipient, GENESIS)
+                        .sigMapPrefixes(uniqueWithFullPrefixesFor(evmAddressRecipient))
+                        .hasPrecheckFrom(STANDARD_PERMISSIBLE_PRECHECKS)
+                        .hasKnownStatusFrom(STANDARD_PERMISSIBLE_OUTCOMES)
+                        .logged();
+
+                allRunFor(spec, opUpdate);
+            }
+        });
+    }
+}

hedera-node/test-clients/src/main/java/com/hedera/services/bdd/spec/infrastructure/providers/ops/precompile/RandomERC721TransferLazyCreate.java

@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2023 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 com.hedera.services.bdd.spec.infrastructure.providers.ops.precompile;
+
+import static com.hedera.node.app.service.evm.utils.EthSigsUtils.recoverAddressFromPubKey;
+import static com.hedera.services.bdd.spec.transactions.TxnVerbs.contractCall;
+import static com.hedera.services.bdd.suites.contract.Utils.asAddress;
+import static com.hedera.services.bdd.suites.regression.factories.IdFuzzingProviderFactory.*;
+import static com.hedera.services.bdd.suites.utils.ECDSAKeysUtils.getEvmAddressFromString;
+import static com.hederahashgraph.api.proto.java.ResponseCodeEnum.*;
+
+import com.hedera.services.bdd.spec.HapiSpecOperation;
+import com.hedera.services.bdd.spec.infrastructure.EntityNameProvider;
+import com.hedera.services.bdd.spec.infrastructure.HapiSpecRegistry;
+import com.hedera.services.bdd.spec.infrastructure.OpProvider;
+import com.hedera.services.bdd.spec.transactions.contract.HapiContractCall;
+import com.hedera.services.bdd.spec.transactions.contract.HapiParserUtil;
+import com.hederahashgraph.api.proto.java.Key;
+import java.math.BigInteger;
+import java.util.Optional;
+
+public class RandomERC721TransferLazyCreate implements OpProvider {
+    private final HapiSpecRegistry registry;
+    private static final long GAS_TO_OFFER = 5_000_000L;
+    private static final String TRANSFER_FROM_ACCOUNT_TXN = "transferFromAccountTxn";
+    private static final String TRANSFER_FROM = "transferFrom";
+    private final EntityNameProvider<Key> keys;
+
+    public RandomERC721TransferLazyCreate(HapiSpecRegistry registry, EntityNameProvider<Key> keys) {
+        this.registry = registry;
+        this.keys = keys;
+    }
+
+    private Optional<String> randomKey() {
+        return keys.getQualifying().filter(k -> !k.isEmpty());
+    }
+
+    @Override
+    public Optional<HapiSpecOperation> get() {
+        return randomKey().map(this::generateERC721TransferLazyCreate);
+    }
+
+    private HapiContractCall generateERC721TransferLazyCreate(String evmAddressRecipient) {
+        final var addressBytes = recoverAddressFromPubKey(getEvmAddressFromString(registry, evmAddressRecipient));
+        /**
+         * CONTRACT_REVERT_EXECUTED is also included in the outcomes, because we have a predefined amount of
+         * ERC721 tokens and predefined allowances. As more and more transfers happen in the fuzzing test once the
+         * predefined allowance limit is reached transfers are impossible and the actual error in the precompile is
+         * SPENDER_DOES_NOT_HAVE_ALLOWANCE
+         */
+        return contractCall(
+                        ERC_721_CONTRACT,
+                        TRANSFER_FROM,
+                        HapiParserUtil.asHeadlongAddress(asAddress(registry.getTokenID(ERC_NON_FUNGIBLE_TOKEN))),
+                        HapiParserUtil.asHeadlongAddress(asAddress(registry.getAccountID(OWNER))),
+                        HapiParserUtil.asHeadlongAddress(addressBytes),
+                        BigInteger.valueOf(1))
+                .via(TRANSFER_FROM_ACCOUNT_TXN)
+                .gas(GAS_TO_OFFER)
+                .hasPrecheckFrom(STANDARD_PERMISSIBLE_PRECHECKS)
+                .hasKnownStatusFrom(SUCCESS, CONTRACT_REVERT_EXECUTED);
+    }
+}

hedera-node/test-clients/src/main/java/com/hedera/services/bdd/spec/infrastructure/providers/ops/precompile/RandomFungibleTransferLazyCreate.java

@@ -0,0 +1,99 @@
+/*
+ * Copyright (C) 2023 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 com.hedera.services.bdd.spec.infrastructure.providers.ops.precompile;
+
+import static com.hedera.node.app.service.evm.utils.EthSigsUtils.recoverAddressFromPubKey;
+import static com.hedera.services.bdd.spec.keys.TrieSigMapGenerator.uniqueWithFullPrefixesFor;
+import static com.hedera.services.bdd.spec.queries.QueryVerbs.getTxnRecord;
+import static com.hedera.services.bdd.spec.transactions.TxnVerbs.contractCall;
+import static com.hedera.services.bdd.spec.transactions.TxnVerbs.cryptoUpdateAliased;
+import static com.hedera.services.bdd.spec.utilops.CustomSpecAssert.allRunFor;
+import static com.hedera.services.bdd.spec.utilops.UtilVerbs.withOpContext;
+import static com.hedera.services.bdd.suites.HapiSuite.GENESIS;
+import static com.hedera.services.bdd.suites.contract.Utils.asAddress;
+import static com.hedera.services.bdd.suites.crypto.AutoCreateUtils.updateSpecFor;
+import static com.hedera.services.bdd.suites.regression.factories.IdFuzzingProviderFactory.*;
+import static com.hedera.services.bdd.suites.utils.ECDSAKeysUtils.getEvmAddressFromString;
+import static com.hederahashgraph.api.proto.java.ResponseCodeEnum.*;
+
+import com.hedera.services.bdd.spec.HapiSpecOperation;
+import com.hedera.services.bdd.spec.infrastructure.EntityNameProvider;
+import com.hedera.services.bdd.spec.infrastructure.HapiSpecRegistry;
+import com.hedera.services.bdd.spec.infrastructure.OpProvider;
+import com.hedera.services.bdd.spec.queries.meta.HapiGetTxnRecord;
+import com.hedera.services.bdd.spec.transactions.contract.HapiParserUtil;
+import com.hederahashgraph.api.proto.java.Key;
+import java.util.Optional;
+
+public class RandomFungibleTransferLazyCreate implements OpProvider {
+    private final HapiSpecRegistry registry;
+    private static final long GAS_TO_OFFER = 5_000_000L;
+
+    private final EntityNameProvider<Key> keys;
+
+    public RandomFungibleTransferLazyCreate(HapiSpecRegistry registry, EntityNameProvider<Key> keys) {
+        this.registry = registry;
+        this.keys = keys;
+    }
+
+    private Optional<String> randomKey() {
+        return keys.getQualifying().filter(k -> !k.isEmpty());
+    }
+
+    @Override
+    public Optional<HapiSpecOperation> get() {
+        return randomKey().map(this::generateLazyCreateTransferOfFungibleToken);
+    }
+
+    private HapiSpecOperation generateLazyCreateTransferOfFungibleToken(String evmAddressRecipient) {
+        final var addressBytes = recoverAddressFromPubKey(getEvmAddressFromString(registry, evmAddressRecipient));
+
+        return withOpContext((spec, opLog) -> {
+            final var opContractCall = contractCall(
+                            TRANSFER_TO_ALIAS_PRECOMPILE_CONTRACT,
+                            "transferTokenCallNestedThenAgain",
+                            HapiParserUtil.asHeadlongAddress(asAddress(registry.getTokenID(FUNGIBLE_TOKEN))),
+                            HapiParserUtil.asHeadlongAddress(asAddress(registry.getAccountID(OWNER))),
+                            HapiParserUtil.asHeadlongAddress(addressBytes),
+                            2L,
+                            2L)
+                    .via(TRANSFER_TOKEN_TXN)
+                    .alsoSigningWithFullPrefix(OWNER)
+                    .gas(GAS_TO_OFFER)
+                    .hasKnownStatus(SUCCESS);
+
+            final HapiGetTxnRecord hapiGetTxnRecord =
+                    getTxnRecord(TRANSFER_TOKEN_TXN).andAllChildRecords().assertingNothingAboutHashes();
+
+            allRunFor(spec, opContractCall, hapiGetTxnRecord);
+
+            if (!hapiGetTxnRecord.getChildRecords().isEmpty()) {
+                updateSpecFor(spec, evmAddressRecipient);
+                final var opUpdate = cryptoUpdateAliased(evmAddressRecipient)
+                        .maxAutomaticAssociations(1000000000)
+                        .payingWith(GENESIS)
+                        .signedBy(evmAddressRecipient, GENESIS)
+                        .sigMapPrefixes(uniqueWithFullPrefixesFor(evmAddressRecipient))
+                        .hasPrecheckFrom(OK)
+                        .hasKnownStatusFrom(SUCCESS, INVALID_SIGNATURE)
+                        .logged();
+
+                allRunFor(spec, opUpdate);
+            }
+        });
+    }
+}

hedera-node/test-clients/src/main/java/com/hedera/services/bdd/spec/infrastructure/providers/ops/precompile/RandomHbarTransferLazyCreate.java

@@ -0,0 +1,86 @@
+/*
+ * Copyright (C) 2023 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 com.hedera.services.bdd.spec.infrastructure.providers.ops.precompile;
+
+import static com.hedera.node.app.service.evm.utils.EthSigsUtils.recoverAddressFromPubKey;
+import static com.hedera.services.bdd.spec.transactions.TxnVerbs.contractCall;
+import static com.hedera.services.bdd.spec.utilops.UtilVerbs.accountAmount;
+import static com.hedera.services.bdd.spec.utilops.UtilVerbs.transferList;
+import static com.hedera.services.bdd.suites.regression.factories.IdFuzzingProviderFactory.*;
+import static com.hedera.services.bdd.suites.utils.ECDSAKeysUtils.getEvmAddressFromString;
+
+import com.esaulpaugh.headlong.abi.Tuple;
+import com.hedera.services.bdd.spec.HapiSpecOperation;
+import com.hedera.services.bdd.spec.infrastructure.EntityNameProvider;
+import com.hedera.services.bdd.spec.infrastructure.HapiSpecRegistry;
+import com.hedera.services.bdd.spec.infrastructure.OpProvider;
+import com.hedera.services.bdd.spec.transactions.contract.HapiContractCall;
+import com.hedera.services.bdd.spec.utilops.UtilVerbs;
+import com.hederahashgraph.api.proto.java.Key;
+import java.util.Optional;
+
+public class RandomHbarTransferLazyCreate implements OpProvider {
+    private static final String TRANSFER_TXN = "transferTxn";
+
+    private final HapiSpecRegistry registry;
+    private static final long GAS_TO_OFFER = 5_000_000L;
+    private static final Tuple[] EMPTY_TUPLE_ARRAY = new Tuple[] {};
+    private final EntityNameProvider<Key> keys;
+
+    public RandomHbarTransferLazyCreate(HapiSpecRegistry registry, EntityNameProvider<Key> keys) {
+        this.registry = registry;
+        this.keys = keys;
+    }
+
+    private Optional<String> randomKey() {
+        return keys.getQualifying().filter(k -> !k.isEmpty());
+    }
+
+    @Override
+    public Optional<HapiSpecOperation> get() {
+        return randomKey().map(this::generateHbarTransferLazyCreate);
+    }
+
+    private HapiContractCall generateHbarTransferLazyCreate(String evmAddressRecipient) {
+        final var cryptoTransferV2LazyCreateFn = "cryptoTransferV2LazyCreate";
+        final var sender = registry.getAccountID(SENDER);
+        final var amountToBeSent = 50L;
+
+        final var addressBytes = recoverAddressFromPubKey(getEvmAddressFromString(registry, evmAddressRecipient));
+        return contractCall(
+                        NESTED_LAZY_PRECOMPILE_CONTRACT,
+                        cryptoTransferV2LazyCreateFn,
+                        transferList()
+                                .withAccountAmounts(
+                                        accountAmount(sender, -amountToBeSent, false),
+                                        UtilVerbs.accountAmountAlias(addressBytes, amountToBeSent, false))
+                                .build(),
+                        EMPTY_TUPLE_ARRAY,
+                        transferList()
+                                .withAccountAmounts(
+                                        accountAmount(sender, -amountToBeSent, false),
+                                        UtilVerbs.accountAmountAlias(addressBytes, amountToBeSent, false))
+                                .build(),
+                        EMPTY_TUPLE_ARRAY)
+                .payingWith(UNIQUE_PAYER_ACCOUNT)
+                .via(TRANSFER_TXN)
+                .signedBy(UNIQUE_PAYER_ACCOUNT, MULTI_KEY)
+                .alsoSigningWithFullPrefix(MULTI_KEY)
+                .hasPrecheckFrom(STANDARD_PERMISSIBLE_PRECHECKS)
+                .gas(GAS_TO_OFFER);
+    }
+}