fix(jsonrpc): accept "input" as alias for "data" in call args

Closes #6517.

JSON-RPC requests using the execution-apis field name `input` were
rejected with UnrecognizedPropertyException, blocking spec-compliant
clients -- notably go-ethereum's ethclient since
ethereum/go-ethereum#28078, which only emits `input`.

CallArguments and BuildArguments now declare both fields. A new
resolveData() prefers `input` over `data`, mirroring geth's
TransactionArgs.data(). Five call sites in TronJsonRpcImpl use the
resolver instead of getData(). The verb-prefix name (not getXxx) is
the defence keeping JavaBean introspection in Jackson and FastJSON
from picking the method up as a `resolveData` wire property; two
serialisation tests pin this as a regression guard.

Hex validation is asymmetric:

- `input` (new field) follows the execution-apis BYTES schema --
  requires `0x` prefix and even length; "" is accepted as empty
  bytes per geth's hexutil.Bytes.UnmarshalText.
- `data` retains lenient parsing via ByteArray.fromHexString for
  backward compatibility with existing callers (e.g.
  BuildTransactionTest.testCreateSmartContract uses bare-hex
  bytecode).

On the build path, conflicting input/data byte values throw
JsonRpcInvalidParamsException with go-ethereum's setDefaults wording
verbatim. The query path stays lenient (input wins silently).
Comparison is byte-level so case differences are not flagged.

Tested by 53 unit tests including Jackson/FastJSON serialisation
safety guards; BuildTransactionTest.testCreateSmartContract still
passes; checkstyle clean.

Author: waynercheung

framework/src/main/java/org/tron/core/services/jsonrpc/JsonRpcApiUtil.java

@@ -439,6 +439,39 @@ public static boolean paramQuantityIsNull(String quantity) {
     return StringUtils.isEmpty(quantity) || quantity.equals("0x0");
   }
 
+  /**
+   * Throws if {@code value} is not parseable hex.
+   *
+   * <p>For {@code "input"}, applies the execution-apis BYTES schema:
+   * {@code 0x} prefix and even length required; {@code ""} is accepted
+   * as empty bytes per geth's {@code hexutil.Bytes.UnmarshalText}.
+   *
+   * <p>Other fields (notably {@code "data"}) keep
+   * {@link ByteArray#fromHexString}'s lenient parsing for backward
+   * compatibility.
+   */
+  public static void requireValidHex(String fieldName, String value)
+      throws JsonRpcInvalidParamsException {
+    if (value == null) {
+      return;
+    }
+    if ("input".equals(fieldName)) {
+      if (value.isEmpty()) {
+        return;
+      }
+      if (!value.startsWith("0x") || value.length() % 2 != 0) {
+        throw new JsonRpcInvalidParamsException(
+            "invalid hex string for \"" + fieldName + "\"");
+      }
+    }
+    try {
+      ByteArray.fromHexString(value);
+    } catch (Exception e) {
+      throw new JsonRpcInvalidParamsException(
+          "invalid hex string for \"" + fieldName + "\"");
+    }
+  }
+
   public static long parseQuantityValue(String value) throws JsonRpcInvalidParamsException {
     long callValue = 0L;
 

framework/src/main/java/org/tron/core/services/jsonrpc/TronJsonRpcImpl.java

@@ -647,15 +647,15 @@ public String estimateGas(CallArguments args) throws JsonRpcInvalidRequestExcept
         estimateEnergy(ownerAddress,
             contractAddress,
             args.parseValue(),
-            ByteArray.fromHexString(args.getData()),
+            ByteArray.fromHexString(args.resolveData()),
             trxExtBuilder,
             retBuilder,
             estimateBuilder);
       } else {
         callTriggerConstantContract(ownerAddress,
             contractAddress,
             args.parseValue(),
-            ByteArray.fromHexString(args.getData()),
+            ByteArray.fromHexString(args.resolveData()),
             trxExtBuilder,
             retBuilder);
       }
@@ -1012,7 +1012,7 @@ public String getCall(CallArguments transactionCall, Object blockParamObj)
       byte[] contractAddressData = addressCompatibleToByteArray(transactionCall.getTo());
 
       return call(addressData, contractAddressData, transactionCall.parseValue(),
-          ByteArray.fromHexString(transactionCall.getData()));
+          ByteArray.fromHexString(transactionCall.resolveData()));
     } else {
       try {
         ByteArray.hexToBigInteger(blockNumOrTag);
@@ -1128,7 +1128,8 @@ private TransactionJson buildCreateSmartContractTransaction(byte[] ownerAddress,
       smartBuilder.setOriginAddress(ByteString.copyFrom(ownerAddress));
 
       // bytecode + parameter
-      smartBuilder.setBytecode(ByteString.copyFrom(ByteArray.fromHexString(args.getData())));
+      smartBuilder.setBytecode(
+          ByteString.copyFrom(ByteArray.fromHexString(args.resolveData())));
 
       if (StringUtils.isNotEmpty(args.getName())) {
         smartBuilder.setName(args.getName());
@@ -1173,8 +1174,9 @@ private TransactionJson buildTriggerSmartContractTransaction(byte[] ownerAddress
       build.setOwnerAddress(ByteString.copyFrom(ownerAddress))
           .setContractAddress(ByteString.copyFrom(contractAddress));
 
-      if (StringUtils.isNotEmpty(args.getData())) {
-        build.setData(ByteString.copyFrom(ByteArray.fromHexString(args.getData())));
+      String callData = args.resolveData();
+      if (StringUtils.isNotEmpty(callData)) {
+        build.setData(ByteString.copyFrom(ByteArray.fromHexString(callData)));
       } else {
         build.setData(ByteString.copyFrom(new byte[0]));
       }

framework/src/main/java/org/tron/core/services/jsonrpc/types/BuildArguments.java

@@ -4,15 +4,18 @@
 import static org.tron.core.services.jsonrpc.JsonRpcApiUtil.paramQuantityIsNull;
 import static org.tron.core.services.jsonrpc.JsonRpcApiUtil.paramStringIsNull;
 import static org.tron.core.services.jsonrpc.JsonRpcApiUtil.parseQuantityValue;
+import static org.tron.core.services.jsonrpc.JsonRpcApiUtil.requireValidHex;
 
 import com.google.protobuf.ByteString;
+import java.util.Arrays;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.Setter;
 import lombok.ToString;
 import org.apache.commons.lang3.StringUtils;
 import org.tron.api.GrpcAPI.BytesMessage;
+import org.tron.common.utils.ByteArray;
 import org.tron.core.Wallet;
 import org.tron.core.exception.jsonrpc.JsonRpcInvalidParamsException;
 import org.tron.core.exception.jsonrpc.JsonRpcInvalidRequestException;
@@ -44,6 +47,9 @@ public class BuildArguments {
   private String data;
   @Getter
   @Setter
+  private String input;
+  @Getter
+  @Setter
   private String nonce = ""; //not used
 
   @Getter
@@ -83,16 +89,41 @@ public BuildArguments(CallArguments args) {
     gasPrice = args.getGasPrice();
     value = args.getValue();
     data = args.getData();
+    input = args.getInput();
+  }
+
+  /**
+   * Returns {@code input} if non-null, else {@code data}. Both go
+   * through {@link org.tron.core.services.jsonrpc.JsonRpcApiUtil#requireValidHex}
+   * (strict for {@code input}, lenient for {@code data}); see that
+   * method for the rules.
+   *
+   * <p>Java callers using positional constructors should pass
+   * {@code null} (not {@code ""}) for unset {@code input}. If both
+   * fields are supplied and decode to non-equal bytes, throws — strict
+   * build-path counterpart of {@link CallArguments#resolveData()}.
+   *
+   * <p>Verb-prefix name (not {@code getXxx}) keeps Jackson/FastJSON
+   * introspection from invoking it during serialisation.
+   */
+  public String resolveData() throws JsonRpcInvalidParamsException {
+    requireValidHex("input", input);
+    requireValidHex("data", data);
+    validateCallDataConflict();
+    return input != null ? input : data;
   }
 
   public ContractType getContractType(Wallet wallet) throws JsonRpcInvalidRequestException,
       JsonRpcInvalidParamsException {
+    // Fail fast on bad hex / conflict before the state lookup.
+    String resolvedData = resolveData();
+
     ContractType contractType;
 
     // to is null
     if (paramStringIsNull(to)) {
       // data is null
-      if (paramStringIsNull(data)) {
+      if (paramStringIsNull(resolvedData)) {
         throw new JsonRpcInvalidRequestException("invalid json request");
       }
 
@@ -136,4 +167,24 @@ private boolean availableTransferAsset() {
     return tokenId > 0 && tokenValue > 0 && paramQuantityIsNull(value);
   }
 
+  /**
+   * Throws when both fields decode to non-equal bytes. Wording matches
+   * geth's setDefaults so existing tooling can detect the error string.
+   */
+  private void validateCallDataConflict() throws JsonRpcInvalidParamsException {
+    if (input != null && data != null && !calldataEquals(input, data)) {
+      throw new JsonRpcInvalidParamsException(
+          "both \"data\" and \"input\" are set and not equal. "
+              + "Please use \"input\" to pass transaction call data");
+    }
+  }
+
+  /**
+   * Byte-level equality, so {@code "0xDEAD"} equals {@code "0xdead"}. Both
+   * args must have passed {@code requireValidHex} first.
+   */
+  private static boolean calldataEquals(String a, String b) {
+    return Arrays.equals(ByteArray.fromHexString(a), ByteArray.fromHexString(b));
+  }
+
 }

framework/src/main/java/org/tron/core/services/jsonrpc/types/CallArguments.java

@@ -3,6 +3,7 @@
 import static org.tron.core.services.jsonrpc.JsonRpcApiUtil.addressCompatibleToByteArray;
 import static org.tron.core.services.jsonrpc.JsonRpcApiUtil.paramStringIsNull;
 import static org.tron.core.services.jsonrpc.JsonRpcApiUtil.parseQuantityValue;
+import static org.tron.core.services.jsonrpc.JsonRpcApiUtil.requireValidHex;
 
 import com.google.protobuf.ByteString;
 import lombok.AllArgsConstructor;
@@ -43,21 +44,47 @@ public class CallArguments {
   private String data;
   @Getter
   @Setter
+  private String input;
+  @Getter
+  @Setter
   private String nonce; // not used
 
+  /**
+   * Returns {@code input} if non-null, else {@code data}. Both go
+   * through {@link org.tron.core.services.jsonrpc.JsonRpcApiUtil#requireValidHex}
+   * (strict for {@code input}, lenient for {@code data}); see that
+   * method for the rules.
+   *
+   * <p>Java callers using positional constructors should pass
+   * {@code null} (not {@code ""}) for unset {@code input}. No conflict
+   * raised here — see {@link BuildArguments#resolveData()} for the
+   * strict build-path version.
+   *
+   * <p>Verb-prefix name (not {@code getXxx}) keeps Jackson/FastJSON
+   * introspection from invoking it during serialisation.
+   */
+  public String resolveData() throws JsonRpcInvalidParamsException {
+    requireValidHex("input", input);
+    requireValidHex("data", data);
+    return input != null ? input : data;
+  }
+
   /**
    * just support TransferContract, CreateSmartContract and TriggerSmartContract
    * */
   public ContractType getContractType(Wallet wallet) throws JsonRpcInvalidRequestException,
       JsonRpcInvalidParamsException {
-    ContractType contractType;
-
     // from or to is null
     if (paramStringIsNull(from)) {
       throw new JsonRpcInvalidRequestException("invalid json request");
-    } else if (paramStringIsNull(to)) {
+    }
+    // Fail fast on bad hex before the state lookup.
+    String resolvedData = resolveData();
+
+    ContractType contractType;
+    if (paramStringIsNull(to)) {
       // data is null
-      if (paramStringIsNull(data)) {
+      if (paramStringIsNull(resolvedData)) {
         throw new JsonRpcInvalidRequestException("invalid json request");
       }