Return null in case token with negative num value is being read

web3/src/main/java/org/hiero/mirror/web3/state/CommonEntityAccessor.java

@@ -13,6 +13,7 @@
 import lombok.RequiredArgsConstructor;
 import org.hiero.mirror.common.domain.entity.Entity;
 import org.hiero.mirror.common.domain.entity.EntityId;
+import org.hiero.mirror.common.exception.InvalidEntityException;
 import org.hiero.mirror.web3.repository.EntityRepository;
 
 @Named
@@ -35,7 +36,11 @@
     }
 
     public @Nonnull Optional<Entity> get(@Nonnull final TokenID tokenID, final Optional<Long> timestamp) {
-        return get(toEntityId(tokenID), timestamp);
+        try {
+            return get(toEntityId(tokenID), timestamp);
+        } catch (final InvalidEntityException e) {
+            return Optional.empty();
+        }
     }
 
     public @Nonnull Optional<Entity> get(@Nonnull final EntityId entityId, final Optional<Long> timestamp) {

web3/src/test/java/org/hiero/mirror/web3/service/ContractCallAirdropSystemContractTest.java

@@ -4,6 +4,7 @@
 
 import static com.hedera.hapi.node.base.ResponseCodeEnum.CONTRACT_REVERT_EXECUTED;
 import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
+import static org.assertj.core.api.AssertionsForClassTypes.assertThatThrownBy;
 import static org.hiero.mirror.common.domain.entity.EntityType.ACCOUNT;
 import static org.hiero.mirror.common.domain.entity.EntityType.CONTRACT;
 import static org.hiero.mirror.web3.evm.utils.EvmTokenUtils.toAddress;
@@ -14,26 +15,32 @@
 import java.util.List;
 import java.util.function.Consumer;
 import java.util.stream.Stream;
+import org.apache.tuweni.bytes.Bytes;
 import org.hiero.mirror.common.domain.entity.Entity;
 import org.hiero.mirror.common.domain.entity.EntityId;
 import org.hiero.mirror.common.domain.entity.EntityType;
 import org.hiero.mirror.common.domain.token.FixedFee;
 import org.hiero.mirror.common.domain.token.FractionalFee;
 import org.hiero.mirror.common.domain.token.TokenFreezeStatusEnum;
+import org.hiero.mirror.common.util.DomainUtils;
 import org.hiero.mirror.web3.evm.exception.PrecompileNotSupportedException;
 import org.hiero.mirror.web3.exception.MirrorEvmTransactionException;
 import org.hiero.mirror.web3.utils.BytecodeUtils;
 import org.hiero.mirror.web3.web3j.generated.Airdrop;
 import org.hiero.mirror.web3.web3j.generated.ClaimAirdrop;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.CsvSource;
 import org.junit.jupiter.params.provider.MethodSource;
+import org.springframework.boot.test.system.CapturedOutput;
+import org.springframework.boot.test.system.OutputCaptureExtension;
 import org.web3j.protocol.core.RemoteFunctionCall;
 import org.web3j.protocol.core.methods.response.TransactionReceipt;
 
+@ExtendWith({OutputCaptureExtension.class})
 class ContractCallAirdropSystemContractTest extends AbstractContractCallServiceTest {
 
     private static final BigInteger DEFAULT_DEPLOYED_CONTRACT_BALANCE = BigInteger.valueOf(100_000_000L);
@@ -108,6 +115,33 @@
         verifyContractCall(functionCall, contract);
     }
 
+    @ParameterizedTest(name = "Airdrop token with invalid token address: {0}")
+    @CsvSource({"0xa7d9ddbe1f17865597fbd27ec712455208b6b76d", "0.0.-1900", "2.1.-1234", "0.0.5901004952499928656"})
+    void airdropTokenWithInvalidTokenAddress(String invalidTokenId, CapturedOutput output) {
+        if (mirrorNodeEvmProperties.isModularizedServices()) {
+            // Given
+            final var contract = testWeb3jService.deployWithValue(Airdrop::deploy, DEFAULT_DEPLOYED_CONTRACT_BALANCE);
+            final var sender = accountEntityPersist();
+            final var receiver = persistAirdropReceiver(EntityType.ACCOUNT, e -> {});
+
+            final var tokenId = fungibleTokenSetup(sender);
+            tokenAccountPersist(tokenId, receiver.getId());
+            final var invalidTokenAddress = parseTokenIdToAddress(invalidTokenId);
+
+            // When
+            final var functionCall = contract.send_tokenAirdrop(
+                    invalidTokenAddress,
+                    getAddressFromEntity(sender),
+                    toAddress(receiver).toHexString(),
+                    DEFAULT_TOKEN_AIRDROP_AMOUNT,
+                    DEFAULT_TINYBAR_VALUE);
+
+            // Then
+            assertThatThrownBy(functionCall::send).isInstanceOf(MirrorEvmTransactionException.class);
+            assertThat(output.getAll()).doesNotContain("InvalidEntityException");
+        }
+    }
+
     @ParameterizedTest(name = "Airdrop non-fungible token to a(an) {0} that is already associated to it")
     @MethodSource("receiverData")
     void airdropNFT(final EntityType receiverType) {
@@ -868,4 +902,23 @@
             assertThrows(PrecompileNotSupportedException.class, functionCall::send);
         }
     }
+
+    /**
+     * Parses a token ID to string
+     *
+     * @param tokenId the token ID in format "shard.realm.num" or EVM address
+     * @return the token address string
+     */
+    private String parseTokenIdToAddress(String tokenId) {
+        if (tokenId.startsWith("0x")) {
+            return tokenId;
+        }
+
+        // Parse shard.realm.num format
+        String[] parts = tokenId.split("\\.");
+
+        long num = Long.parseLong(parts[2]);
+
+        return Bytes.wrap(DomainUtils.toEvmAddress(num)).toHexString();
+    }
 }