Repository: hashgraph/hedera-services
Issue: Smart contract Allowance Solidity Interfaces Incorrectly Implemented

The interfaces as described in [HIP-218](https://hips.hedera.com/hip/hip-218) have only been implemented for HTS redirect, not for direct HTS calls.

We should implement a set of methods against the HTS Precompile address (0x167) that includes the token ID as an argument, 
* allowance(address token, address owner, address spender)
* approve(address token, address spender, uint256 amount)
* approveNFT(address token, address to, uint256 tokenId)
* setApprovalForAll(address token, address operator, bool approved)
* isApprovedForAll(address token, address owner, address operator)
*  isApproved(address token, uint256 tokenId)


Changed files:
hedera-node/src/test/java/com/hedera/services/txns/crypto/validators/DeleteAllowanceChecksTest.java
hedera-node/src/main/java/com/hedera/services/store/contracts/precompile/HTSPrecompiledContract.java
hedera-node/src/main/java/com/hedera/services/store/contracts/precompile/impl/ApprovePrecompile.java
hedera-node/src/main/java/com/hedera/services/exceptions/ValidationUtils.java
hedera-node/src/main/java/com/hedera/services/store/contracts/precompile/AbiConstants.java
hedera-node/src/test/java/com/hedera/services/store/contracts/precompile/proxy/RedirectViewExecutorTest.java
hedera-node/src/main/java/com/hedera/services/exceptions/InvalidTransactionException.java
hedera-node/src/test/java/com/hedera/services/exceptions/InvalidTransactionExceptionTest.java
hedera-node/src/test/java/com/hedera/services/store/contracts/precompile/HTSPrecompiledContractTest.java
hedera-node/src/test/java/com/hedera/services/store/contracts/precompile/ERC20PrecompilesTest.java
hedera-node/src/main/java/com/hedera/services/store/contracts/precompile/proxy/RedirectViewExecutor.java
hedera-node/src/test/java/com/hedera/services/store/contracts/precompile/ERC721PrecompilesTest.java
hedera-node/src/main/java/com/hedera/services/store/contracts/precompile/impl/ERCTransferPrecompile.java

diff --git a/hedera-node/src/main/java/com/hedera/services/exceptions/InvalidTransactionException.java b/hedera-node/src/main/java/com/hedera/services/exceptions/InvalidTransactionException.java
index 81084c2ab6..d330601b2c 100644
--- a/hedera-node/src/main/java/com/hedera/services/exceptions/InvalidTransactionException.java
+++ b/hedera-node/src/main/java/com/hedera/services/exceptions/InvalidTransactionException.java
@@ -34,27 +34,27 @@ import org.apache.tuweni.bytes.Bytes;
  * detail message in the constructor.
  */
 public class InvalidTransactionException extends RuntimeException {
-	private static final String REVERT_REASON_TAG_START = "{{";
-	private static final String REVERT_REASON_TAG_END = "}}";
 
 	private final ResponseCodeEnum responseCode;
+	private final boolean reverting;
 
 	public InvalidTransactionException(final ResponseCodeEnum responseCode) {
-		super(responseCode.name());
-		this.responseCode = responseCode;
+		this(responseCode.name(), responseCode, false);
 	}
-
-	public InvalidTransactionException(final String detailMessage, final ResponseCodeEnum responseCode) {
-		super(detailMessage);
-		this.responseCode = responseCode;
+	
+	public InvalidTransactionException(final ResponseCodeEnum responseCode, boolean reverting) {
+		this(responseCode.name(), responseCode, reverting);
 	}
 
-	public static InvalidTransactionException fromReverting(final ResponseCodeEnum code) {
-		return new InvalidTransactionException(revertingDetail(code.name()), code);
+	public InvalidTransactionException(final String detailMessage, final ResponseCodeEnum responseCode) {
+		this(detailMessage, responseCode, false);
 	}
 
-	public static InvalidTransactionException fromReverting(final ResponseCodeEnum code, final String reason) {
-		return new InvalidTransactionException(revertingDetail(reason), code);
+	public InvalidTransactionException(final String detailMessage, final ResponseCodeEnum responseCode,
+			boolean reverting) {
+		super(detailMessage);
+		this.responseCode = responseCode;
+		this.reverting = reverting;
 	}
 
 	public ResponseCodeEnum getResponseCode() {
@@ -62,7 +62,7 @@ public class InvalidTransactionException extends RuntimeException {
 	}
 
 	public boolean isReverting() {
-		return getMessage().startsWith(REVERT_REASON_TAG_START);
+		return reverting;
 	}
 
 	public Bytes getRevertReason() {
@@ -70,11 +70,6 @@ public class InvalidTransactionException extends RuntimeException {
 			throw new IllegalStateException();
 		}
 		final var detail = getMessage();
-		return Bytes.of(
-				detail.substring(REVERT_REASON_TAG_START.length(), detail.indexOf(REVERT_REASON_TAG_END)).getBytes());
-	}
-
-	private static String revertingDetail(final String revertReason) {
-		return REVERT_REASON_TAG_START + revertReason + REVERT_REASON_TAG_END;
+		return Bytes.of(detail.getBytes());
 	}
 }
diff --git a/hedera-node/src/main/java/com/hedera/services/exceptions/ValidationUtils.java b/hedera-node/src/main/java/com/hedera/services/exceptions/ValidationUtils.java
index fbb1128e2b..d3cf2052fd 100644
--- a/hedera-node/src/main/java/com/hedera/services/exceptions/ValidationUtils.java
+++ b/hedera-node/src/main/java/com/hedera/services/exceptions/ValidationUtils.java
@@ -39,7 +39,7 @@ public final class ValidationUtils {
 
 	public static void validateTrueOrRevert(final boolean flag, final ResponseCodeEnum code) {
 		if (!flag) {
-			throw InvalidTransactionException.fromReverting(code, code.name());
+			throw new InvalidTransactionException(code, true);
 		}
 	}
 
diff --git a/hedera-node/src/main/java/com/hedera/services/store/contracts/precompile/AbiConstants.java b/hedera-node/src/main/java/com/hedera/services/store/contracts/precompile/AbiConstants.java
index 0dab06036b..e3db941d58 100644
--- a/hedera-node/src/main/java/com/hedera/services/store/contracts/precompile/AbiConstants.java
+++ b/hedera-node/src/main/java/com/hedera/services/store/contracts/precompile/AbiConstants.java
@@ -58,35 +58,35 @@ public final class AbiConstants {
 	//redirectForToken(address token, bytes memory data)
 	public static final int ABI_ID_REDIRECT_FOR_TOKEN = 0x618dc65e;
 	//name()
-	public static final int ABI_ID_NAME = 0x06fdde03;
+	public static final int ABI_ID_ERC_NAME = 0x06fdde03;
 	//symbol()
-	public static final int ABI_ID_SYMBOL = 0x95d89b41;
+	public static final int ABI_ID_ERC_SYMBOL = 0x95d89b41;
 	//decimals()
-	public static final int ABI_ID_DECIMALS = 0x313ce567;
+	public static final int ABI_ID_ERC_DECIMALS = 0x313ce567;
 	//totalSupply()
-	public static final int ABI_ID_TOTAL_SUPPLY_TOKEN = 0x18160ddd;
+	public static final int ABI_ID_ERC_TOTAL_SUPPLY_TOKEN = 0x18160ddd;
 	//balanceOf(address account)
-	public static final int ABI_ID_BALANCE_OF_TOKEN = 0x70a08231;
+	public static final int ABI_ID_ERC_BALANCE_OF_TOKEN = 0x70a08231;
 	//transfer(address recipient, uint256 amount)
 	public static final int ABI_ID_ERC_TRANSFER = 0xa9059cbb;
 	//transferFrom(address sender, address recipient, uint256 amount)
 	//transferFrom(address from, address to, uint256 tokenId)
 	public static final int ABI_ID_ERC_TRANSFER_FROM = 0x23b872dd;
-	//allowance(address token, address owner, address spender)
-	public static final int ABI_ID_ALLOWANCE = 0xdd62ed3e;
-	//approve(address token, address spender, uint256 amount)
-	//approve(address token, address to, uint256 tokenId)
-	public static final int ABI_ID_APPROVE = 0x95ea7b3;
-	//setApprovalForAll(address token, address operator, bool approved)
-	public static final int ABI_ID_SET_APPROVAL_FOR_ALL = 0xa22cb465;
-	//getApproved(address token, uint256 tokenId)
-	public static final int ABI_ID_GET_APPROVED = 0x081812fc;
-	//isApprovedForAll(address token, address owner, address operator)
-	public static final int ABI_ID_IS_APPROVED_FOR_ALL = 0xe985e9c5;
+	//allowance(address owner, address spender)
+	public static final int ABI_ID_ERC_ALLOWANCE = 0xdd62ed3e;
+	//approve(address spender, uint256 amount)
+	//approve(address to, uint256 tokenId)
+	public static final int ABI_ID_ERC_APPROVE = 0x95ea7b3;
+	//setApprovalForAll(address operator, bool approved)
+	public static final int ABI_ID_ERC_SET_APPROVAL_FOR_ALL = 0xa22cb465;
+	//getApproved(uint256 tokenId)
+	public static final int ABI_ID_ERC_GET_APPROVED = 0x081812fc;
+	//isApprovedForAll(address owner, address operator)
+	public static final int ABI_ID_ERC_IS_APPROVED_FOR_ALL = 0xe985e9c5;
 	//ownerOf(uint256 tokenId)
-	public static final int ABI_ID_OWNER_OF_NFT = 0x6352211e;
+	public static final int ABI_ID_ERC_OWNER_OF_NFT = 0x6352211e;
 	//tokenURI(uint256 tokenId)
-	public static final int ABI_ID_TOKEN_URI_NFT = 0xc87b56dd;
+	public static final int ABI_ID_ERC_TOKEN_URI_NFT = 0xc87b56dd;
 	//Transfer(address indexed from, address indexed to, uint256 indexed tokenId)
 	//Transfer(address indexed from, address indexed to, uint256 value)
 	public static final Bytes TRANSFER_EVENT = Bytes.fromHexString(
diff --git a/hedera-node/src/main/java/com/hedera/services/store/contracts/precompile/HTSPrecompiledContract.java b/hedera-node/src/main/java/com/hedera/services/store/contracts/precompile/HTSPrecompiledContract.java
index dc89a11b9b..d2323814fc 100644
--- a/hedera-node/src/main/java/com/hedera/services/store/contracts/precompile/HTSPrecompiledContract.java
+++ b/hedera-node/src/main/java/com/hedera/services/store/contracts/precompile/HTSPrecompiledContract.java
@@ -86,6 +86,7 @@ import javax.inject.Provider;
 import javax.inject.Singleton;
 import java.util.Collections;
 import java.util.Optional;
+import java.util.function.Supplier;
 import java.util.function.UnaryOperator;
 
 import static com.hedera.services.exceptions.ValidationUtils.validateTrue;
@@ -108,7 +109,7 @@ public class HTSPrecompiledContract extends AbstractPrecompiledContract {
 			EntityId.fromGrpcContractId(HTS_PRECOMPILE_MIRROR_ID);
 
 	private static final PrecompileContractResult NO_RESULT = new PrecompileContractResult(
-					null, true, MessageFrame.State.COMPLETED_FAILED, Optional.empty());
+			null, true, MessageFrame.State.COMPLETED_FAILED, Optional.empty());
 
 	private static final Bytes STATIC_CALL_REVERT_REASON = Bytes.of("HTS precompiles are not static".getBytes());
 	private static final String NOT_SUPPORTED_FUNGIBLE_OPERATION_REASON = "Invalid operation for ERC-20 token!";
@@ -208,7 +209,8 @@ public class HTSPrecompiledContract extends AbstractPrecompiledContract {
 		gasRequirement = precompile.getGasRequirement(now);
 		Bytes result = computeInternal(frame);
 
-		return result == null ? PrecompiledContract.PrecompileContractResult.halt((Bytes)null, Optional.of(ExceptionalHaltReason.NONE)) : PrecompiledContract.PrecompileContractResult.success(result);
+		return result == null ? PrecompiledContract.PrecompileContractResult.halt(null,
+				Optional.of(ExceptionalHaltReason.NONE)) : PrecompiledContract.PrecompileContractResult.success(result);
 	}
 
 	void prepareFields(final MessageFrame frame) {
@@ -235,7 +237,7 @@ public class HTSPrecompiledContract extends AbstractPrecompiledContract {
 							AbiConstants.ABI_ID_TRANSFER_NFTS,
 							AbiConstants.ABI_ID_TRANSFER_NFT -> new TransferPrecompile(
 									ledgers, decoder, updater, sigsVerifier, sideEffectsTracker, syntheticTxnFactory,
-							infrastructureFactory, precompilePricingUtils, functionId, senderAddress, impliedTransfersMarshal);
+									infrastructureFactory, precompilePricingUtils, functionId, senderAddress, impliedTransfersMarshal);
 					case AbiConstants.ABI_ID_MINT_TOKEN -> new MintPrecompile(
 							ledgers, decoder, encoder, updater.aliases(), sigsVerifier, recordsHistorian,
 							sideEffectsTracker, syntheticTxnFactory, infrastructureFactory, precompilePricingUtils);
@@ -262,104 +264,84 @@ public class HTSPrecompiledContract extends AbstractPrecompiledContract {
 						final var target = DescriptorUtils.getRedirectTarget(input);
 						final var tokenId = target.tokenId();
 						final var isFungibleToken = TokenType.FUNGIBLE_COMMON.equals(ledgers.typeOf(tokenId));
-						Precompile nestedPrecompile;
 						final var nestedFunctionSelector = target.descriptor();
-						if (AbiConstants.ABI_ID_NAME == nestedFunctionSelector) {
-							nestedPrecompile = new NamePrecompile(
+						yield switch (nestedFunctionSelector) {
+							case AbiConstants.ABI_ID_ERC_NAME -> new NamePrecompile(
 									tokenId, syntheticTxnFactory, ledgers, encoder, decoder, precompilePricingUtils);
-						} else if (AbiConstants.ABI_ID_SYMBOL == nestedFunctionSelector) {
-							nestedPrecompile = new SymbolPrecompile(
+							case AbiConstants.ABI_ID_ERC_SYMBOL -> new SymbolPrecompile(
 									tokenId, syntheticTxnFactory, ledgers, encoder, decoder, precompilePricingUtils);
-						} else if (AbiConstants.ABI_ID_DECIMALS == nestedFunctionSelector) {
-							if (!isFungibleToken) {
-								throw new InvalidTransactionException(
-										NOT_SUPPORTED_NON_FUNGIBLE_OPERATION_REASON, INVALID_TOKEN_ID);
-							}
-							nestedPrecompile = new DecimalsPrecompile(
+							case AbiConstants.ABI_ID_ERC_DECIMALS ->
+									checkFungible(isFungibleToken, () -> new DecimalsPrecompile(
+											tokenId, syntheticTxnFactory, ledgers, encoder, decoder,
+											precompilePricingUtils));
+							case AbiConstants.ABI_ID_ERC_TOTAL_SUPPLY_TOKEN -> new TotalSupplyPrecompile(
 									tokenId, syntheticTxnFactory, ledgers, encoder, decoder, precompilePricingUtils);
-						} else if (AbiConstants.ABI_ID_TOTAL_SUPPLY_TOKEN == nestedFunctionSelector) {
-							nestedPrecompile = new TotalSupplyPrecompile(
+							case AbiConstants.ABI_ID_ERC_BALANCE_OF_TOKEN -> new BalanceOfPrecompile(
 									tokenId, syntheticTxnFactory, ledgers, encoder, decoder, precompilePricingUtils);
-						} else if (AbiConstants.ABI_ID_BALANCE_OF_TOKEN == nestedFunctionSelector) {
-							nestedPrecompile = new BalanceOfPrecompile(
-									tokenId, syntheticTxnFactory, ledgers, encoder, decoder, precompilePricingUtils);
-						} else if (AbiConstants.ABI_ID_OWNER_OF_NFT == nestedFunctionSelector) {
-							if (isFungibleToken) {
-								throw new InvalidTransactionException(
-										NOT_SUPPORTED_FUNGIBLE_OPERATION_REASON, INVALID_TOKEN_ID);
-							}
-							nestedPrecompile = new OwnerOfPrecompile(
-									tokenId, syntheticTxnFactory, ledgers, encoder, decoder, precompilePricingUtils);
-						} else if (AbiConstants.ABI_ID_TOKEN_URI_NFT == nestedFunctionSelector) {
-							if (isFungibleToken) {
-								throw new InvalidTransactionException(
-										NOT_SUPPORTED_FUNGIBLE_OPERATION_REASON, INVALID_TOKEN_ID);
-							}
-							nestedPrecompile = new TokenURIPrecompile(
-									tokenId, syntheticTxnFactory, ledgers, encoder, decoder, precompilePricingUtils);
-						} else if (AbiConstants.ABI_ID_ERC_TRANSFER == nestedFunctionSelector) {
-							if (!isFungibleToken) {
-								throw new InvalidTransactionException(
-										NOT_SUPPORTED_NON_FUNGIBLE_OPERATION_REASON, INVALID_TOKEN_ID);
-							}
-							nestedPrecompile = new ERCTransferPrecompile( tokenId, senderAddress, isFungibleToken,
-									ledgers, decoder, encoder, updater, sigsVerifier, sideEffectsTracker,
-									syntheticTxnFactory, infrastructureFactory, precompilePricingUtils, functionId,
-									impliedTransfersMarshal);
-						} else if (AbiConstants.ABI_ID_ERC_TRANSFER_FROM == nestedFunctionSelector) {
-							if (!dynamicProperties.areAllowancesEnabled()) {
-								throw new InvalidTransactionException(NOT_SUPPORTED);
-							}
-							nestedPrecompile = new ERCTransferPrecompile( tokenId, senderAddress, isFungibleToken,
-									ledgers, decoder, encoder, updater, sigsVerifier, sideEffectsTracker,
-									syntheticTxnFactory, infrastructureFactory, precompilePricingUtils, functionId,
-									impliedTransfersMarshal);
-						} else if (AbiConstants.ABI_ID_ALLOWANCE == nestedFunctionSelector) {
-							if (!dynamicProperties.areAllowancesEnabled()) {
-								throw new InvalidTransactionException(NOT_SUPPORTED);
-							}
-							nestedPrecompile = new AllowancePrecompile(
-									tokenId, syntheticTxnFactory, ledgers, encoder, decoder, precompilePricingUtils);
-						} else if (AbiConstants.ABI_ID_APPROVE == nestedFunctionSelector) {
-							if (!dynamicProperties.areAllowancesEnabled()) {
-								throw new InvalidTransactionException(NOT_SUPPORTED);
-							}
-							nestedPrecompile = new ApprovePrecompile(
-									tokenId, isFungibleToken, ledgers, decoder, encoder, currentView, sideEffectsTracker,
-									syntheticTxnFactory, infrastructureFactory, precompilePricingUtils, senderAddress);
-						} else if (AbiConstants.ABI_ID_SET_APPROVAL_FOR_ALL == nestedFunctionSelector) {
-							if (!dynamicProperties.areAllowancesEnabled()) {
-								throw new InvalidTransactionException(NOT_SUPPORTED);
-							}
-							nestedPrecompile = new SetApprovalForAllPrecompile(
-									tokenId, ledgers, decoder, currentView, sideEffectsTracker, syntheticTxnFactory,
-									infrastructureFactory, precompilePricingUtils, senderAddress);
-						} else if (AbiConstants.ABI_ID_GET_APPROVED == nestedFunctionSelector) {
-							if (!dynamicProperties.areAllowancesEnabled()) {
-								throw new InvalidTransactionException(NOT_SUPPORTED);
-							}
-							nestedPrecompile = new GetApprovedPrecompile(
-									tokenId, syntheticTxnFactory, ledgers, encoder, decoder, precompilePricingUtils);
-						} else if (AbiConstants.ABI_ID_IS_APPROVED_FOR_ALL == nestedFunctionSelector) {
-							if (!dynamicProperties.areAllowancesEnabled()) {
-								throw new InvalidTransactionException(NOT_SUPPORTED);
-							}
-							nestedPrecompile = new IsApprovedForAllPrecompile(
-									tokenId, syntheticTxnFactory, ledgers, encoder, decoder, precompilePricingUtils);
-						} else {
-							nestedPrecompile = null;
-						}
-						yield nestedPrecompile;
+							case AbiConstants.ABI_ID_ERC_OWNER_OF_NFT ->
+									checkNFT(isFungibleToken, () -> new OwnerOfPrecompile(
+											tokenId, syntheticTxnFactory, ledgers, encoder, decoder,
+											precompilePricingUtils));
+							case AbiConstants.ABI_ID_ERC_TOKEN_URI_NFT ->
+									checkNFT(isFungibleToken, () -> new TokenURIPrecompile(
+											tokenId, syntheticTxnFactory, ledgers, encoder, decoder,
+											precompilePricingUtils));
+							case AbiConstants.ABI_ID_ERC_TRANSFER -> checkFungible(isFungibleToken,
+									() -> new ERCTransferPrecompile(tokenId, senderAddress, isFungibleToken,
+											ledgers, decoder, encoder, updater, sigsVerifier, sideEffectsTracker,
+											syntheticTxnFactory, infrastructureFactory, precompilePricingUtils,
+											functionId,
+											impliedTransfersMarshal));
+							case AbiConstants.ABI_ID_ERC_TRANSFER_FROM ->
+									checkFeatureFlag(dynamicProperties.areAllowancesEnabled(),
+											() -> new ERCTransferPrecompile(tokenId, senderAddress, isFungibleToken,
+													ledgers, decoder, encoder, updater, sigsVerifier,
+													sideEffectsTracker,
+													syntheticTxnFactory, infrastructureFactory, precompilePricingUtils,
+													functionId,
+													impliedTransfersMarshal));
+							case AbiConstants.ABI_ID_ERC_ALLOWANCE ->
+									checkFeatureFlag(dynamicProperties.areAllowancesEnabled(),
+											() -> new AllowancePrecompile(
+													tokenId, syntheticTxnFactory, ledgers, encoder, decoder,
+													precompilePricingUtils));
+							case AbiConstants.ABI_ID_ERC_APPROVE ->
+									checkFeatureFlag(dynamicProperties.areAllowancesEnabled(),
+											() -> new ApprovePrecompile(
+													tokenId, isFungibleToken, ledgers, decoder, encoder, currentView,
+													sideEffectsTracker,
+													syntheticTxnFactory, infrastructureFactory, precompilePricingUtils,
+													senderAddress));
+							case AbiConstants.ABI_ID_ERC_SET_APPROVAL_FOR_ALL ->
+									checkFeatureFlag(dynamicProperties.areAllowancesEnabled(),
+											() -> new SetApprovalForAllPrecompile(
+													tokenId, ledgers, decoder, currentView, sideEffectsTracker,
+													syntheticTxnFactory,
+													infrastructureFactory, precompilePricingUtils, senderAddress));
+							case AbiConstants.ABI_ID_ERC_GET_APPROVED ->
+									checkFeatureFlag(dynamicProperties.areAllowancesEnabled(),
+											() -> new GetApprovedPrecompile(
+													tokenId, syntheticTxnFactory, ledgers, encoder, decoder,
+													precompilePricingUtils));
+							case AbiConstants.ABI_ID_ERC_IS_APPROVED_FOR_ALL ->
+									checkFeatureFlag(dynamicProperties.areAllowancesEnabled(),
+											() -> new IsApprovedForAllPrecompile(
+													tokenId, syntheticTxnFactory, ledgers, encoder, decoder,
+													precompilePricingUtils));
+							default -> null;
+						};
 					}
 					case AbiConstants.ABI_ID_CREATE_FUNGIBLE_TOKEN,
 							AbiConstants.ABI_ID_CREATE_FUNGIBLE_TOKEN_WITH_FEES,
 							AbiConstants.ABI_ID_CREATE_NON_FUNGIBLE_TOKEN,
-							AbiConstants.ABI_ID_CREATE_NON_FUNGIBLE_TOKEN_WITH_FEES -> (dynamicProperties.isHTSPrecompileCreateEnabled())
-							? new TokenCreatePrecompile(
+							AbiConstants.ABI_ID_CREATE_NON_FUNGIBLE_TOKEN_WITH_FEES ->
+							(dynamicProperties.isHTSPrecompileCreateEnabled())
+									? new TokenCreatePrecompile(
 									ledgers, decoder, encoder, updater, sigsVerifier, recordsHistorian,
-							sideEffectsTracker, syntheticTxnFactory, infrastructureFactory, functionId, senderAddress,
-							dynamicProperties.fundingAccount(), feeCalculator, precompilePricingUtils)
-							: null;
+									sideEffectsTracker, syntheticTxnFactory, infrastructureFactory, functionId,
+									senderAddress,
+									dynamicProperties.fundingAccount(), feeCalculator, precompilePricingUtils)
+									: null;
 					default -> null;
 				};
 		if (precompile != null) {
@@ -378,6 +360,32 @@ public class HTSPrecompiledContract extends AbstractPrecompiledContract {
 		}
 	}
 
+	private Precompile checkNFT(boolean isFungible, Supplier<Precompile> precompileSupplier) {
+		if (isFungible) {
+			throw new InvalidTransactionException(
+					NOT_SUPPORTED_FUNGIBLE_OPERATION_REASON, INVALID_TOKEN_ID);
+		} else {
+			return precompileSupplier.get();
+		}
+	}
+
+	private Precompile checkFungible(boolean isFungible, Supplier<Precompile> precompileSupplier) {
+		if (!isFungible) {
+			throw new InvalidTransactionException(
+					NOT_SUPPORTED_NON_FUNGIBLE_OPERATION_REASON, INVALID_TOKEN_ID);
+		} else {
+			return precompileSupplier.get();
+		}
+	}
+
+	private Precompile checkFeatureFlag(boolean featureFlag, Supplier<Precompile> precompileSupplier) {
+		if (!featureFlag) {
+			throw new InvalidTransactionException(NOT_SUPPORTED);
+		} else {
+			return precompileSupplier.get();
+		}
+	}
+
 	@SuppressWarnings("rawtypes")
 	protected Bytes computeInternal(final MessageFrame frame) {
 		Bytes result;
diff --git a/hedera-node/src/main/java/com/hedera/services/store/contracts/precompile/impl/ApprovePrecompile.java b/hedera-node/src/main/java/com/hedera/services/store/contracts/precompile/impl/ApprovePrecompile.java
index 68ad190f70..daea9ce3cb 100644
--- a/hedera-node/src/main/java/com/hedera/services/store/contracts/precompile/impl/ApprovePrecompile.java
+++ b/hedera-node/src/main/java/com/hedera/services/store/contracts/precompile/impl/ApprovePrecompile.java
@@ -162,7 +162,7 @@ public class ApprovePrecompile extends AbstractWritePrecompile {
 						transactionBody.getCryptoApproveAllowance().getNftAllowancesList(),
 						grpcOperatorId);
 			} catch (InvalidTransactionException e) {
-				throw InvalidTransactionException.fromReverting(e.getResponseCode());
+				throw new InvalidTransactionException(e.getResponseCode(), true);
 			}
 		}
 		final var precompileAddress = Address.fromHexString(HTS_PRECOMPILED_CONTRACT_ADDRESS);
diff --git a/hedera-node/src/main/java/com/hedera/services/store/contracts/precompile/impl/ERCTransferPrecompile.java b/hedera-node/src/main/java/com/hedera/services/store/contracts/precompile/impl/ERCTransferPrecompile.java
index 03bc2974b5..ea2f72b373 100644
--- a/hedera-node/src/main/java/com/hedera/services/store/contracts/precompile/impl/ERCTransferPrecompile.java
+++ b/hedera-node/src/main/java/com/hedera/services/store/contracts/precompile/impl/ERCTransferPrecompile.java
@@ -112,7 +112,7 @@ public class ERCTransferPrecompile extends TransferPrecompile {
 		try {
 			super.run(frame);
 		} catch (InvalidTransactionException e) {
-			throw InvalidTransactionException.fromReverting(e.getResponseCode());
+			throw new InvalidTransactionException(e.getResponseCode(), true);
 		}
 
 		final var precompileAddress = Address.fromHexString(HTS_PRECOMPILED_CONTRACT_ADDRESS);
diff --git a/hedera-node/src/main/java/com/hedera/services/store/contracts/precompile/proxy/RedirectViewExecutor.java b/hedera-node/src/main/java/com/hedera/services/store/contracts/precompile/proxy/RedirectViewExecutor.java
index 2449999474..09c335660d 100644
--- a/hedera-node/src/main/java/com/hedera/services/store/contracts/precompile/proxy/RedirectViewExecutor.java
+++ b/hedera-node/src/main/java/com/hedera/services/store/contracts/precompile/proxy/RedirectViewExecutor.java
@@ -34,13 +34,13 @@ import static com.hedera.services.exceptions.ValidationUtils.validateFalse;
 import static com.hedera.services.exceptions.ValidationUtils.validateTrue;
 import static com.hedera.services.state.enums.TokenType.FUNGIBLE_COMMON;
 import static com.hedera.services.store.contracts.precompile.utils.DescriptorUtils.getRedirectTarget;
-import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_BALANCE_OF_TOKEN;
-import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_DECIMALS;
-import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_NAME;
-import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_OWNER_OF_NFT;
-import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_SYMBOL;
-import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_TOKEN_URI_NFT;
-import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_TOTAL_SUPPLY_TOKEN;
+import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_ERC_BALANCE_OF_TOKEN;
+import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_ERC_DECIMALS;
+import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_ERC_NAME;
+import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_ERC_OWNER_OF_NFT;
+import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_ERC_SYMBOL;
+import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_ERC_TOKEN_URI_NFT;
+import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_ERC_TOTAL_SUPPLY_TOKEN;
 import static com.hedera.services.utils.MiscUtils.asSecondsTimestamp;
 import static com.hederahashgraph.api.proto.java.ResponseCodeEnum.INVALID_TOKEN_ID;
 import static com.hederahashgraph.api.proto.java.ResponseCodeEnum.NOT_SUPPORTED;
@@ -82,31 +82,31 @@ public class RedirectViewExecutor {
 		final var selector = target.descriptor();
 		final var isFungibleToken = FUNGIBLE_COMMON.equals(ledgers.typeOf(tokenId));
 		final Bytes answer;
-		if (selector == ABI_ID_NAME) {
+		if (selector == ABI_ID_ERC_NAME) {
 			final var name = ledgers.nameOf(tokenId);
 			answer = encoder.encodeName(name);
-		} else if (selector == ABI_ID_SYMBOL) {
+		} else if (selector == ABI_ID_ERC_SYMBOL) {
 			final var symbol = ledgers.symbolOf(tokenId);
 			answer = encoder.encodeSymbol(symbol);
-		} else if (selector == ABI_ID_DECIMALS) {
+		} else if (selector == ABI_ID_ERC_DECIMALS) {
 			validateTrue(isFungibleToken, INVALID_TOKEN_ID);
 			final var decimals = ledgers.decimalsOf(tokenId);
 			answer = encoder.encodeDecimals(decimals);
-		} else if (selector == ABI_ID_TOTAL_SUPPLY_TOKEN) {
+		} else if (selector == ABI_ID_ERC_TOTAL_SUPPLY_TOKEN) {
 			final var totalSupply = ledgers.totalSupplyOf(tokenId);
 			answer = encoder.encodeTotalSupply(totalSupply);
-		} else if (selector == ABI_ID_BALANCE_OF_TOKEN) {
+		} else if (selector == ABI_ID_ERC_BALANCE_OF_TOKEN) {
 			final var wrapper = decoder.decodeBalanceOf(input.slice(24), updater::unaliased);
 			final var balance = ledgers.balanceOf(wrapper.accountId(), tokenId);
 			answer = encoder.encodeBalance(balance);
-		} else if (selector == ABI_ID_OWNER_OF_NFT) {
+		} else if (selector == ABI_ID_ERC_OWNER_OF_NFT) {
 			validateFalse(isFungibleToken, INVALID_TOKEN_ID);
 			final var wrapper = decoder.decodeOwnerOf(input.slice(24));
 			final var nftId = NftId.fromGrpc(tokenId, wrapper.serialNo());
 			final var owner = ledgers.ownerOf(nftId);
 			final var priorityAddress = ledgers.canonicalAddress(owner);
 			answer = encoder.encodeOwner(priorityAddress);
-		} else if (selector == ABI_ID_TOKEN_URI_NFT) {
+		} else if (selector == ABI_ID_ERC_TOKEN_URI_NFT) {
 			validateFalse(isFungibleToken, INVALID_TOKEN_ID);
 			final var wrapper = decoder.decodeTokenUriNFT(input.slice(24));
 			final var nftId = NftId.fromGrpc(tokenId, wrapper.serialNo());
diff --git a/hedera-node/src/test/java/com/hedera/services/exceptions/InvalidTransactionExceptionTest.java b/hedera-node/src/test/java/com/hedera/services/exceptions/InvalidTransactionExceptionTest.java
index a0ed11ba1b..1743fb8b3b 100644
--- a/hedera-node/src/test/java/com/hedera/services/exceptions/InvalidTransactionExceptionTest.java
+++ b/hedera-node/src/test/java/com/hedera/services/exceptions/InvalidTransactionExceptionTest.java
@@ -35,8 +35,8 @@ class InvalidTransactionExceptionTest {
 	void canBuildRevertingExceptionWithDetail() {
 		final var reason = "I don't like it!";
 		final var frameReason = Bytes.of(reason.getBytes());
-		final var revertingEx = InvalidTransactionException.fromReverting(
-				INVALID_ALLOWANCE_OWNER_ID, reason);
+		final var revertingEx = new InvalidTransactionException(
+				reason, INVALID_ALLOWANCE_OWNER_ID, true);
 
 		assertTrue(revertingEx.isReverting());
 		assertEquals(frameReason, revertingEx.getRevertReason());
@@ -45,8 +45,8 @@ class InvalidTransactionExceptionTest {
 	@Test
 	void canBuildRevertingExceptionNoDetail() {
 		final var frameReason = Bytes.of(INVALID_ALLOWANCE_OWNER_ID.name().getBytes());
-		final var revertingEx = InvalidTransactionException.fromReverting(
-				INVALID_ALLOWANCE_OWNER_ID);
+		final var revertingEx = new InvalidTransactionException(
+				INVALID_ALLOWANCE_OWNER_ID, true);
 
 		assertTrue(revertingEx.isReverting());
 		assertEquals(frameReason, revertingEx.getRevertReason());
diff --git a/hedera-node/src/test/java/com/hedera/services/store/contracts/precompile/ERC20PrecompilesTest.java b/hedera-node/src/test/java/com/hedera/services/store/contracts/precompile/ERC20PrecompilesTest.java
index 9578ef0c75..eec29af49a 100644
--- a/hedera-node/src/test/java/com/hedera/services/store/contracts/precompile/ERC20PrecompilesTest.java
+++ b/hedera-node/src/test/java/com/hedera/services/store/contracts/precompile/ERC20PrecompilesTest.java
@@ -67,7 +67,6 @@ import com.hedera.services.store.tokens.HederaTokenStore;
 import com.hedera.services.txns.crypto.ApproveAllowanceLogic;
 import com.hedera.services.txns.crypto.validators.ApproveAllowanceChecks;
 import com.hedera.services.txns.crypto.validators.DeleteAllowanceChecks;
-import com.hedera.services.txns.token.validators.CreateChecks;
 import com.hedera.services.utils.EntityIdUtils;
 import com.hedera.services.utils.EntityNum;
 import com.hederahashgraph.api.proto.java.AccountID;
@@ -113,21 +112,21 @@ import java.util.Optional;
 import java.util.TreeMap;
 
 import static com.hedera.services.state.EntityCreator.EMPTY_MEMO;
-import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_ALLOWANCE;
-import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_APPROVE;
-import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_BALANCE_OF_TOKEN;
-import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_DECIMALS;
+import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_ERC_ALLOWANCE;
+import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_ERC_APPROVE;
+import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_ERC_BALANCE_OF_TOKEN;
+import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_ERC_DECIMALS;
 import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_ERC_TRANSFER;
 import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_ERC_TRANSFER_FROM;
-import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_GET_APPROVED;
-import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_IS_APPROVED_FOR_ALL;
-import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_NAME;
-import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_OWNER_OF_NFT;
+import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_ERC_GET_APPROVED;
+import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_ERC_IS_APPROVED_FOR_ALL;
+import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_ERC_NAME;
+import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_ERC_OWNER_OF_NFT;
 import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_REDIRECT_FOR_TOKEN;
-import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_SET_APPROVAL_FOR_ALL;
-import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_SYMBOL;
-import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_TOKEN_URI_NFT;
-import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_TOTAL_SUPPLY_TOKEN;
+import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_ERC_SET_APPROVAL_FOR_ALL;
+import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_ERC_SYMBOL;
+import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_ERC_TOKEN_URI_NFT;
+import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_ERC_TOTAL_SUPPLY_TOKEN;
 import static com.hedera.services.store.contracts.precompile.HTSPrecompiledContract.HTS_PRECOMPILED_CONTRACT_ADDRESS;
 import static com.hedera.services.store.contracts.precompile.HTSTestsUtil.AMOUNT;
 import static com.hedera.services.store.contracts.precompile.HTSTestsUtil.NOT_SUPPORTED_FUNGIBLE_OPERATION_REASON;
@@ -286,7 +285,7 @@ class ERC20PrecompilesTest {
         Bytes pretendArgumentsApprove = Bytes.concatenate(
                 Bytes.of(Integers.toBytes(ABI_ID_REDIRECT_FOR_TOKEN)),
                 fungibleTokenAddr,
-                Bytes.of(Integers.toBytes(ABI_ID_APPROVE)));
+                Bytes.of(Integers.toBytes(ABI_ID_ERC_APPROVE)));
 
         // when:
         subject.prepareFields(frame);
@@ -306,7 +305,7 @@ class ERC20PrecompilesTest {
         Bytes pretendArgumentsAllowance = Bytes.concatenate(
                 Bytes.of(Integers.toBytes(ABI_ID_REDIRECT_FOR_TOKEN)),
                 fungibleTokenAddr,
-                Bytes.of(Integers.toBytes(ABI_ID_ALLOWANCE)));
+                Bytes.of(Integers.toBytes(ABI_ID_ERC_ALLOWANCE)));
 
 
         // when:
@@ -317,7 +316,7 @@ class ERC20PrecompilesTest {
         Bytes pretendArgumentsApproveForAll = Bytes.concatenate(
                 Bytes.of(Integers.toBytes(ABI_ID_REDIRECT_FOR_TOKEN)),
                 fungibleTokenAddr,
-                Bytes.of(Integers.toBytes(ABI_ID_SET_APPROVAL_FOR_ALL)));
+                Bytes.of(Integers.toBytes(ABI_ID_ERC_SET_APPROVAL_FOR_ALL)));
 
         // when:
         subject.prepareFields(frame);
@@ -327,7 +326,7 @@ class ERC20PrecompilesTest {
         Bytes pretendArgumentsGetApproved = Bytes.concatenate(
                 Bytes.of(Integers.toBytes(ABI_ID_REDIRECT_FOR_TOKEN)),
                 fungibleTokenAddr,
-                Bytes.of(Integers.toBytes(ABI_ID_GET_APPROVED)));
+                Bytes.of(Integers.toBytes(ABI_ID_ERC_GET_APPROVED)));
 
         // when:
         subject.prepareFields(frame);
@@ -337,7 +336,7 @@ class ERC20PrecompilesTest {
         Bytes pretendArgumentsApprovedForAll = Bytes.concatenate(
                 Bytes.of(Integers.toBytes(ABI_ID_REDIRECT_FOR_TOKEN)),
                 fungibleTokenAddr,
-                Bytes.of(Integers.toBytes(ABI_ID_IS_APPROVED_FOR_ALL)));
+                Bytes.of(Integers.toBytes(ABI_ID_ERC_IS_APPROVED_FOR_ALL)));
 
 
         // when:
@@ -361,7 +360,7 @@ class ERC20PrecompilesTest {
 
     @Test
     void gasCalculationForReadOnlyMethod() {
-        Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_NAME));
+        Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_ERC_NAME));
         Bytes pretendArguments = givenMinimalFrameContext(nestedPretendArguments);
 
         given(syntheticTxnFactory.createTransactionCall(1L, pretendArguments)).willReturn(mockSynthBodyBuilder);
@@ -455,7 +454,7 @@ class ERC20PrecompilesTest {
 
     @Test
     void name() {
-        Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_NAME));
+        Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_ERC_NAME));
         Bytes pretendArguments = givenMinimalFrameContext(nestedPretendArguments);
 
         given(syntheticTxnFactory.createTransactionCall(1L, pretendArguments)).willReturn(mockSynthBodyBuilder);
@@ -494,7 +493,7 @@ class ERC20PrecompilesTest {
 
     @Test
     void symbol() {
-        Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_SYMBOL));
+        Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_ERC_SYMBOL));
         Bytes pretendArguments = givenMinimalFrameContext(nestedPretendArguments);
 
         given(syntheticTxnFactory.createTransactionCall(1L, pretendArguments)).willReturn(mockSynthBodyBuilder);
@@ -528,7 +527,7 @@ class ERC20PrecompilesTest {
 
     @Test
     void decimals() {
-        Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_DECIMALS));
+        Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_ERC_DECIMALS));
         Bytes pretendArguments = givenMinimalFrameContext(nestedPretendArguments);
 
         given(syntheticTxnFactory.createTransactionCall(1L, pretendArguments)).willReturn(mockSynthBodyBuilder);
@@ -564,7 +563,7 @@ class ERC20PrecompilesTest {
 
     @Test
     void totalSupply() {
-        Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_TOTAL_SUPPLY_TOKEN));
+        Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_ERC_TOTAL_SUPPLY_TOKEN));
         Bytes pretendArguments = givenMinimalFrameContext(nestedPretendArguments);
         given(syntheticTxnFactory.createTransactionCall(1L, pretendArguments)).willReturn(mockSynthBodyBuilder);
         given(creator.createSuccessfulSyntheticRecord(Collections.emptyList(), sideEffects, EMPTY_MEMO))
@@ -602,7 +601,7 @@ class ERC20PrecompilesTest {
         TreeMap<FcTokenAllowanceId, Long> alowances = new TreeMap<>();
         alowances.put(FcTokenAllowanceId.from(EntityNum.fromLong(token.getTokenNum()), EntityNum.fromLong(receiver.getAccountNum())), 10L);
 
-        Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_ALLOWANCE));
+        Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_ERC_ALLOWANCE));
         Bytes pretendArguments = givenMinimalFrameContext(nestedPretendArguments);
         given(wrappedLedgers.accounts()).willReturn(accounts);
         given(dynamicProperties.areAllowancesEnabled()).willReturn(true);
@@ -644,7 +643,7 @@ class ERC20PrecompilesTest {
 
     @Test
     void balanceOf() {
-        Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_BALANCE_OF_TOKEN));
+        Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_ERC_BALANCE_OF_TOKEN));
         Bytes pretendArguments = givenMinimalFrameContext(nestedPretendArguments);
 
         given(syntheticTxnFactory.createTransactionCall(1L, pretendArguments)).willReturn(mockSynthBodyBuilder);
@@ -690,7 +689,7 @@ class ERC20PrecompilesTest {
         Map<FcTokenAllowanceId, Long> allowances = Map.of(fungibleAllowanceId, 0L);
         givenPricingUtilsContext();
 
-        Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_APPROVE));
+        Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_ERC_APPROVE));
         Bytes pretendArguments = givenMinimalFrameContext(nestedPretendArguments);
 
         given(feeCalculator.estimatedGasPriceInTinybars(HederaFunctionality.ContractCall, timestamp))
@@ -729,7 +728,7 @@ class ERC20PrecompilesTest {
         List<NftAllowance> nftAllowances = new ArrayList<>();
         Map<FcTokenAllowanceId, Long> allowances = Map.of(fungibleAllowanceId, 0L);
 
-        Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_APPROVE));
+        Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_ERC_APPROVE));
         Bytes pretendArguments = givenMinimalFrameContext(nestedPretendArguments);
         givenLedgers();
         givenPricingUtilsContext();
@@ -952,7 +951,7 @@ class ERC20PrecompilesTest {
 
     @Test
     void ownerOfNotSupported() {
-        Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_OWNER_OF_NFT));
+        Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_ERC_OWNER_OF_NFT));
         Bytes pretendArguments = givenMinimalFrameContextWithoutParentUpdater(nestedPretendArguments);
 
         given(wrappedLedgers.typeOf(token)).willReturn(TokenType.FUNGIBLE_COMMON);
@@ -965,7 +964,7 @@ class ERC20PrecompilesTest {
 
     @Test
     void tokenURINotSupported() {
-        Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_TOKEN_URI_NFT));
+        Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_ERC_TOKEN_URI_NFT));
         Bytes pretendArguments = givenMinimalFrameContextWithoutParentUpdater(nestedPretendArguments);
 
         given(wrappedLedgers.typeOf(token)).willReturn(TokenType.FUNGIBLE_COMMON);
diff --git a/hedera-node/src/test/java/com/hedera/services/store/contracts/precompile/ERC721PrecompilesTest.java b/hedera-node/src/test/java/com/hedera/services/store/contracts/precompile/ERC721PrecompilesTest.java
index 4774ac771b..066bb23cc6 100644
--- a/hedera-node/src/test/java/com/hedera/services/store/contracts/precompile/ERC721PrecompilesTest.java
+++ b/hedera-node/src/test/java/com/hedera/services/store/contracts/precompile/ERC721PrecompilesTest.java
@@ -111,20 +111,20 @@ import java.util.Set;
 import java.util.TreeSet;
 
 import static com.hedera.services.state.EntityCreator.EMPTY_MEMO;
-import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_APPROVE;
-import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_BALANCE_OF_TOKEN;
-import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_DECIMALS;
+import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_ERC_APPROVE;
+import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_ERC_BALANCE_OF_TOKEN;
+import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_ERC_DECIMALS;
 import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_ERC_TRANSFER;
 import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_ERC_TRANSFER_FROM;
-import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_GET_APPROVED;
-import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_IS_APPROVED_FOR_ALL;
-import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_NAME;
-import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_OWNER_OF_NFT;
+import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_ERC_GET_APPROVED;
+import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_ERC_IS_APPROVED_FOR_ALL;
+import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_ERC_NAME;
+import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_ERC_OWNER_OF_NFT;
 import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_REDIRECT_FOR_TOKEN;
-import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_SET_APPROVAL_FOR_ALL;
-import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_SYMBOL;
-import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_TOKEN_URI_NFT;
-import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_TOTAL_SUPPLY_TOKEN;
+import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_ERC_SET_APPROVAL_FOR_ALL;
+import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_ERC_SYMBOL;
+import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_ERC_TOKEN_URI_NFT;
+import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_ERC_TOTAL_SUPPLY_TOKEN;
 import static com.hedera.services.store.contracts.precompile.HTSPrecompiledContract.HTS_PRECOMPILED_CONTRACT_ADDRESS;
 import static com.hedera.services.store.contracts.precompile.HTSTestsUtil.NOT_SUPPORTED_NON_FUNGIBLE_OPERATION_REASON;
 import static com.hedera.services.store.contracts.precompile.HTSTestsUtil.TEST_CONSENSUS_TIME;
@@ -281,7 +281,7 @@ class ERC721PrecompilesTest {
 
 	@Test
 	void name() {
-		Bytes pretendArguments = givenMinimalFrameContext(Bytes.of(Integers.toBytes(ABI_ID_NAME)));
+		Bytes pretendArguments = givenMinimalFrameContext(Bytes.of(Integers.toBytes(ABI_ID_ERC_NAME)));
 		given(syntheticTxnFactory.createTransactionCall(1L, pretendArguments)).willReturn(mockSynthBodyBuilder);
 		given(creator.createSuccessfulSyntheticRecord(Collections.emptyList(), sideEffects, EMPTY_MEMO))
 				.willReturn(mockRecordBuilder);
@@ -310,7 +310,7 @@ class ERC721PrecompilesTest {
 
 	@Test
 	void symbol() {
-		Bytes pretendArguments = givenMinimalFrameContext(Bytes.of(Integers.toBytes(ABI_ID_SYMBOL)));
+		Bytes pretendArguments = givenMinimalFrameContext(Bytes.of(Integers.toBytes(ABI_ID_ERC_SYMBOL)));
 		given(syntheticTxnFactory.createTransactionCall(1L, pretendArguments)).willReturn(mockSynthBodyBuilder);
 		given(creator.createSuccessfulSyntheticRecord(Collections.emptyList(), sideEffects, EMPTY_MEMO))
 				.willReturn(mockRecordBuilder);
@@ -344,7 +344,7 @@ class ERC721PrecompilesTest {
 				EntityNum.fromLong(receiver.getAccountNum()));
 		allowances.add(fcTokenAllowanceId);
 
-		Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_IS_APPROVED_FOR_ALL));
+		Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_ERC_IS_APPROVED_FOR_ALL));
 		Bytes pretendArguments = givenMinimalFrameContext(nestedPretendArguments);
 		given(wrappedLedgers.accounts()).willReturn(accounts);
 		given(accounts.contains(IS_APPROVE_FOR_ALL_WRAPPER.owner())).willReturn(true);
@@ -383,7 +383,7 @@ class ERC721PrecompilesTest {
 
 	@Test
 	void isApprovedForAllWorksWithOperatorMissing() {
-		Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_IS_APPROVED_FOR_ALL));
+		Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_ERC_IS_APPROVED_FOR_ALL));
 		Bytes pretendArguments = givenMinimalFrameContext(nestedPretendArguments);
 		given(wrappedLedgers.accounts()).willReturn(accounts);
 		given(accounts.contains(IS_APPROVE_FOR_ALL_WRAPPER.owner())).willReturn(true);
@@ -423,7 +423,7 @@ class ERC721PrecompilesTest {
 		List<CryptoAllowance> cryptoAllowances = new ArrayList<>();
 		List<TokenAllowance> tokenAllowances = new ArrayList<>();
 		List<NftAllowance> nftAllowances = new ArrayList<>();
-		Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_APPROVE));
+		Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_ERC_APPROVE));
 		Bytes pretendArguments = givenMinimalFrameContext(nestedPretendArguments);
 		givenLedgers();
 		givenPricingUtilsContext();
@@ -486,7 +486,7 @@ class ERC721PrecompilesTest {
 		List<CryptoAllowance> cryptoAllowances = new ArrayList<>();
 		List<TokenAllowance> tokenAllowances = new ArrayList<>();
 		List<NftAllowance> nftAllowances = new ArrayList<>();
-		Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_APPROVE));
+		Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_ERC_APPROVE));
 		Bytes pretendArguments = givenMinimalFrameContext(nestedPretendArguments);
 
 		given(wrappedLedgers.tokens()).willReturn(tokens);
@@ -542,7 +542,7 @@ class ERC721PrecompilesTest {
 	@Test
 	void approveSpender0WhenOwner() {
 		givenPricingUtilsContext();
-		Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_APPROVE));
+		Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_ERC_APPROVE));
 		Bytes pretendArguments = givenMinimalFrameContext(nestedPretendArguments);
 
 		given(wrappedLedgers.tokens()).willReturn(tokens);
@@ -603,7 +603,7 @@ class ERC721PrecompilesTest {
 	@Test
 	void approveSpender0WhenGrantedApproveForAll() {
 		givenPricingUtilsContext();
-		Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_APPROVE));
+		Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_ERC_APPROVE));
 		Bytes pretendArguments = givenMinimalFrameContext(nestedPretendArguments);
 
 		given(wrappedLedgers.tokens()).willReturn(tokens);
@@ -663,7 +663,7 @@ class ERC721PrecompilesTest {
 	@Test
 	void approveSpender0NoGoodIfNotPermissioned() {
 		givenPricingUtilsContext();
-		Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_APPROVE));
+		Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_ERC_APPROVE));
 		Bytes pretendArguments = givenMinimalFrameContext(nestedPretendArguments);
 
 		given(feeCalculator.estimatedGasPriceInTinybars(HederaFunctionality.ContractCall, timestamp))
@@ -701,7 +701,7 @@ class ERC721PrecompilesTest {
 	@Test
 	void validatesImpliedNftApprovalDeletion() {
 		givenPricingUtilsContext();
-		Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_APPROVE));
+		Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_ERC_APPROVE));
 		Bytes pretendArguments = givenMinimalFrameContext(nestedPretendArguments);
 		given(wrappedLedgers.tokens()).willReturn(tokens);
 		given(wrappedLedgers.accounts()).willReturn(accounts);
@@ -758,7 +758,7 @@ class ERC721PrecompilesTest {
 		List<TokenAllowance> tokenAllowances = new ArrayList<>();
 		List<NftAllowance> nftAllowances = new ArrayList<>();
 
-		Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_APPROVE));
+		Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_ERC_APPROVE));
 		Bytes pretendArguments = givenMinimalFrameContext(nestedPretendArguments);
 
 		given(wrappedLedgers.tokens()).willReturn(tokens);
@@ -811,7 +811,7 @@ class ERC721PrecompilesTest {
 		List<TokenAllowance> tokenAllowances = new ArrayList<>();
 		List<NftAllowance> nftAllowances = new ArrayList<>();
 
-		Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_SET_APPROVAL_FOR_ALL));
+		Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_ERC_SET_APPROVAL_FOR_ALL));
 		Bytes pretendArguments = givenMinimalFrameContext(nestedPretendArguments);
 		givenLedgers();
 		givenPricingUtilsContext();
@@ -871,7 +871,7 @@ class ERC721PrecompilesTest {
 				EntityNum.fromLong(receiver.getAccountNum()));
 		allowances.add(fcTokenAllowanceId);
 
-		Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_GET_APPROVED));
+		Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_ERC_GET_APPROVED));
 		Bytes pretendArguments = givenMinimalFrameContext(nestedPretendArguments);
 
 		given(wrappedLedgers.nfts()).willReturn(nfts);
@@ -906,7 +906,7 @@ class ERC721PrecompilesTest {
 
 	@Test
 	void totalSupply() {
-		Bytes pretendArguments = givenMinimalFrameContext(Bytes.of(Integers.toBytes(ABI_ID_TOTAL_SUPPLY_TOKEN)));
+		Bytes pretendArguments = givenMinimalFrameContext(Bytes.of(Integers.toBytes(ABI_ID_ERC_TOTAL_SUPPLY_TOKEN)));
 		given(syntheticTxnFactory.createTransactionCall(1L, pretendArguments)).willReturn(mockSynthBodyBuilder);
 		given(creator.createSuccessfulSyntheticRecord(Collections.emptyList(), sideEffects, EMPTY_MEMO))
 				.willReturn(mockRecordBuilder);
@@ -934,7 +934,7 @@ class ERC721PrecompilesTest {
 
 	@Test
 	void balanceOf() {
-		Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_BALANCE_OF_TOKEN));
+		Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_ERC_BALANCE_OF_TOKEN));
 		Bytes pretendArguments = givenMinimalFrameContext(nestedPretendArguments);
 
 		given(syntheticTxnFactory.createTransactionCall(1L, pretendArguments)).willReturn(mockSynthBodyBuilder);
@@ -967,7 +967,7 @@ class ERC721PrecompilesTest {
 
 	@Test
 	void ownerOfHappyPathWorks() {
-		Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_OWNER_OF_NFT));
+		Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_ERC_OWNER_OF_NFT));
 		Bytes pretendArguments = givenMinimalFrameContext(nestedPretendArguments);
 
 		given(syntheticTxnFactory.createTransactionCall(1L, pretendArguments)).willReturn(mockSynthBodyBuilder);
@@ -1001,7 +1001,7 @@ class ERC721PrecompilesTest {
 
 	@Test
 	void ownerOfRevertsWithMissingNft() {
-		Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_OWNER_OF_NFT));
+		Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_ERC_OWNER_OF_NFT));
 		Bytes pretendArguments = givenMinimalFrameContext(nestedPretendArguments);
 
 		given(syntheticTxnFactory.createTransactionCall(1L, pretendArguments)).willReturn(mockSynthBodyBuilder);
@@ -1141,7 +1141,7 @@ class ERC721PrecompilesTest {
 
 	@Test
 	void erc721SystemFailureSurfacesResult() {
-		Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_OWNER_OF_NFT));
+		Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_ERC_OWNER_OF_NFT));
 		Bytes pretendArguments = givenMinimalFrameContext(nestedPretendArguments);
 
 		given(syntheticTxnFactory.createTransactionCall(1L, pretendArguments)).willReturn(mockSynthBodyBuilder);
@@ -1169,7 +1169,7 @@ class ERC721PrecompilesTest {
 
 	@Test
 	void tokenURI() {
-		Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_TOKEN_URI_NFT));
+		Bytes nestedPretendArguments = Bytes.of(Integers.toBytes(ABI_ID_ERC_TOKEN_URI_NFT));
 		Bytes pretendArguments = givenMinimalFrameContext(nestedPretendArguments);
 
 		given(syntheticTxnFactory.createTransactionCall(1L, pretendArguments)).willReturn(mockSynthBodyBuilder);
@@ -1211,7 +1211,8 @@ class ERC721PrecompilesTest {
 
 	@Test
 	void decimalsNotSupported() {
-		Bytes pretendArguments = givenMinimalFrameContextWithoutParentUpdater(Bytes.of(Integers.toBytes(ABI_ID_DECIMALS)));
+		Bytes pretendArguments = givenMinimalFrameContextWithoutParentUpdater(Bytes.of(Integers.toBytes(
+				ABI_ID_ERC_DECIMALS)));
 		given(wrappedLedgers.typeOf(token)).willReturn(TokenType.NON_FUNGIBLE_UNIQUE);
 		subject.prepareFields(frame);
 
diff --git a/hedera-node/src/test/java/com/hedera/services/store/contracts/precompile/HTSPrecompiledContractTest.java b/hedera-node/src/test/java/com/hedera/services/store/contracts/precompile/HTSPrecompiledContractTest.java
index 5f6a3ec820..73c33d4112 100644
--- a/hedera-node/src/test/java/com/hedera/services/store/contracts/precompile/HTSPrecompiledContractTest.java
+++ b/hedera-node/src/test/java/com/hedera/services/store/contracts/precompile/HTSPrecompiledContractTest.java
@@ -92,7 +92,7 @@ import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID
 import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_DISSOCIATE_TOKEN;
 import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_DISSOCIATE_TOKENS;
 import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_MINT_TOKEN;
-import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_NAME;
+import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_ERC_NAME;
 import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_REDIRECT_FOR_TOKEN;
 import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_TRANSFER_NFT;
 import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_TRANSFER_NFTS;
@@ -215,7 +215,7 @@ class HTSPrecompiledContractTest {
 	void computeCostedWorks() {
 		given(worldUpdater.trackingLedgers()).willReturn(wrappedLedgers);
 		given(wrappedLedgers.typeOf(fungible)).willReturn(TokenType.FUNGIBLE_COMMON);
-		Bytes input = prerequisites(ABI_ID_NAME);
+		Bytes input = prerequisites(ABI_ID_ERC_NAME);
 		given(messageFrame.isStatic()).willReturn(true);
 		given(messageFrame.getWorldUpdater()).willReturn(worldUpdater);
 		given(worldUpdater.hasMutableLedgers()).willReturn(false);
diff --git a/hedera-node/src/test/java/com/hedera/services/store/contracts/precompile/proxy/RedirectViewExecutorTest.java b/hedera-node/src/test/java/com/hedera/services/store/contracts/precompile/proxy/RedirectViewExecutorTest.java
index e42b14d6ea..7205dda549 100644
--- a/hedera-node/src/test/java/com/hedera/services/store/contracts/precompile/proxy/RedirectViewExecutorTest.java
+++ b/hedera-node/src/test/java/com/hedera/services/store/contracts/precompile/proxy/RedirectViewExecutorTest.java
@@ -46,14 +46,14 @@ import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
 
-import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_BALANCE_OF_TOKEN;
-import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_DECIMALS;
-import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_NAME;
-import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_OWNER_OF_NFT;
+import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_ERC_BALANCE_OF_TOKEN;
+import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_ERC_DECIMALS;
+import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_ERC_NAME;
+import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_ERC_OWNER_OF_NFT;
 import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_REDIRECT_FOR_TOKEN;
-import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_SYMBOL;
-import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_TOKEN_URI_NFT;
-import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_TOTAL_SUPPLY_TOKEN;
+import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_ERC_SYMBOL;
+import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_ERC_TOKEN_URI_NFT;
+import static com.hedera.services.store.contracts.precompile.AbiConstants.ABI_ID_ERC_TOTAL_SUPPLY_TOKEN;
 import static com.hedera.services.store.contracts.precompile.proxy.RedirectViewExecutor.MINIMUM_TINYBARS_COST;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.mockito.ArgumentMatchers.any;
@@ -99,7 +99,7 @@ class RedirectViewExecutorTest {
 
 	@Test
 	void computeCostedNAME() {
-		prerequisites(ABI_ID_NAME, fungibleTokenAddress);
+		prerequisites(ABI_ID_ERC_NAME, fungibleTokenAddress);
 
 		final var result = "name";
 
@@ -111,7 +111,7 @@ class RedirectViewExecutorTest {
 
 	@Test
 	void computeCostedSYMBOL() {
-		prerequisites(ABI_ID_SYMBOL, fungibleTokenAddress);
+		prerequisites(ABI_ID_ERC_SYMBOL, fungibleTokenAddress);
 
 		final var result = "symbol";
 
@@ -123,7 +123,7 @@ class RedirectViewExecutorTest {
 
 	@Test
 	void computeCostedDECIMALS() {
-		prerequisites(ABI_ID_DECIMALS, fungibleTokenAddress);
+		prerequisites(ABI_ID_ERC_DECIMALS, fungibleTokenAddress);
 
 		final var result = 1;
 
@@ -136,7 +136,7 @@ class RedirectViewExecutorTest {
 
 	@Test
 	void computeCostedTOTAL_SUPPY_TOKEN() {
-		prerequisites(ABI_ID_TOTAL_SUPPLY_TOKEN, fungibleTokenAddress);
+		prerequisites(ABI_ID_ERC_TOTAL_SUPPLY_TOKEN, fungibleTokenAddress);
 
 		final var result = 1L;
 
@@ -148,7 +148,7 @@ class RedirectViewExecutorTest {
 
 	@Test
 	void computeCostedBALANCE_OF_TOKEN() {
-		Bytes nestedInput = prerequisites(ABI_ID_BALANCE_OF_TOKEN, fungibleTokenAddress);
+		Bytes nestedInput = prerequisites(ABI_ID_ERC_BALANCE_OF_TOKEN, fungibleTokenAddress);
 
 		final var result = 1L;
 
@@ -162,7 +162,7 @@ class RedirectViewExecutorTest {
 
 	@Test
 	void computeCostedOWNER_OF_NFT() {
-		Bytes nestedInput = prerequisites(ABI_ID_OWNER_OF_NFT, nonfungibleTokenAddress);
+		Bytes nestedInput = prerequisites(ABI_ID_ERC_OWNER_OF_NFT, nonfungibleTokenAddress);
 
 		final var result = Address.fromHexString("0x000000000000013");
 		final var serialNum = 1L;
@@ -178,7 +178,7 @@ class RedirectViewExecutorTest {
 
 	@Test
 	void computeCostedTOKEN_URI_NFT() {
-		Bytes nestedInput = prerequisites(ABI_ID_TOKEN_URI_NFT, nonfungibleTokenAddress);
+		Bytes nestedInput = prerequisites(ABI_ID_ERC_TOKEN_URI_NFT, nonfungibleTokenAddress);
 
 		final var result = "some metadata";
 		final var serialNum = 1L;
diff --git a/hedera-node/src/test/java/com/hedera/services/txns/crypto/validators/DeleteAllowanceChecksTest.java b/hedera-node/src/test/java/com/hedera/services/txns/crypto/validators/DeleteAllowanceChecksTest.java
index ed8593942d..86c32c6427 100644
--- a/hedera-node/src/test/java/com/hedera/services/txns/crypto/validators/DeleteAllowanceChecksTest.java
+++ b/hedera-node/src/test/java/com/hedera/services/txns/crypto/validators/DeleteAllowanceChecksTest.java
@@ -183,7 +183,7 @@ class DeleteAllowanceChecksTest {
 	@Test
 	void rejectsMissingToken() {
 		given(tokenStore.loadPossiblyPausedToken(Id.fromGrpcToken(nftToken)))
-				.willThrow(InvalidTransactionException.fromReverting(INVALID_TOKEN_ID));
+				.willThrow(new InvalidTransactionException(INVALID_TOKEN_ID, true));
 		nftAllowances.add(nftAllowance2);
 		assertEquals(INVALID_TOKEN_ID,
 				subject.validateNftDeleteAllowances(nftAllowances, payer, accountStore, tokenStore));