From b52de4018df3b8fd8cb17d0df0176655d6cf638c Mon Sep 17 00:00:00 2001 From: nikolay Date: Thu, 18 Jan 2024 20:45:45 +0200 Subject: [PATCH 01/16] chore: increment nonce flow Signed-off-by: nikolay --- .../contracts/execution/EvmTxProcessor.java | 3 ++ .../contract/ContractCallTransitionLogic.java | 3 -- .../bdd/suites/ethereum/EthereumSuite.java | 43 ++++++++++++++++++- 3 files changed, 45 insertions(+), 4 deletions(-) diff --git a/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/contracts/execution/EvmTxProcessor.java b/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/contracts/execution/EvmTxProcessor.java index cfd122b6bdfa..43a15227c035 100644 --- a/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/contracts/execution/EvmTxProcessor.java +++ b/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/contracts/execution/EvmTxProcessor.java @@ -143,6 +143,9 @@ protected TransactionProcessingResult execute( super.setOperationTracer(hederaTracer); try { + // increment sender's nonce right before entering the evm + // and after all handler's checks to prevent nonce discrepancies + chargingResult.sender().incrementNonce(); super.execute(sender, receiver, gasPrice, gasLimit, value, payload, isStatic, mirrorReceiver); } catch (final ResourceLimitException e) { handleResourceLimitExceeded( diff --git a/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/txns/contract/ContractCallTransitionLogic.java b/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/txns/contract/ContractCallTransitionLogic.java index ebd92083bac0..29dbbe6e7dac 100644 --- a/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/txns/contract/ContractCallTransitionLogic.java +++ b/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/txns/contract/ContractCallTransitionLogic.java @@ -158,9 +158,6 @@ public void doStateTransitionOperation( result = evmTxProcessor.execute( sender, receiver.canonicalAddress(), op.getGas(), op.getAmount(), callData, txnCtx.consensusTime()); } else { - sender.incrementEthereumNonce(); - accountStore.commitAccount(sender); - result = evmTxProcessor.executeEth( sender, receiver.canonicalAddress(), diff --git a/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/ethereum/EthereumSuite.java b/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/ethereum/EthereumSuite.java index 11baf729766d..51f3f94d4614 100644 --- a/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/ethereum/EthereumSuite.java +++ b/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/ethereum/EthereumSuite.java @@ -136,6 +136,8 @@ public class EthereumSuite extends HapiSuite { private static final String PAY_TXN = "payTxn"; private static final String TOTAL_SUPPLY_TX = "totalSupplyTx"; private static final String ERC20_ABI = "ERC20ABI"; + private final String INTERNAL_CALLEE_CONTRACT = "InternalCallee"; + private final String EXTERNAL_FUNCTION = "externalFunction"; public static void main(String... args) { new EthereumSuite().runSuiteAsync(); @@ -165,10 +167,49 @@ public List getSpecsInSuite() { directTransferWorksForERC20(), transferHbarsViaEip2930TxSuccessfully(), callToTokenAddressViaEip2930TxSuccessfully(), - transferTokensViaEip2930TxSuccessfully())) + transferTokensViaEip2930TxSuccessfully(), + nonceNotUpdatedOnHandlerCheckFailed(), + nonceUpdatedAfterSuccessfulExecutedTx())) .toList(); } + private HapiSpec nonceNotUpdatedOnHandlerCheckFailed() { + return defaultHapiSpec("nonceNotUpdatedOnHandlerCheckFailed") + .given( + newKeyNamed(SECP_256K1_SOURCE_KEY).shape(SECP_256K1_SHAPE), + cryptoCreate(RELAYER).balance(ONE_HUNDRED_HBARS), + cryptoTransfer(tinyBarsFromAccountToAlias(GENESIS, SECP_256K1_SOURCE_KEY, ONE_HBAR)), + uploadInitCode(INTERNAL_CALLEE_CONTRACT), + contractCreate(INTERNAL_CALLEE_CONTRACT)) + .when(ethereumCall(INTERNAL_CALLEE_CONTRACT, EXTERNAL_FUNCTION) + .type(EthTxData.EthTransactionType.EIP1559) + .signingWith(SECP_256K1_SOURCE_KEY) + .payingWith(RELAYER) + .nonce(0) + .gasLimit(21_000L) + .hasKnownStatus(ResponseCodeEnum.INSUFFICIENT_GAS)) + .then(getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(0L))); + } + + private HapiSpec nonceUpdatedAfterSuccessfulExecutedTx() { + return defaultHapiSpec("nonceUpdatedAfterSuccessfulExecutedTx") + .given( + newKeyNamed(SECP_256K1_SOURCE_KEY).shape(SECP_256K1_SHAPE), + cryptoCreate(RELAYER).balance(ONE_HUNDRED_HBARS), + cryptoTransfer(tinyBarsFromAccountToAlias(GENESIS, SECP_256K1_SOURCE_KEY, ONE_HBAR)), + uploadInitCode(INTERNAL_CALLEE_CONTRACT), + contractCreate(INTERNAL_CALLEE_CONTRACT)) + .when(ethereumCall(INTERNAL_CALLEE_CONTRACT, EXTERNAL_FUNCTION) + .type(EthTxData.EthTransactionType.EIP1559) + .signingWith(SECP_256K1_SOURCE_KEY) + .payingWith(RELAYER) + .nonce(0) + .gasLimit(100_000L)) + .then(getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(1L))); + } + @HapiTest HapiSpec sendingLargerBalanceThanAvailableFailsGracefully() { final AtomicReference
tokenCreateContractAddress = new AtomicReference<>(); From a55c6c84ba407dcee7594ed542f5535b5fef2c5a Mon Sep 17 00:00:00 2001 From: nikolay Date: Fri, 19 Jan 2024 09:20:44 +0200 Subject: [PATCH 02/16] chore: edint cotnract create transition logic Signed-off-by: nikolay --- .../service/mono/contracts/execution/EvmTxProcessor.java | 6 ++++-- .../mono/txns/contract/ContractCreateTransitionLogic.java | 3 --- 2 files changed, 4 insertions(+), 5 deletions(-) diff --git a/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/contracts/execution/EvmTxProcessor.java b/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/contracts/execution/EvmTxProcessor.java index 43a15227c035..15813fec8ce3 100644 --- a/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/contracts/execution/EvmTxProcessor.java +++ b/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/contracts/execution/EvmTxProcessor.java @@ -143,9 +143,11 @@ protected TransactionProcessingResult execute( super.setOperationTracer(hederaTracer); try { - // increment sender's nonce right before entering the evm + // increment sender's ethereum nonce right before entering the evm // and after all handler's checks to prevent nonce discrepancies - chargingResult.sender().incrementNonce(); + if (relayer != null) { + chargingResult.sender().incrementNonce(); + } super.execute(sender, receiver, gasPrice, gasLimit, value, payload, isStatic, mirrorReceiver); } catch (final ResourceLimitException e) { handleResourceLimitExceeded( diff --git a/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/txns/contract/ContractCreateTransitionLogic.java b/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/txns/contract/ContractCreateTransitionLogic.java index 24943704cbee..893dd99f1795 100644 --- a/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/txns/contract/ContractCreateTransitionLogic.java +++ b/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/txns/contract/ContractCreateTransitionLogic.java @@ -210,9 +210,6 @@ public void doStateTransitionOperation( codeWithConstructorArgs, consensusTime); } else { - sender.incrementEthereumNonce(); - accountStore.commitAccount(sender); - result = evmTxProcessor.executeEth( sender, newContractAddress, From 62de76ceb39a82516887c21be6f64b0bcb4c7fa7 Mon Sep 17 00:00:00 2001 From: nikolay Date: Fri, 19 Jan 2024 14:50:25 +0200 Subject: [PATCH 03/16] chore: refactor evm tx processor Signed-off-by: nikolay --- .../contracts/execution/EvmTxProcessor.java | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) diff --git a/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/contracts/execution/EvmTxProcessor.java b/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/contracts/execution/EvmTxProcessor.java index 15813fec8ce3..bb90427ca48f 100644 --- a/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/contracts/execution/EvmTxProcessor.java +++ b/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/contracts/execution/EvmTxProcessor.java @@ -117,7 +117,7 @@ protected TransactionProcessingResult execute( super.setupFields(payload, contractCreation); - final var chargingResult = chargeForGas( + final var chargingResult = chargeForGasAndIncrementEthereumNonce( gasCost, upfrontCost, value, @@ -143,11 +143,6 @@ protected TransactionProcessingResult execute( super.setOperationTracer(hederaTracer); try { - // increment sender's ethereum nonce right before entering the evm - // and after all handler's checks to prevent nonce discrepancies - if (relayer != null) { - chargingResult.sender().incrementNonce(); - } super.execute(sender, receiver, gasPrice, gasLimit, value, payload, isStatic, mirrorReceiver); } catch (final ResourceLimitException e) { handleResourceLimitExceeded( @@ -252,7 +247,7 @@ private void sendToCoinbase( mutableCoinbase.incrementBalance(Wei.of(amount * gasPrice)); } - private ChargingResult chargeForGas( + private ChargingResult chargeForGasAndIncrementEthereumNonce( final Wei gasCost, final Wei upfrontCost, final long value, @@ -314,6 +309,12 @@ private ChargingResult chargeForGas( validateTrue(senderCanAffordValue, INSUFFICIENT_PAYER_BALANCE); } } + + // increment sender's ethereum nonce right after all checks and before entering the evm + if (relayer != null) { + senderAccount.incrementNonce(); + } + return new ChargingResult(senderAccount, mutableRelayer, allowanceCharged); } @@ -330,7 +331,7 @@ private void handleResourceLimitExceeded( final Wei upfrontCost) { // Consume all gas on resource exhaustion, using a clean updater final var feesOnlyUpdater = (HederaWorldState.Updater) worldState.updater(); - chargeForGas( + chargeForGasAndIncrementEthereumNonce( gasCost, upfrontCost, value, From 573a9a060d142f41f94ed7aa103b97dccfb3e98a Mon Sep 17 00:00:00 2001 From: nikolay Date: Sat, 20 Jan 2024 15:18:43 +0200 Subject: [PATCH 04/16] chore: add nonce suite Signed-off-by: nikolay --- .../contracts/execution/EvmTxProcessor.java | 9 +- .../bdd/suites/ethereum/EthereumSuite.java | 43 +- .../bdd/suites/ethereum/NonceSuite.java | 473 ++++++++++++++++++ 3 files changed, 479 insertions(+), 46 deletions(-) create mode 100644 hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/ethereum/NonceSuite.java diff --git a/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/contracts/execution/EvmTxProcessor.java b/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/contracts/execution/EvmTxProcessor.java index bb90427ca48f..2549427d4aea 100644 --- a/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/contracts/execution/EvmTxProcessor.java +++ b/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/contracts/execution/EvmTxProcessor.java @@ -308,11 +308,12 @@ private ChargingResult chargeForGasAndIncrementEthereumNonce( final var senderCanAffordValue = senderAccount.getBalance().compareTo(Wei.of(value)) >= 0; validateTrue(senderCanAffordValue, INSUFFICIENT_PAYER_BALANCE); } - } - // increment sender's ethereum nonce right after all checks and before entering the evm - if (relayer != null) { - senderAccount.incrementNonce(); + // increment sender's ethereum nonce right after all checks + // and before entering the evm for non-static calls + if (relayer != null) { + senderAccount.incrementNonce(); + } } return new ChargingResult(senderAccount, mutableRelayer, allowanceCharged); diff --git a/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/ethereum/EthereumSuite.java b/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/ethereum/EthereumSuite.java index 51f3f94d4614..11baf729766d 100644 --- a/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/ethereum/EthereumSuite.java +++ b/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/ethereum/EthereumSuite.java @@ -136,8 +136,6 @@ public class EthereumSuite extends HapiSuite { private static final String PAY_TXN = "payTxn"; private static final String TOTAL_SUPPLY_TX = "totalSupplyTx"; private static final String ERC20_ABI = "ERC20ABI"; - private final String INTERNAL_CALLEE_CONTRACT = "InternalCallee"; - private final String EXTERNAL_FUNCTION = "externalFunction"; public static void main(String... args) { new EthereumSuite().runSuiteAsync(); @@ -167,49 +165,10 @@ public List getSpecsInSuite() { directTransferWorksForERC20(), transferHbarsViaEip2930TxSuccessfully(), callToTokenAddressViaEip2930TxSuccessfully(), - transferTokensViaEip2930TxSuccessfully(), - nonceNotUpdatedOnHandlerCheckFailed(), - nonceUpdatedAfterSuccessfulExecutedTx())) + transferTokensViaEip2930TxSuccessfully())) .toList(); } - private HapiSpec nonceNotUpdatedOnHandlerCheckFailed() { - return defaultHapiSpec("nonceNotUpdatedOnHandlerCheckFailed") - .given( - newKeyNamed(SECP_256K1_SOURCE_KEY).shape(SECP_256K1_SHAPE), - cryptoCreate(RELAYER).balance(ONE_HUNDRED_HBARS), - cryptoTransfer(tinyBarsFromAccountToAlias(GENESIS, SECP_256K1_SOURCE_KEY, ONE_HBAR)), - uploadInitCode(INTERNAL_CALLEE_CONTRACT), - contractCreate(INTERNAL_CALLEE_CONTRACT)) - .when(ethereumCall(INTERNAL_CALLEE_CONTRACT, EXTERNAL_FUNCTION) - .type(EthTxData.EthTransactionType.EIP1559) - .signingWith(SECP_256K1_SOURCE_KEY) - .payingWith(RELAYER) - .nonce(0) - .gasLimit(21_000L) - .hasKnownStatus(ResponseCodeEnum.INSUFFICIENT_GAS)) - .then(getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) - .has(accountWith().nonce(0L))); - } - - private HapiSpec nonceUpdatedAfterSuccessfulExecutedTx() { - return defaultHapiSpec("nonceUpdatedAfterSuccessfulExecutedTx") - .given( - newKeyNamed(SECP_256K1_SOURCE_KEY).shape(SECP_256K1_SHAPE), - cryptoCreate(RELAYER).balance(ONE_HUNDRED_HBARS), - cryptoTransfer(tinyBarsFromAccountToAlias(GENESIS, SECP_256K1_SOURCE_KEY, ONE_HBAR)), - uploadInitCode(INTERNAL_CALLEE_CONTRACT), - contractCreate(INTERNAL_CALLEE_CONTRACT)) - .when(ethereumCall(INTERNAL_CALLEE_CONTRACT, EXTERNAL_FUNCTION) - .type(EthTxData.EthTransactionType.EIP1559) - .signingWith(SECP_256K1_SOURCE_KEY) - .payingWith(RELAYER) - .nonce(0) - .gasLimit(100_000L)) - .then(getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) - .has(accountWith().nonce(1L))); - } - @HapiTest HapiSpec sendingLargerBalanceThanAvailableFailsGracefully() { final AtomicReference
tokenCreateContractAddress = new AtomicReference<>(); diff --git a/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/ethereum/NonceSuite.java b/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/ethereum/NonceSuite.java new file mode 100644 index 000000000000..061127eaf7c5 --- /dev/null +++ b/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/ethereum/NonceSuite.java @@ -0,0 +1,473 @@ +/* + * Copyright (C) 2022-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 com.hedera.services.bdd.suites.ethereum; + +import static com.hedera.services.bdd.spec.HapiPropertySource.asHexedSolidityAddress; +import static com.hedera.services.bdd.spec.HapiSpec.defaultHapiSpec; +import static com.hedera.services.bdd.spec.assertions.AccountInfoAsserts.accountWith; +import static com.hedera.services.bdd.spec.queries.QueryVerbs.getAccountInfo; +import static com.hedera.services.bdd.spec.queries.QueryVerbs.getAliasedAccountInfo; +import static com.hedera.services.bdd.spec.transactions.TxnVerbs.contractCall; +import static com.hedera.services.bdd.spec.transactions.TxnVerbs.contractCreate; +import static com.hedera.services.bdd.spec.transactions.TxnVerbs.cryptoCreate; +import static com.hedera.services.bdd.spec.transactions.TxnVerbs.cryptoTransfer; +import static com.hedera.services.bdd.spec.transactions.TxnVerbs.ethereumCall; +import static com.hedera.services.bdd.spec.transactions.TxnVerbs.tokenCreate; +import static com.hedera.services.bdd.spec.transactions.TxnVerbs.uploadInitCode; +import static com.hedera.services.bdd.spec.transactions.contract.HapiParserUtil.asHeadlongAddress; +import static com.hedera.services.bdd.spec.transactions.crypto.HapiCryptoTransfer.tinyBarsFromAccountToAlias; +import static com.hedera.services.bdd.spec.utilops.CustomSpecAssert.allRunFor; +import static com.hedera.services.bdd.spec.utilops.UtilVerbs.newKeyNamed; +import static com.hedera.services.bdd.spec.utilops.UtilVerbs.withOpContext; +import static com.hedera.services.bdd.suites.contract.Utils.mirrorAddrWith; +import static com.hederahashgraph.api.proto.java.ResponseCodeEnum.CONTRACT_REVERT_EXECUTED; +import static com.hederahashgraph.api.proto.java.ResponseCodeEnum.INSUFFICIENT_GAS; +import static com.hederahashgraph.api.proto.java.ResponseCodeEnum.INSUFFICIENT_PAYER_BALANCE; +import static com.hederahashgraph.api.proto.java.ResponseCodeEnum.INSUFFICIENT_TX_FEE; +import static com.hederahashgraph.api.proto.java.ResponseCodeEnum.MAX_CHILD_RECORDS_EXCEEDED; +import static com.hederahashgraph.api.proto.java.TokenType.FUNGIBLE_COMMON; + +import com.hedera.node.app.hapi.utils.ethereum.EthTxData.EthTransactionType; +import com.hedera.services.bdd.spec.HapiPropertySource; +import com.hedera.services.bdd.spec.HapiSpec; +import com.hedera.services.bdd.spec.HapiSpecSetup; +import com.hedera.services.bdd.suites.HapiSuite; +import com.hederahashgraph.api.proto.java.AccountID; +import java.math.BigInteger; +import java.util.List; +import java.util.concurrent.atomic.AtomicReference; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; + +// @HapiTestSuite(fuzzyMatch = true) +// @Tag(SMART_CONTRACT) +@SuppressWarnings("java:S5960") +public class NonceSuite extends HapiSuite { + + private static final Logger log = LogManager.getLogger(NonceSuite.class); + private static final long LOW_GAS_PRICE = 1L; + private static final long ENOUGH_GAS_PRICE = 75L; + private static final long ENOUGH_GAS_LIMIT = 150_000L; + private static final String RECEIVER = "receiver"; + private static final String INTERNAL_CALLEE_CONTRACT = "InternalCallee"; + private static final String INTERNAL_CALLER_CONTRACT = "InternalCaller"; + private static final String FACTORY_CONTRACT = "FactoryContract"; + private static final String EXTERNAL_FUNCTION = "externalFunction"; + private static final String REVERT_WITH_REVERT_REASON_FUNCTION = "revertWithRevertReason"; + private static final String TRANSFER_TO_FUNCTION = "transferTo"; + private static final String DEPLOYMENT_SUCCESS_FUNCTION = "deploymentSuccess"; + + public static void main(String... args) { + new NonceSuite().runSuiteAsync(); + } + + @Override + public boolean canRunConcurrent() { + return true; + } + + @Override + public List getSpecsInSuite() { + return List.of( + // handler checks + nonceNotUpdatedWhenIntrinsicGasHandlerCheckFailed(), + nonceNotUpdatedWhenUserOfferedGasPriceAndAllowanceAreZeroHandlerCheckFailed(), + nonceNotUpdatedWhenOfferedGasPriceIsLessThanCurrentAndSenderDoesNotHaveEnoughBalanceHandlerCheckFailed(), + nonceNotUpdatedWhenOfferedGasPriceIsLessThanCurrentAndGasAllowanceIsLessThanRemainingFeeHandlerCheckFailed(), + nonceNotUpdatedWhenOfferedGasPriceIsBiggerThanCurrentAndSenderDoesNotHaveEnoughBalanceHandlerCheckFailed(), + nonceNotUpdatedWhenSenderDoesNotHaveEnoughBalanceHandlerCheckFailed(), + nonceNotUpdatedForNonEthereumTransaction(), + // evm smart contract reversions + nonceUpdatedAfterEvmReversionDueContractLogic(), + nonceUpdatedAfterEvmReversionDueInsufficientGas(), + nonceUpdatedAfterEvmReversionDueInsufficientTransferAmount(), + // evm hedera specific reversions + nonceUpdatedAfterEvmReversionDueSendingValueToEthereumPrecompile0x2(), + nonceUpdatedAfterEvmReversionDueSendingValueToHederaPrecompile0x167(), + // evm hedera specific resource validation reversions + nonceUpdatedAfterEvmReversionDueMaxChildRecordsExceeded(), + // successful ethereum transactions via internal calls + nonceUpdatedAfterSuccessfulInternalCall(), + nonceUpdatedAfterSuccessfulInternalTransfer(), + nonceUpdatedAfterSuccessfulInternalContractDeployment()); + } + + private HapiSpec nonceNotUpdatedWhenIntrinsicGasHandlerCheckFailed() { + return defaultHapiSpec("nonceNotUpdatedWhenIntrinsicGasHandlerCheckFailed") + .given( + newKeyNamed(SECP_256K1_SOURCE_KEY).shape(SECP_256K1_SHAPE), + cryptoCreate(RELAYER).balance(ONE_HUNDRED_HBARS), + cryptoTransfer(tinyBarsFromAccountToAlias(GENESIS, SECP_256K1_SOURCE_KEY, ONE_HBAR)), + uploadInitCode(INTERNAL_CALLEE_CONTRACT), + contractCreate(INTERNAL_CALLEE_CONTRACT)) + .when(ethereumCall(INTERNAL_CALLEE_CONTRACT, EXTERNAL_FUNCTION) + .type(EthTransactionType.EIP1559) + .signingWith(SECP_256K1_SOURCE_KEY) + .payingWith(RELAYER) + .nonce(0) + .gasLimit(21_000L) + .hasKnownStatus(INSUFFICIENT_GAS)) + .then(getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(0L))); + } + + private HapiSpec nonceNotUpdatedWhenUserOfferedGasPriceAndAllowanceAreZeroHandlerCheckFailed() { + return defaultHapiSpec("nonceNotUpdatedWhenUserOfferedGasPriceAndAllowanceAreZeroHandlerCheckFailed") + .given( + newKeyNamed(SECP_256K1_SOURCE_KEY).shape(SECP_256K1_SHAPE), + cryptoCreate(RELAYER).balance(ONE_HUNDRED_HBARS), + cryptoTransfer(tinyBarsFromAccountToAlias(GENESIS, SECP_256K1_SOURCE_KEY, ONE_HBAR)), + uploadInitCode(INTERNAL_CALLEE_CONTRACT), + contractCreate(INTERNAL_CALLEE_CONTRACT)) + .when(ethereumCall(INTERNAL_CALLEE_CONTRACT, EXTERNAL_FUNCTION) + .type(EthTransactionType.EIP1559) + .signingWith(SECP_256K1_SOURCE_KEY) + .payingWith(RELAYER) + .nonce(0) + .gasLimit(ENOUGH_GAS_LIMIT) + .maxFeePerGas(0L) + .maxGasAllowance(0L) + .hasKnownStatus(INSUFFICIENT_TX_FEE)) + .then(getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(0L))); + } + + private HapiSpec + nonceNotUpdatedWhenOfferedGasPriceIsLessThanCurrentAndSenderDoesNotHaveEnoughBalanceHandlerCheckFailed() { + return defaultHapiSpec( + "nonceNotUpdatedWhenOfferedGasPriceIsLessThanCurrentAndSenderDoesNotHaveEnoughBalanceHandlerCheckFailed") + .given( + newKeyNamed(SECP_256K1_SOURCE_KEY).shape(SECP_256K1_SHAPE), + cryptoCreate(RELAYER).balance(ONE_HUNDRED_HBARS), + cryptoTransfer(tinyBarsFromAccountToAlias(GENESIS, SECP_256K1_SOURCE_KEY, 1L)), + uploadInitCode(INTERNAL_CALLEE_CONTRACT), + contractCreate(INTERNAL_CALLEE_CONTRACT)) + .when(ethereumCall(INTERNAL_CALLEE_CONTRACT, EXTERNAL_FUNCTION) + .type(EthTransactionType.EIP1559) + .signingWith(SECP_256K1_SOURCE_KEY) + .payingWith(RELAYER) + .nonce(0) + .gasLimit(ENOUGH_GAS_LIMIT) + .maxFeePerGas(LOW_GAS_PRICE) + .hasKnownStatus(INSUFFICIENT_PAYER_BALANCE)) + .then(getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(0L))); + } + + private HapiSpec + nonceNotUpdatedWhenOfferedGasPriceIsLessThanCurrentAndGasAllowanceIsLessThanRemainingFeeHandlerCheckFailed() { + return defaultHapiSpec( + "nonceNotUpdatedWhenOfferedGasPriceIsLessThanCurrentAndGasAllowanceIsLessThanRemainingFeeHandlerCheckFailed") + .given( + newKeyNamed(SECP_256K1_SOURCE_KEY).shape(SECP_256K1_SHAPE), + cryptoCreate(RELAYER).balance(ONE_HUNDRED_HBARS), + cryptoTransfer(tinyBarsFromAccountToAlias(GENESIS, SECP_256K1_SOURCE_KEY, ONE_HUNDRED_HBARS)), + uploadInitCode(INTERNAL_CALLEE_CONTRACT), + contractCreate(INTERNAL_CALLEE_CONTRACT)) + .when(ethereumCall(INTERNAL_CALLEE_CONTRACT, EXTERNAL_FUNCTION) + .type(EthTransactionType.EIP1559) + .signingWith(SECP_256K1_SOURCE_KEY) + .payingWith(RELAYER) + .nonce(0) + .gasLimit(ENOUGH_GAS_LIMIT) + .maxFeePerGas(LOW_GAS_PRICE) + .maxGasAllowance(0L) + .hasKnownStatus(INSUFFICIENT_TX_FEE)) + .then(getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(0L))); + } + + private HapiSpec + nonceNotUpdatedWhenOfferedGasPriceIsBiggerThanCurrentAndSenderDoesNotHaveEnoughBalanceHandlerCheckFailed() { + return defaultHapiSpec( + "nonceNotUpdatedWhenOfferedGasPriceIsBiggerThanCurrentAndSenderDoesNotHaveEnoughBalanceHandlerCheckFailed") + .given( + newKeyNamed(SECP_256K1_SOURCE_KEY).shape(SECP_256K1_SHAPE), + cryptoCreate(RELAYER).balance(ONE_HUNDRED_HBARS), + cryptoTransfer(tinyBarsFromAccountToAlias(GENESIS, SECP_256K1_SOURCE_KEY, 1L)), + uploadInitCode(INTERNAL_CALLEE_CONTRACT), + contractCreate(INTERNAL_CALLEE_CONTRACT)) + .when(ethereumCall(INTERNAL_CALLEE_CONTRACT, EXTERNAL_FUNCTION) + .type(EthTransactionType.EIP1559) + .signingWith(SECP_256K1_SOURCE_KEY) + .payingWith(RELAYER) + .nonce(0) + .gasLimit(ENOUGH_GAS_LIMIT) + .maxFeePerGas(ENOUGH_GAS_PRICE) + .hasKnownStatus(INSUFFICIENT_PAYER_BALANCE)) + .then(getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(0L))); + } + + private HapiSpec nonceNotUpdatedWhenSenderDoesNotHaveEnoughBalanceHandlerCheckFailed() { + return defaultHapiSpec("nonceNotUpdatedWhenSenderDoesNotHaveEnoughBalanceHandlerCheckFailed") + .given( + newKeyNamed(SECP_256K1_SOURCE_KEY).shape(SECP_256K1_SHAPE), + cryptoCreate(RELAYER).balance(ONE_HUNDRED_HBARS), + cryptoTransfer(tinyBarsFromAccountToAlias(GENESIS, SECP_256K1_SOURCE_KEY, 1L)), + uploadInitCode(INTERNAL_CALLEE_CONTRACT), + contractCreate(INTERNAL_CALLEE_CONTRACT)) + .when(ethereumCall(INTERNAL_CALLEE_CONTRACT, EXTERNAL_FUNCTION) + .type(EthTransactionType.EIP1559) + .signingWith(SECP_256K1_SOURCE_KEY) + .payingWith(RELAYER) + .nonce(0) + .gasLimit(ENOUGH_GAS_LIMIT) + .maxFeePerGas(0L) + .sending(5L) + .hasKnownStatus(INSUFFICIENT_PAYER_BALANCE)) + .then(getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(0L))); + } + + private HapiSpec nonceNotUpdatedForNonEthereumTransaction() { + return defaultHapiSpec("nonceNotUpdatedForNonEthereumTransaction") + .given( + cryptoCreate(RELAYER).balance(ONE_HUNDRED_HBARS), + uploadInitCode(INTERNAL_CALLEE_CONTRACT), + contractCreate(INTERNAL_CALLEE_CONTRACT)) + .when(contractCall(INTERNAL_CALLEE_CONTRACT, EXTERNAL_FUNCTION) + .gas(ENOUGH_GAS_LIMIT) + .payingWith(RELAYER) + .signingWith(RELAYER)) + .then(getAccountInfo(RELAYER).has(accountWith().nonce(0L))); + } + + private HapiSpec nonceUpdatedAfterSuccessfulInternalCall() { + return defaultHapiSpec("nonceUpdatedAfterSuccessfulInternalCall") + .given( + newKeyNamed(SECP_256K1_SOURCE_KEY).shape(SECP_256K1_SHAPE), + cryptoCreate(RELAYER).balance(ONE_HUNDRED_HBARS), + cryptoTransfer(tinyBarsFromAccountToAlias(GENESIS, SECP_256K1_SOURCE_KEY, ONE_HBAR)), + uploadInitCode(INTERNAL_CALLEE_CONTRACT), + contractCreate(INTERNAL_CALLEE_CONTRACT)) + .when(ethereumCall(INTERNAL_CALLEE_CONTRACT, EXTERNAL_FUNCTION) + .type(EthTransactionType.EIP1559) + .signingWith(SECP_256K1_SOURCE_KEY) + .payingWith(RELAYER) + .nonce(0) + .gasLimit(ENOUGH_GAS_LIMIT)) + .then(getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(1L))); + } + + private HapiSpec nonceUpdatedAfterEvmReversionDueContractLogic() { + return defaultHapiSpec("nonceUpdatedAfterEvmReversionDueContractLogic") + .given( + newKeyNamed(SECP_256K1_SOURCE_KEY).shape(SECP_256K1_SHAPE), + cryptoCreate(RELAYER).balance(ONE_HUNDRED_HBARS), + cryptoTransfer(tinyBarsFromAccountToAlias(GENESIS, SECP_256K1_SOURCE_KEY, ONE_HBAR)), + uploadInitCode(INTERNAL_CALLEE_CONTRACT), + contractCreate(INTERNAL_CALLEE_CONTRACT)) + .when(ethereumCall(INTERNAL_CALLEE_CONTRACT, REVERT_WITH_REVERT_REASON_FUNCTION) + .type(EthTransactionType.EIP1559) + .signingWith(SECP_256K1_SOURCE_KEY) + .payingWith(RELAYER) + .nonce(0) + .gasLimit(ENOUGH_GAS_LIMIT) + .hasKnownStatus(CONTRACT_REVERT_EXECUTED)) + .then(getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(1L))); + } + + private HapiSpec nonceUpdatedAfterEvmReversionDueInsufficientGas() { + return defaultHapiSpec("nonceUpdatedAfterEvmReversionDueInsufficientGas") + .given( + newKeyNamed(SECP_256K1_SOURCE_KEY).shape(SECP_256K1_SHAPE), + cryptoCreate(RELAYER).balance(ONE_HUNDRED_HBARS), + cryptoTransfer(tinyBarsFromAccountToAlias(GENESIS, SECP_256K1_SOURCE_KEY, ONE_HBAR)), + uploadInitCode(INTERNAL_CALLEE_CONTRACT), + contractCreate(INTERNAL_CALLEE_CONTRACT)) + .when(ethereumCall(INTERNAL_CALLEE_CONTRACT, EXTERNAL_FUNCTION) + .type(EthTransactionType.EIP1559) + .signingWith(SECP_256K1_SOURCE_KEY) + .payingWith(RELAYER) + .nonce(0) + .gasLimit(21_064L) + .hasKnownStatus(INSUFFICIENT_GAS)) + .then(getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(1L))); + } + + private HapiSpec nonceUpdatedAfterEvmReversionDueInsufficientTransferAmount() { + AtomicReference receiverId = new AtomicReference<>(); + return defaultHapiSpec("nonceUpdatedAfterEvmReversionDueInsufficientTransferAmount") + .given( + cryptoCreate(RECEIVER).balance(0L).exposingCreatedIdTo(receiverId::set), + newKeyNamed(SECP_256K1_SOURCE_KEY).shape(SECP_256K1_SHAPE), + cryptoCreate(RELAYER).balance(ONE_HUNDRED_HBARS), + cryptoTransfer(tinyBarsFromAccountToAlias(GENESIS, SECP_256K1_SOURCE_KEY, ONE_HBAR)), + uploadInitCode(INTERNAL_CALLER_CONTRACT), + contractCreate(INTERNAL_CALLER_CONTRACT)) + .when(withOpContext((spec, op) -> allRunFor( + spec, + ethereumCall( + INTERNAL_CALLER_CONTRACT, + TRANSFER_TO_FUNCTION, + mirrorAddrWith(receiverId.get().getAccountNum())) + .type(EthTransactionType.EIP1559) + .signingWith(SECP_256K1_SOURCE_KEY) + .payingWith(RELAYER) + .nonce(0) + .gasLimit(ENOUGH_GAS_LIMIT) + .hasKnownStatus(CONTRACT_REVERT_EXECUTED)))) + .then(getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(1L))); + } + + private HapiSpec nonceUpdatedAfterEvmReversionDueSendingValueToEthereumPrecompile0x2() { + AccountID eth0x2 = AccountID.newBuilder().setAccountNum(2).build(); + return defaultHapiSpec("nonceUpdatedAfterEvmReversionDueSendingValueToEthereumPrecompile0x2") + .given( + newKeyNamed(SECP_256K1_SOURCE_KEY).shape(SECP_256K1_SHAPE), + cryptoCreate(RELAYER).balance(ONE_HUNDRED_HBARS), + cryptoTransfer(tinyBarsFromAccountToAlias(GENESIS, SECP_256K1_SOURCE_KEY, ONE_HBAR)), + uploadInitCode(INTERNAL_CALLER_CONTRACT), + contractCreate(INTERNAL_CALLER_CONTRACT)) + .when(withOpContext((spec, op) -> allRunFor( + spec, + ethereumCall( + INTERNAL_CALLER_CONTRACT, + TRANSFER_TO_FUNCTION, + mirrorAddrWith(eth0x2.getAccountNum())) + .type(EthTransactionType.EIP1559) + .signingWith(SECP_256K1_SOURCE_KEY) + .payingWith(RELAYER) + .nonce(0) + .gasLimit(ENOUGH_GAS_LIMIT) + .hasKnownStatus(CONTRACT_REVERT_EXECUTED)))) + .then(getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(1L))); + } + + private HapiSpec nonceUpdatedAfterEvmReversionDueSendingValueToHederaPrecompile0x167() { + AccountID eth0x167 = AccountID.newBuilder().setAccountNum(2).build(); + return defaultHapiSpec("nonceUpdatedAfterEvmReversionDueSendingValueToHederaPrecompile0x167") + .given( + newKeyNamed(SECP_256K1_SOURCE_KEY).shape(SECP_256K1_SHAPE), + cryptoCreate(RELAYER).balance(ONE_HUNDRED_HBARS), + cryptoTransfer(tinyBarsFromAccountToAlias(GENESIS, SECP_256K1_SOURCE_KEY, ONE_HBAR)), + uploadInitCode(INTERNAL_CALLER_CONTRACT), + contractCreate(INTERNAL_CALLER_CONTRACT)) + .when(withOpContext((spec, op) -> allRunFor( + spec, + ethereumCall( + INTERNAL_CALLER_CONTRACT, + TRANSFER_TO_FUNCTION, + mirrorAddrWith(eth0x167.getAccountNum())) + .type(EthTransactionType.EIP1559) + .signingWith(SECP_256K1_SOURCE_KEY) + .payingWith(RELAYER) + .nonce(0) + .gasLimit(ENOUGH_GAS_LIMIT) + .hasKnownStatus(CONTRACT_REVERT_EXECUTED)))) + .then(getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(1L))); + } + + private HapiSpec nonceUpdatedAfterEvmReversionDueMaxChildRecordsExceeded() { + final String MANY_CHILDREN_CONTRACT = "ManyChildren"; + final String CHECK_BALANCE_REPEATEDLY_FUNCTION = "checkBalanceRepeatedly"; + final String TOKEN_TREASURY = "treasury"; + final String FUNGIBLE_TOKEN = "fungibleToken"; + final AtomicReference treasuryMirrorAddr = new AtomicReference<>(); + final AtomicReference tokenMirrorAddr = new AtomicReference<>(); + final var illegalNumChildren = + HapiSpecSetup.getDefaultNodeProps().getInteger("consensus.handle.maxFollowingRecords") + 1; + return defaultHapiSpec("nonceUpdatedAfterEvmReversionDueMaxChildRecordsExceeded") + .given( + cryptoCreate(TOKEN_TREASURY) + .exposingCreatedIdTo(id -> treasuryMirrorAddr.set(asHexedSolidityAddress(id))), + newKeyNamed(SECP_256K1_SOURCE_KEY).shape(SECP_256K1_SHAPE), + cryptoCreate(RELAYER).balance(ONE_HUNDRED_HBARS), + cryptoTransfer(tinyBarsFromAccountToAlias(GENESIS, SECP_256K1_SOURCE_KEY, ONE_HBAR)), + uploadInitCode(MANY_CHILDREN_CONTRACT), + contractCreate(MANY_CHILDREN_CONTRACT), + tokenCreate(FUNGIBLE_TOKEN) + .tokenType(FUNGIBLE_COMMON) + .treasury(TOKEN_TREASURY) + .initialSupply(1_000_000L) + .exposingCreatedIdTo(id -> + tokenMirrorAddr.set(asHexedSolidityAddress(HapiPropertySource.asToken(id))))) + .when(withOpContext((spec, op) -> allRunFor( + spec, + ethereumCall( + MANY_CHILDREN_CONTRACT, + CHECK_BALANCE_REPEATEDLY_FUNCTION, + asHeadlongAddress(tokenMirrorAddr.get()), + asHeadlongAddress(treasuryMirrorAddr.get()), + BigInteger.valueOf(illegalNumChildren)) + .type(EthTransactionType.EIP1559) + .signingWith(SECP_256K1_SOURCE_KEY) + .payingWith(RELAYER) + .nonce(0) + .gasLimit(ENOUGH_GAS_LIMIT) + .hasKnownStatus(MAX_CHILD_RECORDS_EXCEEDED)))) + .then(getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(1L))); + } + + private HapiSpec nonceUpdatedAfterSuccessfulInternalTransfer() { + AtomicReference receiverId = new AtomicReference<>(); + return defaultHapiSpec("nonceUpdatedAfterSuccessfulInternalTransfer") + .given( + cryptoCreate(RECEIVER).balance(0L).exposingCreatedIdTo(receiverId::set), + newKeyNamed(SECP_256K1_SOURCE_KEY).shape(SECP_256K1_SHAPE), + cryptoCreate(RELAYER).balance(ONE_HUNDRED_HBARS), + cryptoTransfer(tinyBarsFromAccountToAlias(GENESIS, SECP_256K1_SOURCE_KEY, ONE_HBAR)), + uploadInitCode(INTERNAL_CALLER_CONTRACT), + contractCreate(INTERNAL_CALLER_CONTRACT).balance(ONE_HBAR)) + .when(withOpContext((spec, op) -> allRunFor( + spec, + ethereumCall( + INTERNAL_CALLER_CONTRACT, + TRANSFER_TO_FUNCTION, + mirrorAddrWith(receiverId.get().getAccountNum())) + .type(EthTransactionType.EIP1559) + .signingWith(SECP_256K1_SOURCE_KEY) + .payingWith(RELAYER) + .nonce(0) + .gasLimit(ENOUGH_GAS_LIMIT)))) + .then(getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(1L))); + } + + private HapiSpec nonceUpdatedAfterSuccessfulInternalContractDeployment() { + return defaultHapiSpec("nonceUpdatedAfterSuccessfulInternalContractDeployment") + .given( + cryptoCreate(RECEIVER).balance(0L), + newKeyNamed(SECP_256K1_SOURCE_KEY).shape(SECP_256K1_SHAPE), + cryptoCreate(RELAYER).balance(ONE_HUNDRED_HBARS), + cryptoTransfer(tinyBarsFromAccountToAlias(GENESIS, SECP_256K1_SOURCE_KEY, ONE_HBAR)), + uploadInitCode(FACTORY_CONTRACT), + contractCreate(FACTORY_CONTRACT)) + .when(withOpContext((spec, op) -> allRunFor( + spec, + ethereumCall(FACTORY_CONTRACT, DEPLOYMENT_SUCCESS_FUNCTION) + .type(EthTransactionType.EIP1559) + .signingWith(SECP_256K1_SOURCE_KEY) + .payingWith(RELAYER) + .nonce(0)))) + .then(getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(1L))); + } + + @Override + protected Logger getResultsLogger() { + return log; + } +} From 5e407d341b91bbb209b267e63af0af55d35d7582 Mon Sep 17 00:00:00 2001 From: nikolay Date: Sat, 20 Jan 2024 19:15:00 +0200 Subject: [PATCH 05/16] chore: add nonce suite to concurrent suites Signed-off-by: nikolay --- hedera-node/test-clients/src/itest/java/ConcurrentSuites.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/hedera-node/test-clients/src/itest/java/ConcurrentSuites.java b/hedera-node/test-clients/src/itest/java/ConcurrentSuites.java index b2d993f71d83..9b54f9df5601 100644 --- a/hedera-node/test-clients/src/itest/java/ConcurrentSuites.java +++ b/hedera-node/test-clients/src/itest/java/ConcurrentSuites.java @@ -72,6 +72,7 @@ import com.hedera.services.bdd.suites.crypto.HollowAccountFinalizationSuite; import com.hedera.services.bdd.suites.ethereum.EthereumSuite; import com.hedera.services.bdd.suites.ethereum.HelloWorldEthereumSuite; +import com.hedera.services.bdd.suites.ethereum.NonceSuite; import com.hedera.services.bdd.suites.file.FileAppendSuite; import com.hedera.services.bdd.suites.file.FileCreateSuite; import com.hedera.services.bdd.suites.file.PermissionSemanticsSpec; @@ -176,7 +177,8 @@ static Supplier[] all() { HelloWorldEthereumSuite::new, // network info VersionInfoSpec::new, - Evm46ValidationSuite::new + Evm46ValidationSuite::new, + NonceSuite::new }; } From 21896cdad8ef1d063c79413c3d94f8c9301c52ff Mon Sep 17 00:00:00 2001 From: nikolay Date: Sun, 21 Jan 2024 12:37:09 +0200 Subject: [PATCH 06/16] chore: add more tests Signed-off-by: nikolay --- .../bdd/suites/ethereum/NonceSuite.java | 108 +++++++++++++++++- 1 file changed, 106 insertions(+), 2 deletions(-) diff --git a/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/ethereum/NonceSuite.java b/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/ethereum/NonceSuite.java index 061127eaf7c5..8c69a7b563d6 100644 --- a/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/ethereum/NonceSuite.java +++ b/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/ethereum/NonceSuite.java @@ -38,7 +38,10 @@ import static com.hederahashgraph.api.proto.java.ResponseCodeEnum.INSUFFICIENT_GAS; import static com.hederahashgraph.api.proto.java.ResponseCodeEnum.INSUFFICIENT_PAYER_BALANCE; import static com.hederahashgraph.api.proto.java.ResponseCodeEnum.INSUFFICIENT_TX_FEE; +import static com.hederahashgraph.api.proto.java.ResponseCodeEnum.INVALID_ACCOUNT_ID; import static com.hederahashgraph.api.proto.java.ResponseCodeEnum.MAX_CHILD_RECORDS_EXCEEDED; +import static com.hederahashgraph.api.proto.java.ResponseCodeEnum.MAX_GAS_LIMIT_EXCEEDED; +import static com.hederahashgraph.api.proto.java.ResponseCodeEnum.NEGATIVE_ALLOWANCE_AMOUNT; import static com.hederahashgraph.api.proto.java.TokenType.FUNGIBLE_COMMON; import com.hedera.node.app.hapi.utils.ethereum.EthTxData.EthTransactionType; @@ -65,11 +68,13 @@ public class NonceSuite extends HapiSuite { private static final String RECEIVER = "receiver"; private static final String INTERNAL_CALLEE_CONTRACT = "InternalCallee"; private static final String INTERNAL_CALLER_CONTRACT = "InternalCaller"; + private static final String MANY_CHILDREN_CONTRACT = "ManyChildren"; private static final String FACTORY_CONTRACT = "FactoryContract"; private static final String EXTERNAL_FUNCTION = "externalFunction"; private static final String REVERT_WITH_REVERT_REASON_FUNCTION = "revertWithRevertReason"; private static final String TRANSFER_TO_FUNCTION = "transferTo"; private static final String DEPLOYMENT_SUCCESS_FUNCTION = "deploymentSuccess"; + private static final String CHECK_BALANCE_REPEATEDLY_FUNCTION = "checkBalanceRepeatedly"; public static void main(String... args) { new NonceSuite().runSuiteAsync(); @@ -83,6 +88,12 @@ public boolean canRunConcurrent() { @Override public List getSpecsInSuite() { return List.of( + // pre-checks + nonceNotUpdatedWhenSignerDoesExistPrecheckFailed(), + nonceNotUpdatedWhenPayerHasInsufficientBalancePrecheckFailed(), + nonceNotUpdatedWhenNegativeMaxGasAllowancePrecheckFailed(), + nonceNotUpdatedWhenInsufficientIntrinsicGasPrecheckFailed(), + nonceNotUpdatedWhenMaxGasPerSecPrecheckFailed(), // handler checks nonceNotUpdatedWhenIntrinsicGasHandlerCheckFailed(), nonceNotUpdatedWhenUserOfferedGasPriceAndAllowanceAreZeroHandlerCheckFailed(), @@ -106,6 +117,101 @@ public List getSpecsInSuite() { nonceUpdatedAfterSuccessfulInternalContractDeployment()); } + private HapiSpec nonceNotUpdatedWhenSignerDoesExistPrecheckFailed() { + return defaultHapiSpec("nonceNotUpdatedWhenSignerDoesExistPrecheckFailed") + .given( + newKeyNamed(SECP_256K1_SOURCE_KEY).shape(SECP_256K1_SHAPE), + cryptoCreate(RELAYER).balance(ONE_HUNDRED_HBARS), + uploadInitCode(INTERNAL_CALLEE_CONTRACT), + contractCreate(INTERNAL_CALLEE_CONTRACT)) + .when(ethereumCall(INTERNAL_CALLEE_CONTRACT, EXTERNAL_FUNCTION) + .type(EthTransactionType.EIP1559) + .signingWith(SECP_256K1_SOURCE_KEY) + .payingWith(RELAYER) + .nonce(0) + .gasLimit(ENOUGH_GAS_LIMIT) + .hasPrecheck(INVALID_ACCOUNT_ID)) + .then(getAliasedAccountInfo(SECP_256K1_SOURCE_KEY).hasCostAnswerPrecheck(INVALID_ACCOUNT_ID)); + } + + private HapiSpec nonceNotUpdatedWhenPayerHasInsufficientBalancePrecheckFailed() { + return defaultHapiSpec("nonceNotUpdatedWhenPayerHasInsufficientBalancePrecheckFailed") + .given( + newKeyNamed(SECP_256K1_SOURCE_KEY).shape(SECP_256K1_SHAPE), + cryptoCreate(RELAYER).balance(1L), + cryptoTransfer(tinyBarsFromAccountToAlias(GENESIS, SECP_256K1_SOURCE_KEY, ONE_HBAR)), + uploadInitCode(INTERNAL_CALLEE_CONTRACT), + contractCreate(INTERNAL_CALLEE_CONTRACT)) + .when(ethereumCall(INTERNAL_CALLEE_CONTRACT, EXTERNAL_FUNCTION) + .type(EthTransactionType.EIP1559) + .signingWith(SECP_256K1_SOURCE_KEY) + .payingWith(RELAYER) + .nonce(5644L) + .gasLimit(ENOUGH_GAS_LIMIT) + .hasPrecheck(INSUFFICIENT_PAYER_BALANCE)) + .then(getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(0L))); + } + + private HapiSpec nonceNotUpdatedWhenNegativeMaxGasAllowancePrecheckFailed() { + return defaultHapiSpec("nonceNotUpdatedWhenNegativeMaxGasAllowancePrecheckFailed") + .given( + newKeyNamed(SECP_256K1_SOURCE_KEY).shape(SECP_256K1_SHAPE), + cryptoCreate(RELAYER).balance(ONE_HUNDRED_HBARS), + cryptoTransfer(tinyBarsFromAccountToAlias(GENESIS, SECP_256K1_SOURCE_KEY, ONE_HBAR)), + uploadInitCode(INTERNAL_CALLEE_CONTRACT), + contractCreate(INTERNAL_CALLEE_CONTRACT)) + .when(ethereumCall(INTERNAL_CALLEE_CONTRACT, EXTERNAL_FUNCTION) + .type(EthTransactionType.EIP1559) + .signingWith(SECP_256K1_SOURCE_KEY) + .payingWith(RELAYER) + .nonce(0) + .maxGasAllowance(-1L) + .gasLimit(ENOUGH_GAS_LIMIT) + .hasPrecheck(NEGATIVE_ALLOWANCE_AMOUNT)) + .then(getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(0L))); + } + + private HapiSpec nonceNotUpdatedWhenInsufficientIntrinsicGasPrecheckFailed() { + return defaultHapiSpec("nonceNotUpdatedWhenInsufficientIntrinsicGasPrecheckFailed") + .given( + newKeyNamed(SECP_256K1_SOURCE_KEY).shape(SECP_256K1_SHAPE), + cryptoCreate(RELAYER).balance(ONE_HUNDRED_HBARS), + cryptoTransfer(tinyBarsFromAccountToAlias(GENESIS, SECP_256K1_SOURCE_KEY, ONE_HBAR)), + uploadInitCode(INTERNAL_CALLEE_CONTRACT), + contractCreate(INTERNAL_CALLEE_CONTRACT)) + .when(ethereumCall(INTERNAL_CALLEE_CONTRACT, EXTERNAL_FUNCTION) + .type(EthTransactionType.EIP1559) + .signingWith(SECP_256K1_SOURCE_KEY) + .payingWith(RELAYER) + .nonce(0) + .gasLimit(0L) + .hasPrecheck(INSUFFICIENT_GAS)) + .then(getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(0L))); + } + + private HapiSpec nonceNotUpdatedWhenMaxGasPerSecPrecheckFailed() { + final var illegalMaxGasPerSec = HapiSpecSetup.getDefaultNodeProps().getInteger("contracts.maxGasPerSec") + 1; + return defaultHapiSpec("nonceNotUpdatedWhenMaxGasPerSecPrecheckFailed") + .given( + newKeyNamed(SECP_256K1_SOURCE_KEY).shape(SECP_256K1_SHAPE), + cryptoCreate(RELAYER).balance(ONE_HUNDRED_HBARS), + cryptoTransfer(tinyBarsFromAccountToAlias(GENESIS, SECP_256K1_SOURCE_KEY, ONE_HBAR)), + uploadInitCode(INTERNAL_CALLEE_CONTRACT), + contractCreate(INTERNAL_CALLEE_CONTRACT)) + .when(ethereumCall(INTERNAL_CALLEE_CONTRACT, EXTERNAL_FUNCTION) + .type(EthTransactionType.EIP1559) + .signingWith(SECP_256K1_SOURCE_KEY) + .payingWith(RELAYER) + .nonce(0) + .gasLimit(illegalMaxGasPerSec) + .hasPrecheck(MAX_GAS_LIMIT_EXCEEDED)) + .then(getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(0L))); + } + private HapiSpec nonceNotUpdatedWhenIntrinsicGasHandlerCheckFailed() { return defaultHapiSpec("nonceNotUpdatedWhenIntrinsicGasHandlerCheckFailed") .given( @@ -380,8 +486,6 @@ private HapiSpec nonceUpdatedAfterEvmReversionDueSendingValueToHederaPrecompile0 } private HapiSpec nonceUpdatedAfterEvmReversionDueMaxChildRecordsExceeded() { - final String MANY_CHILDREN_CONTRACT = "ManyChildren"; - final String CHECK_BALANCE_REPEATEDLY_FUNCTION = "checkBalanceRepeatedly"; final String TOKEN_TREASURY = "treasury"; final String FUNGIBLE_TOKEN = "fungibleToken"; final AtomicReference treasuryMirrorAddr = new AtomicReference<>(); From c0a063c171551a1661d5a1ce4fd648020c6c6f8d Mon Sep 17 00:00:00 2001 From: nikolay Date: Thu, 25 Jan 2024 16:04:26 +0200 Subject: [PATCH 07/16] chore: edit record file Signed-off-by: nikolay --- .../TransactionProcessingResult.java | 9 + .../service/mono/state/serdes/IoUtils.java | 11 ++ .../mono/state/submerkle/EvmFnResult.java | 46 ++++- .../precompile/utils/PrecompileUtils.java | 3 +- .../contract/ContractCallTransitionLogic.java | 1 + .../ethereum/EthereumTransitionLogic.java | 1 + .../mono/state/submerkle/EvmFnResultTest.java | 37 ++-- .../test/utils/SeededPropertySource.java | 6 +- .../com/hedera/test/utils/SerdeUtils.java | 3 +- .../assertions/ContractFnResultAsserts.java | 9 + .../bdd/suites/ethereum/NonceSuite.java | 184 +++++++++++++----- 11 files changed, 240 insertions(+), 70 deletions(-) diff --git a/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/contracts/execution/TransactionProcessingResult.java b/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/contracts/execution/TransactionProcessingResult.java index 29433f27ff82..126a00f8d28a 100644 --- a/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/contracts/execution/TransactionProcessingResult.java +++ b/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/contracts/execution/TransactionProcessingResult.java @@ -43,6 +43,7 @@ public class TransactionProcessingResult extends HederaEvmTransactionProcessingR private List createdContracts = Collections.emptyList(); private Map contractNonces = new TreeMap<>(); + private Long signerNonce; public static TransactionProcessingResult failed( final long gasUsed, @@ -143,6 +144,14 @@ public void setActions(final List actions) { this.actions = actions; } + public Long getSignerNonce() { + return signerNonce; + } + + public void setSignerNonce(Long signerNonce) { + this.signerNonce = signerNonce; + } + /** * Converts the {@link TransactionProcessingResult} into {@link ContractFunctionResult} gRPC * model. diff --git a/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/state/serdes/IoUtils.java b/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/state/serdes/IoUtils.java index 2815798fdfe3..970434444471 100644 --- a/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/state/serdes/IoUtils.java +++ b/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/state/serdes/IoUtils.java @@ -19,6 +19,7 @@ import com.hedera.node.app.service.mono.legacy.core.jproto.JKey; import com.hedera.node.app.service.mono.legacy.core.jproto.JKeySerializer; import com.swirlds.common.io.SelfSerializable; +import com.swirlds.common.io.streams.AugmentedDataInputStream; import com.swirlds.common.io.streams.SerializableDataInputStream; import com.swirlds.common.io.streams.SerializableDataOutputStream; import edu.umd.cs.findbugs.annotations.Nullable; @@ -41,6 +42,16 @@ public static void writeNullableString(@Nullable final String msg, final Seriali writeNullable(msg, out, (msgVal, outVal) -> outVal.writeNormalisedString(msgVal)); } + @Nullable + public static Long readNullableLong(final SerializableDataInputStream in) throws IOException { + return readNullable(in, AugmentedDataInputStream::readLong); + } + + public static void writeNullableLong(@Nullable final Long num, final SerializableDataOutputStream out) + throws IOException { + writeNullable(num, out, (numVal, outVal) -> outVal.writeLong(numVal)); + } + @Nullable public static T readNullable(final SerializableDataInputStream in, final IoReadingFunction reader) throws IOException { diff --git a/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/state/submerkle/EvmFnResult.java b/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/state/submerkle/EvmFnResult.java index 5778ac773179..800c8b840139 100644 --- a/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/state/submerkle/EvmFnResult.java +++ b/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/state/submerkle/EvmFnResult.java @@ -17,8 +17,10 @@ package com.hedera.node.app.service.mono.state.submerkle; import static com.hedera.node.app.service.evm.accounts.HederaEvmContractAliases.isMirror; +import static com.hedera.node.app.service.mono.state.serdes.IoUtils.readNullableLong; import static com.hedera.node.app.service.mono.state.serdes.IoUtils.readNullableSerializable; import static com.hedera.node.app.service.mono.state.serdes.IoUtils.readNullableString; +import static com.hedera.node.app.service.mono.state.serdes.IoUtils.writeNullableLong; import static com.hedera.node.app.service.mono.state.serdes.IoUtils.writeNullableSerializable; import static com.hedera.node.app.service.mono.state.serdes.IoUtils.writeNullableString; import static com.swirlds.common.utility.CommonUtils.hex; @@ -27,6 +29,7 @@ import com.google.common.base.MoreObjects; import com.google.protobuf.ByteString; import com.google.protobuf.BytesValue; +import com.google.protobuf.Int64Value; import com.hedera.node.app.hapi.utils.ethereum.EthTxData; import com.hedera.node.app.service.mono.contracts.execution.TransactionProcessingResult; import com.hederahashgraph.api.proto.java.ContractFunctionResult; @@ -54,7 +57,8 @@ public class EvmFnResult implements SelfSerializable { static final int RELEASE_0260_VERSION = 5; static final int RELEASE_0290_VERSION = 6; static final int RELEASE_0400_VERSION = 7; - static final int CURRENT_VERSION = RELEASE_0400_VERSION; + static final int RELEASE_0470_VERSION = 7; + static final int CURRENT_VERSION = RELEASE_0470_VERSION; static final long RUNTIME_CONSTRUCTABLE_ID = 0x2055c5c03ff84eb4L; @@ -79,6 +83,7 @@ public class EvmFnResult implements SelfSerializable { private long amount; private byte[] functionParameters = EMPTY; private EntityId senderId; + private Long signerNonce; public EvmFnResult() { // RuntimeConstructable @@ -105,12 +110,13 @@ private static EvmFnResult from(final TransactionProcessingResult result, final recipient, serializableIdsFrom(result.getCreatedContracts()), serializableContractNoncesFrom(result.getContractNonces()), - evmAddress); + evmAddress, + result.getSignerNonce()); } else { final var error = result.getRevertReason() .map(Object::toString) .orElse(result.getHaltReason().map(Object::toString).orElse(null)); - return failure(result.getGasUsed(), error); + return failure(result.getGasUsed(), error, result.getSignerNonce()); } } @@ -127,7 +133,8 @@ public EvmFnResult( final long gas, final long amount, final byte[] functionParameters, - final EntityId senderId) { + final EntityId senderId, + final Long signerNonce) { this.contractId = contractId; this.result = result; this.error = error; @@ -141,6 +148,7 @@ public EvmFnResult( this.amount = amount; this.functionParameters = functionParameters; this.senderId = senderId; + this.signerNonce = signerNonce; } /* --- SelfSerializable --- */ @@ -197,6 +205,9 @@ public void deserialize(final SerializableDataInputStream in, final int version) if (version >= RELEASE_0400_VERSION) { contractNonces = in.readSerializableList(MAX_CREATED_CONTRACT_NONCES, true, ContractNonceInfo::new); } + if (version >= RELEASE_0470_VERSION) { + signerNonce = readNullableLong(in); + } } @Override @@ -214,6 +225,7 @@ public void serialize(final SerializableDataOutputStream out) throws IOException out.writeByteArray(functionParameters); writeNullableSerializable(senderId, out); out.writeSerializableList(contractNonces, true, true); + writeNullableLong(signerNonce, out); } /* --- Object --- */ @@ -238,7 +250,8 @@ public boolean equals(final Object o) { && gas == that.gas && amount == that.amount && Arrays.equals(functionParameters, that.functionParameters) - && Objects.equals(senderId, that.senderId); + && Objects.equals(senderId, that.senderId) + && Objects.equals(signerNonce, that.signerNonce); } @Override @@ -265,6 +278,7 @@ public String toString() { .add("amount", amount) .add("functionParameters", hex(functionParameters)) .add("senderId", senderId) + .add("signerNonce", signerNonce) .toString(); } @@ -325,6 +339,10 @@ public EntityId getSenderId() { return senderId; } + public Long getSignerNonce() { + return signerNonce; + } + public void setEvmAddress(final byte[] evmAddress) { this.evmAddress = evmAddress; } @@ -345,6 +363,10 @@ public void setSenderId(final EntityId senderId) { this.senderId = senderId; } + public void setSignerNonce(Long signerNonce) { + this.signerNonce = signerNonce; + } + public void setContractNonces(List contractNonces) { this.contractNonces = contractNonces; } @@ -391,6 +413,9 @@ public ContractFunctionResult toGrpc() { if (senderId != null) { grpc.setSenderId(senderId.toGrpcAccountId()); } + if (signerNonce != null) { + grpc.setSignerNonce(Int64Value.newBuilder().setValue(signerNonce).build()); + } return grpc.build(); } @@ -433,7 +458,8 @@ private static EvmFnResult success( final Address recipient, final List createdContractIds, final List contractNonces, - final byte[] evmAddress) { + final byte[] evmAddress, + final Long signerNonce) { return new EvmFnResult( isMirror(recipient.toArray()) ? EntityId.fromAddress(recipient) : null, output.toArrayUnsafe(), @@ -447,10 +473,11 @@ private static EvmFnResult success( 0L, 0L, EMPTY, - null); + null, + signerNonce); } - private static EvmFnResult failure(final long gasUsed, final String error) { + private static EvmFnResult failure(final long gasUsed, final String error, final Long signerNonce) { return new EvmFnResult( null, EMPTY, @@ -464,6 +491,7 @@ private static EvmFnResult failure(final long gasUsed, final String error) { 0L, 0L, EMPTY, - null); + null, + signerNonce); } } diff --git a/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/store/contracts/precompile/utils/PrecompileUtils.java b/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/store/contracts/precompile/utils/PrecompileUtils.java index e3dca592d6f3..163d510df3dc 100644 --- a/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/store/contracts/precompile/utils/PrecompileUtils.java +++ b/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/store/contracts/precompile/utils/PrecompileUtils.java @@ -57,7 +57,8 @@ public static void addContractCallResultToRecord( traceabilityOn ? messageFrame.getRemainingGas() : 0L, traceabilityOn ? messageFrame.getValue().toLong() : 0L, traceabilityOn ? messageFrame.getInputData().toArrayUnsafe() : EvmFnResult.EMPTY, - EntityId.fromAddress(senderAddress)); + EntityId.fromAddress(senderAddress), + null); childRecord.setContractCallResult(evmFnResult); } } diff --git a/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/txns/contract/ContractCallTransitionLogic.java b/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/txns/contract/ContractCallTransitionLogic.java index d2a61f164008..f524a25301d7 100644 --- a/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/txns/contract/ContractCallTransitionLogic.java +++ b/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/txns/contract/ContractCallTransitionLogic.java @@ -168,6 +168,7 @@ public void doStateTransitionOperation( offeredGasPrice, accountStore.loadAccount(relayerId), maxGasAllowanceInTinybars); + result.setSignerNonce(worldState.get(senderId.asEvmAddress()).getNonce()); } /* --- Externalise result --- */ diff --git a/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/txns/ethereum/EthereumTransitionLogic.java b/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/txns/ethereum/EthereumTransitionLogic.java index 5c2ac29b43e8..b966ca5a8d98 100644 --- a/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/txns/ethereum/EthereumTransitionLogic.java +++ b/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/txns/ethereum/EthereumTransitionLogic.java @@ -134,6 +134,7 @@ public void doStateTransition() { } catch (InvalidTransactionException e) { var result = TransactionProcessingResult.failed( 0, 0, 0, Optional.of(e.messageBytes()), Optional.empty(), Collections.emptyMap(), List.of()); + result.setSignerNonce((Long) accountsLedger.get(callerNum.toGrpcAccountId(), ETHEREUM_NONCE)); recordService.externaliseEvmCallTransaction(result); throw e; } finally { diff --git a/hedera-node/hedera-mono-service/src/test/java/com/hedera/node/app/service/mono/state/submerkle/EvmFnResultTest.java b/hedera-node/hedera-mono-service/src/test/java/com/hedera/node/app/service/mono/state/submerkle/EvmFnResultTest.java index 705112a75aa9..2e2b75e90466 100644 --- a/hedera-node/hedera-mono-service/src/test/java/com/hedera/node/app/service/mono/state/submerkle/EvmFnResultTest.java +++ b/hedera-node/hedera-mono-service/src/test/java/com/hedera/node/app/service/mono/state/submerkle/EvmFnResultTest.java @@ -107,7 +107,8 @@ void setup() { gas, amount, functionParameters, - senderId); + senderId, + null); } @Test @@ -143,6 +144,7 @@ void besuParsingWorksForRevertFailure() { 0L, 0L, new byte[0], + null, null); final var input = TransactionProcessingResult.failed( @@ -174,6 +176,7 @@ void besuParsingWorksForCallSuccess() { 0L, 0L, new byte[0], + null, null); final var input = TransactionProcessingResult.successful( @@ -216,6 +219,7 @@ void besuParsingWorksForCreateSuccess() { 0L, 0L, new byte[0], + null, null); final var input = TransactionProcessingResult.successful( @@ -251,7 +255,8 @@ void objectContractWorks() { gas, amount, functionParameters, - senderId); + senderId, + null); final var three = new EvmFnResult( contractId, result, @@ -265,7 +270,8 @@ void objectContractWorks() { gas, amount, functionParameters, - senderId); + senderId, + null); final var four = new EvmFnResult( contractId, result, @@ -279,7 +285,8 @@ void objectContractWorks() { gas, amount, functionParameters, - senderId); + senderId, + null); final var five = new EvmFnResult( contractId, result, @@ -293,7 +300,8 @@ void objectContractWorks() { gas, amount, functionParameters, - senderId); + senderId, + null); final var six = new EvmFnResult( contractId, result, @@ -307,7 +315,8 @@ void objectContractWorks() { gas, amount, functionParameters, - senderId); + senderId, + null); final var seven = new EvmFnResult( contractId, result, @@ -321,7 +330,8 @@ void objectContractWorks() { gas, amount, functionParameters, - senderId); + senderId, + null); final var nine = new EvmFnResult( contractId, result, @@ -335,7 +345,8 @@ void objectContractWorks() { gas, amount, "randomParameters".getBytes(), - senderId); + senderId, + null); final var ten = new EvmFnResult( contractId, result, @@ -349,6 +360,7 @@ void objectContractWorks() { gas, amount, "randomParameters".getBytes(), + null, null); assertNotEquals(null, one); @@ -382,7 +394,8 @@ void beanWorks() { subject.getGas(), subject.getAmount(), subject.getFunctionParameters(), - subject.getSenderId()), + subject.getSenderId(), + subject.getSignerNonce()), subject); } @@ -449,7 +462,8 @@ void grpcFactoryWorksWithEverythingSet() { gas, amount, functionParameters, - senderId); + senderId, + null); final var grpc = ContractFunctionResult.newBuilder() .setGasUsed(gasUsed) @@ -489,7 +503,8 @@ void grpcFactoryWorksWithSomeFieldsMissing() { gas, 0L, functionParameters, - senderId); + senderId, + null); final var grpc = ContractFunctionResult.newBuilder() .setGasUsed(gasUsed) diff --git a/hedera-node/hedera-mono-service/src/test/java/com/hedera/test/utils/SeededPropertySource.java b/hedera-node/hedera-mono-service/src/test/java/com/hedera/test/utils/SeededPropertySource.java index 59438f0bca9b..b135f2f27314 100644 --- a/hedera-node/hedera-mono-service/src/test/java/com/hedera/test/utils/SeededPropertySource.java +++ b/hedera-node/hedera-mono-service/src/test/java/com/hedera/test/utils/SeededPropertySource.java @@ -128,7 +128,8 @@ public EvmFnResult nextEvmResult() { nextUnsignedLong(), nextUnsignedLong(), nextBytes(128), - nextEntityId()); + nextEntityId(), + nextLong()); evmResult.setContractNonces(nextContractNonces(2)); return evmResult; } @@ -800,7 +801,8 @@ public EvmFnResult nextEvmFnResult() { nextUnsignedLong(), nextUnsignedLong(), nextBytes(64), - null); + null, + nextLong()); } public List nextEvmLogs(final int n) { diff --git a/hedera-node/hedera-mono-service/src/testFixtures/java/com/hedera/test/utils/SerdeUtils.java b/hedera-node/hedera-mono-service/src/testFixtures/java/com/hedera/test/utils/SerdeUtils.java index a915159c3036..466139c11b62 100644 --- a/hedera-node/hedera-mono-service/src/testFixtures/java/com/hedera/test/utils/SerdeUtils.java +++ b/hedera-node/hedera-mono-service/src/testFixtures/java/com/hedera/test/utils/SerdeUtils.java @@ -97,7 +97,8 @@ public static EvmFnResult fromGrpc(final ContractFunctionResult that) { that.getFunctionParameters().isEmpty() ? EvmFnResult.EMPTY : that.getFunctionParameters().toByteArray(), - that.hasSenderId() ? EntityId.fromGrpcAccountId(that.getSenderId()) : null); + that.hasSenderId() ? EntityId.fromGrpcAccountId(that.getSenderId()) : null, + that.hasSignerNonce() ? that.getSignerNonce().getValue() : null); } public static EvmLog fromGrpc(ContractLoginfo grpc) { diff --git a/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/spec/assertions/ContractFnResultAsserts.java b/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/spec/assertions/ContractFnResultAsserts.java index 6d41cd541a33..3d1825c35f1a 100644 --- a/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/spec/assertions/ContractFnResultAsserts.java +++ b/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/spec/assertions/ContractFnResultAsserts.java @@ -341,4 +341,13 @@ public ContractFnResultAsserts contractWithNonce(final ContractID contractID, fi }); return this; } + + public ContractFnResultAsserts signerNonce(final Long expectedNonce) { + registerProvider((spec, o) -> { + ContractFunctionResult result = (ContractFunctionResult) o; + assertEquals( + expectedNonce.longValue(), result.getSignerNonce().getValue(), "Wrong signer nonce expectation"); + }); + return this; + } } diff --git a/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/ethereum/NonceSuite.java b/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/ethereum/NonceSuite.java index 8c69a7b563d6..17c9faa40d4e 100644 --- a/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/ethereum/NonceSuite.java +++ b/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/ethereum/NonceSuite.java @@ -19,8 +19,11 @@ import static com.hedera.services.bdd.spec.HapiPropertySource.asHexedSolidityAddress; import static com.hedera.services.bdd.spec.HapiSpec.defaultHapiSpec; import static com.hedera.services.bdd.spec.assertions.AccountInfoAsserts.accountWith; +import static com.hedera.services.bdd.spec.assertions.ContractFnResultAsserts.resultWith; +import static com.hedera.services.bdd.spec.assertions.TransactionRecordAsserts.recordWith; import static com.hedera.services.bdd.spec.queries.QueryVerbs.getAccountInfo; import static com.hedera.services.bdd.spec.queries.QueryVerbs.getAliasedAccountInfo; +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.contractCreate; import static com.hedera.services.bdd.spec.transactions.TxnVerbs.cryptoCreate; @@ -75,6 +78,7 @@ public class NonceSuite extends HapiSuite { private static final String TRANSFER_TO_FUNCTION = "transferTo"; private static final String DEPLOYMENT_SUCCESS_FUNCTION = "deploymentSuccess"; private static final String CHECK_BALANCE_REPEATEDLY_FUNCTION = "checkBalanceRepeatedly"; + private static final String TX = "tx"; public static void main(String... args) { new NonceSuite().runSuiteAsync(); @@ -226,9 +230,15 @@ private HapiSpec nonceNotUpdatedWhenIntrinsicGasHandlerCheckFailed() { .payingWith(RELAYER) .nonce(0) .gasLimit(21_000L) - .hasKnownStatus(INSUFFICIENT_GAS)) - .then(getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) - .has(accountWith().nonce(0L))); + .hasKnownStatus(INSUFFICIENT_GAS) + .via(TX)) + .then( + getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(0L)), + getTxnRecord(TX) + .hasPriority(recordWith() + .status(INSUFFICIENT_GAS) + .contractCallResult(resultWith().signerNonce(0L)))); } private HapiSpec nonceNotUpdatedWhenUserOfferedGasPriceAndAllowanceAreZeroHandlerCheckFailed() { @@ -247,9 +257,15 @@ private HapiSpec nonceNotUpdatedWhenUserOfferedGasPriceAndAllowanceAreZeroHandle .gasLimit(ENOUGH_GAS_LIMIT) .maxFeePerGas(0L) .maxGasAllowance(0L) - .hasKnownStatus(INSUFFICIENT_TX_FEE)) - .then(getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) - .has(accountWith().nonce(0L))); + .hasKnownStatus(INSUFFICIENT_TX_FEE) + .via(TX)) + .then( + getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(0L)), + getTxnRecord(TX) + .hasPriority(recordWith() + .status(INSUFFICIENT_TX_FEE) + .contractCallResult(resultWith().signerNonce(0L)))); } private HapiSpec @@ -269,9 +285,15 @@ private HapiSpec nonceNotUpdatedWhenUserOfferedGasPriceAndAllowanceAreZeroHandle .nonce(0) .gasLimit(ENOUGH_GAS_LIMIT) .maxFeePerGas(LOW_GAS_PRICE) - .hasKnownStatus(INSUFFICIENT_PAYER_BALANCE)) - .then(getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) - .has(accountWith().nonce(0L))); + .hasKnownStatus(INSUFFICIENT_PAYER_BALANCE) + .via(TX)) + .then( + getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(0L)), + getTxnRecord(TX) + .hasPriority(recordWith() + .status(INSUFFICIENT_PAYER_BALANCE) + .contractCallResult(resultWith().signerNonce(0L)))); } private HapiSpec @@ -292,9 +314,15 @@ private HapiSpec nonceNotUpdatedWhenUserOfferedGasPriceAndAllowanceAreZeroHandle .gasLimit(ENOUGH_GAS_LIMIT) .maxFeePerGas(LOW_GAS_PRICE) .maxGasAllowance(0L) - .hasKnownStatus(INSUFFICIENT_TX_FEE)) - .then(getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) - .has(accountWith().nonce(0L))); + .hasKnownStatus(INSUFFICIENT_TX_FEE) + .via(TX)) + .then( + getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(0L)), + getTxnRecord(TX) + .hasPriority(recordWith() + .status(INSUFFICIENT_TX_FEE) + .contractCallResult(resultWith().signerNonce(0L)))); } private HapiSpec @@ -314,9 +342,15 @@ private HapiSpec nonceNotUpdatedWhenUserOfferedGasPriceAndAllowanceAreZeroHandle .nonce(0) .gasLimit(ENOUGH_GAS_LIMIT) .maxFeePerGas(ENOUGH_GAS_PRICE) - .hasKnownStatus(INSUFFICIENT_PAYER_BALANCE)) - .then(getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) - .has(accountWith().nonce(0L))); + .hasKnownStatus(INSUFFICIENT_PAYER_BALANCE) + .via(TX)) + .then( + getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(0L)), + getTxnRecord(TX) + .hasPriority(recordWith() + .status(INSUFFICIENT_PAYER_BALANCE) + .contractCallResult(resultWith().signerNonce(0L)))); } private HapiSpec nonceNotUpdatedWhenSenderDoesNotHaveEnoughBalanceHandlerCheckFailed() { @@ -335,9 +369,15 @@ private HapiSpec nonceNotUpdatedWhenSenderDoesNotHaveEnoughBalanceHandlerCheckFa .gasLimit(ENOUGH_GAS_LIMIT) .maxFeePerGas(0L) .sending(5L) - .hasKnownStatus(INSUFFICIENT_PAYER_BALANCE)) - .then(getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) - .has(accountWith().nonce(0L))); + .hasKnownStatus(INSUFFICIENT_PAYER_BALANCE) + .via(TX)) + .then( + getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(0L)), + getTxnRecord(TX) + .hasPriority(recordWith() + .status(INSUFFICIENT_PAYER_BALANCE) + .contractCallResult(resultWith().signerNonce(0L)))); } private HapiSpec nonceNotUpdatedForNonEthereumTransaction() { @@ -349,7 +389,8 @@ private HapiSpec nonceNotUpdatedForNonEthereumTransaction() { .when(contractCall(INTERNAL_CALLEE_CONTRACT, EXTERNAL_FUNCTION) .gas(ENOUGH_GAS_LIMIT) .payingWith(RELAYER) - .signingWith(RELAYER)) + .signingWith(RELAYER) + .via(TX)) .then(getAccountInfo(RELAYER).has(accountWith().nonce(0L))); } @@ -366,9 +407,14 @@ private HapiSpec nonceUpdatedAfterSuccessfulInternalCall() { .signingWith(SECP_256K1_SOURCE_KEY) .payingWith(RELAYER) .nonce(0) - .gasLimit(ENOUGH_GAS_LIMIT)) - .then(getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) - .has(accountWith().nonce(1L))); + .gasLimit(ENOUGH_GAS_LIMIT) + .via(TX)) + .then( + getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(1L)), + getTxnRecord(TX) + .hasPriority(recordWith() + .contractCallResult(resultWith().signerNonce(1L)))); } private HapiSpec nonceUpdatedAfterEvmReversionDueContractLogic() { @@ -385,9 +431,15 @@ private HapiSpec nonceUpdatedAfterEvmReversionDueContractLogic() { .payingWith(RELAYER) .nonce(0) .gasLimit(ENOUGH_GAS_LIMIT) - .hasKnownStatus(CONTRACT_REVERT_EXECUTED)) - .then(getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) - .has(accountWith().nonce(1L))); + .hasKnownStatus(CONTRACT_REVERT_EXECUTED) + .via(TX)) + .then( + getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(1L)), + getTxnRecord(TX) + .hasPriority(recordWith() + .status(CONTRACT_REVERT_EXECUTED) + .contractCallResult(resultWith().signerNonce(1L)))); } private HapiSpec nonceUpdatedAfterEvmReversionDueInsufficientGas() { @@ -404,9 +456,15 @@ private HapiSpec nonceUpdatedAfterEvmReversionDueInsufficientGas() { .payingWith(RELAYER) .nonce(0) .gasLimit(21_064L) - .hasKnownStatus(INSUFFICIENT_GAS)) - .then(getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) - .has(accountWith().nonce(1L))); + .hasKnownStatus(INSUFFICIENT_GAS) + .via(TX)) + .then( + getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(1L)), + getTxnRecord(TX) + .hasPriority(recordWith() + .status(INSUFFICIENT_GAS) + .contractCallResult(resultWith().signerNonce(1L)))); } private HapiSpec nonceUpdatedAfterEvmReversionDueInsufficientTransferAmount() { @@ -430,9 +488,15 @@ private HapiSpec nonceUpdatedAfterEvmReversionDueInsufficientTransferAmount() { .payingWith(RELAYER) .nonce(0) .gasLimit(ENOUGH_GAS_LIMIT) - .hasKnownStatus(CONTRACT_REVERT_EXECUTED)))) - .then(getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) - .has(accountWith().nonce(1L))); + .hasKnownStatus(CONTRACT_REVERT_EXECUTED) + .via(TX)))) + .then( + getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(1L)), + getTxnRecord(TX) + .hasPriority(recordWith() + .status(CONTRACT_REVERT_EXECUTED) + .contractCallResult(resultWith().signerNonce(1L)))); } private HapiSpec nonceUpdatedAfterEvmReversionDueSendingValueToEthereumPrecompile0x2() { @@ -455,9 +519,15 @@ private HapiSpec nonceUpdatedAfterEvmReversionDueSendingValueToEthereumPrecompil .payingWith(RELAYER) .nonce(0) .gasLimit(ENOUGH_GAS_LIMIT) - .hasKnownStatus(CONTRACT_REVERT_EXECUTED)))) - .then(getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) - .has(accountWith().nonce(1L))); + .hasKnownStatus(CONTRACT_REVERT_EXECUTED) + .via(TX)))) + .then( + getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(1L)), + getTxnRecord(TX) + .hasPriority(recordWith() + .status(CONTRACT_REVERT_EXECUTED) + .contractCallResult(resultWith().signerNonce(1L)))); } private HapiSpec nonceUpdatedAfterEvmReversionDueSendingValueToHederaPrecompile0x167() { @@ -480,9 +550,15 @@ private HapiSpec nonceUpdatedAfterEvmReversionDueSendingValueToHederaPrecompile0 .payingWith(RELAYER) .nonce(0) .gasLimit(ENOUGH_GAS_LIMIT) - .hasKnownStatus(CONTRACT_REVERT_EXECUTED)))) - .then(getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) - .has(accountWith().nonce(1L))); + .hasKnownStatus(CONTRACT_REVERT_EXECUTED) + .via(TX)))) + .then( + getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(1L)), + getTxnRecord(TX) + .hasPriority(recordWith() + .status(CONTRACT_REVERT_EXECUTED) + .contractCallResult(resultWith().signerNonce(1L)))); } private HapiSpec nonceUpdatedAfterEvmReversionDueMaxChildRecordsExceeded() { @@ -520,9 +596,15 @@ private HapiSpec nonceUpdatedAfterEvmReversionDueMaxChildRecordsExceeded() { .payingWith(RELAYER) .nonce(0) .gasLimit(ENOUGH_GAS_LIMIT) - .hasKnownStatus(MAX_CHILD_RECORDS_EXCEEDED)))) - .then(getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) - .has(accountWith().nonce(1L))); + .hasKnownStatus(MAX_CHILD_RECORDS_EXCEEDED) + .via(TX)))) + .then( + getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(1L)), + getTxnRecord(TX) + .hasPriority(recordWith() + .status(MAX_CHILD_RECORDS_EXCEEDED) + .contractCallResult(resultWith().signerNonce(1L)))); } private HapiSpec nonceUpdatedAfterSuccessfulInternalTransfer() { @@ -545,9 +627,14 @@ private HapiSpec nonceUpdatedAfterSuccessfulInternalTransfer() { .signingWith(SECP_256K1_SOURCE_KEY) .payingWith(RELAYER) .nonce(0) - .gasLimit(ENOUGH_GAS_LIMIT)))) - .then(getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) - .has(accountWith().nonce(1L))); + .gasLimit(ENOUGH_GAS_LIMIT) + .via(TX)))) + .then( + getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(1L)), + getTxnRecord(TX) + .hasPriority(recordWith() + .contractCallResult(resultWith().signerNonce(1L)))); } private HapiSpec nonceUpdatedAfterSuccessfulInternalContractDeployment() { @@ -565,9 +652,14 @@ private HapiSpec nonceUpdatedAfterSuccessfulInternalContractDeployment() { .type(EthTransactionType.EIP1559) .signingWith(SECP_256K1_SOURCE_KEY) .payingWith(RELAYER) - .nonce(0)))) - .then(getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) - .has(accountWith().nonce(1L))); + .nonce(0) + .via(TX)))) + .then( + getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(1L)), + getTxnRecord(TX) + .hasPriority(recordWith() + .contractCallResult(resultWith().signerNonce(1L)))); } @Override From 3affb1fc71aae710a44935277a2b5d0ba7b32e1a Mon Sep 17 00:00:00 2001 From: nikolay Date: Fri, 26 Jan 2024 11:41:07 +0200 Subject: [PATCH 08/16] chore: fix unit tests Signed-off-by: nikolay --- .../node/app/service/mono/state/submerkle/EvmFnResult.java | 2 +- .../app/service/mono/state/submerkle/EvmFnResultTest.java | 6 +++--- .../mono/state/submerkle/ExpirableTxnRecordTest.java | 4 ++-- .../java/com/hedera/test/utils/SeededPropertySource.java | 4 ++-- 4 files changed, 8 insertions(+), 8 deletions(-) diff --git a/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/state/submerkle/EvmFnResult.java b/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/state/submerkle/EvmFnResult.java index 800c8b840139..e67727fcca05 100644 --- a/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/state/submerkle/EvmFnResult.java +++ b/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/state/submerkle/EvmFnResult.java @@ -57,7 +57,7 @@ public class EvmFnResult implements SelfSerializable { static final int RELEASE_0260_VERSION = 5; static final int RELEASE_0290_VERSION = 6; static final int RELEASE_0400_VERSION = 7; - static final int RELEASE_0470_VERSION = 7; + static final int RELEASE_0470_VERSION = 8; static final int CURRENT_VERSION = RELEASE_0470_VERSION; static final long RUNTIME_CONSTRUCTABLE_ID = 0x2055c5c03ff84eb4L; diff --git a/hedera-node/hedera-mono-service/src/test/java/com/hedera/node/app/service/mono/state/submerkle/EvmFnResultTest.java b/hedera-node/hedera-mono-service/src/test/java/com/hedera/node/app/service/mono/state/submerkle/EvmFnResultTest.java index 2e2b75e90466..573844f57722 100644 --- a/hedera-node/hedera-mono-service/src/test/java/com/hedera/node/app/service/mono/state/submerkle/EvmFnResultTest.java +++ b/hedera-node/hedera-mono-service/src/test/java/com/hedera/node/app/service/mono/state/submerkle/EvmFnResultTest.java @@ -122,7 +122,7 @@ void gettersWork() { assertEquals(createdContractIds, subject.getCreatedContractIds()); assertEquals(createdContractNonces, subject.getContractNonces()); assertEquals(0x2055c5c03ff84eb4L, subject.getClassId()); - assertEquals(EvmFnResult.RELEASE_0400_VERSION, subject.getVersion()); + assertEquals(EvmFnResult.RELEASE_0470_VERSION, subject.getVersion()); assertEquals(gas, subject.getGas()); assertEquals(amount, subject.getAmount()); assertEquals(functionParameters, subject.getFunctionParameters()); @@ -436,7 +436,7 @@ void toStringWorks() { + "functionParameters=" + CommonUtils.hex(functionParameters) + ", senderId=EntityId{shard=0, realm=0, num=42}" - + "}", + + ", signerNonce=null}", subject.toString()); } @@ -546,7 +546,7 @@ void viewWorks() { @Test void serializableDetWorks() { - assertEquals(EvmFnResult.RELEASE_0400_VERSION, subject.getVersion()); + assertEquals(EvmFnResult.RELEASE_0470_VERSION, subject.getVersion()); assertEquals(EvmFnResult.RUNTIME_CONSTRUCTABLE_ID, subject.getClassId()); } diff --git a/hedera-node/hedera-mono-service/src/test/java/com/hedera/node/app/service/mono/state/submerkle/ExpirableTxnRecordTest.java b/hedera-node/hedera-mono-service/src/test/java/com/hedera/node/app/service/mono/state/submerkle/ExpirableTxnRecordTest.java index 0db78b439bcb..86efce41f158 100644 --- a/hedera-node/hedera-mono-service/src/test/java/com/hedera/node/app/service/mono/state/submerkle/ExpirableTxnRecordTest.java +++ b/hedera-node/hedera-mono-service/src/test/java/com/hedera/node/app/service/mono/state/submerkle/ExpirableTxnRecordTest.java @@ -465,7 +465,7 @@ void toStringWorksWithParentConsTime() { + " contractId=EntityId{shard=4, realm=3, num=2}, createdContractIds=[]," + " logs=[EvmLog{data=4e6f6e73656e736963616c21, bloom=, contractId=null," + " topics=[]}], contractNonces=[], evmAddress=, gas=1000000, amount=0," - + " functionParameters=53656e7369626c6521, senderId=null}," + + " functionParameters=53656e7369626c6521, senderId=null, signerNonce=null}," + " hbarAdjustments=CurrencyAdjustments{readable=[0.0.2 -> -4, 0.0.1001 <- +2," + " 0.0.1002 <- +2]}, stakingRewardsPaid=CurrencyAdjustments{readable=[0.0.5 <-" + " +100, 0.0.8 <- +1000]}, scheduleRef=EntityId{shard=5, realm=6, num=7}," @@ -500,7 +500,7 @@ void toStringWorksWithoutParentConsTime() { + " contractId=EntityId{shard=4, realm=3, num=2}, createdContractIds=[]," + " logs=[EvmLog{data=4e6f6e73656e736963616c21, bloom=, contractId=null," + " topics=[]}], contractNonces=[], evmAddress=, gas=1000000, amount=0," - + " functionParameters=53656e7369626c6521, senderId=null}," + + " functionParameters=53656e7369626c6521, senderId=null, signerNonce=null}," + " hbarAdjustments=CurrencyAdjustments{readable=[0.0.2 -> -4, 0.0.1001 <- +2," + " 0.0.1002 <- +2]}, stakingRewardsPaid=CurrencyAdjustments{readable=[0.0.5 <-" + " +100, 0.0.8 <- +1000]}, scheduleRef=EntityId{shard=5, realm=6, num=7}," diff --git a/hedera-node/hedera-mono-service/src/test/java/com/hedera/test/utils/SeededPropertySource.java b/hedera-node/hedera-mono-service/src/test/java/com/hedera/test/utils/SeededPropertySource.java index b135f2f27314..f16865f5c9d0 100644 --- a/hedera-node/hedera-mono-service/src/test/java/com/hedera/test/utils/SeededPropertySource.java +++ b/hedera-node/hedera-mono-service/src/test/java/com/hedera/test/utils/SeededPropertySource.java @@ -129,7 +129,7 @@ public EvmFnResult nextEvmResult() { nextUnsignedLong(), nextBytes(128), nextEntityId(), - nextLong()); + null); evmResult.setContractNonces(nextContractNonces(2)); return evmResult; } @@ -802,7 +802,7 @@ public EvmFnResult nextEvmFnResult() { nextUnsignedLong(), nextBytes(64), null, - nextLong()); + null); } public List nextEvmLogs(final int n) { From 446c7311e1a00b2f9ea2caa436a183efbaa48de8 Mon Sep 17 00:00:00 2001 From: nikolay Date: Mon, 29 Jan 2024 12:56:08 +0200 Subject: [PATCH 09/16] chore: add v8 evm fn result test files Signed-off-by: nikolay --- .../app/service/mono/state/submerkle/EvmFnResultSerdeTest.java | 3 +++ .../src/test/resources/serdes/EvmFnResult-v8-sn0.hex | 1 + .../src/test/resources/serdes/EvmFnResult-v8-sn1.hex | 1 + .../src/test/resources/serdes/EvmFnResult-v8-sn2.hex | 1 + .../src/test/resources/serdes/EvmFnResult-v8-sn3.hex | 1 + .../src/test/resources/serdes/EvmFnResult-v8-sn4.hex | 1 + .../src/test/resources/serdes/EvmFnResult-v8-sn5.hex | 1 + .../src/test/resources/serdes/EvmFnResult-v8-sn6.hex | 1 + .../src/test/resources/serdes/EvmFnResult-v8-sn7.hex | 1 + .../src/test/resources/serdes/EvmFnResult-v8-sn8.hex | 1 + .../src/test/resources/serdes/EvmFnResult-v8-sn9.hex | 1 + 11 files changed, 13 insertions(+) create mode 100644 hedera-node/hedera-mono-service/src/test/resources/serdes/EvmFnResult-v8-sn0.hex create mode 100644 hedera-node/hedera-mono-service/src/test/resources/serdes/EvmFnResult-v8-sn1.hex create mode 100644 hedera-node/hedera-mono-service/src/test/resources/serdes/EvmFnResult-v8-sn2.hex create mode 100644 hedera-node/hedera-mono-service/src/test/resources/serdes/EvmFnResult-v8-sn3.hex create mode 100644 hedera-node/hedera-mono-service/src/test/resources/serdes/EvmFnResult-v8-sn4.hex create mode 100644 hedera-node/hedera-mono-service/src/test/resources/serdes/EvmFnResult-v8-sn5.hex create mode 100644 hedera-node/hedera-mono-service/src/test/resources/serdes/EvmFnResult-v8-sn6.hex create mode 100644 hedera-node/hedera-mono-service/src/test/resources/serdes/EvmFnResult-v8-sn7.hex create mode 100644 hedera-node/hedera-mono-service/src/test/resources/serdes/EvmFnResult-v8-sn8.hex create mode 100644 hedera-node/hedera-mono-service/src/test/resources/serdes/EvmFnResult-v8-sn9.hex diff --git a/hedera-node/hedera-mono-service/src/test/java/com/hedera/node/app/service/mono/state/submerkle/EvmFnResultSerdeTest.java b/hedera-node/hedera-mono-service/src/test/java/com/hedera/node/app/service/mono/state/submerkle/EvmFnResultSerdeTest.java index acbc5559aaab..4f373e23b86d 100644 --- a/hedera-node/hedera-mono-service/src/test/java/com/hedera/node/app/service/mono/state/submerkle/EvmFnResultSerdeTest.java +++ b/hedera-node/hedera-mono-service/src/test/java/com/hedera/node/app/service/mono/state/submerkle/EvmFnResultSerdeTest.java @@ -54,6 +54,9 @@ protected EvmFnResult getExpectedObject( // Always empty before 0.40 seeded.setContractNonces(Collections.emptyList()); } + if (version < EvmFnResult.RELEASE_0470_VERSION) { + seeded.setSignerNonce(null); + } return seeded; } diff --git a/hedera-node/hedera-mono-service/src/test/resources/serdes/EvmFnResult-v8-sn0.hex b/hedera-node/hedera-mono-service/src/test/resources/serdes/EvmFnResult-v8-sn0.hex new file mode 100644 index 000000000000..08734b591a9d --- /dev/null +++ b/hedera-node/hedera-mono-service/src/test/resources/serdes/EvmFnResult-v8-sn0.hex @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/hedera-node/hedera-mono-service/src/test/resources/serdes/EvmFnResult-v8-sn1.hex b/hedera-node/hedera-mono-service/src/test/resources/serdes/EvmFnResult-v8-sn1.hex new file mode 100644 index 000000000000..72e4fdfb2c40 --- /dev/null +++ b/hedera-node/hedera-mono-service/src/test/resources/serdes/EvmFnResult-v8-sn1.hex @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/hedera-node/hedera-mono-service/src/test/resources/serdes/EvmFnResult-v8-sn2.hex b/hedera-node/hedera-mono-service/src/test/resources/serdes/EvmFnResult-v8-sn2.hex new file mode 100644 index 000000000000..a73bc28ea8d4 --- /dev/null +++ b/hedera-node/hedera-mono-service/src/test/resources/serdes/EvmFnResult-v8-sn2.hex @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/hedera-node/hedera-mono-service/src/test/resources/serdes/EvmFnResult-v8-sn3.hex b/hedera-node/hedera-mono-service/src/test/resources/serdes/EvmFnResult-v8-sn3.hex new file mode 100644 index 000000000000..d94500bd2db5 --- /dev/null +++ b/hedera-node/hedera-mono-service/src/test/resources/serdes/EvmFnResult-v8-sn3.hex @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/hedera-node/hedera-mono-service/src/test/resources/serdes/EvmFnResult-v8-sn4.hex b/hedera-node/hedera-mono-service/src/test/resources/serdes/EvmFnResult-v8-sn4.hex new file mode 100644 index 000000000000..7cbea7b05695 --- /dev/null +++ b/hedera-node/hedera-mono-service/src/test/resources/serdes/EvmFnResult-v8-sn4.hex @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/hedera-node/hedera-mono-service/src/test/resources/serdes/EvmFnResult-v8-sn5.hex b/hedera-node/hedera-mono-service/src/test/resources/serdes/EvmFnResult-v8-sn5.hex new file mode 100644 index 000000000000..ba0d19b900d9 --- /dev/null +++ b/hedera-node/hedera-mono-service/src/test/resources/serdes/EvmFnResult-v8-sn5.hex @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/hedera-node/hedera-mono-service/src/test/resources/serdes/EvmFnResult-v8-sn6.hex b/hedera-node/hedera-mono-service/src/test/resources/serdes/EvmFnResult-v8-sn6.hex new file mode 100644 index 000000000000..f367af9b6b4f --- /dev/null +++ b/hedera-node/hedera-mono-service/src/test/resources/serdes/EvmFnResult-v8-sn6.hex @@ -0,0 +1 @@ +3198b0d76e2e6499000001008e0b45b3f85a97e225232d548aca86c314df2c96a7599b2f73ad75041c9de7fe4a4a17e286b6213a274a5469c2610fb278ae2723e2a4369a00747d6e4731e61f6109247ab3c3a1cb9ac924ad2c172911ca614037d4e584976cb1c691582f07cbc3c14ee3252d635fd9fdf3b142b77c1f42a981f78ffcce2b03cf1dbb71a46a2d4347b393af5d0da447b0ed29b35e575a43f01a552af9591f5d108ec89b1a5255cc60c6f2d0067b5be09e6f42769cc712f6ad1a799872e9d0dcbcfa283213bdd4ac20a50d75b05dd038526d33b729ab70068e3e466de40c2a4a092b474f556f29274ed1bf2b831165b90482614b7a888dca656e402ccbf115bc96c5a01ea269970000002003e7e9e2c139bf2f09cb294d826ce17f73c324ff1b942c94b0f3256b2db2f23801000000403f6e3a49545737233a7816165853144c4866717c1c615f412e28416647520d7418460f06683c28387366596a03262d064438312b724c6d131f047d397815280801f35ba643324efa370000000136300ca238bc49115677b879443b70a810e6bacb1660dee500000003010002af05aa9c7ff917000000010000004004c41cf872cdafa48f6354002a446395243be7ddec3b20dd4ee238fb9f5a3a2f1148c40e27dd495aa2cbcbbe364bb01c9ed09496a279dd3e43decac71191f95900000100ef5015dc57d515f3e66333478dda8fd212031de17b45e78f003ac873fa6a4db0115a3d2be715b4966188dbf82c41a5237a51b807f84960b7304d257834a39ba9481f5ac9d10289da8cf802658531b8ee2a2d427cf853671f811becd7615a7a14d36b6ed1437d38a610c9876202d9ec13214190e203d84c8492bdd04429ec2f8937614cb18c6ad4cadb30cdc1f7bf1da432eb5399ecc9eff0d8769a55f0ba6ef34c36a79ac7944ab7e7b0b2452ce9fecfae3853d1e415810ebb3d988f7ca5fa82164ddd7347a338aa3adcf1ae4cd0000c48c0d30bcc8252e09fd408d41cc44d0c6a1d06e719727ee5ac5611fe09d7be2241f847a29bc04c5de812bc340bef534801f35ba643324efa370000000160585601600cfca30fc8cca4106f162e1b8b37f642505ae3000000020000010026e6e5b6552f2ceacd27accddccb155c82374daf89f8f17e6d92a867f41a4b385f2b4bbf56d4974f1903c71de0c3e6f1e3d8577b18d4866303de5af8875bc2b4f76b9d06ea5007f653cd4d7df7b9d73000f3e31869aaf5897343c35fbdaad09fd8841912efd5cb7b234b2d7ab8da6a0466fbabc8d07d4b1c4effac31938d361a34fd18aae35cf1a294219b33449e8700e20a26668a1b5222dedd56d47de027a13b06be374f6cf154b569a7d8daa2ee71c4a0970460d7d38eba70321ebcb6016f5522349a7ca37bd3ac4e26912b39383e4ac905de4156acd994b693650a6eebf1fddc8c4a95a1b7b565a488a9074ce833a03ecbb3029a1bedd83a881859515be20000010011bd90bc2d794ca0315c3f21936fea22ce9ed5e0d07d736f80368acf337500d329ff9311e65af0baf69c9d66a470c39636b03f72417df78ecf6b39f7f3227913778abdbcb725a30aafd97794d2a342dbf506aa296d9bba88f22c7e3d12b46a3dea703135fe1d6c57f3349e9c22f9b3b8763c427906376f07ec9052686c210396f37ae20cd13f11375b32e9bee34d9464fd29fd5f4b3b9d5eb3b01f22983c9f4d5a2188d618dee5dda670c1253d9b540769b85091d307fc7796559b3851fb4f95a9173c5a9e8c1a08497b6f1cc8563a2be5c6995b1cc7d276e90e1b4638e030397142acea8fd03b1ea4f23ba6660f86c37965c8173420e3d0bc499a70894aa4c40000000040d7bf160afe93ee08d5768827fea704b6b0c92586bf83b60293cc98e8c3fcbc8cd7d606e320e7e293792431dbc07b7756b6813585c12e67a70d44e863b8ba8eb500000100ead82421f392a9d222835b4072520caf719d8b836514b628a4ac829fdbe8226626581b0051c454ebbe005d3c1cb790a43bfd75437b0c6352e10928f24cf6088a1fdaa1dd0a89d519ab05c6b3a7e299650988c229a094966d4b6f5ae043b114b87f92b335ac24bb5ec9a48171acb604c1d478dda4db5576da15d46acc026b2edc067cf493731f7d561224d507eb6b7e3d27dc39d2f976e9dec8ae0e0eed0cc8a3a04a0953d193b310627bfd2b676f0d185d147befb6414ecbb8d7c99ff8e3562a02fec5224080be5c6a22882e9aa24cbfd4fc2f3a315431198e7d8cf2596ff472d8061c7877fd439a76fba80630a3421650720bc026ffd12e3f53406db546377b01f35ba643324efa370000000146e6cae55e2ce394002945732bd1c22957d2b06b5b3b8a0b0000000200000100b741919b2010cb2fa41483a9ea3a8f37506b5b49064e8cd981911fca2889823f7a52e1efad689cca2f8f427dc43771e9bda3984181c7727a8096a1dcc462c68615292fc0723167c9b4da7b04ae7a9c361fbcde6ca74e3307a6e25fb6e954b8feefd9e70af2364b1d67c876c492af9733f43f6f1c10ad7a9cadfabb3e1097271fb179b55bc7bdda415c6753f1233258f24da06e9dd21d0cf9165dc14363400c00df3832dfe321804ca12fa11d48af6905690abb2ec57e58cd9a520d0c7da9fa8c3092b41e336602e1542d8d52aa00b81de2bf94c2e9cd7568e8e6bd202e016ed851a88fbedf63c598466a910f626c57d0416d490cebcf5c706cec0523c59f9c92000001007fd9043a6b1c6b53b2e289eb9f0f5e108c53470df4f70904017c657e8aea8aeba71269eacb0c6a7149225ec65ea2e714cd2ffb898f07c7a1e7b29f5ef1bbe0142a8dd2ddd75ad53537ae35daff98b426d340f06dd76ab9ec27523ea261031770e95433ef6122bae80582816b7bfe372bbea96ab9e34cb8a21df8e7ed13139255f822a8d183f18df30b3535a2635be32043191a154359568bf53008ed23c6344d2748aee92aa492798ea527f6ec3efe453002d627d7592c7b4d9046606532432525268d7f9dacb55c050b9c67cd7a3c2294dac3921fd1ae0bc990c0fdba3694c8fded611dcce60f1886272d32e1c69d8b9c5e71a63e8ed5cdc582c93f03053b2f0000000040a30e65f8f67ac7c40c384e0a3ab9fc23a0a6b2e9ece27b76f553fdcc01b53fea6650bd6b710fc24d727193eb77f2ea81b78d7ed4f9d796b7db705d67af61a1d600000100106352361070701a0cc483161841cb05f45c2ba6380ffd691c34629f0ddf523aae716fe9889c2266767d35af7c2ba0e57316603a18bbd7f166f9428b15792a532d5fcb0f1c0af71e3cedc0fd03c043fee16fa36cef9a3fadee75da07c3e79f7d4f16bb1532504957a7558e67b2a640594b88309389c859b42f12ac80dd719fd91a9c7c85ed10efe890721d8667e71a9aed12131869d6e6a91e02ea1048c0911bcd4b1f835db66da54e5c22ab761e7a12fe2101cef1d55d83495825381a8039a1d8ded5237f7ef04a36cdf5c42e2ee5e158cbde309572fc118dc01d9a6c89754e0dfe99426686ceee55a138f35051ee2c2b3bb7f0f20e3dc80abf2792316f4cd901f35ba643324efa37000000014f92a6c31d6d912f1689e3891c3f34b80ca1ada4ba53df190000000200000100a4701ed71e3a3cd4c7bd7c1c79fc5769eb0c233591d18e665c994143d9405d041034c128276a8691cd6635f36bfecb4d419b0bd3c55a954e6344eb4fcf7ec7c02c1ee497ffdab475550409420312c6bab6ce0aa71a5a2f1f921f5e9140ac7bdfbc415e5c8c55599c77de4fa271a3bd6d2aaa4ac9e803c8548a22d915df30b216b017f0581414173a1b87694f9f580231045e560affc7d7b59e1b95a5af76471303f092c8924d5d23c0e41e9920eb899a70d2db1607b349d7f7e20a74736d9e3ed208c2393dc6b61df399bb15feca3fb55d6f92fc0b9a9d2591d8e41c844185e3e388d69eb8ec785f56fbde1ec3bae23121781fb1d2ea80084eab998e28e5ee8d00000100cf26dbdaa8dad0d2db7778dc418512361f1bd6a6ac0567a408939469fe5499ead418a742320cfcf6dd5dd618a224b15ced80d8e3593d7dcd4b1326f0828e27cdcd0a555f7c3c1a28839df6c3fe8aa321db411f5b749f6a4b49324f5180dcd6dd3f4c336a97bd9d3c69f1498d334f91c45de7c7d5c7fbd9183b246ef4c537f1cfe9fe3660c12f8bf8b4ed823f72fa5464f740f39717b13db9685d2f0ece4cc38eea4819a1b0a27b9c26e1d0f1f635305a0fac1c1d8f52d745e865c6316080d99baebb6eb76442044a1d215e805062053a5f86ed09640247a1de3fb753f779c5456dc96bda98d5632651bd752fd5f3c8637290ae26eae02c1009ab94421b14742f000000020100f35ba643324efa370000000173067ea64d285362002427e94b614ee114132ab904b6c40c00075b013c84540190608ba1bdf59766762c25da80d3e79d3c00000014561f2aba0babd1bae73b2ae4600a5e14716cce5d46944e9d69edb0df05fa88c1f81ad68c000000805026ed12d0249e38325cd4dcf8235c5676a8d7db649bf1400dbe7340f678b3cdaedad832d0e83b660048a17bac06e023e11eb407f281585516ba342f3511b06ec627ca13d70c912725222e6396ace870b1dcfc67f042ae41a6f454c1f78b6680be8e6d289ad2431b46ad5beecdc479700b7354ba6eb6fa549c9a2f309243c3c901f35ba643324efa370000000121f365bfb382757d23d618367c3b2e6f4eca08b40e4f4e5b00000002010018ec32eaf93715510000000101f35ba643324efa3700000001005f21dea686064162cad2f51588cf451ed67aaeef3093ec5496afee1f9af92d0001f35ba643324efa37000000012362a881f615109c63dc1e0e6de9d7482365256acc128ca660cbbf722a3a3f2300 \ No newline at end of file diff --git a/hedera-node/hedera-mono-service/src/test/resources/serdes/EvmFnResult-v8-sn7.hex b/hedera-node/hedera-mono-service/src/test/resources/serdes/EvmFnResult-v8-sn7.hex new file mode 100644 index 000000000000..185ed3f76275 --- /dev/null +++ b/hedera-node/hedera-mono-service/src/test/resources/serdes/EvmFnResult-v8-sn7.hex @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/hedera-node/hedera-mono-service/src/test/resources/serdes/EvmFnResult-v8-sn8.hex b/hedera-node/hedera-mono-service/src/test/resources/serdes/EvmFnResult-v8-sn8.hex new file mode 100644 index 000000000000..8d0445a49b04 --- /dev/null +++ b/hedera-node/hedera-mono-service/src/test/resources/serdes/EvmFnResult-v8-sn8.hex @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/hedera-node/hedera-mono-service/src/test/resources/serdes/EvmFnResult-v8-sn9.hex b/hedera-node/hedera-mono-service/src/test/resources/serdes/EvmFnResult-v8-sn9.hex new file mode 100644 index 000000000000..11d99febff40 --- /dev/null +++ b/hedera-node/hedera-mono-service/src/test/resources/serdes/EvmFnResult-v8-sn9.hex @@ -0,0 +1 @@ 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 \ No newline at end of file From 1f15bf6f2374fe71b81133cac63c694218c6a593 Mon Sep 17 00:00:00 2001 From: Ivo Yankov Date: Tue, 30 Jan 2024 16:33:48 +0200 Subject: [PATCH 10/16] fix: unit test mocks Signed-off-by: Ivo Yankov --- .../ContractCallTransitionLogicTest.java | 43 +++++++++++++++++-- 1 file changed, 39 insertions(+), 4 deletions(-) diff --git a/hedera-node/hedera-mono-service/src/test/java/com/hedera/node/app/service/mono/txns/contract/ContractCallTransitionLogicTest.java b/hedera-node/hedera-mono-service/src/test/java/com/hedera/node/app/service/mono/txns/contract/ContractCallTransitionLogicTest.java index b6a4e2da6301..771235bfe9cb 100644 --- a/hedera-node/hedera-mono-service/src/test/java/com/hedera/node/app/service/mono/txns/contract/ContractCallTransitionLogicTest.java +++ b/hedera-node/hedera-mono-service/src/test/java/com/hedera/node/app/service/mono/txns/contract/ContractCallTransitionLogicTest.java @@ -40,6 +40,7 @@ import com.google.protobuf.ByteString; import com.hedera.node.app.hapi.utils.ByteStringUtils; import com.hedera.node.app.service.evm.exceptions.InvalidTransactionException; +import com.hedera.node.app.service.evm.store.contracts.WorldStateAccount; import com.hedera.node.app.service.mono.config.EntityNumbers; import com.hedera.node.app.service.mono.context.TransactionContext; import com.hedera.node.app.service.mono.context.properties.GlobalDynamicProperties; @@ -77,6 +78,7 @@ import java.util.TreeMap; import org.apache.tuweni.bytes.Bytes; import org.hyperledger.besu.datatypes.Address; +import org.hyperledger.besu.datatypes.Wei; import org.hyperledger.besu.evm.gascalculator.GasCalculator; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -241,7 +243,9 @@ void verifyExternaliseContractResultCallEth() { // and: given(accessor.getTxn()).willReturn(contractCallTxn); // and: - senderAccount.initBalance(1234L); + + final long balance = 1234L; + senderAccount.initBalance(balance); given(accountStore.loadAccount(senderAccount.getId())).willReturn(senderAccount); given(accountStore.loadAccount(relayerAccount.getId())).willReturn(relayerAccount); given(sigsVerifier.hasActiveKeyOrNoReceiverSigReq( @@ -266,6 +270,11 @@ false, asTypedEvmAddress(target), Address.ZERO, worldLedgers, HederaFunctionalit given(worldState.getContractNonces()).willReturn(targetContractNonces); given(accountStore.isContractUsable(any())).willReturn(INVALID_CONTRACT_ID); + final Address senderEvmAddress = + asTypedEvmAddress(EntityId.fromNum(senderAccount.getId().num())); + final var worldStateAccount = new WorldStateAccount(senderEvmAddress, Wei.of(balance), codeCache, entityAccess); + given(worldState.get(senderEvmAddress)).willReturn(worldStateAccount); + // when: subject.doStateTransitionOperation( accessor.getTxn(), senderAccount.getId(), relayerAccount.getId(), maxGas, biOfferedGasPrice); @@ -301,7 +310,8 @@ void executesAsExpectedWithReceiverSigReqPresent() { // and: given(accessor.getTxn()).willReturn(contractCallTxn); // and: - senderAccount.initBalance(1234L); + final long balance = 1234L; + senderAccount.initBalance(balance); given(accountStore.loadAccount(senderAccount.getId())).willReturn(senderAccount); given(sigsVerifier.hasActiveKeyOrNoReceiverSigReq( false, asTypedEvmAddress(target), Address.ZERO, worldLedgers, HederaFunctionality.ContractCall)) @@ -322,6 +332,11 @@ false, asTypedEvmAddress(target), Address.ZERO, worldLedgers, HederaFunctionalit maxGas)) .willReturn(results); + final Address senderEvmAddress = + asTypedEvmAddress(EntityId.fromNum(senderAccount.getId().num())); + final var worldStateAccount = new WorldStateAccount(senderEvmAddress, Wei.of(balance), codeCache, entityAccess); + given(worldState.get(senderEvmAddress)).willReturn(worldStateAccount); + assertDoesNotThrow(() -> subject.doStateTransitionOperation( accessor.getTxn(), senderAccount.getId(), relayerAccount.getId(), maxGas, biOfferedGasPrice)); } @@ -342,8 +357,16 @@ void verifyExternaliseContractResultCallSuccessfulLazyCreate() { given(accountStore.loadAccount(senderAccount.getId())).willReturn(senderAccount); given(accountStore.loadAccount(relayerAccount.getId())).willReturn(relayerAccount); // and: + final long balance = 1234L; var results = TransactionProcessingResult.successful( - null, 1234L, 0L, 124L, Bytes.EMPTY, Address.wrap(Bytes.wrap(alias.toByteArray())), Map.of(), List.of()); + null, + balance, + 0L, + 124L, + Bytes.EMPTY, + Address.wrap(Bytes.wrap(alias.toByteArray())), + Map.of(), + List.of()); given(evmTxProcessor.executeEth( senderAccount, Address.wrap(Bytes.wrap(alias.toByteArray())), @@ -360,6 +383,12 @@ void verifyExternaliseContractResultCallSuccessfulLazyCreate() { given(properties.isLazyCreationEnabled()).willReturn(true); given(properties.evmVersion()).willReturn(EVM_VERSION_0_34); // when: + + final Address senderEvmAddress = + asTypedEvmAddress(EntityId.fromNum(senderAccount.getId().num())); + final var worldStateAccount = new WorldStateAccount(senderEvmAddress, Wei.of(balance), codeCache, entityAccess); + given(worldState.get(senderEvmAddress)).willReturn(worldStateAccount); + subject.doStateTransitionOperation( accessor.getTxn(), senderAccount.getId(), relayerAccount.getId(), maxGas, biOfferedGasPrice); @@ -384,8 +413,9 @@ void verifyExternaliseFailedContractResultCallLazyCreate() { given(accountStore.loadAccount(senderAccount.getId())).willReturn(senderAccount); given(accountStore.loadAccount(relayerAccount.getId())).willReturn(relayerAccount); // and: + final long balance = 1234L; var results = TransactionProcessingResult.failed( - 1234L, 0L, 124L, Optional.of(Bytes.EMPTY), Optional.empty(), Map.of(), List.of()); + balance, 0L, 124L, Optional.of(Bytes.EMPTY), Optional.empty(), Map.of(), List.of()); given(evmTxProcessor.executeEth( senderAccount, Address.wrap(Bytes.wrap(alias.toByteArray())), @@ -402,6 +432,11 @@ void verifyExternaliseFailedContractResultCallLazyCreate() { given(properties.isLazyCreationEnabled()).willReturn(true); given(properties.evmVersion()).willReturn(EVM_VERSION_0_34); + final Address senderEvmAddress = + asTypedEvmAddress(EntityId.fromNum(senderAccount.getId().num())); + final var worldStateAccount = new WorldStateAccount(senderEvmAddress, Wei.of(balance), codeCache, entityAccess); + given(worldState.get(senderEvmAddress)).willReturn(worldStateAccount); + // when: subject.doStateTransitionOperation( accessor.getTxn(), senderAccount.getId(), relayerAccount.getId(), maxGas, biOfferedGasPrice); From 7f09a6780c96065d0923fc834e99ce560a071430 Mon Sep 17 00:00:00 2001 From: nikolay Date: Tue, 30 Jan 2024 17:43:41 +0200 Subject: [PATCH 11/16] chore: fix unit tests Signed-off-by: nikolay --- hedera-node/hapi/hedera-protobufs | 1 + .../service/mono/state/submerkle/ExpirableTxnRecord.java | 3 ++- .../state/submerkle/ExpirableTxnRecordSerdeTest.java | 9 +++++++++ .../test/resources/serdes/ExpirableTxnRecord-v13-sn0.hex | 1 + .../test/resources/serdes/ExpirableTxnRecord-v13-sn1.hex | 1 + .../resources/serdes/ExpirableTxnRecord-v13-sn10.hex | 1 + .../resources/serdes/ExpirableTxnRecord-v13-sn11.hex | 1 + .../resources/serdes/ExpirableTxnRecord-v13-sn12.hex | 1 + .../resources/serdes/ExpirableTxnRecord-v13-sn13.hex | 1 + .../resources/serdes/ExpirableTxnRecord-v13-sn14.hex | 1 + .../resources/serdes/ExpirableTxnRecord-v13-sn15.hex | 1 + .../resources/serdes/ExpirableTxnRecord-v13-sn16.hex | 1 + .../resources/serdes/ExpirableTxnRecord-v13-sn17.hex | 1 + .../resources/serdes/ExpirableTxnRecord-v13-sn18.hex | 1 + .../resources/serdes/ExpirableTxnRecord-v13-sn19.hex | 1 + .../test/resources/serdes/ExpirableTxnRecord-v13-sn2.hex | 1 + .../test/resources/serdes/ExpirableTxnRecord-v13-sn3.hex | 1 + .../test/resources/serdes/ExpirableTxnRecord-v13-sn4.hex | 1 + .../test/resources/serdes/ExpirableTxnRecord-v13-sn5.hex | 1 + .../test/resources/serdes/ExpirableTxnRecord-v13-sn6.hex | 1 + .../test/resources/serdes/ExpirableTxnRecord-v13-sn7.hex | 1 + .../test/resources/serdes/ExpirableTxnRecord-v13-sn8.hex | 1 + .../test/resources/serdes/ExpirableTxnRecord-v13-sn9.hex | 1 + .../test/resources/serdes/MerklePayerRecords-v1-sn4.hex | 2 +- 24 files changed, 33 insertions(+), 2 deletions(-) create mode 160000 hedera-node/hapi/hedera-protobufs create mode 100644 hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn0.hex create mode 100644 hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn1.hex create mode 100644 hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn10.hex create mode 100644 hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn11.hex create mode 100644 hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn12.hex create mode 100644 hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn13.hex create mode 100644 hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn14.hex create mode 100644 hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn15.hex create mode 100644 hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn16.hex create mode 100644 hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn17.hex create mode 100644 hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn18.hex create mode 100644 hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn19.hex create mode 100644 hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn2.hex create mode 100644 hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn3.hex create mode 100644 hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn4.hex create mode 100644 hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn5.hex create mode 100644 hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn6.hex create mode 100644 hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn7.hex create mode 100644 hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn8.hex create mode 100644 hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn9.hex diff --git a/hedera-node/hapi/hedera-protobufs b/hedera-node/hapi/hedera-protobufs new file mode 160000 index 000000000000..8857802cc0d7 --- /dev/null +++ b/hedera-node/hapi/hedera-protobufs @@ -0,0 +1 @@ +Subproject commit 8857802cc0d7cd7e571c43964512b7b3ba57c740 diff --git a/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/state/submerkle/ExpirableTxnRecord.java b/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/state/submerkle/ExpirableTxnRecord.java index 4a3124810401..21891dbc9f72 100644 --- a/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/state/submerkle/ExpirableTxnRecord.java +++ b/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/state/submerkle/ExpirableTxnRecord.java @@ -78,7 +78,8 @@ public class ExpirableTxnRecord implements FastCopyable, SerializableHashable { static final int RELEASE_0280_VERSION = 11; // Debatable -- 0.33/0.34? static final int RELEASE_0340_VERSION = 12; - static final int CURRENT_VERSION = RELEASE_0340_VERSION; + static final int RELEASE_0470_VERSION = 13; + static final int CURRENT_VERSION = RELEASE_0470_VERSION; static final long RUNTIME_CONSTRUCTABLE_ID = 0x8b9ede7ca8d8db93L; static final int MAX_MEMO_BYTES = 32 * 1_024; diff --git a/hedera-node/hedera-mono-service/src/test/java/com/hedera/node/app/service/mono/state/submerkle/ExpirableTxnRecordSerdeTest.java b/hedera-node/hedera-mono-service/src/test/java/com/hedera/node/app/service/mono/state/submerkle/ExpirableTxnRecordSerdeTest.java index d0c0f91f0d75..1f3b29d97084 100644 --- a/hedera-node/hedera-mono-service/src/test/java/com/hedera/node/app/service/mono/state/submerkle/ExpirableTxnRecordSerdeTest.java +++ b/hedera-node/hedera-mono-service/src/test/java/com/hedera/node/app/service/mono/state/submerkle/ExpirableTxnRecordSerdeTest.java @@ -20,6 +20,7 @@ import static com.hedera.node.app.service.mono.state.submerkle.ExpirableTxnRecord.RELEASE_0270_VERSION; import static com.hedera.node.app.service.mono.state.submerkle.ExpirableTxnRecord.RELEASE_0280_VERSION; import static com.hedera.node.app.service.mono.state.submerkle.ExpirableTxnRecord.RELEASE_0340_VERSION; +import static com.hedera.node.app.service.mono.state.submerkle.ExpirableTxnRecord.RELEASE_0470_VERSION; import com.hedera.test.serde.EqualityType; import com.hedera.test.serde.SelfSerializableDataTest; @@ -70,6 +71,14 @@ protected ExpirableTxnRecord getExpectedObject( if (version < RELEASE_0340_VERSION) { seeded.clearEvmAddress(); } + if (version < RELEASE_0470_VERSION) { + if (seeded.getContractCallResult() != null) { + seeded.getContractCallResult().setSignerNonce(null); + } + if (seeded.getContractCreateResult() != null) { + seeded.getContractCreateResult().setSignerNonce(null); + } + } return seeded; } diff --git a/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn0.hex b/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn0.hex new file mode 100644 index 000000000000..7476dd6dc3b6 --- /dev/null +++ b/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn0.hex @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn1.hex b/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn1.hex new file mode 100644 index 000000000000..9e99faa3f57a --- /dev/null +++ b/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn1.hex @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn10.hex b/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn10.hex new file mode 100644 index 000000000000..4a97503e119e --- /dev/null +++ b/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn10.hex @@ -0,0 +1 @@ +0165ef569a77dcf1250000000700000016494e56414c49445f544f4b454e5f444543494d414c535dfb7b68d74734160000000114b7446d7f3ffd0b592dc8265fbc04bb4ca78bfb682784b802bb43a1740576180000000001f35ba643324efa3700000001574de69561c4c5e76cdad57b75718f531b8bbf56cf5c5199000000000000000000000000000004000000001915c799000000001b8a46c70000000033713508000000006cde3895ffffffff01061a52dfb3a18d9b00000004f35ba643324efa3700000001160c7cc30808953f1c2367ae46db4eb56193a2d056e0fd1f178461c7de90b3d0000cec010001000001df01449483c641b903780004ce4c004e8d632d25016c5301d8b06bd46e12a466000000020000000600000000397ff84c0000000071c878e000000000167a8cc700000000b4f5946700000000c6595e080000000081cd43a1000000060bc81b87268f8e3fe26af1e4c12cf1c8b66bec021b1ff70033976b623407870a832747bdbfe7b1d161902124f44f3a1d012055c5c03ff84eb400000008545b00aa4c84e1d800000020ccbae1223e37f48789c1a6fdc6e039aa20138e24839ebc65a5222b374383a4dd000000802850944ae458aa22b9bfe41f70ca0507f0f9d9dc21f55e877b6408bcc4c774aff4050d5ba4627074224db2f9a015ec8c951ba7c764b6f25fd7c0f11ffe4f2d05aae75054370252568238204e66a15c47b4cd76cbe3ea3fed846045af404d0e84759f9bb22e5367903150ecf35da60ebd5ad2faf9e16c35b204145660d83a52840100000020632b6f794650526817147061321c067e1173661368317a083b7e5c3c4c56597501f35ba643324efa370000000100fa86d2b44f4ed413851d706622a38840f52270d6f1e362000000000000000000000014950a750c1f88c8dc18d5c47b51f512855e29deae3c4ba77c61d750aa234a87d601d1bd43000000401efe4385b9f2c3d822458ec52daaaca9ace8beb6d58eeec666266209c39e24c9029235694c4b9eb95c05d3e364984cc1d39049f0fe209c01ffde6eff7788340a000000000000006c7d858d9a09f8de4ac0abbfcf4f371cffffffffffffffff01f35ba643324efa37000000014e4cc6255b1d78ce71de181ee2f1513d443e75e2e0b45160ffffffffffffffff0000000001671901dd77f72400033ba20000002081cf5406f291605dcf2010157aa427d6cc3cbf9dc54555f1adfd676fa22616d80000000000010c36b14b00000000 \ No newline at end of file diff --git a/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn11.hex b/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn11.hex new file mode 100644 index 000000000000..54f17738b49e --- /dev/null +++ b/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn11.hex @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn12.hex b/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn12.hex new file mode 100644 index 000000000000..25e0eaeb88ac --- /dev/null +++ b/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn12.hex @@ -0,0 +1 @@ +0165ef569a77dcf125000000070000001550415945525f4143434f554e545f44454c455445445dfb7b68d7473416000000010b6a17eb345f08a679ae7ba47e09923a7dc34d3e533cdcbc26ebc63b1a2a62c600000001f35ba643324efa37000000015a4ab278c73cea70723b19d72694bf104b951cdff85f8b86000000000000000000000000ffffffffffffffff01061a52dfb3a18d9b00000004f35ba643324efa370000000102abcb771c25bc167018c248299709c25c3d3fb6fb50b07877deedb862a5834800021aa60000015e53fb9439defdb2000e0c150004ddc1d13a67855000000023eda6fdfb29eae71a25e42cbd9caf6bffffffffffffffff01f35ba643324efa37000000013ec96677fbb3affe6710d8257d7d6b2c3d824d36c7c18cc8ffffffffffffffff000000000100d1010ee06b5800054f2500000020d373b0ca88723d19bd623e39b0d1ddf05377d4d4aeae9068e7f7ecd025cf602e00000000000200000030e811ead3cbb021d9b9051f90c61ed0131011e62221d5a06ce62e2adc030c9eaa63c60b7f267c28081e9b348287f53eb400000000 \ No newline at end of file diff --git a/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn13.hex b/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn13.hex new file mode 100644 index 000000000000..9f7103042ba3 --- /dev/null +++ b/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn13.hex @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn14.hex b/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn14.hex new file mode 100644 index 000000000000..552291689854 --- /dev/null +++ b/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn14.hex @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn15.hex b/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn15.hex new file mode 100644 index 000000000000..11e64d771cd9 --- /dev/null +++ b/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn15.hex @@ -0,0 +1 @@ +0165ef569a77dcf1250000000700000017434f4e54524143545f4e454741544956455f56414c55455dfb7b68d74734160000000166dcfdb06e238dbb596c1cb410001e0c102ba1fb40a8cdfc5e9a58413e670f4f000001f35ba643324efa370000000145813a57747b1ad268ff5ddacd526bf7477dd00517e3513f00000000000000000000000000ffffffffffffffff01061a52dfb3a18d9b00000004f35ba643324efa37000000011a667009386e85bc2dad643aadcf4ad658d1d5f09953c081447d7735107daafe000399a9000100000270011cfb973acdd3f9790000d9e501000000642612546227446434083c1e61264d290f0d5f5b0f3f3c40376d645d143e0f63201a436e0a5749355773002350140e3d411b5b133e773056766d00435d333c436e76551456190b035c12050c0d107c585a7a2626511a3068265d0f140920692c2d76493539643cbbdb0dda86220000001170fe31e4b0aa68504e904615ff18d2ffffffffffffffff00ffffffff000000030100d8b56ce46e56a46600000002f35ba643324efa370000000157cde01595b124671dbfae79addbdfec622171ebee5c47e2f35ba643324efa3700000001317a4a18df53b4056b1210270b7d70180d4204fb9079870601c19bb3568287640000000100000000d356c0af00f35ba643324efa370000000160691e3697a341771d5d4a820a00d5813fc384f334b479ca800000000000000070ca498c68392ca400000001000000009cae3a8800f35ba643324efa370000000105b851f980bdcaaa389235ac56e5b9807750886dc60e437a80000000000000002f8ea6584a77b6ab00000001000000009b5635a70000000a010041a2569130b01d2f0000000100000000258f8a51000000004bb392850000000000edba42d900000000df4ce290000000000003440dc100000000b21a973200000000006fe7bb6500000000a0e18e3e000000000018edbd670000000034a739fe0000000000972df48200000000b9ecea2b0000000000c4525a8d00000000d2ed33050000000000eadd695e000000000993dc5a00000000005d36e0ae000000007a9de2b80000000000a1182c68000000001944d42a014b9a00000000000000000001d8b06bd46e12a46600000002000000060000000086948e6c00000000c837b5ec00000000f1b9693d00000000f2a4d2ba0000000001690d1a00000000912278df00000006b1836cd43d022448b566e13dc8e7d8f696d2c0a0434dd8a1a8869c3db1fd0b78b3105c638cf8269636123a694984df410000000000 \ No newline at end of file diff --git a/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn16.hex b/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn16.hex new file mode 100644 index 000000000000..ab898def4912 --- /dev/null +++ b/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn16.hex @@ -0,0 +1 @@ +0165ef569a77dcf12500000007000000294d41585f4e4654535f494e5f50524943455f524547494d455f484156455f4245454e5f4d494e5445445dfb7b68d7473416000000016d3af7df283a49ee224bae6fa9ad00425b77d5c854dcf23959a16b16c589285e0000000001f35ba643324efa3700000001736a71e27f6702694f29840f051931ce5e4bb3fadcba7fd5000000000000000000000000000008000000003e4871de000000002dd8589100000000d59055ae00000000b793ce8500000000a0684cda000000009f616e7600000000f3005539000000008f5415a8ffffffff01061a52dfb3a18d9b00000004f35ba643324efa37000000016fd10e76d605725030a8de32067d66c2546ad9266c53c17609fbc8c61dddc8e2000eb6c500010000017a017e4cb351576bf9ad000d9615010000006407787b621972432d327c63230a4e0a74295e6c635a0d0f6725746b1c4f1a623e34506b622b7a5859496058677119034f061668552d40254b5e4c73222d412d2f1d5d653b5c094c0b672946390871065d341d1449541a23012f5e285d0107550d6b5009184e0ebb591839581a01d8b06bd46e12a466000000020000000800000000dc5be322000000004aeed24d000000009f40c442000000006cc07aa600000000900dbf0e00000000e1304e5600000000ba66928b00000000129ebe480000000870e111a606b5e634245f753510c8d9db353de7dfdd7e595af5584ebe7eb1e1aa6fff8347b431e894b74e6ea87956742b1580cefc231893d9b6a991b8ea133bea00002d2347b4190c096738a17f5429487227ffffffffffffffff01f35ba643324efa370000000126cb523bfbeadafb1438f69e091553150bc4c74120ab3dcfffffffffffffffff00000001010041a2569130b01d2f00000001000000000b416c2b000000005cf97a010157680132ddb22a000048430000002071d04633403695320bac5de52cfaa5890cd107ae199bc0b5538846cc18ac8c0b0000000001d8b06bd46e12a466000000020000000100000000fc3ff0ce00000001b241dff4db82ec7601274b7e4400000000 \ No newline at end of file diff --git a/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn17.hex b/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn17.hex new file mode 100644 index 000000000000..7194fb8cb459 --- /dev/null +++ b/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn17.hex @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn18.hex b/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn18.hex new file mode 100644 index 000000000000..e00ef77e8e71 --- /dev/null +++ b/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn18.hex @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn19.hex b/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn19.hex new file mode 100644 index 000000000000..c893f059f37c --- /dev/null +++ b/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn19.hex @@ -0,0 +1 @@ +0165ef569a77dcf12500000007000000265550444154455f46494c455f49445f444f45535f4e4f545f4d415443485f50524550415245445dfb7b68d74734160000000117d1074a273101020da1ac883867eb3a342ba4a51b5e28023273c73491a6f30f00000000000000000000000000000000ffffffffffffffff01061a52dfb3a18d9b00000004f35ba643324efa37000000012e8a37a15231c1c9005ac09248569f767b5998e1af08d8d73387105dc2e02f59000615800000015cee6e25c2db2fb8000ee7bf0063a8e94841e6c15a00012055c5c03ff84eb4000000084e93136b5fa2bef500000020539a28dcec10c5c3efdb0fc96b46eaccddbab423852d1929702f5d4fcb86ccc900000080f9a6d0d0f08c0f50cf782472c8dc32fbb5161266223b86f08085c28d7e5a6c41c8c5d1bb43db72bd0b7bf4e90532e9e6e2aeacd5b3dbfa877cac2bf18407c782cfd7161c9323315a001c95bf66fdb0d7ade07b32af94b2fb29968653223487d4f21d4deee72423ef91db0165accd3ec640eff55446a7e95f47fa0736cb5e68bd010000002048065175213a5d4e03015d513b4f3d053a03042d333f287e5e4d1d0b7e7e5b6301f35ba643324efa37000000010e10210c1be85de9703844f668435e0a4b603fb25ba25b59000000000000000000000014bbc0b1787c1afe12010f69352f31b178ac6cc8ca0c65c8d3b67ce275600483063534f1a700000040f2ef19825e87e18102ceb80cb96c85412db2725017b455293d5fecac323664bafd05baab7a9dad96757e5f30ca1b32e56beea4e5409cf722311a2637dc6902bd01f35ba643324efa37000000017462d9b943d4705d02f536ed95de252822b146075742185400000000000061d2a5d12f58ca33532ed7520b35b888ffffffffffffffff01f35ba643324efa37000000013b8e2cf4abffb7f724057ed5eebf1ef94910b2ba5d3a9667ffffffffffffffff000000000113850156979853000ef20d000000208b48b2fc211a7de0e68d0fd24afca31ffcef0b0fb6780992cc9cbebee2ac74c5000000000001486ac61800000000 \ No newline at end of file diff --git a/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn2.hex b/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn2.hex new file mode 100644 index 000000000000..546ad63062e7 --- /dev/null +++ b/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn2.hex @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn3.hex b/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn3.hex new file mode 100644 index 000000000000..2eb0757c2bcd --- /dev/null +++ b/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn3.hex @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn4.hex b/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn4.hex new file mode 100644 index 000000000000..40b48c771119 --- /dev/null +++ b/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn4.hex @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn5.hex b/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn5.hex new file mode 100644 index 000000000000..4f15c0816ebc --- /dev/null +++ b/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn5.hex @@ -0,0 +1 @@ +0165ef569a77dcf125000000070000001c434f4e54524143545f455845435554494f4e5f455843455054494f4e5dfb7b68d747341600000001212316d5744f59722871dbb2d6a3474953ccb60860c447ed2c5908f81c48501400000000000000000000000000000000ffffffffffffffff01061a52dfb3a18d9b00000004f35ba643324efa37000000011a851d756f555649067ff18a5038a3ab7eb74ac2fe5facad7a850810c3e9bb37000e30040000010e8b441745e669da0003adf701000000642660245a5227470e68542e3a3b14380247285d441a3b5c3961630d265e3b21425a1152240e2c32530a5b0d4140111f022925444f23656f7c22475d046c021d465578181c4f35423b567d242a7c26037b157732153833430245767b1d44435a40110633432c0b107f84ef13fa00012055c5c03ff84eb40000000803c66e206868df03000000209a4f2c54bbad9a96d97188886f779299e69584f040ab9cf68af59e9611a5c97d00000080333efbaaa5ebdd09c6d9615a2bf7c68747938c6ae33ecc2979f13ebcc180081dbf36548c0fb5a9955a9980382d94027e67de7d2b9b84713ecc667c6fc7b4e67b44b3b6c2ba6c7939350504879544c8fdb58e0e9630b2b16bbe7b120cac93a7211eae3bedb0eaba1f7cf4b6b3f38e6d8e8df0891969b27b580124a26b5039206101000000202f0819490b2773470d6a21371e6342056f4262156f776f24046c1a221249286001f35ba643324efa3700000001519f74efdfd92a1b023255241c0fd94b7e1366de8dadef520000000000000000000000141a195643c35be9501b2b7c4b1b65a21be497aa0e411f6624e7b716671e8abfadabe10ec100000040a98d384cd63f1f45d45578312b131a5f9531657a7a308f8f9d36436e96d402fbe9773ffd24ed56af6b57a79598223ef7c27878d612c26827819b3845efb66b9301f35ba643324efa37000000016621960c2777ea5312d768b87ac8d0a64008aabdcb8645a600000000000059a4bd624496ddc768e30e33603f932dffffffffffffffff00ffffffffffffffff0000000001704d0000000020e719ae147c41d268796f67ab52161290cea51b2a72915a4398892ceaa8f476030000000001d8b06bd46e12a466000000020000000a000000002b37c1280000000099822a6a00000000a157fd760000000035e5d57400000000d006c92c000000007bffcb46000000007ba9f8d2000000000c84f93c000000007b7af1cb000000008b3028680000000a5190efea593ac3b9d1ac58b97f27886178e88b74ab6f0c476648b146c2cf59f964971ce3b63bf196013c23967db24cb6c0dc809617c010a205fee9128d3ac2675760f6829db597e0d8d9589f0d8a33e8010c35af0600000000 \ No newline at end of file diff --git a/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn6.hex b/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn6.hex new file mode 100644 index 000000000000..fdca86fedcfe --- /dev/null +++ b/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn6.hex @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn7.hex b/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn7.hex new file mode 100644 index 000000000000..2677c370598f --- /dev/null +++ b/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn7.hex @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn8.hex b/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn8.hex new file mode 100644 index 000000000000..d83c89e14a1c --- /dev/null +++ b/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn8.hex @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn9.hex b/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn9.hex new file mode 100644 index 000000000000..d38cfd9a9504 --- /dev/null +++ b/hedera-node/hedera-mono-service/src/test/resources/serdes/ExpirableTxnRecord-v13-sn9.hex @@ -0,0 +1 @@ +0165ef569a77dcf1250000000700000016494e56414c49445f4c4956455f484153485f53495a455dfb7b68d74734160000000165887676019fbf8941cfe4d7a7a9cd57480e2d983583fa8f41f74623be1185e001f35ba643324efa370000000168751499b233060665541e1950c1dd4837bed9c8621dfa76000000000000000000000000000000ffffffffffffffff01061a52dfb3a18d9b00000004f35ba643324efa37000000012b681b50f53d1e7b1fb0afe1b402702c33911d5ed2fbc26608e4817ef6ff0d6d000ac7d80100011e045190ca9d4c210008b484002d923b698ca6973100012055c5c03ff84eb4000000087427384320ad2a9c000000201675e2ae38d020d200109ca0c7ae5a8dbe45a470bcf7acbce35a23002a403ce9000000803d8fe33d8549dcfd64d8c2aa7554f7636ba40e5c53a22ff5ad5312f1ca4a6c9653c32bbfa9bb5ed812436df01170c68bb069e46efd9beeb1042071995bd4d927351f78f03618952f443a5d5a3af11d35e71216a6eb9eb7897cfb2adfed40ddc8f3b52f54e29d40e144deaf06393b8d21dc188f9a8e6841e4e11cf32044540e56010000002059446a545b27272b185e20553900542c555f4e666c56571d013a063d1e66121401f35ba643324efa37000000014dd7e73f0c7201867b214f4717e8d68235bc618e0e9fbf410000000000000000000000144476cf644aab62d178be9bf4549f6196e30d666a5bdd8f4b36d24b8e30f3f2f94698f62500000040feaf3b0f02330fc77a5d2840ceeeadb3ad2490b6c7c8d23ff1578e9aba7004ee771e9a83e1e37765db0cd9f2e903e30d68eebed007310c4fcfa0d92df82d947e0000000000000000ec93bccf1ff59b701a48fb73bcdc62ffffffffffffffff01f35ba643324efa37000000011ce0b4adba4f2d7204634bdd21a39b4336094fdaf934f90dffffffffffffffff00000003010041a2569130b01d2f00000001000000008eaba19d00000000c9ecf51000000000003886eaa2000000001249f34c0000000000eeb329ad00000000ba97773f014706012613e0280009e086000000000000000000016bc7f41c00000000 \ No newline at end of file diff --git a/hedera-node/hedera-mono-service/src/test/resources/serdes/MerklePayerRecords-v1-sn4.hex b/hedera-node/hedera-mono-service/src/test/resources/serdes/MerklePayerRecords-v1-sn4.hex index 63ca2cbd13e1..0e9676d67167 100644 --- a/hedera-node/hedera-mono-service/src/test/resources/serdes/MerklePayerRecords-v1-sn4.hex +++ b/hedera-node/hedera-mono-service/src/test/resources/serdes/MerklePayerRecords-v1-sn4.hex @@ -1 +1 @@ -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 \ No newline at end of file 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 \ No newline at end of file From b6fdb64e7d662042268a992aa1aa138d79ff499a Mon Sep 17 00:00:00 2001 From: nikolay Date: Wed, 31 Jan 2024 11:47:40 +0200 Subject: [PATCH 12/16] chore: revert Signed-off-by: nikolay --- hedera-node/hapi/hedera-protobufs | 1 - 1 file changed, 1 deletion(-) delete mode 160000 hedera-node/hapi/hedera-protobufs diff --git a/hedera-node/hapi/hedera-protobufs b/hedera-node/hapi/hedera-protobufs deleted file mode 160000 index 8857802cc0d7..000000000000 --- a/hedera-node/hapi/hedera-protobufs +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 8857802cc0d7cd7e571c43964512b7b3ba57c740 From 8504f7dae445a4e44aa600497f2701353598a05b Mon Sep 17 00:00:00 2001 From: nikolay Date: Fri, 2 Feb 2024 23:59:29 +0200 Subject: [PATCH 13/16] chore: fix missing signer nonce for ethereum contract creation record file Signed-off-by: nikolay --- .../ContractCreateTransitionLogic.java | 1 + .../ContractCreateTransitionLogicTest.java | 11 +++++++- .../bdd/suites/ethereum/NonceSuite.java | 28 ++++++++++++++++++- 3 files changed, 38 insertions(+), 2 deletions(-) diff --git a/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/txns/contract/ContractCreateTransitionLogic.java b/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/txns/contract/ContractCreateTransitionLogic.java index 893dd99f1795..9c12fd385888 100644 --- a/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/txns/contract/ContractCreateTransitionLogic.java +++ b/hedera-node/hedera-mono-service/src/main/java/com/hedera/node/app/service/mono/txns/contract/ContractCreateTransitionLogic.java @@ -220,6 +220,7 @@ public void doStateTransitionOperation( accountStore.loadAccount(relayerId), userOfferedGasPrice, maxGasAllowance); + result.setSignerNonce(worldState.get(senderId.asEvmAddress()).getNonce()); } } finally { worldState.resetHapiSenderCustomizer(); diff --git a/hedera-node/hedera-mono-service/src/test/java/com/hedera/node/app/service/mono/txns/contract/ContractCreateTransitionLogicTest.java b/hedera-node/hedera-mono-service/src/test/java/com/hedera/node/app/service/mono/txns/contract/ContractCreateTransitionLogicTest.java index 81ae663ddb05..b8674044fac4 100644 --- a/hedera-node/hedera-mono-service/src/test/java/com/hedera/node/app/service/mono/txns/contract/ContractCreateTransitionLogicTest.java +++ b/hedera-node/hedera-mono-service/src/test/java/com/hedera/node/app/service/mono/txns/contract/ContractCreateTransitionLogicTest.java @@ -54,6 +54,7 @@ import com.google.protobuf.ByteString; import com.hedera.node.app.service.evm.exceptions.InvalidTransactionException; +import com.hedera.node.app.service.evm.store.contracts.WorldStateAccount; import com.hedera.node.app.service.mono.context.NodeInfo; import com.hedera.node.app.service.mono.context.SideEffectsTracker; import com.hedera.node.app.service.mono.context.TransactionContext; @@ -198,6 +199,9 @@ class ContractCreateTransitionLogicTest { @Mock private AliasManager aliasManager; + @Mock + private WorldStateAccount worldSenderAccount; + private ContractCreateTransitionLogic subject; private TransactionBody contractCreateTxn; private MockedStatic sidecarUtilsMockedStatic; @@ -656,9 +660,10 @@ void successfullyUnlinkUnusedCreate1ContractAddress() { // and: given(accountStore.loadAccount(senderAccount.getId())).willReturn(senderAccount); + given(worldState.get(senderAccount.getId().asEvmAddress())).willReturn(worldSenderAccount); + given(worldSenderAccount.getNonce()).willReturn(5644L); given(worldState.newContractAddress(senderAccount.getId().asEvmAddress())) .willReturn(contractAccount.getId().asEvmAddress()); - given(worldState.getCreatedContractIds()).willReturn(expectedCreatedContracts); given(hfs.cat(bytecodeSrc)).willReturn(bytecode); given(txnCtx.consensusTime()).willReturn(consensusTime); @@ -977,6 +982,8 @@ void followsHappyPathWithCounterAndRecord() { given(accountStore.loadAccount(relayerAccount.getId())).willReturn(relayerAccount); given(hfs.cat(bytecodeSrc)).willReturn(bytecode); given(worldState.getCreatedContractIds()).willReturn(secondaryCreations); + given(worldState.get(senderAccount.getId().asEvmAddress())).willReturn(worldSenderAccount); + given(worldSenderAccount.getNonce()).willReturn(5644L); given(accountStore.loadAccountOrFailWith(Id.fromGrpcAccount(autoRenewAccount), INVALID_AUTORENEW_ACCOUNT)) .willReturn(autoRenewModel); given(autoRenewModel.isSmartContract()).willReturn(false); @@ -1031,6 +1038,8 @@ void followsHappyPathWithCounterAndRecordAndSidecars() { given(accountStore.loadAccount(relayerAccount.getId())).willReturn(relayerAccount); given(hfs.cat(bytecodeSrc)).willReturn(bytecode); given(worldState.getCreatedContractIds()).willReturn(secondaryCreations); + given(worldState.get(senderAccount.getId().asEvmAddress())).willReturn(worldSenderAccount); + given(worldSenderAccount.getNonce()).willReturn(5644L); given(accountStore.loadAccountOrFailWith(Id.fromGrpcAccount(autoRenewAccount), INVALID_AUTORENEW_ACCOUNT)) .willReturn(autoRenewModel); given(autoRenewModel.isSmartContract()).willReturn(false); diff --git a/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/ethereum/NonceSuite.java b/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/ethereum/NonceSuite.java index 17c9faa40d4e..75c23f1fd5b0 100644 --- a/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/ethereum/NonceSuite.java +++ b/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/ethereum/NonceSuite.java @@ -29,6 +29,7 @@ import static com.hedera.services.bdd.spec.transactions.TxnVerbs.cryptoCreate; import static com.hedera.services.bdd.spec.transactions.TxnVerbs.cryptoTransfer; import static com.hedera.services.bdd.spec.transactions.TxnVerbs.ethereumCall; +import static com.hedera.services.bdd.spec.transactions.TxnVerbs.ethereumContractCreate; import static com.hedera.services.bdd.spec.transactions.TxnVerbs.tokenCreate; import static com.hedera.services.bdd.spec.transactions.TxnVerbs.uploadInitCode; import static com.hedera.services.bdd.spec.transactions.contract.HapiParserUtil.asHeadlongAddress; @@ -47,6 +48,7 @@ import static com.hederahashgraph.api.proto.java.ResponseCodeEnum.NEGATIVE_ALLOWANCE_AMOUNT; import static com.hederahashgraph.api.proto.java.TokenType.FUNGIBLE_COMMON; +import com.hedera.node.app.hapi.utils.ethereum.EthTxData; import com.hedera.node.app.hapi.utils.ethereum.EthTxData.EthTransactionType; import com.hedera.services.bdd.spec.HapiPropertySource; import com.hedera.services.bdd.spec.HapiSpec; @@ -118,7 +120,9 @@ public List getSpecsInSuite() { // successful ethereum transactions via internal calls nonceUpdatedAfterSuccessfulInternalCall(), nonceUpdatedAfterSuccessfulInternalTransfer(), - nonceUpdatedAfterSuccessfulInternalContractDeployment()); + nonceUpdatedAfterSuccessfulInternalContractDeployment(), + // successful ethereum contract deploy + nonceUpdatedAfterSuccessfulEthereumContractCreation()); } private HapiSpec nonceNotUpdatedWhenSignerDoesExistPrecheckFailed() { @@ -662,6 +666,28 @@ private HapiSpec nonceUpdatedAfterSuccessfulInternalContractDeployment() { .contractCallResult(resultWith().signerNonce(1L)))); } + private HapiSpec nonceUpdatedAfterSuccessfulEthereumContractCreation() { + return defaultHapiSpec("nonceUpdatedAfterSuccessfulEthereumContractCreation") + .given( + newKeyNamed(SECP_256K1_SOURCE_KEY).shape(SECP_256K1_SHAPE), + cryptoCreate(RELAYER).balance(ONE_MILLION_HBARS), + cryptoTransfer(tinyBarsFromAccountToAlias(GENESIS, SECP_256K1_SOURCE_KEY, ONE_MILLION_HBARS)), + uploadInitCode(INTERNAL_CALLER_CONTRACT)) + .when(ethereumContractCreate(INTERNAL_CALLER_CONTRACT) + .type(EthTxData.EthTransactionType.EIP1559) + .signingWith(SECP_256K1_SOURCE_KEY) + .payingWith(RELAYER) + .nonce(0) + .gasLimit(ENOUGH_GAS_LIMIT) + .via(TX)) + .then( + getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(1L)), + getTxnRecord(TX) + .hasPriority(recordWith() + .contractCreateResult(resultWith().signerNonce(1L)))); + } + @Override protected Logger getResultsLogger() { return log; From 8611fd221f4e892eebcf136e39099eddd2105c46 Mon Sep 17 00:00:00 2001 From: nikolay Date: Mon, 5 Feb 2024 16:11:03 +0200 Subject: [PATCH 14/16] chore: add ethereum contract creation tests Signed-off-by: nikolay --- .../contract/HapiEthereumContractCreate.java | 7 +- .../bdd/suites/ethereum/NonceSuite.java | 166 ++++++++++++++++++ 2 files changed, 172 insertions(+), 1 deletion(-) diff --git a/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/spec/transactions/contract/HapiEthereumContractCreate.java b/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/spec/transactions/contract/HapiEthereumContractCreate.java index a3f4581f08b5..b1702b339b25 100644 --- a/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/spec/transactions/contract/HapiEthereumContractCreate.java +++ b/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/spec/transactions/contract/HapiEthereumContractCreate.java @@ -58,7 +58,7 @@ public class HapiEthereumContractCreate extends HapiBaseContractCreate ethFileID = Optional.empty(); private boolean invalidateEthData = false; @@ -173,6 +173,11 @@ public HapiEthereumContractCreate gasPrice(long gasPrice) { return this; } + public HapiEthereumContractCreate maxFeePerGas(long maxFeePerGas) { + this.maxFeePerGas = WEIBARS_TO_TINYBARS.multiply(BigInteger.valueOf(maxFeePerGas)); + return this; + } + public HapiEthereumContractCreate maxPriorityGas(long maxPriorityGas) { this.maxPriorityGas = maxPriorityGas; return this; diff --git a/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/ethereum/NonceSuite.java b/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/ethereum/NonceSuite.java index 75c23f1fd5b0..29a12e3cc7ab 100644 --- a/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/ethereum/NonceSuite.java +++ b/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/ethereum/NonceSuite.java @@ -121,6 +121,13 @@ public List getSpecsInSuite() { nonceUpdatedAfterSuccessfulInternalCall(), nonceUpdatedAfterSuccessfulInternalTransfer(), nonceUpdatedAfterSuccessfulInternalContractDeployment(), + // handler checks for contract creation + nonceNotUpdatedWhenIntrinsicGasHandlerCheckFailedEthContractCreate(), + nonceNotUpdatedWhenUserOfferedGasPriceAndAllowanceAreZeroHandlerCheckFailedEthContractCreate(), + nonceNotUpdatedWhenOfferedGasPriceIsLessThanCurrentAndSenderDoesNotHaveEnoughBalanceHandlerCheckFailedEthContractCreate(), + nonceNotUpdatedWhenOfferedGasPriceIsLessThanCurrentAndGasAllowanceIsLessThanRemainingFeeHandlerCheckFailedEthContractCreate(), + nonceNotUpdatedWhenOfferedGasPriceIsBiggerThanCurrentAndSenderDoesNotHaveEnoughBalanceHandlerCheckFailedEthContractCreate(), + nonceNotUpdatedWhenSenderDoesNotHaveEnoughBalanceHandlerCheckFailedEthContractCreate(), // successful ethereum contract deploy nonceUpdatedAfterSuccessfulEthereumContractCreation()); } @@ -666,6 +673,165 @@ private HapiSpec nonceUpdatedAfterSuccessfulInternalContractDeployment() { .contractCallResult(resultWith().signerNonce(1L)))); } + private HapiSpec nonceNotUpdatedWhenIntrinsicGasHandlerCheckFailedEthContractCreate() { + return defaultHapiSpec("nonceNotUpdatedWhenIntrinsicGasHandlerCheckFailedEthContractCreate") + .given( + newKeyNamed(SECP_256K1_SOURCE_KEY).shape(SECP_256K1_SHAPE), + cryptoCreate(RELAYER).balance(ONE_MILLION_HBARS), + cryptoTransfer(tinyBarsFromAccountToAlias(GENESIS, SECP_256K1_SOURCE_KEY, ONE_MILLION_HBARS)), + uploadInitCode(INTERNAL_CALLEE_CONTRACT)) + .when(ethereumContractCreate(INTERNAL_CALLEE_CONTRACT) + .type(EthTransactionType.EIP1559) + .signingWith(SECP_256K1_SOURCE_KEY) + .payingWith(RELAYER) + .nonce(0) + .gasLimit(21_000L) + .hasKnownStatus(INSUFFICIENT_GAS) + .via(TX)) + .then( + getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(0L)), + getTxnRecord(TX) + .hasPriority(recordWith() + .status(INSUFFICIENT_GAS) + .contractCallResult(resultWith().signerNonce(0L)))); + } + + private HapiSpec nonceNotUpdatedWhenUserOfferedGasPriceAndAllowanceAreZeroHandlerCheckFailedEthContractCreate() { + return defaultHapiSpec( + "nonceNotUpdatedWhenUserOfferedGasPriceAndAllowanceAreZeroHandlerCheckFailedEthContractCreate") + .given( + newKeyNamed(SECP_256K1_SOURCE_KEY).shape(SECP_256K1_SHAPE), + cryptoCreate(RELAYER).balance(ONE_MILLION_HBARS), + cryptoTransfer(tinyBarsFromAccountToAlias(GENESIS, SECP_256K1_SOURCE_KEY, ONE_MILLION_HBARS)), + uploadInitCode(INTERNAL_CALLEE_CONTRACT)) + .when(ethereumContractCreate(INTERNAL_CALLEE_CONTRACT) + .type(EthTransactionType.EIP1559) + .signingWith(SECP_256K1_SOURCE_KEY) + .payingWith(RELAYER) + .nonce(0) + .gasLimit(ENOUGH_GAS_LIMIT) + .maxFeePerGas(0L) + .maxGasAllowance(0L) + .hasKnownStatus(INSUFFICIENT_TX_FEE) + .via(TX)) + .then( + getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(0L)), + getTxnRecord(TX) + .hasPriority(recordWith() + .status(INSUFFICIENT_TX_FEE) + .contractCallResult(resultWith().signerNonce(0L)))); + } + + private HapiSpec + nonceNotUpdatedWhenOfferedGasPriceIsLessThanCurrentAndSenderDoesNotHaveEnoughBalanceHandlerCheckFailedEthContractCreate() { + return defaultHapiSpec( + "nonceNotUpdatedWhenOfferedGasPriceIsLessThanCurrentAndSenderDoesNotHaveEnoughBalanceHandlerCheckFailedEthContractCreate") + .given( + newKeyNamed(SECP_256K1_SOURCE_KEY).shape(SECP_256K1_SHAPE), + cryptoCreate(RELAYER).balance(ONE_MILLION_HBARS), + cryptoTransfer(tinyBarsFromAccountToAlias(GENESIS, SECP_256K1_SOURCE_KEY, 1L)), + uploadInitCode(INTERNAL_CALLEE_CONTRACT)) + .when(ethereumContractCreate(INTERNAL_CALLEE_CONTRACT) + .type(EthTransactionType.EIP1559) + .signingWith(SECP_256K1_SOURCE_KEY) + .payingWith(RELAYER) + .nonce(0) + .gasLimit(ENOUGH_GAS_LIMIT) + .maxFeePerGas(LOW_GAS_PRICE) + .hasKnownStatus(INSUFFICIENT_PAYER_BALANCE) + .via(TX)) + .then( + getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(0L)), + getTxnRecord(TX) + .hasPriority(recordWith() + .status(INSUFFICIENT_PAYER_BALANCE) + .contractCallResult(resultWith().signerNonce(0L)))); + } + + private HapiSpec + nonceNotUpdatedWhenOfferedGasPriceIsLessThanCurrentAndGasAllowanceIsLessThanRemainingFeeHandlerCheckFailedEthContractCreate() { + return defaultHapiSpec( + "nonceNotUpdatedWhenOfferedGasPriceIsLessThanCurrentAndGasAllowanceIsLessThanRemainingFeeHandlerCheckFailedEthContractCreate") + .given( + newKeyNamed(SECP_256K1_SOURCE_KEY).shape(SECP_256K1_SHAPE), + cryptoCreate(RELAYER).balance(ONE_MILLION_HBARS), + cryptoTransfer(tinyBarsFromAccountToAlias(GENESIS, SECP_256K1_SOURCE_KEY, ONE_MILLION_HBARS)), + uploadInitCode(INTERNAL_CALLEE_CONTRACT)) + .when(ethereumContractCreate(INTERNAL_CALLEE_CONTRACT) + .type(EthTransactionType.EIP1559) + .signingWith(SECP_256K1_SOURCE_KEY) + .payingWith(RELAYER) + .nonce(0) + .gasLimit(ENOUGH_GAS_LIMIT) + .maxFeePerGas(LOW_GAS_PRICE) + .maxGasAllowance(0L) + .hasKnownStatus(INSUFFICIENT_TX_FEE) + .via(TX)) + .then( + getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(0L)), + getTxnRecord(TX) + .hasPriority(recordWith() + .status(INSUFFICIENT_TX_FEE) + .contractCallResult(resultWith().signerNonce(0L)))); + } + + private HapiSpec + nonceNotUpdatedWhenOfferedGasPriceIsBiggerThanCurrentAndSenderDoesNotHaveEnoughBalanceHandlerCheckFailedEthContractCreate() { + return defaultHapiSpec( + "nonceNotUpdatedWhenOfferedGasPriceIsBiggerThanCurrentAndSenderDoesNotHaveEnoughBalanceHandlerCheckFailedEthContractCreate") + .given( + newKeyNamed(SECP_256K1_SOURCE_KEY).shape(SECP_256K1_SHAPE), + cryptoCreate(RELAYER).balance(ONE_MILLION_HBARS), + cryptoTransfer(tinyBarsFromAccountToAlias(GENESIS, SECP_256K1_SOURCE_KEY, 1L)), + uploadInitCode(INTERNAL_CALLEE_CONTRACT)) + .when(ethereumContractCreate(INTERNAL_CALLEE_CONTRACT) + .type(EthTransactionType.EIP1559) + .signingWith(SECP_256K1_SOURCE_KEY) + .payingWith(RELAYER) + .nonce(0) + .gasLimit(ENOUGH_GAS_LIMIT) + .maxFeePerGas(ENOUGH_GAS_PRICE) + .hasKnownStatus(INSUFFICIENT_PAYER_BALANCE) + .via(TX)) + .then( + getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(0L)), + getTxnRecord(TX) + .hasPriority(recordWith() + .status(INSUFFICIENT_PAYER_BALANCE) + .contractCallResult(resultWith().signerNonce(0L)))); + } + + private HapiSpec nonceNotUpdatedWhenSenderDoesNotHaveEnoughBalanceHandlerCheckFailedEthContractCreate() { + return defaultHapiSpec("nonceNotUpdatedWhenSenderDoesNotHaveEnoughBalanceHandlerCheckFailedEthContractCreate") + .given( + newKeyNamed(SECP_256K1_SOURCE_KEY).shape(SECP_256K1_SHAPE), + cryptoCreate(RELAYER).balance(ONE_MILLION_HBARS), + cryptoTransfer(tinyBarsFromAccountToAlias(GENESIS, SECP_256K1_SOURCE_KEY, 1L)), + uploadInitCode(INTERNAL_CALLEE_CONTRACT)) + .when(ethereumContractCreate(INTERNAL_CALLEE_CONTRACT) + .type(EthTransactionType.EIP1559) + .signingWith(SECP_256K1_SOURCE_KEY) + .payingWith(RELAYER) + .nonce(0) + .gasLimit(ENOUGH_GAS_LIMIT) + .maxFeePerGas(0L) + .balance(5L) + .hasKnownStatus(INSUFFICIENT_PAYER_BALANCE) + .via(TX)) + .then( + getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(0L)), + getTxnRecord(TX) + .hasPriority(recordWith() + .status(INSUFFICIENT_PAYER_BALANCE) + .contractCallResult(resultWith().signerNonce(0L)))); + } + private HapiSpec nonceUpdatedAfterSuccessfulEthereumContractCreation() { return defaultHapiSpec("nonceUpdatedAfterSuccessfulEthereumContractCreation") .given( From 773113f0f11c1f67c92e75678529ad48a744ee53 Mon Sep 17 00:00:00 2001 From: nikolay Date: Mon, 5 Feb 2024 17:28:41 +0200 Subject: [PATCH 15/16] chore: add eth contract creation tests Signed-off-by: nikolay --- .../bdd/suites/ethereum/NonceSuite.java | 78 +++++++++++++++++++ .../ReverterConstructor.bin | 1 + .../ReverterConstructor.json | 7 ++ .../ReverterConstructor.sol | 8 ++ .../ReverterTransfer/ReverterTransfer.bin | 1 + .../ReverterTransfer/ReverterTransfer.json | 7 ++ .../ReverterTransfer/ReverterTransfer.sol | 9 +++ 7 files changed, 111 insertions(+) create mode 100644 hedera-node/test-clients/src/main/resource/contract/contracts/ReverterConstructor/ReverterConstructor.bin create mode 100644 hedera-node/test-clients/src/main/resource/contract/contracts/ReverterConstructor/ReverterConstructor.json create mode 100644 hedera-node/test-clients/src/main/resource/contract/contracts/ReverterConstructor/ReverterConstructor.sol create mode 100644 hedera-node/test-clients/src/main/resource/contract/contracts/ReverterTransfer/ReverterTransfer.bin create mode 100644 hedera-node/test-clients/src/main/resource/contract/contracts/ReverterTransfer/ReverterTransfer.json create mode 100644 hedera-node/test-clients/src/main/resource/contract/contracts/ReverterTransfer/ReverterTransfer.sol diff --git a/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/ethereum/NonceSuite.java b/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/ethereum/NonceSuite.java index 29a12e3cc7ab..32e09e22350b 100644 --- a/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/ethereum/NonceSuite.java +++ b/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/ethereum/NonceSuite.java @@ -75,6 +75,8 @@ public class NonceSuite extends HapiSuite { private static final String INTERNAL_CALLER_CONTRACT = "InternalCaller"; private static final String MANY_CHILDREN_CONTRACT = "ManyChildren"; private static final String FACTORY_CONTRACT = "FactoryContract"; + private static final String REVERTER_CONSTRUCTOR_CONTRACT = "ReverterConstructor"; + private static final String REVERTER_TRANSFER_CONTRACT = "ReverterTransfer"; private static final String EXTERNAL_FUNCTION = "externalFunction"; private static final String REVERT_WITH_REVERT_REASON_FUNCTION = "revertWithRevertReason"; private static final String TRANSFER_TO_FUNCTION = "transferTo"; @@ -128,6 +130,10 @@ public List getSpecsInSuite() { nonceNotUpdatedWhenOfferedGasPriceIsLessThanCurrentAndGasAllowanceIsLessThanRemainingFeeHandlerCheckFailedEthContractCreate(), nonceNotUpdatedWhenOfferedGasPriceIsBiggerThanCurrentAndSenderDoesNotHaveEnoughBalanceHandlerCheckFailedEthContractCreate(), nonceNotUpdatedWhenSenderDoesNotHaveEnoughBalanceHandlerCheckFailedEthContractCreate(), + // evm smart contract reversions for contract creation + nonceUpdatedAfterEvmReversionDueContractLogicEthContractCreate(), + nonceUpdatedAfterEvmReversionDueInsufficientGasEthContractCreate(), + nonceUpdatedAfterEvmReversionDueInsufficientTransferAmountEthContractCreate(), // successful ethereum contract deploy nonceUpdatedAfterSuccessfulEthereumContractCreation()); } @@ -832,6 +838,78 @@ private HapiSpec nonceNotUpdatedWhenSenderDoesNotHaveEnoughBalanceHandlerCheckFa .contractCallResult(resultWith().signerNonce(0L)))); } + private HapiSpec nonceUpdatedAfterEvmReversionDueContractLogicEthContractCreate() { + return defaultHapiSpec("nonceUpdatedAfterEvmReversionDueContractLogicEthContractCreate") + .given( + newKeyNamed(SECP_256K1_SOURCE_KEY).shape(SECP_256K1_SHAPE), + cryptoCreate(RELAYER).balance(ONE_MILLION_HBARS), + cryptoTransfer(tinyBarsFromAccountToAlias(GENESIS, SECP_256K1_SOURCE_KEY, ONE_MILLION_HBARS)), + uploadInitCode(REVERTER_CONSTRUCTOR_CONTRACT)) + .when(ethereumContractCreate(REVERTER_CONSTRUCTOR_CONTRACT) + .type(EthTransactionType.EIP1559) + .signingWith(SECP_256K1_SOURCE_KEY) + .payingWith(RELAYER) + .nonce(0) + .gasLimit(ENOUGH_GAS_LIMIT) + .hasKnownStatus(CONTRACT_REVERT_EXECUTED) + .via(TX)) + .then( + getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(1L)), + getTxnRecord(TX) + .hasPriority(recordWith() + .status(CONTRACT_REVERT_EXECUTED) + .contractCreateResult(resultWith().signerNonce(1L)))); + } + + private HapiSpec nonceUpdatedAfterEvmReversionDueInsufficientGasEthContractCreate() { + return defaultHapiSpec("nonceUpdatedAfterEvmReversionDueInsufficientGasEthContractCreate") + .given( + newKeyNamed(SECP_256K1_SOURCE_KEY).shape(SECP_256K1_SHAPE), + cryptoCreate(RELAYER).balance(ONE_MILLION_HBARS), + cryptoTransfer(tinyBarsFromAccountToAlias(GENESIS, SECP_256K1_SOURCE_KEY, ONE_MILLION_HBARS)), + uploadInitCode(REVERTER_TRANSFER_CONTRACT)) + .when(ethereumContractCreate(REVERTER_TRANSFER_CONTRACT) + .type(EthTransactionType.EIP1559) + .signingWith(SECP_256K1_SOURCE_KEY) + .payingWith(RELAYER) + .nonce(0) + .gasLimit(60_000L) + .hasKnownStatus(INSUFFICIENT_GAS) + .via(TX)) + .then( + getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(1L)), + getTxnRecord(TX) + .hasPriority(recordWith() + .status(INSUFFICIENT_GAS) + .contractCreateResult(resultWith().signerNonce(1L)))); + } + + private HapiSpec nonceUpdatedAfterEvmReversionDueInsufficientTransferAmountEthContractCreate() { + return defaultHapiSpec("nonceUpdatedAfterEvmReversionDueInsufficientTransferAmountEthContractCreate") + .given( + newKeyNamed(SECP_256K1_SOURCE_KEY).shape(SECP_256K1_SHAPE), + cryptoCreate(RELAYER).balance(ONE_MILLION_HBARS), + cryptoTransfer(tinyBarsFromAccountToAlias(GENESIS, SECP_256K1_SOURCE_KEY, ONE_MILLION_HBARS)), + uploadInitCode(REVERTER_TRANSFER_CONTRACT)) + .when(ethereumContractCreate(REVERTER_TRANSFER_CONTRACT) + .type(EthTransactionType.EIP1559) + .signingWith(SECP_256K1_SOURCE_KEY) + .payingWith(RELAYER) + .nonce(0) + .gasLimit(ENOUGH_GAS_LIMIT) + .hasKnownStatus(CONTRACT_REVERT_EXECUTED) + .via(TX)) + .then( + getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(1L)), + getTxnRecord(TX) + .hasPriority(recordWith() + .status(CONTRACT_REVERT_EXECUTED) + .contractCreateResult(resultWith().signerNonce(1L)))); + } + private HapiSpec nonceUpdatedAfterSuccessfulEthereumContractCreation() { return defaultHapiSpec("nonceUpdatedAfterSuccessfulEthereumContractCreation") .given( diff --git a/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterConstructor/ReverterConstructor.bin b/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterConstructor/ReverterConstructor.bin new file mode 100644 index 000000000000..77d04f83b3a6 --- /dev/null +++ b/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterConstructor/ReverterConstructor.bin @@ -0,0 +1 @@ +6080604052348015600e575f80fd5b5f80fdfe \ No newline at end of file diff --git a/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterConstructor/ReverterConstructor.json b/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterConstructor/ReverterConstructor.json new file mode 100644 index 000000000000..b9a2575bb60b --- /dev/null +++ b/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterConstructor/ReverterConstructor.json @@ -0,0 +1,7 @@ +[ + { + "inputs": [], + "stateMutability": "nonpayable", + "type": "constructor" + } +] diff --git a/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterConstructor/ReverterConstructor.sol b/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterConstructor/ReverterConstructor.sol new file mode 100644 index 000000000000..39d920dd31f8 --- /dev/null +++ b/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterConstructor/ReverterConstructor.sol @@ -0,0 +1,8 @@ +// SPDX-License-Identifier: Apache-2.0 +pragma solidity ^0.8.20; + +contract ReverterConstructor { + constructor() { + revert(); + } +} diff --git a/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterTransfer/ReverterTransfer.bin b/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterTransfer/ReverterTransfer.bin new file mode 100644 index 000000000000..455de30a38d6 --- /dev/null +++ b/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterTransfer/ReverterTransfer.bin @@ -0,0 +1 @@ +60806040525f4260405160200160149190608e565b6040516020818303038152906040528051906020012060601c90508073ffffffffffffffffffffffffffffffffffffffff166108fc600190811502906040515f60405180830381858888f193505050501580156072573d5f803e3d5ffd5b505060a5565b5f819050919050565b6088816078565b82525050565b5f602082019050609f5f8301846081565b92915050565b603e8060b05f395ff3fe60806040525f80fdfea2646970667358221220058262f2fd04a4916e59d9c13fe3a5028d80131c08860d5961afbe77e0b2b32964736f6c63430008180033 \ No newline at end of file diff --git a/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterTransfer/ReverterTransfer.json b/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterTransfer/ReverterTransfer.json new file mode 100644 index 000000000000..5fa856267a8b --- /dev/null +++ b/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterTransfer/ReverterTransfer.json @@ -0,0 +1,7 @@ +[ + { + "inputs": [], + "stateMutability": "payable", + "type": "constructor" + } +] \ No newline at end of file diff --git a/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterTransfer/ReverterTransfer.sol b/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterTransfer/ReverterTransfer.sol new file mode 100644 index 000000000000..e337e748ca7c --- /dev/null +++ b/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterTransfer/ReverterTransfer.sol @@ -0,0 +1,9 @@ +// SPDX-License-Identifier: Apache-2.0 +pragma solidity ^0.8.20; + +contract ReverterTransfer { + constructor() payable { + address addr = address(bytes20(keccak256(abi.encode(block.timestamp)))); + payable(addr).transfer(1); + } +} From 11f63931237a9af690b0f8c0fd2c9bbd4aa8bfd3 Mon Sep 17 00:00:00 2001 From: nikolay Date: Tue, 6 Feb 2024 16:05:35 +0200 Subject: [PATCH 16/16] chore: add tests Signed-off-by: nikolay --- .../bdd/suites/ethereum/NonceSuite.java | 66 +++++++++++++++++-- ...onstructorCallWithValueToEthPrecompile.bin | 1 + ...structorCallWithValueToEthPrecompile.json} | 0 ...onstructorCallWithValueToEthPrecompile.sol | 10 +++ ...tructorCallWithValueToHederaPrecompile.bin | 1 + ...ructorCallWithValueToHederaPrecompile.json | 7 ++ ...tructorCallWithValueToHederaPrecompile.sol | 10 +++ .../ReverterConstructorTransfer.bin | 1 + .../ReverterConstructorTransfer.json | 7 ++ .../ReverterConstructorTransfer.sol | 8 +++ .../ReverterTransfer/ReverterTransfer.bin | 1 - .../ReverterTransfer/ReverterTransfer.sol | 9 --- 12 files changed, 106 insertions(+), 15 deletions(-) create mode 100644 hedera-node/test-clients/src/main/resource/contract/contracts/ReverterConstructorCallWithValueToEthPrecompile/ReverterConstructorCallWithValueToEthPrecompile.bin rename hedera-node/test-clients/src/main/resource/contract/contracts/{ReverterTransfer/ReverterTransfer.json => ReverterConstructorCallWithValueToEthPrecompile/ReverterConstructorCallWithValueToEthPrecompile.json} (100%) create mode 100644 hedera-node/test-clients/src/main/resource/contract/contracts/ReverterConstructorCallWithValueToEthPrecompile/ReverterConstructorCallWithValueToEthPrecompile.sol create mode 100644 hedera-node/test-clients/src/main/resource/contract/contracts/ReverterConstructorCallWithValueToHederaPrecompile/ReverterConstructorCallWithValueToHederaPrecompile.bin create mode 100644 hedera-node/test-clients/src/main/resource/contract/contracts/ReverterConstructorCallWithValueToHederaPrecompile/ReverterConstructorCallWithValueToHederaPrecompile.json create mode 100644 hedera-node/test-clients/src/main/resource/contract/contracts/ReverterConstructorCallWithValueToHederaPrecompile/ReverterConstructorCallWithValueToHederaPrecompile.sol create mode 100644 hedera-node/test-clients/src/main/resource/contract/contracts/ReverterConstructorTransfer/ReverterConstructorTransfer.bin create mode 100644 hedera-node/test-clients/src/main/resource/contract/contracts/ReverterConstructorTransfer/ReverterConstructorTransfer.json create mode 100644 hedera-node/test-clients/src/main/resource/contract/contracts/ReverterConstructorTransfer/ReverterConstructorTransfer.sol delete mode 100644 hedera-node/test-clients/src/main/resource/contract/contracts/ReverterTransfer/ReverterTransfer.bin delete mode 100644 hedera-node/test-clients/src/main/resource/contract/contracts/ReverterTransfer/ReverterTransfer.sol diff --git a/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/ethereum/NonceSuite.java b/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/ethereum/NonceSuite.java index 32e09e22350b..28c7075fe928 100644 --- a/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/ethereum/NonceSuite.java +++ b/hedera-node/test-clients/src/main/java/com/hedera/services/bdd/suites/ethereum/NonceSuite.java @@ -76,7 +76,11 @@ public class NonceSuite extends HapiSuite { private static final String MANY_CHILDREN_CONTRACT = "ManyChildren"; private static final String FACTORY_CONTRACT = "FactoryContract"; private static final String REVERTER_CONSTRUCTOR_CONTRACT = "ReverterConstructor"; - private static final String REVERTER_TRANSFER_CONTRACT = "ReverterTransfer"; + private static final String REVERTER_CONSTRUCTOR_TRANSFER_CONTRACT = "ReverterConstructorTransfer"; + private static final String REVERTER_CONSTRUCTOR_CALL_WITH_VALUE_TO_ETH_PRECOMPILE_CONTRACT = + "ReverterConstructorCallWithValueToEthPrecompile"; + private static final String REVERTER_CONSTRUCTOR_CALL_WITH_VALUE_TO_HEDERA_PRECOMPILE_CONTRACT = + "ReverterConstructorCallWithValueToHederaPrecompile"; private static final String EXTERNAL_FUNCTION = "externalFunction"; private static final String REVERT_WITH_REVERT_REASON_FUNCTION = "revertWithRevertReason"; private static final String TRANSFER_TO_FUNCTION = "transferTo"; @@ -134,6 +138,8 @@ public List getSpecsInSuite() { nonceUpdatedAfterEvmReversionDueContractLogicEthContractCreate(), nonceUpdatedAfterEvmReversionDueInsufficientGasEthContractCreate(), nonceUpdatedAfterEvmReversionDueInsufficientTransferAmountEthContractCreate(), + // evm hedera specific reversions for contract creation + nonceUpdatedAfterEvmReversionDueSendingValueToEthereumPrecompileEthContractCreate(), // successful ethereum contract deploy nonceUpdatedAfterSuccessfulEthereumContractCreation()); } @@ -868,8 +874,8 @@ private HapiSpec nonceUpdatedAfterEvmReversionDueInsufficientGasEthContractCreat newKeyNamed(SECP_256K1_SOURCE_KEY).shape(SECP_256K1_SHAPE), cryptoCreate(RELAYER).balance(ONE_MILLION_HBARS), cryptoTransfer(tinyBarsFromAccountToAlias(GENESIS, SECP_256K1_SOURCE_KEY, ONE_MILLION_HBARS)), - uploadInitCode(REVERTER_TRANSFER_CONTRACT)) - .when(ethereumContractCreate(REVERTER_TRANSFER_CONTRACT) + uploadInitCode(REVERTER_CONSTRUCTOR_TRANSFER_CONTRACT)) + .when(ethereumContractCreate(REVERTER_CONSTRUCTOR_TRANSFER_CONTRACT) .type(EthTransactionType.EIP1559) .signingWith(SECP_256K1_SOURCE_KEY) .payingWith(RELAYER) @@ -892,8 +898,58 @@ private HapiSpec nonceUpdatedAfterEvmReversionDueInsufficientTransferAmountEthCo newKeyNamed(SECP_256K1_SOURCE_KEY).shape(SECP_256K1_SHAPE), cryptoCreate(RELAYER).balance(ONE_MILLION_HBARS), cryptoTransfer(tinyBarsFromAccountToAlias(GENESIS, SECP_256K1_SOURCE_KEY, ONE_MILLION_HBARS)), - uploadInitCode(REVERTER_TRANSFER_CONTRACT)) - .when(ethereumContractCreate(REVERTER_TRANSFER_CONTRACT) + uploadInitCode(REVERTER_CONSTRUCTOR_TRANSFER_CONTRACT)) + .when(ethereumContractCreate(REVERTER_CONSTRUCTOR_TRANSFER_CONTRACT) + .type(EthTransactionType.EIP1559) + .signingWith(SECP_256K1_SOURCE_KEY) + .payingWith(RELAYER) + .nonce(0) + .gasLimit(ENOUGH_GAS_LIMIT) + .hasKnownStatus(CONTRACT_REVERT_EXECUTED) + .via(TX)) + .then( + getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(1L)), + getTxnRecord(TX) + .hasPriority(recordWith() + .contractCreateResult(resultWith().signerNonce(1L)))); + } + + private HapiSpec nonceUpdatedAfterEvmReversionDueSendingValueToEthereumPrecompileEthContractCreate() { + return defaultHapiSpec("nonceUpdatedAfterEvmReversionDueSendingValueToEthereumPrecompileEthContractCreate") + .given( + newKeyNamed(SECP_256K1_SOURCE_KEY).shape(SECP_256K1_SHAPE), + cryptoCreate(RELAYER).balance(ONE_MILLION_HBARS), + cryptoTransfer(tinyBarsFromAccountToAlias(GENESIS, SECP_256K1_SOURCE_KEY, ONE_MILLION_HBARS)), + uploadInitCode(REVERTER_CONSTRUCTOR_CALL_WITH_VALUE_TO_ETH_PRECOMPILE_CONTRACT)) + .when(ethereumContractCreate(REVERTER_CONSTRUCTOR_CALL_WITH_VALUE_TO_ETH_PRECOMPILE_CONTRACT) + .balance(1L) + .type(EthTransactionType.EIP1559) + .signingWith(SECP_256K1_SOURCE_KEY) + .payingWith(RELAYER) + .nonce(0) + .gasLimit(ENOUGH_GAS_LIMIT) + .hasKnownStatus(CONTRACT_REVERT_EXECUTED) + .via(TX)) + .then( + getAliasedAccountInfo(SECP_256K1_SOURCE_KEY) + .has(accountWith().nonce(1L)), + getTxnRecord(TX) + .hasPriority(recordWith() + .status(CONTRACT_REVERT_EXECUTED) + .contractCreateResult(resultWith().signerNonce(1L)))); + } + + // depends on https://github.com/hashgraph/hedera-services/pull/11359 + private HapiSpec nonceUpdatedAfterEvmReversionDueSendingValueToHederaPrecompileEthContractCreate() { + return defaultHapiSpec("nonceUpdatedAfterEvmReversionDueSendingValueToHederaPrecompileEthContractCreate") + .given( + newKeyNamed(SECP_256K1_SOURCE_KEY).shape(SECP_256K1_SHAPE), + cryptoCreate(RELAYER).balance(ONE_MILLION_HBARS), + cryptoTransfer(tinyBarsFromAccountToAlias(GENESIS, SECP_256K1_SOURCE_KEY, ONE_MILLION_HBARS)), + uploadInitCode(REVERTER_CONSTRUCTOR_CALL_WITH_VALUE_TO_HEDERA_PRECOMPILE_CONTRACT)) + .when(ethereumContractCreate(REVERTER_CONSTRUCTOR_CALL_WITH_VALUE_TO_HEDERA_PRECOMPILE_CONTRACT) + .balance(1L) .type(EthTransactionType.EIP1559) .signingWith(SECP_256K1_SOURCE_KEY) .payingWith(RELAYER) diff --git a/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterConstructorCallWithValueToEthPrecompile/ReverterConstructorCallWithValueToEthPrecompile.bin b/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterConstructorCallWithValueToEthPrecompile/ReverterConstructorCallWithValueToEthPrecompile.bin new file mode 100644 index 000000000000..c3109ff3e5c2 --- /dev/null +++ b/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterConstructorCallWithValueToEthPrecompile/ReverterConstructorCallWithValueToEthPrecompile.bin @@ -0,0 +1 @@ +60806040525f600273ffffffffffffffffffffffffffffffffffffffff16600160405160299060a0565b5f6040518083038185875af1925050503d805f81146061576040519150601f19603f3d011682016040523d82523d5f602084013e6066565b606091505b50509050806072575f80fd5b5060b2565b5f81905092915050565b50565b5f608d5f836077565b91506096826081565b5f82019050919050565b5f60a8826084565b9150819050919050565b603e806100be5f395ff3fe60806040525f80fdfea2646970667358221220cfd74ec433260a256306ef1da5c77086227316d3538abdac6b46baa3d537964164736f6c63430008180033 \ No newline at end of file diff --git a/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterTransfer/ReverterTransfer.json b/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterConstructorCallWithValueToEthPrecompile/ReverterConstructorCallWithValueToEthPrecompile.json similarity index 100% rename from hedera-node/test-clients/src/main/resource/contract/contracts/ReverterTransfer/ReverterTransfer.json rename to hedera-node/test-clients/src/main/resource/contract/contracts/ReverterConstructorCallWithValueToEthPrecompile/ReverterConstructorCallWithValueToEthPrecompile.json diff --git a/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterConstructorCallWithValueToEthPrecompile/ReverterConstructorCallWithValueToEthPrecompile.sol b/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterConstructorCallWithValueToEthPrecompile/ReverterConstructorCallWithValueToEthPrecompile.sol new file mode 100644 index 000000000000..3b83e214d928 --- /dev/null +++ b/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterConstructorCallWithValueToEthPrecompile/ReverterConstructorCallWithValueToEthPrecompile.sol @@ -0,0 +1,10 @@ +// SPDX-License-Identifier: Apache-2.0 +pragma solidity ^0.8.20; + +contract ReverterConstructorCallWithValueToEthPrecompile { + constructor() payable { + (bool success,) = address(0x2).call{value: 1}(""); + + require(success); + } +} diff --git a/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterConstructorCallWithValueToHederaPrecompile/ReverterConstructorCallWithValueToHederaPrecompile.bin b/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterConstructorCallWithValueToHederaPrecompile/ReverterConstructorCallWithValueToHederaPrecompile.bin new file mode 100644 index 000000000000..7f0d05915670 --- /dev/null +++ b/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterConstructorCallWithValueToHederaPrecompile/ReverterConstructorCallWithValueToHederaPrecompile.bin @@ -0,0 +1 @@ +60806040525f61016773ffffffffffffffffffffffffffffffffffffffff166001604051602a9060a1565b5f6040518083038185875af1925050503d805f81146062576040519150601f19603f3d011682016040523d82523d5f602084013e6067565b606091505b50509050806073575f80fd5b5060b3565b5f81905092915050565b50565b5f608e5f836078565b91506097826082565b5f82019050919050565b5f60a9826085565b9150819050919050565b603e806100bf5f395ff3fe60806040525f80fdfea2646970667358221220d8429086ef3ca628542c700e6826b788bdc6ab6ee2f72f5f91b318e5ae76981464736f6c63430008180033 \ No newline at end of file diff --git a/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterConstructorCallWithValueToHederaPrecompile/ReverterConstructorCallWithValueToHederaPrecompile.json b/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterConstructorCallWithValueToHederaPrecompile/ReverterConstructorCallWithValueToHederaPrecompile.json new file mode 100644 index 000000000000..5fa856267a8b --- /dev/null +++ b/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterConstructorCallWithValueToHederaPrecompile/ReverterConstructorCallWithValueToHederaPrecompile.json @@ -0,0 +1,7 @@ +[ + { + "inputs": [], + "stateMutability": "payable", + "type": "constructor" + } +] \ No newline at end of file diff --git a/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterConstructorCallWithValueToHederaPrecompile/ReverterConstructorCallWithValueToHederaPrecompile.sol b/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterConstructorCallWithValueToHederaPrecompile/ReverterConstructorCallWithValueToHederaPrecompile.sol new file mode 100644 index 000000000000..b85649416b78 --- /dev/null +++ b/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterConstructorCallWithValueToHederaPrecompile/ReverterConstructorCallWithValueToHederaPrecompile.sol @@ -0,0 +1,10 @@ +// SPDX-License-Identifier: Apache-2.0 +pragma solidity ^0.8.20; + +contract ReverterConstructorCallWithValueToHederaPrecompile { + constructor() payable { + (bool success,) = address(0x167).call{value: 1}(""); + + require(success); + } +} diff --git a/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterConstructorTransfer/ReverterConstructorTransfer.bin b/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterConstructorTransfer/ReverterConstructorTransfer.bin new file mode 100644 index 000000000000..1327b73d5de1 --- /dev/null +++ b/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterConstructorTransfer/ReverterConstructorTransfer.bin @@ -0,0 +1 @@ +60806040523373ffffffffffffffffffffffffffffffffffffffff166108fc600190811502906040515f60405180830381858888f193505050501580156047573d5f803e3d5ffd5b50603e8060535f395ff3fe60806040525f80fdfea2646970667358221220f7a4b5b518a591095ab2a37161bfdd9bde65cfb7d6b46b636b9f36c66446c72364736f6c63430008180033 \ No newline at end of file diff --git a/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterConstructorTransfer/ReverterConstructorTransfer.json b/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterConstructorTransfer/ReverterConstructorTransfer.json new file mode 100644 index 000000000000..5fa856267a8b --- /dev/null +++ b/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterConstructorTransfer/ReverterConstructorTransfer.json @@ -0,0 +1,7 @@ +[ + { + "inputs": [], + "stateMutability": "payable", + "type": "constructor" + } +] \ No newline at end of file diff --git a/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterConstructorTransfer/ReverterConstructorTransfer.sol b/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterConstructorTransfer/ReverterConstructorTransfer.sol new file mode 100644 index 000000000000..4d3c179d60ee --- /dev/null +++ b/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterConstructorTransfer/ReverterConstructorTransfer.sol @@ -0,0 +1,8 @@ +// SPDX-License-Identifier: Apache-2.0 +pragma solidity ^0.8.20; + +contract ReverterConstructorTransfer { + constructor() payable { + payable(msg.sender).transfer(1); + } +} diff --git a/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterTransfer/ReverterTransfer.bin b/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterTransfer/ReverterTransfer.bin deleted file mode 100644 index 455de30a38d6..000000000000 --- a/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterTransfer/ReverterTransfer.bin +++ /dev/null @@ -1 +0,0 @@ -60806040525f4260405160200160149190608e565b6040516020818303038152906040528051906020012060601c90508073ffffffffffffffffffffffffffffffffffffffff166108fc600190811502906040515f60405180830381858888f193505050501580156072573d5f803e3d5ffd5b505060a5565b5f819050919050565b6088816078565b82525050565b5f602082019050609f5f8301846081565b92915050565b603e8060b05f395ff3fe60806040525f80fdfea2646970667358221220058262f2fd04a4916e59d9c13fe3a5028d80131c08860d5961afbe77e0b2b32964736f6c63430008180033 \ No newline at end of file diff --git a/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterTransfer/ReverterTransfer.sol b/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterTransfer/ReverterTransfer.sol deleted file mode 100644 index e337e748ca7c..000000000000 --- a/hedera-node/test-clients/src/main/resource/contract/contracts/ReverterTransfer/ReverterTransfer.sol +++ /dev/null @@ -1,9 +0,0 @@ -// SPDX-License-Identifier: Apache-2.0 -pragma solidity ^0.8.20; - -contract ReverterTransfer { - constructor() payable { - address addr = address(bytes20(keccak256(abi.encode(block.timestamp)))); - payable(addr).transfer(1); - } -}