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() does pure precedence resolution -- `input` wins over
`data` -- mirroring go-ethereum's TransactionArgs.data(). Five call
sites in TronJsonRpcImpl use the resolver instead of getData(). The
verb-prefix name (not getXxx) keeps Jackson and FastJSON's JavaBean
introspection from picking the method up as a `resolveData` wire
property; two serialisation tests pin this as a regression guard.

Hex validation is mode-driven via JsonRpcApiUtil.requireValidHex
(HexMode.STRICT / HexMode.LENIENT):

- `input` (new field) is STRICT: 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).

Conflict between `input` and `data` (both set, not equal) is
detected on the build path at BuildArguments.getContractType(),
mirroring geth's data() / setDefaults split. The error message
matches go-ethereum's setDefaults wording verbatim. Comparison is
byte-level so case differences are not flagged. The query path
(CallArguments.resolveData()) stays lenient -- input wins silently.

Tested by 52 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,50 @@ public static boolean paramQuantityIsNull(String quantity) {
     return StringUtils.isEmpty(quantity) || quantity.equals("0x0");
   }
 
+  /**
+   * Validation mode for {@link #requireValidHex}.
+   */
+  public enum HexMode {
+    /**
+     * Execution-apis BYTES schema: requires {@code 0x} prefix and
+     * even total length; {@code ""} is accepted as empty bytes per
+     * geth's {@code hexutil.Bytes.UnmarshalText}.
+     */
+    STRICT,
+    /**
+     * {@link ByteArray#fromHexString}'s lenient parsing: accepts bare
+     * hex and odd-length input. Kept for backward compatibility.
+     */
+    LENIENT
+  }
+
+  /**
+   * Throws if {@code value} is not parseable hex under the given
+   * {@code mode}. {@code null} is treated as absent and returns
+   * silently. {@code fieldName} is used only in error messages.
+   */
+  public static void requireValidHex(String fieldName, String value, HexMode mode)
+      throws JsonRpcInvalidParamsException {
+    if (value == null) {
+      return;
+    }
+    if (mode == HexMode.STRICT) {
+      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,18 +4,22 @@
 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;
+import org.tron.core.services.jsonrpc.JsonRpcApiUtil.HexMode;
 import org.tron.protos.Protocol.Transaction.Contract.ContractType;
 import org.tron.protos.contract.SmartContractOuterClass.SmartContract;
 
@@ -44,6 +48,9 @@ public class BuildArguments {
   private String data;
   @Getter
   @Setter
+  private String input;
+  @Getter
+  @Setter
   private String nonce = ""; //not used
 
   @Getter
@@ -83,16 +90,47 @@ 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}. Pure
+   * precedence resolution, mirroring go-ethereum's
+   * {@code TransactionArgs.data()}.
+   *
+   * <p>Both fields are first validated by
+   * {@link org.tron.core.services.jsonrpc.JsonRpcApiUtil#requireValidHex}
+   * — strict for {@code input}, lenient for {@code data} (see that
+   * method for the rules). Conflict between {@code input} and
+   * {@code data} is detected at the build entry point
+   * {@link #getContractType(Wallet)}, not here, mirroring geth's
+   * {@code data()} / {@code setDefaults} split.
+   *
+   * <p>Java callers using positional constructors should pass
+   * {@code null} (not {@code ""}) for unset {@code input}.
+   *
+   * <p>Verb-prefix name (not {@code getXxx}) keeps Jackson and
+   * FastJSON's JavaBean introspection from invoking it during
+   * serialisation; two regression tests per DTO pin this invariant.
+   */
+  public String resolveData() throws JsonRpcInvalidParamsException {
+    requireValidHex("input", input, HexMode.STRICT);
+    requireValidHex("data", data, HexMode.LENIENT);
+    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();
+    validateCallDataConflict();
+
     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 +174,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;
@@ -15,6 +16,7 @@
 import org.tron.core.Wallet;
 import org.tron.core.exception.jsonrpc.JsonRpcInvalidParamsException;
 import org.tron.core.exception.jsonrpc.JsonRpcInvalidRequestException;
+import org.tron.core.services.jsonrpc.JsonRpcApiUtil.HexMode;
 import org.tron.protos.Protocol.Transaction.Contract.ContractType;
 import org.tron.protos.contract.SmartContractOuterClass.SmartContract;
 
@@ -43,21 +45,40 @@ 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}. Pure
+   * precedence resolution, mirroring go-ethereum's
+   * {@code TransactionArgs.data()}; see {@link BuildArguments#resolveData()}
+   * for the rationale on naming, validation split, and serialiser
+   * interaction.
+   */
+  public String resolveData() throws JsonRpcInvalidParamsException {
+    requireValidHex("input", input, HexMode.STRICT);
+    requireValidHex("data", data, HexMode.LENIENT);
+    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");
       }