From 3bed7eabefb700bdae01a06bad2194f381e56892 Mon Sep 17 00:00:00 2001 From: halibobo1205 Date: Fri, 3 Apr 2026 12:45:27 +0800 Subject: [PATCH] feat(framework,actuator,common): replace fastjson with jackson MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Replace `com.alibaba:fastjson` with Jackson-backed drop-in wrappers (`org.tron.json.{JSON, JSONObject, JSONArray, JSONException}`). No external API changes — all HTTP and JSON-RPC responses remain identical. Motivation: - Fastjson 1.2.83 is EOL with 20+ CVEs including critical RCE - Upgrade jackson-databind 2.18.3 → 2.18.6 (GHSA-72hv-8253-57qq) - Unify JSON handling (previously split between Jackson and Fastjson) Core changes (common): - Add org.tron.json wrappers backed by a shared ObjectMapper - Remove fastjson from common/build.gradle HTTP & servlet changes (framework): - Swap imports from com.alibaba.fastjson → org.tron.json across all HTTP servlets, JSON-RPC layer, and event/log parsers Test changes: - Add BaseHttpTest base class for servlet test lifecycle Build: - Update jackson to 2.18.6 - Remove fastjson close #6607 --- .../org/tron/core/vm/trace/ProgramTrace.java | 6 +- .../org/tron/core/vm/trace/Serializers.java | 67 +--- common/build.gradle | 2 +- .../java/org/tron/common/utils/JsonUtil.java | 5 +- common/src/main/java/org/tron/json/JSON.java | 155 ++++++++ .../main/java/org/tron/json/JSONArray.java | 146 ++++++++ .../java/org/tron/json/JSONException.java | 19 + .../main/java/org/tron/json/JSONObject.java | 338 ++++++++++++++++++ .../main/java/org/tron/json/TypeUtils.java | 310 ++++++++++++++++ framework/build.gradle | 1 - .../logsfilter/ContractEventParserJson.java | 4 +- .../org/tron/core/config/DefaultConfig.java | 2 - .../services/filter/HttpApiAccessFilter.java | 2 +- .../http/AccountPermissionUpdateServlet.java | 2 +- .../services/http/BroadcastHexServlet.java | 2 +- .../core/services/http/BroadcastServlet.java | 2 +- .../http/CancelAllUnfreezeV2Servlet.java | 4 +- .../core/services/http/ClearABIServlet.java | 2 +- .../services/http/CreateAccountServlet.java | 2 +- .../http/CreateAssetIssueServlet.java | 2 +- .../http/CreateCommonTransactionServlet.java | 2 +- ...TransactionWithoutSpendAuthSigServlet.java | 4 +- .../services/http/CreateWitnessServlet.java | 2 +- .../http/DelegateResourceServlet.java | 4 +- .../services/http/DeployContractServlet.java | 4 +- .../services/http/EstimateEnergyServlet.java | 2 +- .../services/http/ExchangeCreateServlet.java | 2 +- .../services/http/ExchangeInjectServlet.java | 2 +- .../http/ExchangeTransactionServlet.java | 2 +- .../http/ExchangeWithdrawServlet.java | 2 +- .../services/http/FreezeBalanceServlet.java | 2 +- .../services/http/FreezeBalanceV2Servlet.java | 2 +- .../http/GetAccountBalanceServlet.java | 2 - .../services/http/GetAccountByIdServlet.java | 4 +- .../http/GetAccountResourceServlet.java | 2 +- .../core/services/http/GetAccountServlet.java | 2 +- .../http/GetAssetIssueByIdServlet.java | 2 +- .../http/GetAssetIssueByNameServlet.java | 4 +- .../http/GetAssetIssueListByNameServlet.java | 4 +- .../services/http/GetBlockBalanceServlet.java | 2 - .../core/services/http/GetBlockServlet.java | 4 +- .../services/http/GetContractInfoServlet.java | 4 +- .../services/http/GetContractServlet.java | 2 +- ...tDelegatedResourceAccountIndexServlet.java | 2 +- ...elegatedResourceAccountIndexV2Servlet.java | 2 +- .../services/http/GetExchangeByIdServlet.java | 3 +- .../http/GetIncomingViewingKeyServlet.java | 2 +- .../http/GetMarketOrderByAccountServlet.java | 5 +- .../services/http/GetNodeInfoServlet.java | 2 +- .../services/http/GetProposalByIdServlet.java | 4 +- .../GetTransactionInfoByBlockNumServlet.java | 4 +- .../http/GetZenPaymentAddressServlet.java | 2 +- .../tron/core/services/http/JsonFormat.java | 2 +- .../http/MarketCancelOrderServlet.java | 2 +- .../services/http/MarketSellAssetServlet.java | 2 +- .../core/services/http/MetricsServlet.java | 2 +- .../http/ParticipateAssetIssueServlet.java | 2 +- .../services/http/ProposalApproveServlet.java | 2 +- .../services/http/ProposalCreateServlet.java | 2 +- .../services/http/ProposalDeleteServlet.java | 2 +- .../http/ScanAndMarkNoteByIvkServlet.java | 4 +- .../services/http/ScanNoteByIvkServlet.java | 4 +- .../ScanShieldedTRC20NotesByIvkServlet.java | 4 +- .../services/http/SetAccountIdServlet.java | 2 +- .../services/http/TransferAssetServlet.java | 2 +- .../core/services/http/TransferServlet.java | 2 +- .../http/TriggerConstantContractServlet.java | 2 +- .../http/TriggerSmartContractServlet.java | 2 +- .../http/UnDelegateResourceServlet.java | 2 +- .../services/http/UnFreezeAssetServlet.java | 3 +- .../services/http/UnFreezeBalanceServlet.java | 3 +- .../http/UnFreezeBalanceV2Servlet.java | 2 +- .../services/http/UpdateAccountServlet.java | 3 +- .../services/http/UpdateAssetServlet.java | 3 +- .../services/http/UpdateBrokerageServlet.java | 3 +- .../http/UpdateEnergyLimitServlet.java | 3 +- .../services/http/UpdateSettingServlet.java | 2 +- .../services/http/UpdateWitnessServlet.java | 3 +- .../org/tron/core/services/http/Util.java | 9 +- .../services/http/ValidateAddressServlet.java | 4 +- .../http/VoteWitnessAccountServlet.java | 2 +- .../services/http/WithdrawBalanceServlet.java | 2 +- .../http/WithdrawExpireUnfreezeServlet.java | 4 +- .../core/services/jsonrpc/TronJsonRpc.java | 2 +- .../services/jsonrpc/TronJsonRpcImpl.java | 2 +- .../java/org/tron/keystore/WalletUtils.java | 3 +- .../logsfilter/EventParserJsonTest.java | 6 +- .../common/utils/client/utils/AbiUtil.java | 4 +- .../common/utils/client/utils/HttpMethed.java | 4 +- .../utils/client/utils/JSONObjectWarp.java | 27 +- .../core/actuator/vm/SerializersTest.java | 60 +++- .../tron/core/jsonrpc/JsonrpcServiceTest.java | 2 +- .../PbftDataSyncHandlerTest.java | 2 +- .../java/org/tron/core/pbft/PbftApiTest.java | 4 +- .../core/services/NodeInfoServiceTest.java | 2 +- .../AccountPermissionUpdateServletTest.java | 60 ++++ .../tron/core/services/http/BaseHttpTest.java | 127 +++++++ .../http/CancelAllUnfreezeV2ServletTest.java | 47 +++ .../services/http/ClearABIServletTest.java | 5 +- .../http/CreateAccountServletTest.java | 4 +- .../http/CreateAssetIssueServletTest.java | 4 +- .../http/CreateSpendAuthSigServletTest.java | 2 +- .../http/CreateWitnessServletTest.java | 4 +- .../http/DelegateResourceServletTest.java | 59 +++ .../http/DeployContractServletTest.java | 58 +++ .../http/ExchangeCreateServletTest.java | 58 +++ .../http/ExchangeInjectServletTest.java | 56 +++ .../http/ExchangeTransactionServletTest.java | 58 +++ .../http/ExchangeWithdrawServletTest.java | 56 +++ .../http/FreezeBalanceServletTest.java | 53 +++ .../http/FreezeBalanceV2ServletTest.java | 55 +++ .../http/GetAccountResourceServletTest.java | 55 +++ .../services/http/GetAccountServletTest.java | 60 ++++ .../http/GetAssetIssueByIdServletTest.java | 70 ++++ .../http/GetAssetIssueByNameServletTest.java | 71 ++++ .../GetAssetIssueListByNameServletTest.java | 47 +++ .../http/GetAssetIssueListServletTest.java | 2 +- .../http/GetBandwidthPricesServletTest.java | 2 +- .../http/GetBlockByNumServletTest.java | 4 +- .../services/http/GetBlockServletTest.java | 45 +++ .../http/GetBrokerageServletTest.java | 4 +- .../http/GetContractInfoServletTest.java | 60 ++++ .../services/http/GetContractServletTest.java | 71 ++++ ...egatedResourceAccountIndexServletTest.java | 56 +++ ...atedResourceAccountIndexV2ServletTest.java | 57 +++ .../http/GetEnergyPricesServletTest.java | 2 +- .../http/GetExchangeByIdServletTest.java | 52 +++ .../GetMarketOrderByAccountServletTest.java | 55 +++ .../http/GetMemoFeePricesServletTest.java | 2 +- .../services/http/GetNowBlockServletTest.java | 2 +- .../http/GetProposalByIdServletTest.java | 70 ++++ .../services/http/GetRewardServletTest.java | 8 +- ...tTransactionInfoByBlockNumServletTest.java | 7 +- .../GetTransactionInfoByIdServletTest.java | 4 +- .../http/ListProposalsServletTest.java | 2 +- .../http/MarketCancelOrderServletTest.java | 50 +++ .../http/MarketSellAssetServletTest.java | 59 +++ .../ParticipateAssetIssueServletTest.java | 59 +++ .../http/ProposalApproveServletTest.java | 53 +++ .../http/ProposalCreateServletTest.java | 53 +++ .../http/ProposalDeleteServletTest.java | 51 +++ .../http/SetAccountIdServletTest.java | 51 +++ .../http/TransferAssetServletTest.java | 58 +++ .../services/http/TransferServletTest.java | 55 +++ .../http/UnDelegateResourceServletTest.java | 59 +++ .../http/UnFreezeAssetServletTest.java | 47 +++ .../http/UnFreezeBalanceServletTest.java | 46 +++ .../http/UnFreezeBalanceV2ServletTest.java | 55 +++ .../services/http/UpdateAssetServletTest.java | 59 +++ .../http/UpdateBrokerageServletTest.java | 51 +++ .../http/UpdateEnergyLimitServletTest.java | 54 +++ .../http/UpdateSettingServletTest.java | 56 +++ .../http/UpdateWitnessServletTest.java | 52 +++ .../tron/core/services/http/UtilMockTest.java | 6 +- .../http/ValidateAddressServletTest.java | 58 +++ .../http/VoteWitnessAccountServletTest.java | 54 +++ .../http/WithdrawBalanceServletTest.java | 46 +++ .../WithdrawExpireUnfreezeServletTest.java | 47 +++ .../GetBandwidthPricesOnPBFTServletTest.java | 2 +- .../GetEnergyPricesOnPBFTServletTest.java | 2 +- ...tBandwidthPricesOnSolidityServletTest.java | 2 +- .../GetEnergyPricesOnSolidityServletTest.java | 2 +- .../org/tron/core/zksnark/MerkleTreeTest.java | 2 +- .../tron/core/zksnark/SendCoinShieldTest.java | 2 +- .../src/test/java/org/tron/json/JsonTest.java | 107 ++++++ gradle/verification-metadata.xml | 82 ++--- 166 files changed, 3978 insertions(+), 281 deletions(-) create mode 100644 common/src/main/java/org/tron/json/JSON.java create mode 100644 common/src/main/java/org/tron/json/JSONArray.java create mode 100644 common/src/main/java/org/tron/json/JSONException.java create mode 100644 common/src/main/java/org/tron/json/JSONObject.java create mode 100644 common/src/main/java/org/tron/json/TypeUtils.java create mode 100644 framework/src/test/java/org/tron/core/services/http/AccountPermissionUpdateServletTest.java create mode 100644 framework/src/test/java/org/tron/core/services/http/BaseHttpTest.java create mode 100644 framework/src/test/java/org/tron/core/services/http/CancelAllUnfreezeV2ServletTest.java create mode 100644 framework/src/test/java/org/tron/core/services/http/DelegateResourceServletTest.java create mode 100644 framework/src/test/java/org/tron/core/services/http/DeployContractServletTest.java create mode 100644 framework/src/test/java/org/tron/core/services/http/ExchangeCreateServletTest.java create mode 100644 framework/src/test/java/org/tron/core/services/http/ExchangeInjectServletTest.java create mode 100644 framework/src/test/java/org/tron/core/services/http/ExchangeTransactionServletTest.java create mode 100644 framework/src/test/java/org/tron/core/services/http/ExchangeWithdrawServletTest.java create mode 100644 framework/src/test/java/org/tron/core/services/http/FreezeBalanceServletTest.java create mode 100644 framework/src/test/java/org/tron/core/services/http/FreezeBalanceV2ServletTest.java create mode 100644 framework/src/test/java/org/tron/core/services/http/GetAccountResourceServletTest.java create mode 100644 framework/src/test/java/org/tron/core/services/http/GetAccountServletTest.java create mode 100644 framework/src/test/java/org/tron/core/services/http/GetAssetIssueByIdServletTest.java create mode 100644 framework/src/test/java/org/tron/core/services/http/GetAssetIssueByNameServletTest.java create mode 100644 framework/src/test/java/org/tron/core/services/http/GetAssetIssueListByNameServletTest.java create mode 100644 framework/src/test/java/org/tron/core/services/http/GetBlockServletTest.java create mode 100644 framework/src/test/java/org/tron/core/services/http/GetContractInfoServletTest.java create mode 100644 framework/src/test/java/org/tron/core/services/http/GetContractServletTest.java create mode 100644 framework/src/test/java/org/tron/core/services/http/GetDelegatedResourceAccountIndexServletTest.java create mode 100644 framework/src/test/java/org/tron/core/services/http/GetDelegatedResourceAccountIndexV2ServletTest.java create mode 100644 framework/src/test/java/org/tron/core/services/http/GetExchangeByIdServletTest.java create mode 100644 framework/src/test/java/org/tron/core/services/http/GetMarketOrderByAccountServletTest.java create mode 100644 framework/src/test/java/org/tron/core/services/http/GetProposalByIdServletTest.java create mode 100644 framework/src/test/java/org/tron/core/services/http/MarketCancelOrderServletTest.java create mode 100644 framework/src/test/java/org/tron/core/services/http/MarketSellAssetServletTest.java create mode 100644 framework/src/test/java/org/tron/core/services/http/ParticipateAssetIssueServletTest.java create mode 100644 framework/src/test/java/org/tron/core/services/http/ProposalApproveServletTest.java create mode 100644 framework/src/test/java/org/tron/core/services/http/ProposalCreateServletTest.java create mode 100644 framework/src/test/java/org/tron/core/services/http/ProposalDeleteServletTest.java create mode 100644 framework/src/test/java/org/tron/core/services/http/SetAccountIdServletTest.java create mode 100644 framework/src/test/java/org/tron/core/services/http/TransferAssetServletTest.java create mode 100644 framework/src/test/java/org/tron/core/services/http/TransferServletTest.java create mode 100644 framework/src/test/java/org/tron/core/services/http/UnDelegateResourceServletTest.java create mode 100644 framework/src/test/java/org/tron/core/services/http/UnFreezeAssetServletTest.java create mode 100644 framework/src/test/java/org/tron/core/services/http/UnFreezeBalanceServletTest.java create mode 100644 framework/src/test/java/org/tron/core/services/http/UnFreezeBalanceV2ServletTest.java create mode 100644 framework/src/test/java/org/tron/core/services/http/UpdateAssetServletTest.java create mode 100644 framework/src/test/java/org/tron/core/services/http/UpdateBrokerageServletTest.java create mode 100644 framework/src/test/java/org/tron/core/services/http/UpdateEnergyLimitServletTest.java create mode 100644 framework/src/test/java/org/tron/core/services/http/UpdateSettingServletTest.java create mode 100644 framework/src/test/java/org/tron/core/services/http/UpdateWitnessServletTest.java create mode 100644 framework/src/test/java/org/tron/core/services/http/ValidateAddressServletTest.java create mode 100644 framework/src/test/java/org/tron/core/services/http/VoteWitnessAccountServletTest.java create mode 100644 framework/src/test/java/org/tron/core/services/http/WithdrawBalanceServletTest.java create mode 100644 framework/src/test/java/org/tron/core/services/http/WithdrawExpireUnfreezeServletTest.java create mode 100644 framework/src/test/java/org/tron/json/JsonTest.java diff --git a/actuator/src/main/java/org/tron/core/vm/trace/ProgramTrace.java b/actuator/src/main/java/org/tron/core/vm/trace/ProgramTrace.java index bd8bc18e78e..953278ab7f3 100644 --- a/actuator/src/main/java/org/tron/core/vm/trace/ProgramTrace.java +++ b/actuator/src/main/java/org/tron/core/vm/trace/ProgramTrace.java @@ -90,12 +90,12 @@ public void merge(ProgramTrace programTrace) { this.ops.addAll(programTrace.ops); } - public String asJsonString(boolean formatted) { - return serializeFieldsOnly(this, formatted); + public String asJsonString() { + return serializeFieldsOnly(this); } @Override public String toString() { - return asJsonString(true); + return asJsonString(); } } diff --git a/actuator/src/main/java/org/tron/core/vm/trace/Serializers.java b/actuator/src/main/java/org/tron/core/vm/trace/Serializers.java index 69056d359c5..ddf18105941 100644 --- a/actuator/src/main/java/org/tron/core/vm/trace/Serializers.java +++ b/actuator/src/main/java/org/tron/core/vm/trace/Serializers.java @@ -1,73 +1,28 @@ package org.tron.core.vm.trace; -import com.fasterxml.jackson.annotation.JsonAutoDetect; -import com.fasterxml.jackson.core.JsonGenerator; -import com.fasterxml.jackson.core.JsonProcessingException; -import com.fasterxml.jackson.databind.JsonSerializer; +import com.fasterxml.jackson.annotation.JsonAutoDetect.Visibility; +import com.fasterxml.jackson.annotation.PropertyAccessor; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.SerializationFeature; -import com.fasterxml.jackson.databind.SerializerProvider; -import com.fasterxml.jackson.databind.introspect.VisibilityChecker; -import java.io.IOException; +import com.fasterxml.jackson.databind.json.JsonMapper; import lombok.extern.slf4j.Slf4j; -import org.bouncycastle.util.encoders.Hex; -import org.tron.common.runtime.vm.DataWord; -import org.tron.core.vm.Op; @Slf4j(topic = "VM") public final class Serializers { - public static String serializeFieldsOnly(Object value, boolean pretty) { - try { - ObjectMapper mapper = createMapper(pretty); - mapper.setVisibilityChecker(fieldsOnlyVisibilityChecker(mapper)); + private static final ObjectMapper mapper = JsonMapper.builder() + .enable(SerializationFeature.INDENT_OUTPUT) + .visibility(PropertyAccessor.FIELD, Visibility.ANY) + .visibility(PropertyAccessor.GETTER, Visibility.NONE) + .visibility(PropertyAccessor.IS_GETTER, Visibility.NONE) + .build(); + public static String serializeFieldsOnly(Object value) { + try { return mapper.writeValueAsString(value); } catch (Exception e) { logger.error("JSON serialization error: ", e); return "{}"; } } - - private static VisibilityChecker fieldsOnlyVisibilityChecker(ObjectMapper mapper) { - return mapper.getSerializationConfig().getDefaultVisibilityChecker() - .withFieldVisibility(JsonAutoDetect.Visibility.ANY) - .withGetterVisibility(JsonAutoDetect.Visibility.NONE) - .withIsGetterVisibility(JsonAutoDetect.Visibility.NONE); - } - - public static ObjectMapper createMapper(boolean pretty) { - ObjectMapper mapper = new ObjectMapper(); - if (pretty) { - mapper.enable(SerializationFeature.INDENT_OUTPUT); - } - return mapper; - } - - public static class DataWordSerializer extends JsonSerializer { - - @Override - public void serialize(DataWord energy, JsonGenerator jgen, SerializerProvider provider) - throws IOException, JsonProcessingException { - jgen.writeString(energy.value().toString()); - } - } - - public static class ByteArraySerializer extends JsonSerializer { - - @Override - public void serialize(byte[] memory, JsonGenerator jgen, SerializerProvider provider) - throws IOException, JsonProcessingException { - jgen.writeString(Hex.toHexString(memory)); - } - } - - public static class OpCodeSerializer extends JsonSerializer { - - @Override - public void serialize(Byte op, JsonGenerator jgen, SerializerProvider provider) - throws IOException, JsonProcessingException { - jgen.writeString(Op.getNameOf(op)); - } - } } diff --git a/common/build.gradle b/common/build.gradle index 98fc3257190..acde43a1ea9 100644 --- a/common/build.gradle +++ b/common/build.gradle @@ -8,7 +8,7 @@ sourceCompatibility = 1.8 dependencies { - api group: 'com.fasterxml.jackson.core', name: 'jackson-databind', version: '2.18.3' // https://github.com/FasterXML/jackson-databind/issues/3627 + api group: 'com.fasterxml.jackson.core', name: 'jackson-databind', version: '2.18.6' // https://github.com/FasterXML/jackson-databind/issues/3627 api "com.cedarsoftware:java-util:3.2.0" api group: 'org.apache.httpcomponents', name: 'httpasyncclient', version: '4.1.1' api group: 'commons-codec', name: 'commons-codec', version: '1.11' diff --git a/common/src/main/java/org/tron/common/utils/JsonUtil.java b/common/src/main/java/org/tron/common/utils/JsonUtil.java index 0847e18607b..e08b49e8c08 100644 --- a/common/src/main/java/org/tron/common/utils/JsonUtil.java +++ b/common/src/main/java/org/tron/common/utils/JsonUtil.java @@ -1,14 +1,16 @@ package org.tron.common.utils; import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.json.JsonMapper; import org.springframework.util.StringUtils; public class JsonUtil { + private static final ObjectMapper om = new JsonMapper(); + public static final T json2Obj(String jsonString, Class clazz) { if (!StringUtils.isEmpty(jsonString) && clazz != null) { try { - ObjectMapper om = new ObjectMapper(); return om.readValue(jsonString, clazz); } catch (Exception var3) { throw new RuntimeException(var3); @@ -22,7 +24,6 @@ public static final String obj2Json(Object obj) { if (obj == null) { return null; } else { - ObjectMapper om = new ObjectMapper(); try { return om.writeValueAsString(obj); } catch (Exception var3) { diff --git a/common/src/main/java/org/tron/json/JSON.java b/common/src/main/java/org/tron/json/JSON.java new file mode 100644 index 00000000000..6268a26e736 --- /dev/null +++ b/common/src/main/java/org/tron/json/JSON.java @@ -0,0 +1,155 @@ +package org.tron.json; + +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.core.json.JsonReadFeature; +import com.fasterxml.jackson.databind.DeserializationFeature; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.MapperFeature; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.SerializationFeature; +import com.fasterxml.jackson.databind.json.JsonMapper; +import com.fasterxml.jackson.databind.node.ObjectNode; + +/** + * Drop-in replacement for {@code com.alibaba.fastjson.JSON}. + */ +public final class JSON { + + public static final ObjectMapper MAPPER = JsonMapper.builder() + // Fastjson Feature.AllowUnQuotedFieldNames (default ON) + .enable(JsonReadFeature.ALLOW_UNQUOTED_FIELD_NAMES) + // Fastjson Feature.AllowSingleQuotes (default ON) + .enable(JsonReadFeature.ALLOW_SINGLE_QUOTES) + // Fastjson tolerates trailing commas (e.g. {"a":1,}) by default + .enable(JsonReadFeature.ALLOW_TRAILING_COMMA) + // Fastjson accepts NaN/Infinity as valid tokens + .enable(JsonReadFeature.ALLOW_NON_NUMERIC_NUMBERS) + // Fastjson accepts leading plus sign for numbers (e.g. +123) + .enable(JsonReadFeature.ALLOW_LEADING_PLUS_SIGN_FOR_NUMBERS) + // Fastjson accepts leading decimal point for numbers (e.g. .5) + .enable(JsonReadFeature.ALLOW_LEADING_DECIMAL_POINT_FOR_NUMBERS) + // Fastjson accepts trailing decimal point for numbers (e.g. 5.) + .enable(JsonReadFeature.ALLOW_TRAILING_DECIMAL_POINT_FOR_NUMBERS) + // Fastjson accepts leading zeros for numbers (e.g. 007) + .enable(JsonReadFeature.ALLOW_LEADING_ZEROS_FOR_NUMBERS) + // Fastjson accepts unescaped control chars in strings (e.g. raw tab/newline) + .enable(JsonReadFeature.ALLOW_UNESCAPED_CONTROL_CHARS) + // Fastjson accepts backslash-escaping any character (e.g. \q → q) + .enable(JsonReadFeature.ALLOW_BACKSLASH_ESCAPING_ANY_CHARACTER) + // Fastjson accepts Java-style comments (// and /* */) + .enable(JsonReadFeature.ALLOW_JAVA_COMMENTS) + // Fastjson Feature.UseBigDecimal (default ON) + // https://github.com/alibaba/fastjson/wiki/deserialize_disable_bigdecimal_cn + .configure(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS, true) + // Fastjson Feature.IgnoreNotMatch (default ON) — unknown fields silently ignored + .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false) + // Fastjson serializes empty beans as "{}" without error + .configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false) + // Fastjson omits null-valued fields by default (WriteMapNullValue is OFF by default) + // https://github.com/alibaba/fastjson/wiki/WriteNull_cn + .serializationInclusion(JsonInclude.Include.NON_NULL) + // Fastjson uses WriteDateUseDateFormat (string) not timestamps by default + .disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS) + // Fastjson smart-match: field names are matched ignoring case/underscores by default + // (DisableFieldSmartMatch is OFF by default → smart match ON) + .configure(MapperFeature.ACCEPT_CASE_INSENSITIVE_PROPERTIES, true) + .build(); + + private JSON() { + } + + /** + * Returns {@code true} when {@code text} is null, blank, or a + * case-insensitive {@code "null"} literal — mirroring Fastjson's lenient + * treatment of these inputs as JSON {@code null}. + */ + static boolean isNullLiteral(String text) { + if (text == null) { + return true; + } + String trimmed = text.trim(); + return trimmed.isEmpty() || "null".equalsIgnoreCase(trimmed); + } + + public static JSONObject parseObject(String text) { + if (isNullLiteral(text)) { + return null; + } + try { + JsonNode node = MAPPER.readTree(text); + if (node == null || node.isNull()) { + return null; + } + if (!node.isObject()) { + throw new JSONException("can not cast to JSONObject."); + } + return new JSONObject((ObjectNode) node); + } catch (JSONException e) { + throw e; + } catch (Exception e) { + throw new JSONException(e.getMessage(), e); + } + } + + public static T parseObject(String text, Class clazz) { + if (isNullLiteral(text)) { + return null; + } + if (clazz == JSONObject.class) { + return clazz.cast(parseObject(text)); + } + if (clazz == JSONArray.class) { + return clazz.cast(parseArray(text)); + } + try { + return MAPPER.readValue(text, clazz); + } catch (Exception e) { + throw new JSONException(e.getMessage(), e); + } + } + + public static JsonNode parse(String text) { + if (isNullLiteral(text)) { + return null; + } + try { + JsonNode node = MAPPER.readTree(text); + if (node == null || node.isNull()) { + return null; + } + return node; + } catch (Exception e) { + throw new JSONException(e.getMessage(), e); + } + } + + static JSONArray parseArray(String text) { + return JSONArray.parseArray(text); + } + + public static String toJSONString(Object obj) { + return toJSONString(obj, false); + } + + public static String toJSONString(Object obj, boolean pretty) { + if (obj == null) { + return "null"; + } + try { + if (obj instanceof JSONObject) { + return pretty ? MAPPER.writerWithDefaultPrettyPrinter() + .writeValueAsString(((JSONObject) obj).unwrap()) + : MAPPER.writeValueAsString(((JSONObject) obj).unwrap()); + } + if (obj instanceof JSONArray) { + return pretty ? MAPPER.writerWithDefaultPrettyPrinter() + .writeValueAsString(((JSONArray) obj).unwrap()) + : MAPPER.writeValueAsString(((JSONArray) obj).unwrap()); + } + return pretty ? MAPPER.writerWithDefaultPrettyPrinter().writeValueAsString(obj) + : MAPPER.writeValueAsString(obj); + } catch (Exception e) { + throw new JSONException(e.getMessage(), e); + } + } +} diff --git a/common/src/main/java/org/tron/json/JSONArray.java b/common/src/main/java/org/tron/json/JSONArray.java new file mode 100644 index 00000000000..222926326bd --- /dev/null +++ b/common/src/main/java/org/tron/json/JSONArray.java @@ -0,0 +1,146 @@ +package org.tron.json; + +import com.fasterxml.jackson.annotation.JsonValue; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.node.ArrayNode; +import com.fasterxml.jackson.databind.node.ObjectNode; +import com.google.common.annotations.VisibleForTesting; +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; + +/** + * Drop-in replacement for {@code com.alibaba.fastjson.JSONArray}. + */ +public class JSONArray implements Iterable { + + private final ArrayNode node; + + public JSONArray(ArrayNode node) { + this.node = node; + } + + public JSONArray() { + this.node = JSON.MAPPER.createArrayNode(); + } + + public static JSONArray parseArray(String text) { + if (JSON.isNullLiteral(text)) { + return null; + } + try { + JsonNode node = JSON.MAPPER.readTree(text); + if (node == null || node.isNull()) { + return null; + } + if (!node.isArray()) { + throw new JSONException("Expected JSON array but got: " + node.getNodeType()); + } + return new JSONArray((ArrayNode) node); + } catch (JSONException e) { + throw e; + } catch (Exception e) { + throw new JSONException(e.getMessage(), e); + } + } + + public int size() { + return node.size(); + } + + private void rangeCheck(int index) { + if (index < 0 || index >= node.size()) { + throw new IndexOutOfBoundsException( + "Index: " + index + ", Size: " + node.size()); + } + } + + @VisibleForTesting + public Object get(int index) { + rangeCheck(index); + return JSONObject.convertNode(node.get(index)); + } + + public JSONObject getJSONObject(int index) { + rangeCheck(index); + JsonNode child = node.get(index); + if (child.isNull()) { + return null; + } + if (child.isObject()) { + return new JSONObject((ObjectNode) child); + } + // Fastjson auto-parses stringified JSON objects + if (child.isTextual()) { + return JSON.parseObject(child.asText()); + } + throw new JSONException("Element at index " + index + " is not an object"); + } + + @VisibleForTesting + public String getString(int index) { + rangeCheck(index); + JsonNode child = node.get(index); + if (child.isNull()) { + return null; + } + if (child.isContainerNode()) { + try { + return JSON.MAPPER.writeValueAsString(child); + } catch (Exception e) { + throw new JSONException("Serialization failed: " + e.getMessage(), e); + } + } + return child.asText(null); + } + + // ------------------------------------------------------------------------- + // Mutation helpers + // ------------------------------------------------------------------------- + + public JSONArray add(JSONObject value) { + node.add(value == null ? node.nullNode() : value.unwrap()); + return this; + } + + @JsonValue + public ArrayNode unwrap() { + return node; + } + + @Override + public Iterator iterator() { + List list = new ArrayList<>(); + node.forEach(child -> list.add(JSONObject.convertNode(child))); + return list.iterator(); + } + + @Override + public String toString() { + try { + return JSON.MAPPER.writeValueAsString(node); + } catch (Exception e) { + throw new JSONException("Serialization failed: " + e.getMessage(), e); + } + } + + public String toJSONString() { + return toString(); + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (!(o instanceof JSONArray)) { + return false; + } + return node.equals(((JSONArray) o).node); + } + + @Override + public int hashCode() { + return node.hashCode(); + } +} diff --git a/common/src/main/java/org/tron/json/JSONException.java b/common/src/main/java/org/tron/json/JSONException.java new file mode 100644 index 00000000000..7395a025068 --- /dev/null +++ b/common/src/main/java/org/tron/json/JSONException.java @@ -0,0 +1,19 @@ +package org.tron.json; + +/** + * Drop-in replacement for {@code com.alibaba.fastjson.JSONException}. + */ +public class JSONException extends RuntimeException { + + public JSONException(String message) { + super(message); + } + + public JSONException(String message, Throwable cause) { + super(message, cause); + } + + public JSONException(Throwable cause) { + super(cause); + } +} diff --git a/common/src/main/java/org/tron/json/JSONObject.java b/common/src/main/java/org/tron/json/JSONObject.java new file mode 100644 index 00000000000..f33fc4ed0d9 --- /dev/null +++ b/common/src/main/java/org/tron/json/JSONObject.java @@ -0,0 +1,338 @@ +package org.tron.json; + +import com.fasterxml.jackson.annotation.JsonValue; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.node.ArrayNode; +import com.fasterxml.jackson.databind.node.ObjectNode; +import com.google.common.annotations.VisibleForTesting; +import java.math.BigDecimal; +import java.util.Iterator; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Set; + +/** + * Drop-in replacement for {@code com.alibaba.fastjson.JSONObject}. + * + *

Note: {@code put(key, null)} removes the key instead of storing a JSON + * {@code null}. This matches Fastjson's default serialization output + * ({@code WriteMapNullValue=OFF} omits null fields), but differs in + * {@link #containsKey(String)} / {@link #size()} after a null put. To emit an + * explicit {@code "key":null}, pass a Jackson {@code NullNode} via + * {@link #put(String, Object)}. + */ +public class JSONObject { + + private final ObjectNode node; + + public JSONObject(ObjectNode node) { + this.node = node; + } + + public JSONObject() { + this.node = JSON.MAPPER.createObjectNode(); + } + + public static JSONObject parseObject(String text) { + return JSON.parseObject(text); + } + + public boolean containsKey(String key) { + return node.has(key); + } + + @VisibleForTesting + public int size() { + return node.size(); + } + + @VisibleForTesting + public Set keySet() { + Set keys = new LinkedHashSet<>(node.size()); + Iterator names = node.fieldNames(); + while (names.hasNext()) { + keys.add(names.next()); + } + return keys; + } + + public String getString(String key) { + JsonNode child = node.get(key); + if (child == null || child.isNull()) { + return null; + } + if (child.isContainerNode()) { + try { + return JSON.MAPPER.writeValueAsString(child); + } catch (Exception e) { + throw new JSONException("Serialization failed: " + e.getMessage(), e); + } + } + return child.asText(null); + } + + public Boolean getBoolean(String key) { + return TypeUtils.castToBoolean(get(key)); + } + + public Integer getInteger(String key) { + return TypeUtils.castToInt(get(key)); + } + + @VisibleForTesting + public Long getLong(String key) { + return TypeUtils.castToLong(get(key)); + } + + @VisibleForTesting + public long getLongValue(String key) { + Long value = TypeUtils.castToLong(get(key)); + return value == null ? 0L : value; + } + + @VisibleForTesting + public int getIntValue(String key) { + Integer value = TypeUtils.castToInt(get(key)); + return value == null ? 0 : value; + } + + public BigDecimal getBigDecimal(String key) { + return TypeUtils.castToBigDecimal(get(key)); + } + + + public Object get(String key) { + return convertNode(node.get(key)); + } + + static Object convertNode(JsonNode child) { + if (child == null || child.isNull() || child.isMissingNode()) { + return null; + } + if (child.isObject()) { + return new JSONObject((ObjectNode) child); + } + if (child.isArray()) { + return new JSONArray((ArrayNode) child); + } + if (child.isTextual()) { + return child.asText(); + } + if (child.isInt()) { + return child.intValue(); + } + if (child.isShort()) { + return child.shortValue(); + } + if (child.isLong()) { + return child.longValue(); + } + if (child.isBigInteger()) { + return child.bigIntegerValue(); + } + if (child.isBigDecimal()) { + return child.decimalValue(); + } + if (child.isDouble() || child.isFloat()) { + return child.doubleValue(); + } + if (child.isBoolean()) { + return child.booleanValue(); + } + return child.asText(); + } + + public JSONObject getJSONObject(String key) { + JsonNode child = node.get(key); + if (child == null || child.isNull()) { + return null; + } + if (child.isObject()) { + return new JSONObject((ObjectNode) child); + } + // Fastjson auto-parses stringified JSON objects + if (child.isTextual()) { + return JSON.parseObject(child.asText()); + } + throw new JSONException("Field '" + key + "' is not an object"); + } + + public JSONArray getJSONArray(String key) { + JsonNode child = node.get(key); + if (child == null || child.isNull()) { + return null; + } + if (child.isArray()) { + return new JSONArray((ArrayNode) child); + } + if (child.isTextual()) { + return JSON.parseArray(child.asText()); + } + throw new JSONException("Field '" + key + "' is not an array"); + } + + @VisibleForTesting + public T getObject(String key, Class clazz) { + JsonNode child = node.get(key); + if (child == null || child.isNull()) { + return null; + } + try { + if (clazz == JSONObject.class) { + if (!child.isObject()) { + throw new JSONException( + "Field '" + key + "' is " + child.getNodeType() + ", cannot convert to JSONObject"); + } + return clazz.cast(new JSONObject((ObjectNode) child)); + } + if (clazz == JSONArray.class) { + if (!child.isArray()) { + throw new JSONException( + "Field '" + key + "' is " + child.getNodeType() + ", cannot convert to JSONArray"); + } + return clazz.cast(new JSONArray((ArrayNode) child)); + } + return JSON.MAPPER.treeToValue(child, clazz); + } catch (JSONException e) { + throw e; + } catch (Exception e) { + throw new JSONException( + "Failed to convert field '" + key + "' to " + clazz.getSimpleName(), e); + } + } + + public JSONObject put(String key, String value) { + if (value == null) { + node.remove(key); + } else { + node.put(key, value); + } + return this; + } + + public JSONObject put(String key, Boolean value) { + if (value == null) { + node.remove(key); + } else { + node.put(key, value); + } + return this; + } + + public JSONObject put(String key, Integer value) { + if (value == null) { + node.remove(key); + } else { + node.put(key, value); + } + return this; + } + + public JSONObject put(String key, Long value) { + if (value == null) { + node.remove(key); + } else { + node.put(key, value); + } + return this; + } + + public JSONObject put(String key, JSONObject value) { + if (value == null) { + node.remove(key); + } else { + node.set(key, value.unwrap()); + } + return this; + } + + public JSONObject put(String key, JSONArray value) { + if (value == null) { + node.remove(key); + } else { + node.set(key, value.unwrap()); + } + return this; + } + + public JSONObject put(String key, Object value) { + if (value == null) { + node.remove(key); + return this; + } + if (value instanceof JSONObject) { + return put(key, (JSONObject) value); + } + if (value instanceof JSONArray) { + return put(key, (JSONArray) value); + } + if (value instanceof JsonNode) { + node.set(key, (JsonNode) value); + return this; + } + node.set(key, JSON.MAPPER.valueToTree(value)); + return this; + } + + public JSONObject put(String key, List value) { + if (value == null) { + node.remove(key); + return this; + } + ArrayNode arr = JSON.MAPPER.createArrayNode(); + for (Object v : value) { + if (v == null) { + arr.addNull(); + } else if (v instanceof JSONObject) { + arr.add(((JSONObject) v).unwrap()); + } else if (v instanceof JSONArray) { + arr.add(((JSONArray) v).unwrap()); + } else if (v instanceof JsonNode) { + arr.add((JsonNode) v); + } else { + arr.add(JSON.MAPPER.valueToTree(v)); + } + } + node.set(key, arr); + return this; + } + + public Object remove(String key) { + JsonNode removed = node.remove(key); + return convertNode(removed); + } + + @JsonValue + public ObjectNode unwrap() { + return node; + } + + @Override + public String toString() { + try { + return JSON.MAPPER.writeValueAsString(node); + } catch (Exception e) { + throw new JSONException("Serialization failed: " + e.getMessage(), e); + } + } + + public String toJSONString() { + return toString(); + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (!(o instanceof JSONObject)) { + return false; + } + return node.equals(((JSONObject) o).node); + } + + @Override + public int hashCode() { + return node.hashCode(); + } +} diff --git a/common/src/main/java/org/tron/json/TypeUtils.java b/common/src/main/java/org/tron/json/TypeUtils.java new file mode 100644 index 00000000000..adbb0ccc715 --- /dev/null +++ b/common/src/main/java/org/tron/json/TypeUtils.java @@ -0,0 +1,310 @@ +package org.tron.json; + +import java.math.BigDecimal; +import java.math.BigInteger; +import java.util.regex.Pattern; + +/** + * Type coercion utilities ported from {@code com.alibaba.fastjson.util.TypeUtils} + * to maintain exact behavioral parity with Fastjson 1.x. + * + *

Key Fastjson behaviors preserved: + *

    + *
  • Comma stripping in numeric strings ({@code "1,000"} → {@code 1000})
    • + *
  • Trailing-zero removal ({@code "1.0"} → {@code 1} for int/long)
    • + *
  • Boolean coercion from {@code "Y"/"T"/"F"/"N"} strings
    • + *
  • Boolean from Number: {@code intValue() == 1} (only 1 is true)
    • + *
  • {@code NaN}/{@code Infinity} → {@code null} for BigDecimal
    • + *
  • {@code null}/{@code "null"}/{@code "NULL"}/empty → {@code null}
    • + *
+ */ +public final class TypeUtils { + + private static final Pattern NUMBER_WITH_TRAILING_ZEROS_PATTERN = + Pattern.compile("\\.0*$"); + + private TypeUtils() { + } + + public static String castToString(Object value) { + if (value == null) { + return null; + } + return value.toString(); + } + + public static Boolean castToBoolean(Object value) { + if (value == null) { + return null; + } + if (value instanceof Boolean) { + return (Boolean) value; + } + + if (value instanceof BigDecimal) { + return intValue((BigDecimal) value) == 1; + } + + if (value instanceof Number) { + return ((Number) value).intValue() == 1; + } + + if (value instanceof String) { + String strVal = (String) value; + if (strVal.isEmpty() + || "null".equals(strVal) + || "NULL".equals(strVal)) { + return null; + } + if ("true".equalsIgnoreCase(strVal) + || "1".equals(strVal)) { + return Boolean.TRUE; + } + if ("false".equalsIgnoreCase(strVal) + || "0".equals(strVal)) { + return Boolean.FALSE; + } + if ("Y".equalsIgnoreCase(strVal) + || "T".equals(strVal)) { + return Boolean.TRUE; + } + if ("F".equalsIgnoreCase(strVal) + || "N".equals(strVal)) { + return Boolean.FALSE; + } + } + throw new JSONException("can not cast to boolean, value : " + value); + } + + public static Integer castToInt(Object value) { + if (value == null) { + return null; + } + + if (value instanceof Integer) { + return (Integer) value; + } + + if (value instanceof BigDecimal) { + return intValue((BigDecimal) value); + } + + if (value instanceof Number) { + return ((Number) value).intValue(); + } + + if (value instanceof String) { + String strVal = (String) value; + if (strVal.isEmpty() + || "null".equals(strVal) + || "NULL".equals(strVal)) { + return null; + } + if (strVal.indexOf(',') != -1) { + strVal = strVal.replaceAll(",", ""); + } + strVal = NUMBER_WITH_TRAILING_ZEROS_PATTERN.matcher(strVal).replaceAll(""); + return Integer.parseInt(strVal); + } + + if (value instanceof Boolean) { + return (Boolean) value ? 1 : 0; + } + + throw new JSONException("can not cast to int, value : " + value); + } + + public static Long castToLong(Object value) { + if (value == null) { + return null; + } + + if (value instanceof BigDecimal) { + return longValue((BigDecimal) value); + } + + if (value instanceof Number) { + return ((Number) value).longValue(); + } + + if (value instanceof String) { + String strVal = (String) value; + if (strVal.isEmpty() + || "null".equals(strVal) + || "NULL".equals(strVal)) { + return null; + } + if (strVal.indexOf(',') != -1) { + strVal = strVal.replaceAll(",", ""); + } + try { + return Long.parseLong(strVal); + } catch (NumberFormatException ex) { + // Fastjson falls through to BigDecimal attempt + } + + strVal = NUMBER_WITH_TRAILING_ZEROS_PATTERN.matcher(strVal).replaceAll(""); + return Long.parseLong(strVal); + } + + if (value instanceof Boolean) { + return (Boolean) value ? 1L : 0L; + } + + throw new JSONException("can not cast to long, value : " + value); + } + + public static BigDecimal castToBigDecimal(Object value) { + if (value == null) { + return null; + } + + if (value instanceof Float) { + if (Float.isNaN((Float) value) || Float.isInfinite((Float) value)) { + return null; + } + } else if (value instanceof Double) { + if (Double.isNaN((Double) value) || Double.isInfinite((Double) value)) { + return null; + } + } else if (value instanceof BigDecimal) { + return (BigDecimal) value; + } else if (value instanceof BigInteger) { + return new BigDecimal((BigInteger) value); + } + + String strVal = value.toString(); + + if (strVal.isEmpty() || "null".equalsIgnoreCase(strVal)) { + return null; + } + + if (strVal.length() > 65535) { + throw new JSONException("decimal overflow"); + } + + if (strVal.indexOf(',') != -1) { + strVal = strVal.replaceAll(",", ""); + } + + return new BigDecimal(strVal); + } + + public static BigInteger castToBigInteger(Object value) { + if (value == null) { + return null; + } + + if (value instanceof Float) { + Float floatValue = (Float) value; + if (Float.isNaN(floatValue) || Float.isInfinite(floatValue)) { + return null; + } + return BigInteger.valueOf(floatValue.longValue()); + } else if (value instanceof Double) { + Double doubleValue = (Double) value; + if (Double.isNaN(doubleValue) || Double.isInfinite(doubleValue)) { + return null; + } + return BigInteger.valueOf(doubleValue.longValue()); + } else if (value instanceof BigInteger) { + return (BigInteger) value; + } else if (value instanceof BigDecimal) { + BigDecimal decimal = (BigDecimal) value; + int scale = decimal.scale(); + if (scale > -1000 && scale < 1000) { + return decimal.toBigInteger(); + } + } + + String strVal = value.toString(); + + if (strVal.isEmpty() || "null".equalsIgnoreCase(strVal)) { + return null; + } + + if (strVal.length() > 65535) { + throw new JSONException("decimal overflow"); + } + + return new BigInteger(strVal); + } + + public static Float castToFloat(Object value) { + if (value == null) { + return null; + } + if (value instanceof Number) { + return ((Number) value).floatValue(); + } + if (value instanceof String) { + String strVal = (String) value; + if (strVal.isEmpty() + || "null".equals(strVal) + || "NULL".equals(strVal)) { + return null; + } + if (strVal.indexOf(',') != -1) { + strVal = strVal.replaceAll(",", ""); + } + return Float.parseFloat(strVal); + } + + if (value instanceof Boolean) { + return (Boolean) value ? 1F : 0F; + } + + throw new JSONException("can not cast to float, value : " + value); + } + + public static Double castToDouble(Object value) { + if (value == null) { + return null; + } + if (value instanceof Number) { + return ((Number) value).doubleValue(); + } + if (value instanceof String) { + String strVal = (String) value; + if (strVal.isEmpty() + || "null".equals(strVal) + || "NULL".equals(strVal)) { + return null; + } + if (strVal.indexOf(',') != -1) { + strVal = strVal.replaceAll(",", ""); + } + return Double.parseDouble(strVal); + } + + if (value instanceof Boolean) { + return (Boolean) value ? 1D : 0D; + } + + throw new JSONException("can not cast to double, value : " + value); + } + + // -- BigDecimal helper methods (ported from Fastjson) -- + + public static int intValue(BigDecimal decimal) { + if (decimal == null) { + return 0; + } + int scale = decimal.scale(); + if (scale >= -100 && scale <= 100) { + return decimal.intValue(); + } + return decimal.intValueExact(); + } + + public static long longValue(BigDecimal decimal) { + if (decimal == null) { + return 0; + } + int scale = decimal.scale(); + if (scale >= -100 && scale <= 100) { + return decimal.longValue(); + } + return decimal.longValueExact(); + } +} diff --git a/framework/build.gradle b/framework/build.gradle index d884b6a7c49..b48d854eb7d 100644 --- a/framework/build.gradle +++ b/framework/build.gradle @@ -44,7 +44,6 @@ dependencies { // http implementation 'org.eclipse.jetty:jetty-server:9.4.57.v20241219' implementation 'org.eclipse.jetty:jetty-servlet:9.4.57.v20241219' - implementation 'com.alibaba:fastjson:1.2.83' // end http // https://mvnrepository.com/artifact/com.github.briandilley.jsonrpc4j/jsonrpc4j diff --git a/framework/src/main/java/org/tron/common/logsfilter/ContractEventParserJson.java b/framework/src/main/java/org/tron/common/logsfilter/ContractEventParserJson.java index 4236230ef18..4424e28f237 100644 --- a/framework/src/main/java/org/tron/common/logsfilter/ContractEventParserJson.java +++ b/framework/src/main/java/org/tron/common/logsfilter/ContractEventParserJson.java @@ -1,7 +1,5 @@ package org.tron.common.logsfilter; -import com.alibaba.fastjson.JSONArray; -import com.alibaba.fastjson.JSONObject; import java.util.HashMap; import java.util.List; import java.util.Map; @@ -9,6 +7,8 @@ import org.apache.commons.lang3.ArrayUtils; import org.bouncycastle.util.encoders.Hex; import org.pf4j.util.StringUtils; +import org.tron.json.JSONArray; +import org.tron.json.JSONObject; @Slf4j(topic = "Parser") public class ContractEventParserJson extends ContractEventParser { diff --git a/framework/src/main/java/org/tron/core/config/DefaultConfig.java b/framework/src/main/java/org/tron/core/config/DefaultConfig.java index d01820626c3..9bce903d411 100755 --- a/framework/src/main/java/org/tron/core/config/DefaultConfig.java +++ b/framework/src/main/java/org/tron/core/config/DefaultConfig.java @@ -1,6 +1,5 @@ package org.tron.core.config; -import com.alibaba.fastjson.parser.ParserConfig; import lombok.extern.slf4j.Slf4j; import org.rocksdb.RocksDB; import org.springframework.beans.factory.annotation.Autowired; @@ -27,7 +26,6 @@ public class DefaultConfig { static { RocksDB.loadLibrary(); - ParserConfig.getGlobalInstance().setSafeMode(true); } @Autowired diff --git a/framework/src/main/java/org/tron/core/services/filter/HttpApiAccessFilter.java b/framework/src/main/java/org/tron/core/services/filter/HttpApiAccessFilter.java index 59b9b15582b..c598f99aa91 100644 --- a/framework/src/main/java/org/tron/core/services/filter/HttpApiAccessFilter.java +++ b/framework/src/main/java/org/tron/core/services/filter/HttpApiAccessFilter.java @@ -1,6 +1,5 @@ package org.tron.core.services.filter; -import com.alibaba.fastjson.JSONObject; import java.net.URI; import java.util.List; import javax.servlet.Filter; @@ -13,6 +12,7 @@ import lombok.extern.slf4j.Slf4j; import org.springframework.stereotype.Component; import org.tron.common.parameter.CommonParameter; +import org.tron.json.JSONObject; @Component @Slf4j(topic = "httpApiAccessFilter") diff --git a/framework/src/main/java/org/tron/core/services/http/AccountPermissionUpdateServlet.java b/framework/src/main/java/org/tron/core/services/http/AccountPermissionUpdateServlet.java index c8ddd93f103..6fe83eff8be 100644 --- a/framework/src/main/java/org/tron/core/services/http/AccountPermissionUpdateServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/AccountPermissionUpdateServlet.java @@ -1,12 +1,12 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.tron.core.Wallet; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.Transaction; import org.tron.protos.Protocol.Transaction.Contract.ContractType; import org.tron.protos.contract.AccountContract.AccountPermissionUpdateContract; diff --git a/framework/src/main/java/org/tron/core/services/http/BroadcastHexServlet.java b/framework/src/main/java/org/tron/core/services/http/BroadcastHexServlet.java index ec115b20a15..5d59df59678 100644 --- a/framework/src/main/java/org/tron/core/services/http/BroadcastHexServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/BroadcastHexServlet.java @@ -1,6 +1,5 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; import java.util.stream.Collectors; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; @@ -11,6 +10,7 @@ import org.tron.common.utils.ByteArray; import org.tron.core.Wallet; import org.tron.core.capsule.TransactionCapsule; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.Transaction; @Component diff --git a/framework/src/main/java/org/tron/core/services/http/BroadcastServlet.java b/framework/src/main/java/org/tron/core/services/http/BroadcastServlet.java index 6b265c35e02..370a81eef4e 100644 --- a/framework/src/main/java/org/tron/core/services/http/BroadcastServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/BroadcastServlet.java @@ -1,6 +1,5 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import lombok.extern.slf4j.Slf4j; @@ -10,6 +9,7 @@ import org.tron.common.utils.ByteArray; import org.tron.core.Wallet; import org.tron.core.capsule.TransactionCapsule; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.Transaction; diff --git a/framework/src/main/java/org/tron/core/services/http/CancelAllUnfreezeV2Servlet.java b/framework/src/main/java/org/tron/core/services/http/CancelAllUnfreezeV2Servlet.java index 894126e50da..a2d4571be27 100644 --- a/framework/src/main/java/org/tron/core/services/http/CancelAllUnfreezeV2Servlet.java +++ b/framework/src/main/java/org/tron/core/services/http/CancelAllUnfreezeV2Servlet.java @@ -1,13 +1,13 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSON; -import com.alibaba.fastjson.JSONObject; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.tron.core.Wallet; +import org.tron.json.JSON; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.Transaction; import org.tron.protos.Protocol.Transaction.Contract.ContractType; import org.tron.protos.contract.BalanceContract.CancelAllUnfreezeV2Contract; diff --git a/framework/src/main/java/org/tron/core/services/http/ClearABIServlet.java b/framework/src/main/java/org/tron/core/services/http/ClearABIServlet.java index c897b895c58..e0833052ce8 100644 --- a/framework/src/main/java/org/tron/core/services/http/ClearABIServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/ClearABIServlet.java @@ -1,12 +1,12 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.tron.core.Wallet; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.Transaction; import org.tron.protos.Protocol.Transaction.Contract.ContractType; import org.tron.protos.contract.SmartContractOuterClass.ClearABIContract; diff --git a/framework/src/main/java/org/tron/core/services/http/CreateAccountServlet.java b/framework/src/main/java/org/tron/core/services/http/CreateAccountServlet.java index 102d9ca80ce..b547fd00364 100644 --- a/framework/src/main/java/org/tron/core/services/http/CreateAccountServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/CreateAccountServlet.java @@ -1,12 +1,12 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.tron.core.Wallet; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.Transaction; import org.tron.protos.Protocol.Transaction.Contract.ContractType; import org.tron.protos.contract.AccountContract.AccountCreateContract; diff --git a/framework/src/main/java/org/tron/core/services/http/CreateAssetIssueServlet.java b/framework/src/main/java/org/tron/core/services/http/CreateAssetIssueServlet.java index 9d537ab641b..bc1a33509e0 100644 --- a/framework/src/main/java/org/tron/core/services/http/CreateAssetIssueServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/CreateAssetIssueServlet.java @@ -1,12 +1,12 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.tron.core.Wallet; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.Transaction; import org.tron.protos.Protocol.Transaction.Contract.ContractType; import org.tron.protos.contract.AssetIssueContractOuterClass.AssetIssueContract; diff --git a/framework/src/main/java/org/tron/core/services/http/CreateCommonTransactionServlet.java b/framework/src/main/java/org/tron/core/services/http/CreateCommonTransactionServlet.java index c3a515f84a5..f4b5e03db82 100644 --- a/framework/src/main/java/org/tron/core/services/http/CreateCommonTransactionServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/CreateCommonTransactionServlet.java @@ -1,6 +1,5 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; import com.google.protobuf.GeneratedMessageV3; import com.google.protobuf.Message; import java.lang.reflect.Constructor; @@ -13,6 +12,7 @@ import org.tron.core.Wallet; import org.tron.core.actuator.TransactionFactory; import org.tron.core.exception.ContractValidateException; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.Transaction; import org.tron.protos.Protocol.Transaction.Contract.ContractType; diff --git a/framework/src/main/java/org/tron/core/services/http/CreateShieldedTransactionWithoutSpendAuthSigServlet.java b/framework/src/main/java/org/tron/core/services/http/CreateShieldedTransactionWithoutSpendAuthSigServlet.java index b77fff77034..eb870bd1721 100644 --- a/framework/src/main/java/org/tron/core/services/http/CreateShieldedTransactionWithoutSpendAuthSigServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/CreateShieldedTransactionWithoutSpendAuthSigServlet.java @@ -1,7 +1,5 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSON; -import com.alibaba.fastjson.JSONObject; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import lombok.extern.slf4j.Slf4j; @@ -9,6 +7,8 @@ import org.springframework.stereotype.Component; import org.tron.api.GrpcAPI.PrivateParametersWithoutAsk; import org.tron.core.Wallet; +import org.tron.json.JSON; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.Transaction; diff --git a/framework/src/main/java/org/tron/core/services/http/CreateWitnessServlet.java b/framework/src/main/java/org/tron/core/services/http/CreateWitnessServlet.java index 55e1b25ce3d..3258dbbe6b9 100644 --- a/framework/src/main/java/org/tron/core/services/http/CreateWitnessServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/CreateWitnessServlet.java @@ -1,12 +1,12 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.tron.core.Wallet; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.Transaction; import org.tron.protos.Protocol.Transaction.Contract.ContractType; import org.tron.protos.contract.WitnessContract.WitnessCreateContract; diff --git a/framework/src/main/java/org/tron/core/services/http/DelegateResourceServlet.java b/framework/src/main/java/org/tron/core/services/http/DelegateResourceServlet.java index 00994238988..25641ff093c 100644 --- a/framework/src/main/java/org/tron/core/services/http/DelegateResourceServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/DelegateResourceServlet.java @@ -1,13 +1,13 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSON; -import com.alibaba.fastjson.JSONObject; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.tron.core.Wallet; +import org.tron.json.JSON; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.Transaction; import org.tron.protos.Protocol.Transaction.Contract.ContractType; import org.tron.protos.contract.BalanceContract.DelegateResourceContract; diff --git a/framework/src/main/java/org/tron/core/services/http/DeployContractServlet.java b/framework/src/main/java/org/tron/core/services/http/DeployContractServlet.java index 1209c6fb385..45a5be961e9 100644 --- a/framework/src/main/java/org/tron/core/services/http/DeployContractServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/DeployContractServlet.java @@ -3,7 +3,6 @@ import static org.tron.core.services.http.Util.getHexAddress; import static org.tron.core.services.http.Util.setTransactionPermissionId; -import com.alibaba.fastjson.JSONObject; import com.google.common.base.Strings; import com.google.protobuf.ByteString; import javax.servlet.http.HttpServletRequest; @@ -14,6 +13,7 @@ import org.springframework.stereotype.Component; import org.tron.common.utils.ByteArray; import org.tron.core.Wallet; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.Transaction; import org.tron.protos.Protocol.Transaction.Contract.ContractType; import org.tron.protos.contract.SmartContractOuterClass.CreateSmartContract; @@ -91,4 +91,4 @@ protected void doPost(HttpServletRequest request, HttpServletResponse response) Util.processError(e, response); } } -} \ No newline at end of file +} diff --git a/framework/src/main/java/org/tron/core/services/http/EstimateEnergyServlet.java b/framework/src/main/java/org/tron/core/services/http/EstimateEnergyServlet.java index d88f7dd1af1..91d673a2d08 100644 --- a/framework/src/main/java/org/tron/core/services/http/EstimateEnergyServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/EstimateEnergyServlet.java @@ -1,6 +1,5 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; import com.google.protobuf.ByteString; import io.netty.util.internal.StringUtil; import java.io.IOException; @@ -17,6 +16,7 @@ import org.tron.core.Wallet; import org.tron.core.capsule.TransactionCapsule; import org.tron.core.exception.ContractValidateException; +import org.tron.json.JSONObject; import org.tron.protos.Protocol; import org.tron.protos.contract.SmartContractOuterClass.TriggerSmartContract; diff --git a/framework/src/main/java/org/tron/core/services/http/ExchangeCreateServlet.java b/framework/src/main/java/org/tron/core/services/http/ExchangeCreateServlet.java index b7e2d7beb50..84707c5586f 100644 --- a/framework/src/main/java/org/tron/core/services/http/ExchangeCreateServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/ExchangeCreateServlet.java @@ -1,12 +1,12 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.tron.core.Wallet; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.Transaction; import org.tron.protos.Protocol.Transaction.Contract.ContractType; import org.tron.protos.contract.ExchangeContract.ExchangeCreateContract; diff --git a/framework/src/main/java/org/tron/core/services/http/ExchangeInjectServlet.java b/framework/src/main/java/org/tron/core/services/http/ExchangeInjectServlet.java index a6c8ebc2132..b4b2b31221e 100644 --- a/framework/src/main/java/org/tron/core/services/http/ExchangeInjectServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/ExchangeInjectServlet.java @@ -1,12 +1,12 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.tron.core.Wallet; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.Transaction; import org.tron.protos.Protocol.Transaction.Contract.ContractType; import org.tron.protos.contract.ExchangeContract.ExchangeInjectContract; diff --git a/framework/src/main/java/org/tron/core/services/http/ExchangeTransactionServlet.java b/framework/src/main/java/org/tron/core/services/http/ExchangeTransactionServlet.java index b788e6bba9f..a143cd45c70 100644 --- a/framework/src/main/java/org/tron/core/services/http/ExchangeTransactionServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/ExchangeTransactionServlet.java @@ -1,12 +1,12 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.tron.core.Wallet; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.Transaction; import org.tron.protos.Protocol.Transaction.Contract.ContractType; import org.tron.protos.contract.ExchangeContract.ExchangeTransactionContract; diff --git a/framework/src/main/java/org/tron/core/services/http/ExchangeWithdrawServlet.java b/framework/src/main/java/org/tron/core/services/http/ExchangeWithdrawServlet.java index f454e08df9c..159f23abb22 100644 --- a/framework/src/main/java/org/tron/core/services/http/ExchangeWithdrawServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/ExchangeWithdrawServlet.java @@ -1,12 +1,12 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.tron.core.Wallet; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.Transaction; import org.tron.protos.Protocol.Transaction.Contract.ContractType; import org.tron.protos.contract.ExchangeContract.ExchangeWithdrawContract; diff --git a/framework/src/main/java/org/tron/core/services/http/FreezeBalanceServlet.java b/framework/src/main/java/org/tron/core/services/http/FreezeBalanceServlet.java index e73c294e023..2990755b928 100644 --- a/framework/src/main/java/org/tron/core/services/http/FreezeBalanceServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/FreezeBalanceServlet.java @@ -1,12 +1,12 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.tron.core.Wallet; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.Transaction; import org.tron.protos.Protocol.Transaction.Contract.ContractType; import org.tron.protos.contract.BalanceContract.FreezeBalanceContract; diff --git a/framework/src/main/java/org/tron/core/services/http/FreezeBalanceV2Servlet.java b/framework/src/main/java/org/tron/core/services/http/FreezeBalanceV2Servlet.java index f1687a5bbb1..95d20233898 100644 --- a/framework/src/main/java/org/tron/core/services/http/FreezeBalanceV2Servlet.java +++ b/framework/src/main/java/org/tron/core/services/http/FreezeBalanceV2Servlet.java @@ -1,12 +1,12 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.tron.core.Wallet; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.Transaction; import org.tron.protos.Protocol.Transaction.Contract.ContractType; import org.tron.protos.contract.BalanceContract.FreezeBalanceV2Contract; diff --git a/framework/src/main/java/org/tron/core/services/http/GetAccountBalanceServlet.java b/framework/src/main/java/org/tron/core/services/http/GetAccountBalanceServlet.java index 159c3899666..db48fc11340 100644 --- a/framework/src/main/java/org/tron/core/services/http/GetAccountBalanceServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/GetAccountBalanceServlet.java @@ -1,13 +1,11 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.tron.core.Wallet; -import org.tron.protos.Protocol.Account; import org.tron.protos.contract.BalanceContract; diff --git a/framework/src/main/java/org/tron/core/services/http/GetAccountByIdServlet.java b/framework/src/main/java/org/tron/core/services/http/GetAccountByIdServlet.java index 7387b801168..96243327c70 100644 --- a/framework/src/main/java/org/tron/core/services/http/GetAccountByIdServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/GetAccountByIdServlet.java @@ -1,6 +1,5 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; import java.io.IOException; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; @@ -8,6 +7,7 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.tron.core.Wallet; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.Account; @@ -48,4 +48,4 @@ private void fillResponse(Account account, boolean visible, HttpServletResponse Account reply = wallet.getAccountById(account); Util.printAccount(reply, response, visible); } -} \ No newline at end of file +} diff --git a/framework/src/main/java/org/tron/core/services/http/GetAccountResourceServlet.java b/framework/src/main/java/org/tron/core/services/http/GetAccountResourceServlet.java index 98224334e1a..0e26a526a12 100644 --- a/framework/src/main/java/org/tron/core/services/http/GetAccountResourceServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/GetAccountResourceServlet.java @@ -1,6 +1,5 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; import com.google.protobuf.ByteString; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; @@ -10,6 +9,7 @@ import org.tron.api.GrpcAPI.AccountResourceMessage; import org.tron.common.utils.ByteArray; import org.tron.core.Wallet; +import org.tron.json.JSONObject; @Component @Slf4j(topic = "API") diff --git a/framework/src/main/java/org/tron/core/services/http/GetAccountServlet.java b/framework/src/main/java/org/tron/core/services/http/GetAccountServlet.java index 7de95dab541..ee5bbdf3d3a 100644 --- a/framework/src/main/java/org/tron/core/services/http/GetAccountServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/GetAccountServlet.java @@ -1,12 +1,12 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.tron.core.Wallet; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.Account; diff --git a/framework/src/main/java/org/tron/core/services/http/GetAssetIssueByIdServlet.java b/framework/src/main/java/org/tron/core/services/http/GetAssetIssueByIdServlet.java index 08f8227deee..b705c4ed0cd 100644 --- a/framework/src/main/java/org/tron/core/services/http/GetAssetIssueByIdServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/GetAssetIssueByIdServlet.java @@ -1,12 +1,12 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.tron.core.Wallet; +import org.tron.json.JSONObject; import org.tron.protos.contract.AssetIssueContractOuterClass.AssetIssueContract; diff --git a/framework/src/main/java/org/tron/core/services/http/GetAssetIssueByNameServlet.java b/framework/src/main/java/org/tron/core/services/http/GetAssetIssueByNameServlet.java index a1cc0525514..da6a7243f41 100644 --- a/framework/src/main/java/org/tron/core/services/http/GetAssetIssueByNameServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/GetAssetIssueByNameServlet.java @@ -1,7 +1,5 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSON; -import com.alibaba.fastjson.JSONObject; import com.google.protobuf.ByteString; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; @@ -10,6 +8,8 @@ import org.springframework.stereotype.Component; import org.tron.common.utils.ByteArray; import org.tron.core.Wallet; +import org.tron.json.JSON; +import org.tron.json.JSONObject; import org.tron.protos.contract.AssetIssueContractOuterClass.AssetIssueContract; diff --git a/framework/src/main/java/org/tron/core/services/http/GetAssetIssueListByNameServlet.java b/framework/src/main/java/org/tron/core/services/http/GetAssetIssueListByNameServlet.java index d9b7426011d..2c203ed983e 100644 --- a/framework/src/main/java/org/tron/core/services/http/GetAssetIssueListByNameServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/GetAssetIssueListByNameServlet.java @@ -1,7 +1,5 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSON; -import com.alibaba.fastjson.JSONObject; import com.google.protobuf.ByteString; import java.io.IOException; import javax.servlet.http.HttpServletRequest; @@ -12,6 +10,8 @@ import org.tron.api.GrpcAPI.AssetIssueList; import org.tron.common.utils.ByteArray; import org.tron.core.Wallet; +import org.tron.json.JSON; +import org.tron.json.JSONObject; @Component diff --git a/framework/src/main/java/org/tron/core/services/http/GetBlockBalanceServlet.java b/framework/src/main/java/org/tron/core/services/http/GetBlockBalanceServlet.java index 0fc3256899c..5217b37907a 100644 --- a/framework/src/main/java/org/tron/core/services/http/GetBlockBalanceServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/GetBlockBalanceServlet.java @@ -1,13 +1,11 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.tron.core.Wallet; -import org.tron.protos.Protocol.Account; import org.tron.protos.contract.BalanceContract.BlockBalanceTrace; diff --git a/framework/src/main/java/org/tron/core/services/http/GetBlockServlet.java b/framework/src/main/java/org/tron/core/services/http/GetBlockServlet.java index 0e0104e8014..2320fc87c7d 100644 --- a/framework/src/main/java/org/tron/core/services/http/GetBlockServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/GetBlockServlet.java @@ -1,7 +1,5 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSON; -import com.alibaba.fastjson.JSONObject; import com.google.common.base.Strings; import java.io.IOException; import javax.servlet.http.HttpServletRequest; @@ -12,6 +10,8 @@ import org.springframework.stereotype.Component; import org.tron.api.GrpcAPI.BlockReq; import org.tron.core.Wallet; +import org.tron.json.JSON; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.Block; diff --git a/framework/src/main/java/org/tron/core/services/http/GetContractInfoServlet.java b/framework/src/main/java/org/tron/core/services/http/GetContractInfoServlet.java index 86ed7f6d9b6..6a1549bd398 100644 --- a/framework/src/main/java/org/tron/core/services/http/GetContractInfoServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/GetContractInfoServlet.java @@ -1,7 +1,5 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; -import java.util.stream.Collectors; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import lombok.extern.slf4j.Slf4j; @@ -9,7 +7,7 @@ import org.springframework.stereotype.Component; import org.tron.api.GrpcAPI.BytesMessage; import org.tron.core.Wallet; -import org.tron.protos.contract.SmartContractOuterClass.SmartContract; +import org.tron.json.JSONObject; import org.tron.protos.contract.SmartContractOuterClass.SmartContractDataWrapper; diff --git a/framework/src/main/java/org/tron/core/services/http/GetContractServlet.java b/framework/src/main/java/org/tron/core/services/http/GetContractServlet.java index b9efd6c1520..3565d3121f6 100644 --- a/framework/src/main/java/org/tron/core/services/http/GetContractServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/GetContractServlet.java @@ -2,7 +2,6 @@ import static org.tron.core.services.http.PostParams.S_VALUE; -import com.alibaba.fastjson.JSONObject; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import lombok.extern.slf4j.Slf4j; @@ -10,6 +9,7 @@ import org.springframework.stereotype.Component; import org.tron.api.GrpcAPI.BytesMessage; import org.tron.core.Wallet; +import org.tron.json.JSONObject; import org.tron.protos.contract.SmartContractOuterClass.SmartContract; diff --git a/framework/src/main/java/org/tron/core/services/http/GetDelegatedResourceAccountIndexServlet.java b/framework/src/main/java/org/tron/core/services/http/GetDelegatedResourceAccountIndexServlet.java index 035e20cb873..e022c523548 100644 --- a/framework/src/main/java/org/tron/core/services/http/GetDelegatedResourceAccountIndexServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/GetDelegatedResourceAccountIndexServlet.java @@ -1,6 +1,5 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; import com.google.protobuf.ByteString; import java.io.IOException; import javax.servlet.http.HttpServletRequest; @@ -11,6 +10,7 @@ import org.tron.api.GrpcAPI.BytesMessage; import org.tron.common.utils.ByteArray; import org.tron.core.Wallet; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.DelegatedResourceAccountIndex; diff --git a/framework/src/main/java/org/tron/core/services/http/GetDelegatedResourceAccountIndexV2Servlet.java b/framework/src/main/java/org/tron/core/services/http/GetDelegatedResourceAccountIndexV2Servlet.java index 3d5bff80941..7ff517256f9 100644 --- a/framework/src/main/java/org/tron/core/services/http/GetDelegatedResourceAccountIndexV2Servlet.java +++ b/framework/src/main/java/org/tron/core/services/http/GetDelegatedResourceAccountIndexV2Servlet.java @@ -1,6 +1,5 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; import com.google.protobuf.ByteString; import java.io.IOException; import javax.servlet.http.HttpServletRequest; @@ -11,6 +10,7 @@ import org.tron.api.GrpcAPI.BytesMessage; import org.tron.common.utils.ByteArray; import org.tron.core.Wallet; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.DelegatedResourceAccountIndex; diff --git a/framework/src/main/java/org/tron/core/services/http/GetExchangeByIdServlet.java b/framework/src/main/java/org/tron/core/services/http/GetExchangeByIdServlet.java index 7a84c0ea8a4..1e87a4f188f 100644 --- a/framework/src/main/java/org/tron/core/services/http/GetExchangeByIdServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/GetExchangeByIdServlet.java @@ -1,9 +1,7 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; import com.google.protobuf.ByteString; import java.io.IOException; -import java.util.stream.Collectors; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import lombok.extern.slf4j.Slf4j; @@ -11,6 +9,7 @@ import org.springframework.stereotype.Component; import org.tron.common.utils.ByteArray; import org.tron.core.Wallet; +import org.tron.json.JSONObject; @Component diff --git a/framework/src/main/java/org/tron/core/services/http/GetIncomingViewingKeyServlet.java b/framework/src/main/java/org/tron/core/services/http/GetIncomingViewingKeyServlet.java index b572cf348e5..4eb3a01693e 100644 --- a/framework/src/main/java/org/tron/core/services/http/GetIncomingViewingKeyServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/GetIncomingViewingKeyServlet.java @@ -1,6 +1,5 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import lombok.extern.slf4j.Slf4j; @@ -9,6 +8,7 @@ import org.tron.api.GrpcAPI; import org.tron.common.utils.ByteArray; import org.tron.core.Wallet; +import org.tron.json.JSONObject; @Component diff --git a/framework/src/main/java/org/tron/core/services/http/GetMarketOrderByAccountServlet.java b/framework/src/main/java/org/tron/core/services/http/GetMarketOrderByAccountServlet.java index 1c3190b62ea..1f011bb88ce 100644 --- a/framework/src/main/java/org/tron/core/services/http/GetMarketOrderByAccountServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/GetMarketOrderByAccountServlet.java @@ -1,10 +1,7 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSON; -import com.alibaba.fastjson.JSONObject; import com.google.protobuf.ByteString; import java.io.IOException; -import java.util.stream.Collectors; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import lombok.extern.slf4j.Slf4j; @@ -12,6 +9,8 @@ import org.springframework.stereotype.Component; import org.tron.common.utils.ByteArray; import org.tron.core.Wallet; +import org.tron.json.JSON; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.MarketOrderList; diff --git a/framework/src/main/java/org/tron/core/services/http/GetNodeInfoServlet.java b/framework/src/main/java/org/tron/core/services/http/GetNodeInfoServlet.java index 8516d1c51bb..0b8f7b9ce2b 100644 --- a/framework/src/main/java/org/tron/core/services/http/GetNodeInfoServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/GetNodeInfoServlet.java @@ -1,6 +1,5 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSON; import java.io.IOException; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; @@ -9,6 +8,7 @@ import org.springframework.stereotype.Component; import org.tron.common.entity.NodeInfo; import org.tron.core.services.NodeInfoService; +import org.tron.json.JSON; @Component diff --git a/framework/src/main/java/org/tron/core/services/http/GetProposalByIdServlet.java b/framework/src/main/java/org/tron/core/services/http/GetProposalByIdServlet.java index 9d7805d4f98..f57bc8b1b3f 100644 --- a/framework/src/main/java/org/tron/core/services/http/GetProposalByIdServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/GetProposalByIdServlet.java @@ -1,10 +1,7 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; import com.google.protobuf.ByteString; import java.io.IOException; -import java.util.HashMap; -import java.util.stream.Collectors; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import lombok.extern.slf4j.Slf4j; @@ -12,6 +9,7 @@ import org.springframework.stereotype.Component; import org.tron.common.utils.ByteArray; import org.tron.core.Wallet; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.Proposal; diff --git a/framework/src/main/java/org/tron/core/services/http/GetTransactionInfoByBlockNumServlet.java b/framework/src/main/java/org/tron/core/services/http/GetTransactionInfoByBlockNumServlet.java index 587dd2d6613..5d0a09b1a68 100644 --- a/framework/src/main/java/org/tron/core/services/http/GetTransactionInfoByBlockNumServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/GetTransactionInfoByBlockNumServlet.java @@ -1,7 +1,5 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONArray; -import com.alibaba.fastjson.JSONObject; import java.io.IOException; import java.util.List; import javax.servlet.http.HttpServletRequest; @@ -12,6 +10,8 @@ import org.tron.api.GrpcAPI.NumberMessage; import org.tron.api.GrpcAPI.TransactionInfoList; import org.tron.core.Wallet; +import org.tron.json.JSONArray; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.TransactionInfo; import org.tron.protos.Protocol.TransactionInfo.Log; diff --git a/framework/src/main/java/org/tron/core/services/http/GetZenPaymentAddressServlet.java b/framework/src/main/java/org/tron/core/services/http/GetZenPaymentAddressServlet.java index c78b663eec2..c4f81ea7f87 100644 --- a/framework/src/main/java/org/tron/core/services/http/GetZenPaymentAddressServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/GetZenPaymentAddressServlet.java @@ -1,6 +1,5 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; import java.util.stream.Collectors; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; @@ -12,6 +11,7 @@ import org.tron.core.Wallet; import org.tron.core.zen.address.DiversifierT; import org.tron.core.zen.address.IncomingViewingKey; +import org.tron.json.JSONObject; @Component diff --git a/framework/src/main/java/org/tron/core/services/http/JsonFormat.java b/framework/src/main/java/org/tron/core/services/http/JsonFormat.java index 96dedb1e20c..2dd0af9ba80 100644 --- a/framework/src/main/java/org/tron/core/services/http/JsonFormat.java +++ b/framework/src/main/java/org/tron/core/services/http/JsonFormat.java @@ -29,7 +29,6 @@ SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -import com.alibaba.fastjson.JSON; import com.google.common.collect.ImmutableSet; import com.google.protobuf.ByteString; import com.google.protobuf.Descriptors; @@ -58,6 +57,7 @@ SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT import org.tron.common.utils.ByteArray; import org.tron.common.utils.Commons; import org.tron.common.utils.StringUtil; +import org.tron.json.JSON; import org.tron.protos.contract.BalanceContract; /** diff --git a/framework/src/main/java/org/tron/core/services/http/MarketCancelOrderServlet.java b/framework/src/main/java/org/tron/core/services/http/MarketCancelOrderServlet.java index 8d19d60ce5c..a9e27bfb8e3 100644 --- a/framework/src/main/java/org/tron/core/services/http/MarketCancelOrderServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/MarketCancelOrderServlet.java @@ -1,12 +1,12 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.tron.core.Wallet; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.Transaction; import org.tron.protos.Protocol.Transaction.Contract.ContractType; import org.tron.protos.contract.MarketContract.MarketCancelOrderContract; diff --git a/framework/src/main/java/org/tron/core/services/http/MarketSellAssetServlet.java b/framework/src/main/java/org/tron/core/services/http/MarketSellAssetServlet.java index 258dd270811..12bb7e3e078 100644 --- a/framework/src/main/java/org/tron/core/services/http/MarketSellAssetServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/MarketSellAssetServlet.java @@ -1,6 +1,5 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; import java.util.stream.Collectors; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; @@ -8,6 +7,7 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.tron.core.Wallet; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.Transaction; import org.tron.protos.Protocol.Transaction.Contract.ContractType; import org.tron.protos.contract.MarketContract.MarketSellAssetContract; diff --git a/framework/src/main/java/org/tron/core/services/http/MetricsServlet.java b/framework/src/main/java/org/tron/core/services/http/MetricsServlet.java index bb4bf18e58e..aaaebb22146 100644 --- a/framework/src/main/java/org/tron/core/services/http/MetricsServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/MetricsServlet.java @@ -1,6 +1,5 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSON; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import lombok.extern.slf4j.Slf4j; @@ -8,6 +7,7 @@ import org.springframework.stereotype.Component; import org.tron.core.metrics.MetricsApiService; import org.tron.core.metrics.MetricsInfo; +import org.tron.json.JSON; @Component @Slf4j(topic = "API") diff --git a/framework/src/main/java/org/tron/core/services/http/ParticipateAssetIssueServlet.java b/framework/src/main/java/org/tron/core/services/http/ParticipateAssetIssueServlet.java index 1e864250bff..ec5e3d956f6 100644 --- a/framework/src/main/java/org/tron/core/services/http/ParticipateAssetIssueServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/ParticipateAssetIssueServlet.java @@ -1,6 +1,5 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; import java.util.stream.Collectors; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; @@ -8,6 +7,7 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.tron.core.Wallet; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.Transaction; import org.tron.protos.Protocol.Transaction.Contract.ContractType; import org.tron.protos.contract.AssetIssueContractOuterClass.ParticipateAssetIssueContract; diff --git a/framework/src/main/java/org/tron/core/services/http/ProposalApproveServlet.java b/framework/src/main/java/org/tron/core/services/http/ProposalApproveServlet.java index 3fc60016780..dfeeb1acde5 100644 --- a/framework/src/main/java/org/tron/core/services/http/ProposalApproveServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/ProposalApproveServlet.java @@ -1,6 +1,5 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; import java.util.stream.Collectors; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; @@ -8,6 +7,7 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.tron.core.Wallet; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.Transaction; import org.tron.protos.Protocol.Transaction.Contract.ContractType; import org.tron.protos.contract.ProposalContract.ProposalApproveContract; diff --git a/framework/src/main/java/org/tron/core/services/http/ProposalCreateServlet.java b/framework/src/main/java/org/tron/core/services/http/ProposalCreateServlet.java index 9660ee7f863..f1055e00396 100644 --- a/framework/src/main/java/org/tron/core/services/http/ProposalCreateServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/ProposalCreateServlet.java @@ -1,6 +1,5 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; import java.util.stream.Collectors; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; @@ -8,6 +7,7 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.tron.core.Wallet; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.Transaction; import org.tron.protos.Protocol.Transaction.Contract.ContractType; import org.tron.protos.contract.ProposalContract.ProposalCreateContract; diff --git a/framework/src/main/java/org/tron/core/services/http/ProposalDeleteServlet.java b/framework/src/main/java/org/tron/core/services/http/ProposalDeleteServlet.java index 09c4c78a37a..8e7163f490b 100644 --- a/framework/src/main/java/org/tron/core/services/http/ProposalDeleteServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/ProposalDeleteServlet.java @@ -1,6 +1,5 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; import java.util.stream.Collectors; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; @@ -8,6 +7,7 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.tron.core.Wallet; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.Transaction; import org.tron.protos.Protocol.Transaction.Contract.ContractType; import org.tron.protos.contract.ProposalContract.ProposalDeleteContract; diff --git a/framework/src/main/java/org/tron/core/services/http/ScanAndMarkNoteByIvkServlet.java b/framework/src/main/java/org/tron/core/services/http/ScanAndMarkNoteByIvkServlet.java index 692a1c2ecdc..b91fd394442 100644 --- a/framework/src/main/java/org/tron/core/services/http/ScanAndMarkNoteByIvkServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/ScanAndMarkNoteByIvkServlet.java @@ -1,7 +1,5 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONArray; -import com.alibaba.fastjson.JSONObject; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import lombok.extern.slf4j.Slf4j; @@ -11,6 +9,8 @@ import org.tron.api.GrpcAPI.IvkDecryptAndMarkParameters; import org.tron.common.utils.ByteArray; import org.tron.core.Wallet; +import org.tron.json.JSONArray; +import org.tron.json.JSONObject; @Component @Slf4j(topic = "API") diff --git a/framework/src/main/java/org/tron/core/services/http/ScanNoteByIvkServlet.java b/framework/src/main/java/org/tron/core/services/http/ScanNoteByIvkServlet.java index c0076a705f8..c8e25a2fc37 100644 --- a/framework/src/main/java/org/tron/core/services/http/ScanNoteByIvkServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/ScanNoteByIvkServlet.java @@ -1,7 +1,5 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONArray; -import com.alibaba.fastjson.JSONObject; import java.util.stream.Collectors; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; @@ -12,6 +10,8 @@ import org.tron.api.GrpcAPI.IvkDecryptParameters; import org.tron.common.utils.ByteArray; import org.tron.core.Wallet; +import org.tron.json.JSONArray; +import org.tron.json.JSONObject; @Component @Slf4j(topic = "API") diff --git a/framework/src/main/java/org/tron/core/services/http/ScanShieldedTRC20NotesByIvkServlet.java b/framework/src/main/java/org/tron/core/services/http/ScanShieldedTRC20NotesByIvkServlet.java index 2b52883f490..04c956e544a 100644 --- a/framework/src/main/java/org/tron/core/services/http/ScanShieldedTRC20NotesByIvkServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/ScanShieldedTRC20NotesByIvkServlet.java @@ -1,7 +1,5 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONArray; -import com.alibaba.fastjson.JSONObject; import java.util.stream.Collectors; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; @@ -12,6 +10,8 @@ import org.tron.api.GrpcAPI.IvkDecryptTRC20Parameters; import org.tron.common.utils.ByteArray; import org.tron.core.Wallet; +import org.tron.json.JSONArray; +import org.tron.json.JSONObject; @Component @Slf4j(topic = "API") diff --git a/framework/src/main/java/org/tron/core/services/http/SetAccountIdServlet.java b/framework/src/main/java/org/tron/core/services/http/SetAccountIdServlet.java index 36203749e0b..2f5b9fd9cd4 100644 --- a/framework/src/main/java/org/tron/core/services/http/SetAccountIdServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/SetAccountIdServlet.java @@ -1,6 +1,5 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; import java.util.stream.Collectors; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; @@ -8,6 +7,7 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.tron.core.Wallet; +import org.tron.json.JSONObject; import org.tron.protos.Protocol; import org.tron.protos.contract.AccountContract.SetAccountIdContract; diff --git a/framework/src/main/java/org/tron/core/services/http/TransferAssetServlet.java b/framework/src/main/java/org/tron/core/services/http/TransferAssetServlet.java index af2699c4bf4..c8becdb9fde 100644 --- a/framework/src/main/java/org/tron/core/services/http/TransferAssetServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/TransferAssetServlet.java @@ -1,6 +1,5 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; import java.util.stream.Collectors; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; @@ -8,6 +7,7 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.tron.core.Wallet; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.Transaction; import org.tron.protos.Protocol.Transaction.Contract.ContractType; import org.tron.protos.contract.AssetIssueContractOuterClass.TransferAssetContract; diff --git a/framework/src/main/java/org/tron/core/services/http/TransferServlet.java b/framework/src/main/java/org/tron/core/services/http/TransferServlet.java index 6f575e4fe3f..11b2179800a 100644 --- a/framework/src/main/java/org/tron/core/services/http/TransferServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/TransferServlet.java @@ -1,6 +1,5 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; import java.util.stream.Collectors; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; @@ -8,6 +7,7 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.tron.core.Wallet; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.Transaction; import org.tron.protos.Protocol.Transaction.Contract.ContractType; import org.tron.protos.contract.BalanceContract.TransferContract; diff --git a/framework/src/main/java/org/tron/core/services/http/TriggerConstantContractServlet.java b/framework/src/main/java/org/tron/core/services/http/TriggerConstantContractServlet.java index 8a46ee1ed74..634165911d1 100644 --- a/framework/src/main/java/org/tron/core/services/http/TriggerConstantContractServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/TriggerConstantContractServlet.java @@ -1,6 +1,5 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; import com.google.protobuf.ByteString; import io.netty.util.internal.StringUtil; import java.io.IOException; @@ -17,6 +16,7 @@ import org.tron.core.Wallet; import org.tron.core.capsule.TransactionCapsule; import org.tron.core.exception.ContractValidateException; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.Transaction; import org.tron.protos.Protocol.Transaction.Contract.ContractType; import org.tron.protos.contract.SmartContractOuterClass.TriggerSmartContract; diff --git a/framework/src/main/java/org/tron/core/services/http/TriggerSmartContractServlet.java b/framework/src/main/java/org/tron/core/services/http/TriggerSmartContractServlet.java index 6577a9e5f24..bc4d9dc5f66 100644 --- a/framework/src/main/java/org/tron/core/services/http/TriggerSmartContractServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/TriggerSmartContractServlet.java @@ -1,6 +1,5 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; import com.google.protobuf.ByteString; import io.netty.util.internal.StringUtil; import java.io.IOException; @@ -18,6 +17,7 @@ import org.tron.core.Wallet; import org.tron.core.capsule.TransactionCapsule; import org.tron.core.exception.ContractValidateException; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.Transaction; import org.tron.protos.Protocol.Transaction.Contract.ContractType; import org.tron.protos.contract.SmartContractOuterClass.TriggerSmartContract; diff --git a/framework/src/main/java/org/tron/core/services/http/UnDelegateResourceServlet.java b/framework/src/main/java/org/tron/core/services/http/UnDelegateResourceServlet.java index cf9c2c95dcd..140129d4e34 100644 --- a/framework/src/main/java/org/tron/core/services/http/UnDelegateResourceServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/UnDelegateResourceServlet.java @@ -1,12 +1,12 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.tron.core.Wallet; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.Transaction; import org.tron.protos.Protocol.Transaction.Contract.ContractType; import org.tron.protos.contract.BalanceContract.UnDelegateResourceContract; diff --git a/framework/src/main/java/org/tron/core/services/http/UnFreezeAssetServlet.java b/framework/src/main/java/org/tron/core/services/http/UnFreezeAssetServlet.java index 6118b39f2cd..a2218547b4a 100644 --- a/framework/src/main/java/org/tron/core/services/http/UnFreezeAssetServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/UnFreezeAssetServlet.java @@ -1,13 +1,12 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; -import java.util.stream.Collectors; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.tron.core.Wallet; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.Transaction; import org.tron.protos.Protocol.Transaction.Contract.ContractType; import org.tron.protos.contract.AssetIssueContractOuterClass.UnfreezeAssetContract; diff --git a/framework/src/main/java/org/tron/core/services/http/UnFreezeBalanceServlet.java b/framework/src/main/java/org/tron/core/services/http/UnFreezeBalanceServlet.java index eb075b7139d..1f893003c20 100644 --- a/framework/src/main/java/org/tron/core/services/http/UnFreezeBalanceServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/UnFreezeBalanceServlet.java @@ -1,13 +1,12 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; -import java.util.stream.Collectors; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.tron.core.Wallet; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.Transaction; import org.tron.protos.Protocol.Transaction.Contract.ContractType; import org.tron.protos.contract.BalanceContract.UnfreezeBalanceContract; diff --git a/framework/src/main/java/org/tron/core/services/http/UnFreezeBalanceV2Servlet.java b/framework/src/main/java/org/tron/core/services/http/UnFreezeBalanceV2Servlet.java index 614a7ca6b7a..05644c0b941 100644 --- a/framework/src/main/java/org/tron/core/services/http/UnFreezeBalanceV2Servlet.java +++ b/framework/src/main/java/org/tron/core/services/http/UnFreezeBalanceV2Servlet.java @@ -1,12 +1,12 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.tron.core.Wallet; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.Transaction; import org.tron.protos.Protocol.Transaction.Contract.ContractType; import org.tron.protos.contract.BalanceContract.UnfreezeBalanceV2Contract; diff --git a/framework/src/main/java/org/tron/core/services/http/UpdateAccountServlet.java b/framework/src/main/java/org/tron/core/services/http/UpdateAccountServlet.java index 0251a46ec64..532d7acf658 100644 --- a/framework/src/main/java/org/tron/core/services/http/UpdateAccountServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/UpdateAccountServlet.java @@ -1,13 +1,12 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; -import java.util.stream.Collectors; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.tron.core.Wallet; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.Transaction; import org.tron.protos.Protocol.Transaction.Contract.ContractType; import org.tron.protos.contract.AccountContract.AccountUpdateContract; diff --git a/framework/src/main/java/org/tron/core/services/http/UpdateAssetServlet.java b/framework/src/main/java/org/tron/core/services/http/UpdateAssetServlet.java index d3f467ff7a8..e7e8179b1a4 100644 --- a/framework/src/main/java/org/tron/core/services/http/UpdateAssetServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/UpdateAssetServlet.java @@ -1,13 +1,12 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; -import java.util.stream.Collectors; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.tron.core.Wallet; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.Transaction; import org.tron.protos.Protocol.Transaction.Contract.ContractType; import org.tron.protos.contract.AssetIssueContractOuterClass.UpdateAssetContract; diff --git a/framework/src/main/java/org/tron/core/services/http/UpdateBrokerageServlet.java b/framework/src/main/java/org/tron/core/services/http/UpdateBrokerageServlet.java index 23daaef6072..e1073354ddc 100644 --- a/framework/src/main/java/org/tron/core/services/http/UpdateBrokerageServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/UpdateBrokerageServlet.java @@ -1,13 +1,12 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; -import java.util.stream.Collectors; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.tron.core.Wallet; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.Transaction; import org.tron.protos.Protocol.Transaction.Contract.ContractType; import org.tron.protos.contract.StorageContract.UpdateBrokerageContract; diff --git a/framework/src/main/java/org/tron/core/services/http/UpdateEnergyLimitServlet.java b/framework/src/main/java/org/tron/core/services/http/UpdateEnergyLimitServlet.java index aac6e8ff50e..cd349c7e153 100644 --- a/framework/src/main/java/org/tron/core/services/http/UpdateEnergyLimitServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/UpdateEnergyLimitServlet.java @@ -1,13 +1,12 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; -import java.util.stream.Collectors; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.tron.core.Wallet; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.Transaction; import org.tron.protos.Protocol.Transaction.Contract.ContractType; import org.tron.protos.contract.SmartContractOuterClass.UpdateEnergyLimitContract; diff --git a/framework/src/main/java/org/tron/core/services/http/UpdateSettingServlet.java b/framework/src/main/java/org/tron/core/services/http/UpdateSettingServlet.java index 821054c7b4e..e58f02df157 100644 --- a/framework/src/main/java/org/tron/core/services/http/UpdateSettingServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/UpdateSettingServlet.java @@ -1,12 +1,12 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.tron.core.Wallet; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.Transaction; import org.tron.protos.Protocol.Transaction.Contract.ContractType; import org.tron.protos.contract.SmartContractOuterClass.UpdateSettingContract; diff --git a/framework/src/main/java/org/tron/core/services/http/UpdateWitnessServlet.java b/framework/src/main/java/org/tron/core/services/http/UpdateWitnessServlet.java index 3584557d3b6..6b0c4449e88 100644 --- a/framework/src/main/java/org/tron/core/services/http/UpdateWitnessServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/UpdateWitnessServlet.java @@ -1,13 +1,12 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; -import java.util.stream.Collectors; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.tron.core.Wallet; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.Transaction; import org.tron.protos.Protocol.Transaction.Contract.ContractType; import org.tron.protos.contract.WitnessContract.WitnessUpdateContract; diff --git a/framework/src/main/java/org/tron/core/services/http/Util.java b/framework/src/main/java/org/tron/core/services/http/Util.java index 2b6b929d8a0..aa2bb9036fc 100644 --- a/framework/src/main/java/org/tron/core/services/http/Util.java +++ b/framework/src/main/java/org/tron/core/services/http/Util.java @@ -3,16 +3,11 @@ import static org.apache.commons.lang3.StringUtils.EMPTY; import static org.tron.common.utils.Commons.decodeFromBase58Check; -import com.alibaba.fastjson.JSON; -import com.alibaba.fastjson.JSONArray; -import com.alibaba.fastjson.JSONException; -import com.alibaba.fastjson.JSONObject; import com.google.protobuf.Any; import com.google.protobuf.ByteString; import com.google.protobuf.GeneratedMessageV3; import com.google.protobuf.InvalidProtocolBufferException; import com.google.protobuf.Message; - import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; @@ -52,6 +47,10 @@ import org.tron.core.config.args.Args; import org.tron.core.db.TransactionTrace; import org.tron.core.services.http.JsonFormat.ParseException; +import org.tron.json.JSON; +import org.tron.json.JSONArray; +import org.tron.json.JSONException; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.Account; import org.tron.protos.Protocol.Block; import org.tron.protos.Protocol.Transaction; diff --git a/framework/src/main/java/org/tron/core/services/http/ValidateAddressServlet.java b/framework/src/main/java/org/tron/core/services/http/ValidateAddressServlet.java index a65e2ce2ee0..07eecfc5466 100644 --- a/framework/src/main/java/org/tron/core/services/http/ValidateAddressServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/ValidateAddressServlet.java @@ -1,7 +1,5 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSON; -import com.alibaba.fastjson.JSONObject; import java.io.IOException; import java.util.Base64; import java.util.stream.Collectors; @@ -12,6 +10,8 @@ import org.tron.common.utils.ByteArray; import org.tron.common.utils.Commons; import org.tron.common.utils.DecodeUtil; +import org.tron.json.JSON; +import org.tron.json.JSONObject; @Component diff --git a/framework/src/main/java/org/tron/core/services/http/VoteWitnessAccountServlet.java b/framework/src/main/java/org/tron/core/services/http/VoteWitnessAccountServlet.java index 0a77a0e6fc1..f3695b83de8 100644 --- a/framework/src/main/java/org/tron/core/services/http/VoteWitnessAccountServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/VoteWitnessAccountServlet.java @@ -1,6 +1,5 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; import java.util.stream.Collectors; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; @@ -8,6 +7,7 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.tron.core.Wallet; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.Transaction; import org.tron.protos.Protocol.Transaction.Contract.ContractType; import org.tron.protos.contract.WitnessContract.VoteWitnessContract; diff --git a/framework/src/main/java/org/tron/core/services/http/WithdrawBalanceServlet.java b/framework/src/main/java/org/tron/core/services/http/WithdrawBalanceServlet.java index 27ea54d8ee2..33faa01866c 100644 --- a/framework/src/main/java/org/tron/core/services/http/WithdrawBalanceServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/WithdrawBalanceServlet.java @@ -1,6 +1,5 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; import java.util.stream.Collectors; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; @@ -8,6 +7,7 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.tron.core.Wallet; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.Transaction; import org.tron.protos.Protocol.Transaction.Contract.ContractType; import org.tron.protos.contract.BalanceContract.WithdrawBalanceContract; diff --git a/framework/src/main/java/org/tron/core/services/http/WithdrawExpireUnfreezeServlet.java b/framework/src/main/java/org/tron/core/services/http/WithdrawExpireUnfreezeServlet.java index 4888ee42de4..7e5f3f96c57 100644 --- a/framework/src/main/java/org/tron/core/services/http/WithdrawExpireUnfreezeServlet.java +++ b/framework/src/main/java/org/tron/core/services/http/WithdrawExpireUnfreezeServlet.java @@ -1,7 +1,5 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSON; -import com.alibaba.fastjson.JSONObject; import java.util.stream.Collectors; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; @@ -9,6 +7,8 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.tron.core.Wallet; +import org.tron.json.JSON; +import org.tron.json.JSONObject; import org.tron.protos.Protocol.Transaction; import org.tron.protos.Protocol.Transaction.Contract.ContractType; import org.tron.protos.contract.BalanceContract.WithdrawExpireUnfreezeContract; diff --git a/framework/src/main/java/org/tron/core/services/jsonrpc/TronJsonRpc.java b/framework/src/main/java/org/tron/core/services/jsonrpc/TronJsonRpc.java index 115df6ef9da..f94ebe84a9b 100644 --- a/framework/src/main/java/org/tron/core/services/jsonrpc/TronJsonRpc.java +++ b/framework/src/main/java/org/tron/core/services/jsonrpc/TronJsonRpc.java @@ -1,6 +1,5 @@ package org.tron.core.services.jsonrpc; -import com.alibaba.fastjson.JSONObject; import com.fasterxml.jackson.annotation.JsonPropertyOrder; import com.googlecode.jsonrpc4j.JsonRpcError; import com.googlecode.jsonrpc4j.JsonRpcErrors; @@ -30,6 +29,7 @@ import org.tron.core.services.jsonrpc.types.CallArguments; import org.tron.core.services.jsonrpc.types.TransactionReceipt; import org.tron.core.services.jsonrpc.types.TransactionResult; +import org.tron.json.JSONObject; /** * Error code refers to https://www.quicknode.com/docs/ethereum/error-references diff --git a/framework/src/main/java/org/tron/core/services/jsonrpc/TronJsonRpcImpl.java b/framework/src/main/java/org/tron/core/services/jsonrpc/TronJsonRpcImpl.java index de939bdfff4..9084df3e5c7 100644 --- a/framework/src/main/java/org/tron/core/services/jsonrpc/TronJsonRpcImpl.java +++ b/framework/src/main/java/org/tron/core/services/jsonrpc/TronJsonRpcImpl.java @@ -10,7 +10,6 @@ import static org.tron.core.services.jsonrpc.JsonRpcApiUtil.getTxID; import static org.tron.core.services.jsonrpc.JsonRpcApiUtil.triggerCallContract; -import com.alibaba.fastjson.JSON; import com.google.common.cache.Cache; import com.google.common.cache.CacheBuilder; import com.google.protobuf.ByteString; @@ -85,6 +84,7 @@ import org.tron.core.services.jsonrpc.types.TransactionResult; import org.tron.core.store.StorageRowStore; import org.tron.core.vm.program.Storage; +import org.tron.json.JSON; import org.tron.program.Version; import org.tron.protos.Protocol.Account; import org.tron.protos.Protocol.Block; diff --git a/framework/src/main/java/org/tron/keystore/WalletUtils.java b/framework/src/main/java/org/tron/keystore/WalletUtils.java index 8bcc68cbab0..1ddb64eded5 100644 --- a/framework/src/main/java/org/tron/keystore/WalletUtils.java +++ b/framework/src/main/java/org/tron/keystore/WalletUtils.java @@ -3,6 +3,7 @@ import com.fasterxml.jackson.core.JsonParser; import com.fasterxml.jackson.databind.DeserializationFeature; import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.json.JsonMapper; import java.io.Console; import java.io.File; import java.io.IOException; @@ -25,7 +26,7 @@ */ public class WalletUtils { - private static final ObjectMapper objectMapper = new ObjectMapper(); + private static final ObjectMapper objectMapper = JsonMapper.builder().build(); static { objectMapper.configure(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true); diff --git a/framework/src/test/java/org/tron/common/logsfilter/EventParserJsonTest.java b/framework/src/test/java/org/tron/common/logsfilter/EventParserJsonTest.java index 34a8e82c424..7c81fed005a 100644 --- a/framework/src/test/java/org/tron/common/logsfilter/EventParserJsonTest.java +++ b/framework/src/test/java/org/tron/common/logsfilter/EventParserJsonTest.java @@ -2,8 +2,6 @@ import static org.tron.core.Constant.ADD_PRE_FIX_BYTE_MAINNET; -import com.alibaba.fastjson.JSONArray; -import com.alibaba.fastjson.JSONObject; import java.util.LinkedList; import java.util.List; import java.util.Map; @@ -12,6 +10,8 @@ import org.tron.common.crypto.Hash; import org.tron.common.utils.ByteArray; import org.tron.core.Wallet; +import org.tron.json.JSONArray; +import org.tron.json.JSONObject; public class EventParserJsonTest { @@ -60,7 +60,7 @@ public synchronized void testEventParser() { topicList.add(ByteArray .fromHexString("0xb7685f178b1c93df3422f7bfcb61ae2c6f66d0947bb9eb293259c231b986b81b")); - JSONArray entryArr = JSONObject.parseArray(abiStr); + JSONArray entryArr = JSONArray.parseArray(abiStr); JSONObject entry = new JSONObject(); for (int i = 0; i < entryArr.size(); i++) { diff --git a/framework/src/test/java/org/tron/common/utils/client/utils/AbiUtil.java b/framework/src/test/java/org/tron/common/utils/client/utils/AbiUtil.java index 1d780bfacd4..5f28fb3e13a 100644 --- a/framework/src/test/java/org/tron/common/utils/client/utils/AbiUtil.java +++ b/framework/src/test/java/org/tron/common/utils/client/utils/AbiUtil.java @@ -3,6 +3,7 @@ import static org.tron.common.math.Maths.abs; import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.json.JsonMapper; import java.io.IOException; import java.util.ArrayList; import java.util.List; @@ -19,6 +20,7 @@ public class AbiUtil { private static Pattern paramTypeBytes = Pattern.compile("^bytes([0-9]*)$"); private static Pattern paramTypeNumber = Pattern.compile("^(u?int)([0-9]*)$"); private static Pattern paramTypeArray = Pattern.compile("^(.*)\\[([0-9]*)]$"); + private static final ObjectMapper mapper = new ObjectMapper(); public static String[] getTypes(String methodSign) { int start = methodSign.indexOf('(') + 1; @@ -221,7 +223,6 @@ public static String parseSelector(String methodSign) { } public static byte[] encodeInput(String methodSign, String input) { - ObjectMapper mapper = new ObjectMapper(); input = "[" + input + "]"; List items; try { @@ -315,7 +316,6 @@ byte[] encode(String arrayValues) { List items; try { - ObjectMapper mapper = new ObjectMapper(); items = mapper.readValue(arrayValues, List.class); } catch (IOException e) { e.printStackTrace(); diff --git a/framework/src/test/java/org/tron/common/utils/client/utils/HttpMethed.java b/framework/src/test/java/org/tron/common/utils/client/utils/HttpMethed.java index 030fbd80dea..cea17b0c033 100644 --- a/framework/src/test/java/org/tron/common/utils/client/utils/HttpMethed.java +++ b/framework/src/test/java/org/tron/common/utils/client/utils/HttpMethed.java @@ -1,7 +1,5 @@ package org.tron.common.utils.client.utils; -import com.alibaba.fastjson.JSONArray; -import com.alibaba.fastjson.JSONObject; import com.google.common.collect.Lists; import com.google.gson.Gson; import com.google.gson.JsonArray; @@ -29,6 +27,8 @@ import org.tron.common.utils.ByteUtil; import org.tron.common.utils.PublicMethod; import org.tron.common.utils.client.Configuration; +import org.tron.json.JSONArray; +import org.tron.json.JSONObject; @Slf4j public class HttpMethed { diff --git a/framework/src/test/java/org/tron/common/utils/client/utils/JSONObjectWarp.java b/framework/src/test/java/org/tron/common/utils/client/utils/JSONObjectWarp.java index bab667dedf1..500d1f452b2 100644 --- a/framework/src/test/java/org/tron/common/utils/client/utils/JSONObjectWarp.java +++ b/framework/src/test/java/org/tron/common/utils/client/utils/JSONObjectWarp.java @@ -1,9 +1,34 @@ package org.tron.common.utils.client.utils; -import com.alibaba.fastjson.JSONObject; +import org.tron.json.JSONObject; public class JSONObjectWarp extends JSONObject { + @Override + public JSONObjectWarp put(String key, String value) { + super.put(key, value); + return this; + } + + @Override + public JSONObjectWarp put(String key, Boolean value) { + super.put(key, value); + return this; + } + + @Override + public JSONObjectWarp put(String key, Integer value) { + super.put(key, value); + return this; + } + + @Override + public JSONObjectWarp put(String key, Long value) { + super.put(key, value); + return this; + } + + @Override public JSONObjectWarp put(String key, Object value) { super.put(key, value); return this; diff --git a/framework/src/test/java/org/tron/core/actuator/vm/SerializersTest.java b/framework/src/test/java/org/tron/core/actuator/vm/SerializersTest.java index 52ee1eeb937..9e9b5d35fbe 100644 --- a/framework/src/test/java/org/tron/core/actuator/vm/SerializersTest.java +++ b/framework/src/test/java/org/tron/core/actuator/vm/SerializersTest.java @@ -1,5 +1,9 @@ package org.tron.core.actuator.vm; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; + import org.junit.Test; import org.tron.core.vm.trace.Serializers; @@ -7,6 +11,60 @@ public class SerializersTest { @Test public void testSerializeFieldsOnly() { - Serializers.serializeFieldsOnly("testString", true); + assertEquals("\"testString\"", Serializers.serializeFieldsOnly("testString")); + } + + @Test + public void testSerializeFieldsOnlyPojo() { + TestBean bean = new TestBean("hello", 42); + String json = Serializers.serializeFieldsOnly(bean); + assertTrue("Should contain name field", json.contains("\"name\"")); + assertTrue("Should contain name value", json.contains("\"hello\"")); + assertTrue("Should contain value field", json.contains("\"value\"")); + assertTrue("Should contain value 42", json.contains("42")); + } + + @Test + public void testSerializeFieldsOnlyIgnoresGetters() { + TestBean bean = new TestBean("hello", 42); + String json = Serializers.serializeFieldsOnly(bean); + // getComputedField() returns "computed" but should not appear + // because getter visibility is NONE + assertFalse("Should not serialize getter-only property", + json.contains("computed")); + } + + @Test + public void testSerializeFieldsOnlyNull() { + TestBean bean = new TestBean(null, 0); + String json = Serializers.serializeFieldsOnly(bean); + assertTrue("Should contain null name", json.replaceAll("\\s+", "") + .contains("\"name\":null")); + assertTrue("Should contain value 0", json.replaceAll("\\s+", "") + .contains("\"value\":0")); + } + + @Test + public void testSerializeFieldsOnlyReturnsEmptyOnError() { + // A non-serializable object should return "{}" + assertEquals("{}", Serializers.serializeFieldsOnly(new Object() { + // anonymous class with circular reference + Object self = this; + })); + } + + @SuppressWarnings("unused") + static class TestBean { + private String name; + private int value; + + TestBean(String name, int value) { + this.name = name; + this.value = value; + } + + public String getComputedField() { + return "computed"; + } } } diff --git a/framework/src/test/java/org/tron/core/jsonrpc/JsonrpcServiceTest.java b/framework/src/test/java/org/tron/core/jsonrpc/JsonrpcServiceTest.java index ced7048c9d2..5f57890d4a7 100644 --- a/framework/src/test/java/org/tron/core/jsonrpc/JsonrpcServiceTest.java +++ b/framework/src/test/java/org/tron/core/jsonrpc/JsonrpcServiceTest.java @@ -3,7 +3,6 @@ import static org.tron.core.services.jsonrpc.JsonRpcApiUtil.getByJsonBlockId; import static org.tron.core.services.jsonrpc.TronJsonRpcImpl.TAG_PENDING_SUPPORT_ERROR; -import com.alibaba.fastjson.JSON; import com.google.gson.JsonArray; import com.google.gson.JsonObject; import com.google.protobuf.ByteString; @@ -50,6 +49,7 @@ import org.tron.core.services.jsonrpc.types.BlockResult; import org.tron.core.services.jsonrpc.types.TransactionReceipt; import org.tron.core.services.jsonrpc.types.TransactionResult; +import org.tron.json.JSON; import org.tron.protos.Protocol; import org.tron.protos.Protocol.Transaction.Contract.ContractType; import org.tron.protos.contract.BalanceContract.TransferContract; diff --git a/framework/src/test/java/org/tron/core/net/messagehandler/PbftDataSyncHandlerTest.java b/framework/src/test/java/org/tron/core/net/messagehandler/PbftDataSyncHandlerTest.java index e5d242a6c4d..8c5196ce04a 100644 --- a/framework/src/test/java/org/tron/core/net/messagehandler/PbftDataSyncHandlerTest.java +++ b/framework/src/test/java/org/tron/core/net/messagehandler/PbftDataSyncHandlerTest.java @@ -1,6 +1,5 @@ package org.tron.core.net.messagehandler; -import com.alibaba.fastjson.JSON; import com.google.protobuf.ByteString; import java.lang.reflect.Field; import java.util.ArrayList; @@ -15,6 +14,7 @@ import org.tron.core.db.PbftSignDataStore; import org.tron.core.net.message.pbft.PbftCommitMessage; import org.tron.core.store.DynamicPropertiesStore; +import org.tron.json.JSON; import org.tron.protos.Protocol; public class PbftDataSyncHandlerTest { diff --git a/framework/src/test/java/org/tron/core/pbft/PbftApiTest.java b/framework/src/test/java/org/tron/core/pbft/PbftApiTest.java index 48af7408b6f..36253333a4e 100755 --- a/framework/src/test/java/org/tron/core/pbft/PbftApiTest.java +++ b/framework/src/test/java/org/tron/core/pbft/PbftApiTest.java @@ -1,7 +1,5 @@ package org.tron.core.pbft; -import com.alibaba.fastjson.JSON; -import com.alibaba.fastjson.JSONObject; import com.google.protobuf.ByteString; import java.io.IOException; import java.util.Objects; @@ -29,6 +27,8 @@ import org.tron.core.db2.ISession; import org.tron.core.services.interfaceOnPBFT.http.PBFT.HttpApiOnPBFTService; import org.tron.core.store.DynamicPropertiesStore; +import org.tron.json.JSON; +import org.tron.json.JSONObject; @Slf4j public class PbftApiTest extends BaseTest { diff --git a/framework/src/test/java/org/tron/core/services/NodeInfoServiceTest.java b/framework/src/test/java/org/tron/core/services/NodeInfoServiceTest.java index 10e69258406..ce0a09da94a 100644 --- a/framework/src/test/java/org/tron/core/services/NodeInfoServiceTest.java +++ b/framework/src/test/java/org/tron/core/services/NodeInfoServiceTest.java @@ -1,6 +1,5 @@ package org.tron.core.services; -import com.alibaba.fastjson.JSON; import com.google.protobuf.ByteString; import java.net.InetSocketAddress; import javax.annotation.Resource; @@ -21,6 +20,7 @@ import org.tron.core.net.P2pEventHandlerImpl; import org.tron.core.net.TronNetService; import org.tron.core.net.peer.PeerManager; +import org.tron.json.JSON; import org.tron.p2p.P2pConfig; import org.tron.p2p.connection.Channel; import org.tron.program.Version; diff --git a/framework/src/test/java/org/tron/core/services/http/AccountPermissionUpdateServletTest.java b/framework/src/test/java/org/tron/core/services/http/AccountPermissionUpdateServletTest.java new file mode 100644 index 00000000000..e93c41397a2 --- /dev/null +++ b/framework/src/test/java/org/tron/core/services/http/AccountPermissionUpdateServletTest.java @@ -0,0 +1,60 @@ +package org.tron.core.services.http; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.argThat; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import org.junit.Test; +import org.springframework.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.core.capsule.TransactionCapsule; +import org.tron.protos.Protocol; +import org.tron.protos.contract.AccountContract; + +public class AccountPermissionUpdateServletTest extends BaseHttpTest { + + private AccountPermissionUpdateServlet servlet; + private final String ownerAddr = ByteArray.toHexString(new ECKey().getAddress()); + + @Override + protected void setUpMocks() throws Exception { + servlet = new AccountPermissionUpdateServlet(); + injectWallet(servlet); + when(wallet.createTransactionCapsule( + any(AccountContract.AccountPermissionUpdateContract.class), + eq(Protocol.Transaction.Contract.ContractType.AccountPermissionUpdateContract))) + .thenReturn(new TransactionCapsule(MINIMAL_TX)); + } + + @Test + public void testAccountPermissionUpdate() throws Exception { + String jsonParam = "{" + + "\"owner_address\": \"" + ownerAddr + "\"," + + "\"owner\": {\"type\": 0, \"permission_name\": \"owner\", \"threshold\": 1," + + " \"keys\": [{\"address\": \"" + ownerAddr + "\"," + + " \"weight\": 1}]}," + + "\"actives\": [{\"type\": 2, \"permission_name\": \"active\", \"threshold\": 1," + + " \"operations\": \"7fff1fc0033e0000000000000000000000000000000000000000000000000000\"," + + " \"keys\": [{\"address\": \"" + ownerAddr + "\"," + + " \"weight\": 1}]}]" + + "}"; + MockHttpServletRequest request = postRequest(jsonParam); + + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + verify(wallet).createTransactionCapsule( + argThat(c -> c instanceof AccountContract.AccountPermissionUpdateContract + && addressEquals(((AccountContract.AccountPermissionUpdateContract) c) + .getOwnerAddress(), ownerAddr) + && ((AccountContract.AccountPermissionUpdateContract) c) + .getOwner().getThreshold() == 1 + && ((AccountContract.AccountPermissionUpdateContract) c) + .getActivesCount() == 1), + eq(Protocol.Transaction.Contract.ContractType.AccountPermissionUpdateContract)); + assertTransactionResponse(response); + } +} diff --git a/framework/src/test/java/org/tron/core/services/http/BaseHttpTest.java b/framework/src/test/java/org/tron/core/services/http/BaseHttpTest.java new file mode 100644 index 00000000000..47710a8ca93 --- /dev/null +++ b/framework/src/test/java/org/tron/core/services/http/BaseHttpTest.java @@ -0,0 +1,127 @@ +package org.tron.core.services.http; + +import static java.nio.charset.StandardCharsets.UTF_8; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; + +import com.google.protobuf.ByteString; +import java.lang.reflect.Field; +import javax.servlet.http.HttpServlet; +import org.junit.After; +import org.junit.AfterClass; +import org.junit.Before; +import org.junit.BeforeClass; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.springframework.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; +import org.tron.common.TestConstants; +import org.tron.common.utils.ByteArray; +import org.tron.core.Wallet; +import org.tron.core.config.args.Args; +import org.tron.protos.Protocol.Transaction; + +/** + * Base class for HTTP servlet unit tests. + * + *

Manages {@link Args} lifecycle so that + * {@link org.tron.common.parameter.CommonParameter} + * (e.g. {@code maxMessageSize}) is properly initialised from + * {@code config-test.conf} before any servlet touches it, and + * cleaned up after the test class finishes. + */ +public abstract class BaseHttpTest { + + protected static final Transaction MINIMAL_TX = Transaction.newBuilder() + .setRawData(Transaction.raw.newBuilder().addContract(Transaction.Contract.newBuilder())) + .build(); + + @Mock + protected Wallet wallet; + private AutoCloseable closeable; + + @BeforeClass + public static void initArgs() { + Args.setParam(new String[]{}, TestConstants.TEST_CONF); + } + + @AfterClass + public static void clearArgs() { + Args.clearParam(); + } + + @Before + public void initMocks() throws Exception { + closeable = MockitoAnnotations.openMocks(this); + setUpMocks(); + } + + @After + public void closeMocks() throws Exception { + if (closeable != null) { + closeable.close(); + closeable = null; + } + } + + /** + * Override to configure mocks and inject the wallet into the servlet. + */ + protected abstract void setUpMocks() throws Exception; + + /** + * Injects the wallet mock into the servlet's private {@code wallet} field. + */ + protected void injectWallet(HttpServlet servlet) throws Exception { + Field f = servlet.getClass().getDeclaredField("wallet"); + f.setAccessible(true); + f.set(servlet, wallet); + } + + /** + * Creates a POST request with JSON body. + */ + protected static MockHttpServletRequest postRequest(String json) { + MockHttpServletRequest request = new MockHttpServletRequest(); + request.setMethod("POST"); + request.setContentType("application/json"); + request.setContent(json.getBytes(UTF_8)); + request.setCharacterEncoding(UTF_8.name()); + return request; + } + + /** + * Creates a GET request with optional query parameters (key, value pairs). + */ + protected static MockHttpServletRequest getRequest(String... params) { + MockHttpServletRequest request = new MockHttpServletRequest(); + request.setMethod("GET"); + for (int i = 0; i < params.length - 1; i += 2) { + request.addParameter(params[i], params[i + 1]); + } + return request; + } + + protected static MockHttpServletResponse newResponse() { + return new MockHttpServletResponse(); + } + + /** + * Checks if a protobuf ByteString field matches the expected hex address. + */ + protected static boolean addressEquals(ByteString actual, String expectedHex) { + return ByteArray.toHexString(actual.toByteArray()).equals(expectedHex); + } + + /** + * Asserts that the servlet response represents a valid transaction: + * no error, contains txID and raw_data. + */ + protected static void assertTransactionResponse(MockHttpServletResponse response) + throws Exception { + String content = response.getContentAsString(); + assertFalse("Should not contain error", content.contains("\"Error\"")); + assertTrue("Should contain txID", content.contains("txID")); + assertTrue("Should contain raw_data", content.contains("\"raw_data\"")); + } +} diff --git a/framework/src/test/java/org/tron/core/services/http/CancelAllUnfreezeV2ServletTest.java b/framework/src/test/java/org/tron/core/services/http/CancelAllUnfreezeV2ServletTest.java new file mode 100644 index 00000000000..59a3f02256c --- /dev/null +++ b/framework/src/test/java/org/tron/core/services/http/CancelAllUnfreezeV2ServletTest.java @@ -0,0 +1,47 @@ +package org.tron.core.services.http; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.argThat; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import org.junit.Test; +import org.springframework.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.core.capsule.TransactionCapsule; +import org.tron.protos.Protocol; +import org.tron.protos.contract.BalanceContract; + +public class CancelAllUnfreezeV2ServletTest extends BaseHttpTest { + + private CancelAllUnfreezeV2Servlet servlet; + private final String ownerAddr = ByteArray.toHexString(new ECKey().getAddress()); + + @Override + protected void setUpMocks() throws Exception { + servlet = new CancelAllUnfreezeV2Servlet(); + injectWallet(servlet); + when(wallet.createTransactionCapsule( + any(BalanceContract.CancelAllUnfreezeV2Contract.class), + eq(Protocol.Transaction.Contract.ContractType.CancelAllUnfreezeV2Contract))) + .thenReturn(new TransactionCapsule(MINIMAL_TX)); + } + + @Test + public void testCancelAllUnfreezeV2() throws Exception { + String jsonParam = "{\"owner_address\": \"" + ownerAddr + "\"}"; + MockHttpServletRequest request = postRequest(jsonParam); + + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + verify(wallet).createTransactionCapsule( + argThat(c -> c instanceof BalanceContract.CancelAllUnfreezeV2Contract + && addressEquals(((BalanceContract.CancelAllUnfreezeV2Contract) c) + .getOwnerAddress(), ownerAddr)), + eq(Protocol.Transaction.Contract.ContractType.CancelAllUnfreezeV2Contract)); + assertTransactionResponse(response); + } +} diff --git a/framework/src/test/java/org/tron/core/services/http/ClearABIServletTest.java b/framework/src/test/java/org/tron/core/services/http/ClearABIServletTest.java index 48b538380c2..9d75226aa42 100644 --- a/framework/src/test/java/org/tron/core/services/http/ClearABIServletTest.java +++ b/framework/src/test/java/org/tron/core/services/http/ClearABIServletTest.java @@ -5,14 +5,10 @@ import static org.junit.Assert.fail; import static org.tron.common.utils.client.utils.HttpMethed.createRequest; -import com.alibaba.fastjson.JSONObject; import com.google.protobuf.ByteString; - import java.io.UnsupportedEncodingException; import javax.annotation.Resource; - import org.apache.http.client.methods.HttpPost; - import org.junit.Assert; import org.junit.Test; import org.springframework.mock.web.MockHttpServletRequest; @@ -22,6 +18,7 @@ import org.tron.common.utils.ByteArray; import org.tron.core.capsule.ContractCapsule; import org.tron.core.config.args.Args; +import org.tron.json.JSONObject; import org.tron.protos.contract.SmartContractOuterClass; public class ClearABIServletTest extends BaseTest { diff --git a/framework/src/test/java/org/tron/core/services/http/CreateAccountServletTest.java b/framework/src/test/java/org/tron/core/services/http/CreateAccountServletTest.java index 1c34d7b8a92..c9d6a4f2a63 100644 --- a/framework/src/test/java/org/tron/core/services/http/CreateAccountServletTest.java +++ b/framework/src/test/java/org/tron/core/services/http/CreateAccountServletTest.java @@ -4,12 +4,9 @@ import static org.junit.Assert.fail; import static org.tron.common.utils.client.utils.HttpMethed.createRequest; -import com.alibaba.fastjson.JSONObject; import com.google.protobuf.ByteString; - import java.io.UnsupportedEncodingException; import javax.annotation.Resource; - import org.apache.http.client.methods.HttpPost; import org.junit.Assert; import org.junit.Before; @@ -21,6 +18,7 @@ import org.tron.common.utils.ByteArray; import org.tron.core.capsule.AccountCapsule; import org.tron.core.config.args.Args; +import org.tron.json.JSONObject; import org.tron.protos.Protocol; diff --git a/framework/src/test/java/org/tron/core/services/http/CreateAssetIssueServletTest.java b/framework/src/test/java/org/tron/core/services/http/CreateAssetIssueServletTest.java index 52ada9dd0d0..9a53814ea11 100644 --- a/framework/src/test/java/org/tron/core/services/http/CreateAssetIssueServletTest.java +++ b/framework/src/test/java/org/tron/core/services/http/CreateAssetIssueServletTest.java @@ -4,12 +4,9 @@ import static org.junit.Assert.fail; import static org.tron.common.utils.client.utils.HttpMethed.createRequest; -import com.alibaba.fastjson.JSONObject; import com.google.protobuf.ByteString; - import java.io.UnsupportedEncodingException; import javax.annotation.Resource; - import org.apache.http.client.methods.HttpPost; import org.junit.Assert; import org.junit.Before; @@ -21,6 +18,7 @@ import org.tron.common.utils.ByteArray; import org.tron.core.capsule.AccountCapsule; import org.tron.core.config.args.Args; +import org.tron.json.JSONObject; import org.tron.protos.Protocol; public class CreateAssetIssueServletTest extends BaseTest { diff --git a/framework/src/test/java/org/tron/core/services/http/CreateSpendAuthSigServletTest.java b/framework/src/test/java/org/tron/core/services/http/CreateSpendAuthSigServletTest.java index 85d6764132b..0be8fe632e7 100644 --- a/framework/src/test/java/org/tron/core/services/http/CreateSpendAuthSigServletTest.java +++ b/framework/src/test/java/org/tron/core/services/http/CreateSpendAuthSigServletTest.java @@ -4,7 +4,6 @@ import static org.junit.Assert.fail; import static org.tron.common.utils.client.utils.HttpMethed.createRequest; -import com.alibaba.fastjson.JSONObject; import java.io.UnsupportedEncodingException; import javax.annotation.Resource; import org.apache.http.client.methods.HttpPost; @@ -15,6 +14,7 @@ import org.tron.common.BaseTest; import org.tron.common.TestConstants; import org.tron.core.config.args.Args; +import org.tron.json.JSONObject; public class CreateSpendAuthSigServletTest extends BaseTest { diff --git a/framework/src/test/java/org/tron/core/services/http/CreateWitnessServletTest.java b/framework/src/test/java/org/tron/core/services/http/CreateWitnessServletTest.java index 62908c1563f..bd8145fed7b 100644 --- a/framework/src/test/java/org/tron/core/services/http/CreateWitnessServletTest.java +++ b/framework/src/test/java/org/tron/core/services/http/CreateWitnessServletTest.java @@ -4,12 +4,9 @@ import static org.junit.Assert.fail; import static org.tron.common.utils.client.utils.HttpMethed.createRequest; -import com.alibaba.fastjson.JSONObject; import com.google.protobuf.ByteString; - import java.io.UnsupportedEncodingException; import javax.annotation.Resource; - import org.apache.http.client.methods.HttpPost; import org.junit.Assert; import org.junit.Before; @@ -24,6 +21,7 @@ import org.tron.core.capsule.AccountCapsule; import org.tron.core.capsule.WitnessCapsule; import org.tron.core.config.args.Args; +import org.tron.json.JSONObject; import org.tron.protos.Protocol; public class CreateWitnessServletTest extends BaseTest { diff --git a/framework/src/test/java/org/tron/core/services/http/DelegateResourceServletTest.java b/framework/src/test/java/org/tron/core/services/http/DelegateResourceServletTest.java new file mode 100644 index 00000000000..07ca6750e31 --- /dev/null +++ b/framework/src/test/java/org/tron/core/services/http/DelegateResourceServletTest.java @@ -0,0 +1,59 @@ +package org.tron.core.services.http; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.argThat; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import org.junit.Test; +import org.springframework.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.core.capsule.TransactionCapsule; +import org.tron.protos.Protocol; +import org.tron.protos.contract.BalanceContract; +import org.tron.protos.contract.Common.ResourceCode; + +public class DelegateResourceServletTest extends BaseHttpTest { + + private DelegateResourceServlet servlet; + private final String ownerAddr = ByteArray.toHexString(new ECKey().getAddress()); + private final String receiverAddr = ByteArray.toHexString(new ECKey().getAddress()); + + @Override + protected void setUpMocks() throws Exception { + servlet = new DelegateResourceServlet(); + injectWallet(servlet); + when(wallet.createTransactionCapsule( + any(BalanceContract.DelegateResourceContract.class), + eq(Protocol.Transaction.Contract.ContractType.DelegateResourceContract))) + .thenReturn(new TransactionCapsule(MINIMAL_TX)); + } + + @Test + public void testDelegateResource() throws Exception { + String jsonParam = "{" + + "\"owner_address\": \"" + ownerAddr + "\"," + + "\"receiver_address\": \"" + receiverAddr + "\"," + + "\"balance\": 1000000," + + "\"resource\": \"ENERGY\"" + + "}"; + MockHttpServletRequest request = postRequest(jsonParam); + + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + verify(wallet).createTransactionCapsule( + argThat(c -> c instanceof BalanceContract.DelegateResourceContract + && addressEquals(((BalanceContract.DelegateResourceContract) c) + .getOwnerAddress(), ownerAddr) + && addressEquals(((BalanceContract.DelegateResourceContract) c) + .getReceiverAddress(), receiverAddr) + && ((BalanceContract.DelegateResourceContract) c).getBalance() == 1000000 + && ((BalanceContract.DelegateResourceContract) c) + .getResource() == ResourceCode.ENERGY), + eq(Protocol.Transaction.Contract.ContractType.DelegateResourceContract)); + assertTransactionResponse(response); + } +} diff --git a/framework/src/test/java/org/tron/core/services/http/DeployContractServletTest.java b/framework/src/test/java/org/tron/core/services/http/DeployContractServletTest.java new file mode 100644 index 00000000000..83fb64880c3 --- /dev/null +++ b/framework/src/test/java/org/tron/core/services/http/DeployContractServletTest.java @@ -0,0 +1,58 @@ +package org.tron.core.services.http; + +import static org.junit.Assert.assertEquals; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.argThat; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import org.junit.Test; +import org.springframework.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; +import org.tron.core.capsule.TransactionCapsule; +import org.tron.protos.Protocol; +import org.tron.protos.contract.SmartContractOuterClass.CreateSmartContract; + +public class DeployContractServletTest extends BaseHttpTest { + + private DeployContractServlet servlet; + + @Override + protected void setUpMocks() throws Exception { + servlet = new DeployContractServlet(); + injectWallet(servlet); + when(wallet.createTransactionCapsule( + any(), eq(Protocol.Transaction.Contract.ContractType.CreateSmartContract))) + .thenReturn(new TransactionCapsule(MINIMAL_TX)); + } + + @Test + public void testDeployContract() throws Exception { + String jsonParam = "{" + + "\"owner_address\": \"4199357684BC659F5166046B56C95A0E99F1265CD1\"," + + "\"name\": \"TestContract\"," + + "\"abi\": \"[{\\\"inputs\\\":[],\\\"name\\\":\\\"test\\\"," + + "\\\"outputs\\\":[],\\\"type\\\":\\\"function\\\"}]\"," + + "\"bytecode\": \"608060405234801561001057600080fd5b50\"," + + "\"fee_limit\": 1000000000," + + "\"call_value\": 0," + + "\"consume_user_resource_percent\": 100," + + "\"origin_energy_limit\": 10000000" + + "}"; + MockHttpServletRequest request = postRequest(jsonParam); + + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + assertEquals(200, response.getStatus()); + verify(wallet).createTransactionCapsule( + argThat(c -> c instanceof CreateSmartContract + && addressEquals(((CreateSmartContract) c).getOwnerAddress(), + "4199357684bc659f5166046b56c95a0e99f1265cd1") + && ((CreateSmartContract) c).getNewContract().getName().equals("TestContract") + && ((CreateSmartContract) c).getNewContract() + .getOriginEnergyLimit() == 10000000), + eq(Protocol.Transaction.Contract.ContractType.CreateSmartContract)); + assertTransactionResponse(response); + } +} diff --git a/framework/src/test/java/org/tron/core/services/http/ExchangeCreateServletTest.java b/framework/src/test/java/org/tron/core/services/http/ExchangeCreateServletTest.java new file mode 100644 index 00000000000..11840a895bd --- /dev/null +++ b/framework/src/test/java/org/tron/core/services/http/ExchangeCreateServletTest.java @@ -0,0 +1,58 @@ +package org.tron.core.services.http; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.argThat; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import org.junit.Test; +import org.springframework.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.core.capsule.TransactionCapsule; +import org.tron.protos.Protocol.Transaction.Contract.ContractType; +import org.tron.protos.contract.ExchangeContract.ExchangeCreateContract; + +public class ExchangeCreateServletTest extends BaseHttpTest { + + private ExchangeCreateServlet servlet; + private final String ownerAddr = ByteArray.toHexString(new ECKey().getAddress()); + + @Override + protected void setUpMocks() throws Exception { + servlet = new ExchangeCreateServlet(); + injectWallet(servlet); + when(wallet.createTransactionCapsule( + any(ExchangeCreateContract.class), eq(ContractType.ExchangeCreateContract))) + .thenReturn(new TransactionCapsule(MINIMAL_TX)); + } + + @Test + public void testExchangeCreate() throws Exception { + String jsonParam = "{" + + "\"owner_address\": \"" + ownerAddr + "\"," + + "\"first_token_id\": \"5f\"," + + "\"first_token_balance\": 100," + + "\"second_token_id\": \"61\"," + + "\"second_token_balance\": 200" + + "}"; + MockHttpServletRequest request = postRequest(jsonParam); + + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + verify(wallet).createTransactionCapsule( + argThat(c -> c instanceof ExchangeCreateContract + && addressEquals(((ExchangeCreateContract) c) + .getOwnerAddress(), ownerAddr) + && ((ExchangeCreateContract) c).getFirstTokenBalance() == 100 + && ((ExchangeCreateContract) c).getSecondTokenBalance() == 200 + && ((ExchangeCreateContract) c) + .getFirstTokenId().toStringUtf8().equals("_") + && ((ExchangeCreateContract) c) + .getSecondTokenId().toStringUtf8().equals("a")), + eq(ContractType.ExchangeCreateContract)); + assertTransactionResponse(response); + } +} diff --git a/framework/src/test/java/org/tron/core/services/http/ExchangeInjectServletTest.java b/framework/src/test/java/org/tron/core/services/http/ExchangeInjectServletTest.java new file mode 100644 index 00000000000..f2f661732d2 --- /dev/null +++ b/framework/src/test/java/org/tron/core/services/http/ExchangeInjectServletTest.java @@ -0,0 +1,56 @@ +package org.tron.core.services.http; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.argThat; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import org.junit.Test; +import org.springframework.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.core.capsule.TransactionCapsule; +import org.tron.protos.Protocol; +import org.tron.protos.contract.ExchangeContract; + +public class ExchangeInjectServletTest extends BaseHttpTest { + + private ExchangeInjectServlet servlet; + private final String ownerAddr = ByteArray.toHexString(new ECKey().getAddress()); + + @Override + protected void setUpMocks() throws Exception { + servlet = new ExchangeInjectServlet(); + injectWallet(servlet); + when(wallet.createTransactionCapsule( + any(ExchangeContract.ExchangeInjectContract.class), + eq(Protocol.Transaction.Contract.ContractType.ExchangeInjectContract))) + .thenReturn(new TransactionCapsule(MINIMAL_TX)); + } + + @Test + public void testExchangeInject() throws Exception { + String jsonParam = "{" + + "\"owner_address\": \"" + ownerAddr + "\"," + + "\"exchange_id\": 1," + + "\"token_id\": \"5f\"," + + "\"quant\": 100" + + "}"; + MockHttpServletRequest request = postRequest(jsonParam); + + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + verify(wallet).createTransactionCapsule( + argThat(c -> c instanceof ExchangeContract.ExchangeInjectContract + && addressEquals(((ExchangeContract.ExchangeInjectContract) c) + .getOwnerAddress(), ownerAddr) + && ((ExchangeContract.ExchangeInjectContract) c).getExchangeId() == 1 + && ((ExchangeContract.ExchangeInjectContract) c).getQuant() == 100 + && ((ExchangeContract.ExchangeInjectContract) c) + .getTokenId().toStringUtf8().equals("_")), + eq(Protocol.Transaction.Contract.ContractType.ExchangeInjectContract)); + assertTransactionResponse(response); + } +} diff --git a/framework/src/test/java/org/tron/core/services/http/ExchangeTransactionServletTest.java b/framework/src/test/java/org/tron/core/services/http/ExchangeTransactionServletTest.java new file mode 100644 index 00000000000..6e986288b3c --- /dev/null +++ b/framework/src/test/java/org/tron/core/services/http/ExchangeTransactionServletTest.java @@ -0,0 +1,58 @@ +package org.tron.core.services.http; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.argThat; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import org.junit.Test; +import org.springframework.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.core.capsule.TransactionCapsule; +import org.tron.protos.Protocol; +import org.tron.protos.contract.ExchangeContract; + +public class ExchangeTransactionServletTest extends BaseHttpTest { + + private ExchangeTransactionServlet servlet; + private final String ownerAddr = ByteArray.toHexString(new ECKey().getAddress()); + + @Override + protected void setUpMocks() throws Exception { + servlet = new ExchangeTransactionServlet(); + injectWallet(servlet); + when(wallet.createTransactionCapsule( + any(ExchangeContract.ExchangeTransactionContract.class), + eq(Protocol.Transaction.Contract.ContractType.ExchangeTransactionContract))) + .thenReturn(new TransactionCapsule(MINIMAL_TX)); + } + + @Test + public void testExchangeTransaction() throws Exception { + String jsonParam = "{" + + "\"owner_address\": \"" + ownerAddr + "\"," + + "\"exchange_id\": 1," + + "\"token_id\": \"5f\"," + + "\"quant\": 100," + + "\"expected\": 10" + + "}"; + MockHttpServletRequest request = postRequest(jsonParam); + + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + verify(wallet).createTransactionCapsule( + argThat(c -> c instanceof ExchangeContract.ExchangeTransactionContract + && addressEquals(((ExchangeContract.ExchangeTransactionContract) c) + .getOwnerAddress(), ownerAddr) + && ((ExchangeContract.ExchangeTransactionContract) c).getExchangeId() == 1 + && ((ExchangeContract.ExchangeTransactionContract) c).getQuant() == 100 + && ((ExchangeContract.ExchangeTransactionContract) c).getExpected() == 10 + && ((ExchangeContract.ExchangeTransactionContract) c) + .getTokenId().toStringUtf8().equals("_")), + eq(Protocol.Transaction.Contract.ContractType.ExchangeTransactionContract)); + assertTransactionResponse(response); + } +} diff --git a/framework/src/test/java/org/tron/core/services/http/ExchangeWithdrawServletTest.java b/framework/src/test/java/org/tron/core/services/http/ExchangeWithdrawServletTest.java new file mode 100644 index 00000000000..b1147b819dd --- /dev/null +++ b/framework/src/test/java/org/tron/core/services/http/ExchangeWithdrawServletTest.java @@ -0,0 +1,56 @@ +package org.tron.core.services.http; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.argThat; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import org.junit.Test; +import org.springframework.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.core.capsule.TransactionCapsule; +import org.tron.protos.Protocol; +import org.tron.protos.contract.ExchangeContract; + +public class ExchangeWithdrawServletTest extends BaseHttpTest { + + private ExchangeWithdrawServlet servlet; + private final String ownerAddr = ByteArray.toHexString(new ECKey().getAddress()); + + @Override + protected void setUpMocks() throws Exception { + servlet = new ExchangeWithdrawServlet(); + injectWallet(servlet); + when(wallet.createTransactionCapsule( + any(ExchangeContract.ExchangeWithdrawContract.class), + eq(Protocol.Transaction.Contract.ContractType.ExchangeWithdrawContract))) + .thenReturn(new TransactionCapsule(MINIMAL_TX)); + } + + @Test + public void testExchangeWithdraw() throws Exception { + String jsonParam = "{" + + "\"owner_address\": \"" + ownerAddr + "\"," + + "\"exchange_id\": 1," + + "\"token_id\": \"5f\"," + + "\"quant\": 50" + + "}"; + MockHttpServletRequest request = postRequest(jsonParam); + + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + verify(wallet).createTransactionCapsule( + argThat(c -> c instanceof ExchangeContract.ExchangeWithdrawContract + && addressEquals(((ExchangeContract.ExchangeWithdrawContract) c) + .getOwnerAddress(), ownerAddr) + && ((ExchangeContract.ExchangeWithdrawContract) c).getExchangeId() == 1 + && ((ExchangeContract.ExchangeWithdrawContract) c).getQuant() == 50 + && ((ExchangeContract.ExchangeWithdrawContract) c) + .getTokenId().toStringUtf8().equals("_")), + eq(Protocol.Transaction.Contract.ContractType.ExchangeWithdrawContract)); + assertTransactionResponse(response); + } +} diff --git a/framework/src/test/java/org/tron/core/services/http/FreezeBalanceServletTest.java b/framework/src/test/java/org/tron/core/services/http/FreezeBalanceServletTest.java new file mode 100644 index 00000000000..9d56381f9a8 --- /dev/null +++ b/framework/src/test/java/org/tron/core/services/http/FreezeBalanceServletTest.java @@ -0,0 +1,53 @@ +package org.tron.core.services.http; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.argThat; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import org.junit.Test; +import org.springframework.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.core.capsule.TransactionCapsule; +import org.tron.protos.Protocol; +import org.tron.protos.contract.BalanceContract; + +public class FreezeBalanceServletTest extends BaseHttpTest { + + private FreezeBalanceServlet servlet; + private final String ownerAddr = ByteArray.toHexString(new ECKey().getAddress()); + + @Override + protected void setUpMocks() throws Exception { + servlet = new FreezeBalanceServlet(); + injectWallet(servlet); + when(wallet.createTransactionCapsule( + any(BalanceContract.FreezeBalanceContract.class), + eq(Protocol.Transaction.Contract.ContractType.FreezeBalanceContract))) + .thenReturn(new TransactionCapsule(MINIMAL_TX)); + } + + @Test + public void testFreezeBalance() throws Exception { + String jsonParam = "{" + + "\"owner_address\": \"" + ownerAddr + "\"," + + "\"frozen_balance\": 1000000," + + "\"frozen_duration\": 3" + + "}"; + MockHttpServletRequest request = postRequest(jsonParam); + + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + verify(wallet).createTransactionCapsule( + argThat(c -> c instanceof BalanceContract.FreezeBalanceContract + && addressEquals(((BalanceContract.FreezeBalanceContract) c) + .getOwnerAddress(), ownerAddr) + && ((BalanceContract.FreezeBalanceContract) c).getFrozenBalance() == 1000000 + && ((BalanceContract.FreezeBalanceContract) c).getFrozenDuration() == 3), + eq(Protocol.Transaction.Contract.ContractType.FreezeBalanceContract)); + assertTransactionResponse(response); + } +} diff --git a/framework/src/test/java/org/tron/core/services/http/FreezeBalanceV2ServletTest.java b/framework/src/test/java/org/tron/core/services/http/FreezeBalanceV2ServletTest.java new file mode 100644 index 00000000000..414054501e6 --- /dev/null +++ b/framework/src/test/java/org/tron/core/services/http/FreezeBalanceV2ServletTest.java @@ -0,0 +1,55 @@ +package org.tron.core.services.http; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.argThat; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import org.junit.Test; +import org.springframework.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.core.capsule.TransactionCapsule; +import org.tron.protos.Protocol; +import org.tron.protos.contract.BalanceContract; +import org.tron.protos.contract.Common.ResourceCode; + +public class FreezeBalanceV2ServletTest extends BaseHttpTest { + + private FreezeBalanceV2Servlet servlet; + private final String ownerAddr = ByteArray.toHexString(new ECKey().getAddress()); + + @Override + protected void setUpMocks() throws Exception { + servlet = new FreezeBalanceV2Servlet(); + injectWallet(servlet); + when(wallet.createTransactionCapsule( + any(BalanceContract.FreezeBalanceV2Contract.class), + eq(Protocol.Transaction.Contract.ContractType.FreezeBalanceV2Contract))) + .thenReturn(new TransactionCapsule(MINIMAL_TX)); + } + + @Test + public void testFreezeBalanceV2() throws Exception { + String jsonParam = "{" + + "\"owner_address\": \"" + ownerAddr + "\"," + + "\"frozen_balance\": 1000000," + + "\"resource\": \"ENERGY\"" + + "}"; + MockHttpServletRequest request = postRequest(jsonParam); + + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + verify(wallet).createTransactionCapsule( + argThat(c -> c instanceof BalanceContract.FreezeBalanceV2Contract + && addressEquals(((BalanceContract.FreezeBalanceV2Contract) c) + .getOwnerAddress(), ownerAddr) + && ((BalanceContract.FreezeBalanceV2Contract) c).getFrozenBalance() == 1000000 + && ((BalanceContract.FreezeBalanceV2Contract) c) + .getResource() == ResourceCode.ENERGY), + eq(Protocol.Transaction.Contract.ContractType.FreezeBalanceV2Contract)); + assertTransactionResponse(response); + } +} diff --git a/framework/src/test/java/org/tron/core/services/http/GetAccountResourceServletTest.java b/framework/src/test/java/org/tron/core/services/http/GetAccountResourceServletTest.java new file mode 100644 index 00000000000..cc5ed97b94b --- /dev/null +++ b/framework/src/test/java/org/tron/core/services/http/GetAccountResourceServletTest.java @@ -0,0 +1,55 @@ +package org.tron.core.services.http; + +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import com.google.protobuf.ByteString; +import org.junit.Test; +import org.springframework.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; +import org.tron.api.GrpcAPI.AccountResourceMessage; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; + +public class GetAccountResourceServletTest extends BaseHttpTest { + + private GetAccountResourceServlet servlet; + private final String addrStr = ByteArray.toHexString(new ECKey().getAddress()); + + @Override + protected void setUpMocks() throws Exception { + servlet = new GetAccountResourceServlet(); + injectWallet(servlet); + when(wallet.getAccountResource(any())) + .thenReturn(AccountResourceMessage.newBuilder().setFreeNetUsed(1L).build()); + } + + @Test + public void testGetAccountResourcePost() throws Exception { + String jsonParam = "{\"address\": \"" + addrStr + "\"}"; + MockHttpServletRequest request = postRequest(jsonParam); + + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + verify(wallet).getAccountResource(eq(ByteString.copyFrom(ByteArray.fromHexString(addrStr)))); + String content = response.getContentAsString(); + assertFalse("Should not contain error", content.contains("\"Error\"")); + assertTrue("Should contain freeNetUsed", content.contains("freeNetUsed")); + } + + @Test + public void testGetAccountResourceGet() throws Exception { + MockHttpServletRequest request = getRequest("address", addrStr); + + MockHttpServletResponse response = newResponse(); + servlet.doGet(request, response); + verify(wallet).getAccountResource(eq(ByteString.copyFrom(ByteArray.fromHexString(addrStr)))); + String content = response.getContentAsString(); + assertFalse("Should not contain error", content.contains("\"Error\"")); + assertTrue("Should contain freeNetUsed", content.contains("freeNetUsed")); + } +} diff --git a/framework/src/test/java/org/tron/core/services/http/GetAccountServletTest.java b/framework/src/test/java/org/tron/core/services/http/GetAccountServletTest.java new file mode 100644 index 00000000000..466917d0cd5 --- /dev/null +++ b/framework/src/test/java/org/tron/core/services/http/GetAccountServletTest.java @@ -0,0 +1,60 @@ +package org.tron.core.services.http; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.argThat; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import com.google.protobuf.ByteString; +import org.junit.Test; +import org.springframework.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.protos.Protocol.Account; + +public class GetAccountServletTest extends BaseHttpTest { + + private GetAccountServlet servlet; + private final byte[] address = new ECKey().getAddress(); + private final String addrStr = ByteArray.toHexString(address); + private final ByteString addr = ByteString.copyFrom(address); + + @Override + protected void setUpMocks() throws Exception { + servlet = new GetAccountServlet(); + injectWallet(servlet); + when(wallet.getAccount(any(Account.class))).thenReturn( + Account.newBuilder().setAddress(addr).build()); + } + + @Test + public void testGetAccountPost() throws Exception { + String jsonParam = "{\"address\": \"" + addrStr + "\"}"; + MockHttpServletRequest request = postRequest(jsonParam); + + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + assertEquals(200, response.getStatus()); + verify(wallet).getAccount(argThat(req -> req != null && req.getAddress().equals(addr))); + String content = response.getContentAsString(); + assertFalse("Should not contain error", content.contains("\"Error\"")); + assertTrue("Should contain address", content.contains("address")); + } + + @Test + public void testGetAccountGet() throws Exception { + MockHttpServletRequest request = getRequest("address", addrStr); + + MockHttpServletResponse response = newResponse(); + servlet.doGet(request, response); + assertEquals(200, response.getStatus()); + verify(wallet).getAccount(argThat(req -> req != null && req.getAddress().equals(addr))); + String content = response.getContentAsString(); + assertFalse("Should not contain error", content.contains("\"Error\"")); + assertTrue("Should contain address", content.contains("address")); + } +} diff --git a/framework/src/test/java/org/tron/core/services/http/GetAssetIssueByIdServletTest.java b/framework/src/test/java/org/tron/core/services/http/GetAssetIssueByIdServletTest.java new file mode 100644 index 00000000000..b87331d6d61 --- /dev/null +++ b/framework/src/test/java/org/tron/core/services/http/GetAssetIssueByIdServletTest.java @@ -0,0 +1,70 @@ +package org.tron.core.services.http; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import org.junit.Test; +import org.springframework.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; +import org.tron.protos.contract.AssetIssueContractOuterClass.AssetIssueContract; + +public class GetAssetIssueByIdServletTest extends BaseHttpTest { + + private GetAssetIssueByIdServlet servlet; + + @Override + protected void setUpMocks() throws Exception { + servlet = new GetAssetIssueByIdServlet(); + injectWallet(servlet); + when(wallet.getAssetIssueById(any())).thenReturn(null); + } + + @Test + public void testGetAssetIssueByIdPost() throws Exception { + String jsonParam = "{\"value\": \"100001\"}"; + MockHttpServletRequest request = postRequest(jsonParam); + + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + verify(wallet).getAssetIssueById(eq("100001")); + assertEquals(200, response.getStatus()); + String content = response.getContentAsString(); + assertFalse("Should not contain error", content.contains("\"Error\"")); + assertEquals("{}" + System.lineSeparator(), content); + } + + @Test + public void testGetAssetIssueByIdGet() throws Exception { + MockHttpServletRequest request = getRequest("value", "100001"); + + MockHttpServletResponse response = newResponse(); + servlet.doGet(request, response); + verify(wallet).getAssetIssueById(eq("100001")); + assertEquals(200, response.getStatus()); + String content = response.getContentAsString(); + assertFalse("Should not contain error", content.contains("\"Error\"")); + assertEquals("{}" + System.lineSeparator(), content); + } + + @Test + public void testPostReturnsAssetWhenFound() throws Exception { + AssetIssueContract asset = AssetIssueContract.newBuilder() + .setId("100001") + .setTotalSupply(1000L) + .build(); + when(wallet.getAssetIssueById(eq("100001"))).thenReturn(asset); + + MockHttpServletRequest request = postRequest("{\"value\": \"100001\"}"); + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + assertEquals(200, response.getStatus()); + String content = response.getContentAsString(); + assertTrue("Should contain id", content.contains("100001")); + assertTrue("Should contain total_supply", content.contains("total_supply")); + } +} diff --git a/framework/src/test/java/org/tron/core/services/http/GetAssetIssueByNameServletTest.java b/framework/src/test/java/org/tron/core/services/http/GetAssetIssueByNameServletTest.java new file mode 100644 index 00000000000..ccfa3af2e56 --- /dev/null +++ b/framework/src/test/java/org/tron/core/services/http/GetAssetIssueByNameServletTest.java @@ -0,0 +1,71 @@ +package org.tron.core.services.http; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import com.google.protobuf.ByteString; +import org.junit.Test; +import org.springframework.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; +import org.tron.common.utils.ByteArray; +import org.tron.protos.contract.AssetIssueContractOuterClass.AssetIssueContract; + +public class GetAssetIssueByNameServletTest extends BaseHttpTest { + + private GetAssetIssueByNameServlet servlet; + private final ByteString data = + ByteString.copyFrom(ByteArray.fromHexString("74657374")); + + @Override + protected void setUpMocks() throws Exception { + servlet = new GetAssetIssueByNameServlet(); + injectWallet(servlet); + when(wallet.getAssetIssueByName(any())).thenReturn(null); + } + + @Test + public void testPost() throws Exception { + String jsonParam = "{\"value\": \"74657374\"}"; + MockHttpServletRequest request = postRequest(jsonParam); + + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + verify(wallet).getAssetIssueByName(eq(data)); + String content = response.getContentAsString(); + assertFalse("Should not contain error", content.contains("\"Error\"")); + assertEquals("{}" + System.lineSeparator(), content); + } + + @Test + public void testGet() throws Exception { + MockHttpServletRequest request = getRequest("value", "74657374"); + + MockHttpServletResponse response = newResponse(); + servlet.doGet(request, response); + verify(wallet).getAssetIssueByName(eq(data)); + String content = response.getContentAsString(); + assertFalse("Should not contain error", content.contains("\"Error\"")); + assertEquals("{}" + System.lineSeparator(), content); + } + + @Test + public void testPostReturnsAssetWhenFound() throws Exception { + AssetIssueContract asset = AssetIssueContract.newBuilder() + .setName(data) + .setTotalSupply(5000L) + .build(); + when(wallet.getAssetIssueByName(eq(data))).thenReturn(asset); + + MockHttpServletRequest request = postRequest("{\"value\": \"74657374\"}"); + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + assertEquals(200, response.getStatus()); + String content = response.getContentAsString(); + assertTrue("Should contain total_supply", content.contains("total_supply")); + } +} diff --git a/framework/src/test/java/org/tron/core/services/http/GetAssetIssueListByNameServletTest.java b/framework/src/test/java/org/tron/core/services/http/GetAssetIssueListByNameServletTest.java new file mode 100644 index 00000000000..e3055e21f99 --- /dev/null +++ b/framework/src/test/java/org/tron/core/services/http/GetAssetIssueListByNameServletTest.java @@ -0,0 +1,47 @@ +package org.tron.core.services.http; + +import static org.junit.Assert.assertEquals; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import com.google.protobuf.ByteString; +import org.junit.Test; +import org.springframework.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; +import org.tron.common.utils.ByteArray; + +public class GetAssetIssueListByNameServletTest extends BaseHttpTest { + + private GetAssetIssueListByNameServlet servlet; + private final ByteString data = ByteString.copyFrom(ByteArray.fromHexString("74657374")); + + @Override + protected void setUpMocks() throws Exception { + servlet = new GetAssetIssueListByNameServlet(); + injectWallet(servlet); + when(wallet.getAssetIssueListByName(any())).thenReturn(null); + } + + @Test + public void testPost() throws Exception { + String jsonParam = "{\"value\": \"74657374\"}"; + MockHttpServletRequest request = postRequest(jsonParam); + + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + verify(wallet).getAssetIssueListByName(eq(data)); + assertEquals("{}" + System.lineSeparator(), response.getContentAsString()); + } + + @Test + public void testGet() throws Exception { + MockHttpServletRequest request = getRequest("value", "74657374"); + + MockHttpServletResponse response = newResponse(); + servlet.doGet(request, response); + verify(wallet).getAssetIssueListByName(eq(data)); + assertEquals("{}" + System.lineSeparator(), response.getContentAsString()); + } +} diff --git a/framework/src/test/java/org/tron/core/services/http/GetAssetIssueListServletTest.java b/framework/src/test/java/org/tron/core/services/http/GetAssetIssueListServletTest.java index 935a3d1416d..2b9e997cf80 100644 --- a/framework/src/test/java/org/tron/core/services/http/GetAssetIssueListServletTest.java +++ b/framework/src/test/java/org/tron/core/services/http/GetAssetIssueListServletTest.java @@ -3,7 +3,6 @@ import static java.nio.charset.StandardCharsets.UTF_8; import static org.junit.Assert.fail; -import com.alibaba.fastjson.JSONObject; import java.io.UnsupportedEncodingException; import javax.annotation.Resource; import org.junit.Test; @@ -12,6 +11,7 @@ import org.tron.common.BaseTest; import org.tron.common.TestConstants; import org.tron.core.config.args.Args; +import org.tron.json.JSONObject; public class GetAssetIssueListServletTest extends BaseTest { diff --git a/framework/src/test/java/org/tron/core/services/http/GetBandwidthPricesServletTest.java b/framework/src/test/java/org/tron/core/services/http/GetBandwidthPricesServletTest.java index e4837610e23..2ddfda17bef 100644 --- a/framework/src/test/java/org/tron/core/services/http/GetBandwidthPricesServletTest.java +++ b/framework/src/test/java/org/tron/core/services/http/GetBandwidthPricesServletTest.java @@ -4,7 +4,6 @@ import static org.junit.Assert.fail; import static org.tron.common.utils.client.utils.HttpMethed.createRequest; -import com.alibaba.fastjson.JSONObject; import java.io.UnsupportedEncodingException; import javax.annotation.Resource; import org.apache.http.client.methods.HttpGet; @@ -16,6 +15,7 @@ import org.tron.common.BaseTest; import org.tron.common.TestConstants; import org.tron.core.config.args.Args; +import org.tron.json.JSONObject; public class GetBandwidthPricesServletTest extends BaseTest { diff --git a/framework/src/test/java/org/tron/core/services/http/GetBlockByNumServletTest.java b/framework/src/test/java/org/tron/core/services/http/GetBlockByNumServletTest.java index d4d6f33cf17..b28e1d33308 100644 --- a/framework/src/test/java/org/tron/core/services/http/GetBlockByNumServletTest.java +++ b/framework/src/test/java/org/tron/core/services/http/GetBlockByNumServletTest.java @@ -3,11 +3,8 @@ import static org.junit.Assert.assertTrue; import static org.tron.common.utils.client.utils.HttpMethed.createRequest; -import com.alibaba.fastjson.JSONObject; - import java.io.UnsupportedEncodingException; import javax.annotation.Resource; - import org.apache.http.client.methods.HttpPost; import org.junit.Test; import org.springframework.mock.web.MockHttpServletRequest; @@ -15,6 +12,7 @@ import org.tron.common.BaseTest; import org.tron.common.TestConstants; import org.tron.core.config.args.Args; +import org.tron.json.JSONObject; public class GetBlockByNumServletTest extends BaseTest { diff --git a/framework/src/test/java/org/tron/core/services/http/GetBlockServletTest.java b/framework/src/test/java/org/tron/core/services/http/GetBlockServletTest.java new file mode 100644 index 00000000000..f48f9eb0fbc --- /dev/null +++ b/framework/src/test/java/org/tron/core/services/http/GetBlockServletTest.java @@ -0,0 +1,45 @@ +package org.tron.core.services.http; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import static org.mockito.Mockito.when; + +import org.junit.Test; +import org.springframework.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; +import org.tron.protos.Protocol.Block; + +public class GetBlockServletTest extends BaseHttpTest { + + private GetBlockServlet servlet; + + @Override + protected void setUpMocks() throws Exception { + servlet = new GetBlockServlet(); + injectWallet(servlet); + when(wallet.getBlock(org.mockito.ArgumentMatchers.argThat( + req -> req != null && "0".equals(req.getIdOrNum()) && !req.getDetail()))) + .thenReturn(Block.getDefaultInstance()); + } + + @Test + public void testGetBlockPost() throws Exception { + String jsonParam = "{\"id_or_num\": \"0\", \"detail\": false}"; + MockHttpServletRequest request = postRequest(jsonParam); + + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + assertEquals(200, response.getStatus()); + assertTrue(response.getContentAsString().contains("blockID")); + } + + @Test + public void testGetBlockGet() throws Exception { + MockHttpServletRequest request = getRequest("id_or_num", "0", "detail", "false"); + + MockHttpServletResponse response = newResponse(); + servlet.doGet(request, response); + assertEquals(200, response.getStatus()); + assertTrue(response.getContentAsString().contains("blockID")); + } +} diff --git a/framework/src/test/java/org/tron/core/services/http/GetBrokerageServletTest.java b/framework/src/test/java/org/tron/core/services/http/GetBrokerageServletTest.java index b5fa1914541..9b37c2e4205 100644 --- a/framework/src/test/java/org/tron/core/services/http/GetBrokerageServletTest.java +++ b/framework/src/test/java/org/tron/core/services/http/GetBrokerageServletTest.java @@ -1,10 +1,7 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; - import java.io.UnsupportedEncodingException; import javax.annotation.Resource; - import org.junit.Assert; import org.junit.Test; import org.springframework.mock.web.MockHttpServletRequest; @@ -12,6 +9,7 @@ import org.tron.common.BaseTest; import org.tron.common.TestConstants; import org.tron.core.config.args.Args; +import org.tron.json.JSONObject; public class GetBrokerageServletTest extends BaseTest { diff --git a/framework/src/test/java/org/tron/core/services/http/GetContractInfoServletTest.java b/framework/src/test/java/org/tron/core/services/http/GetContractInfoServletTest.java new file mode 100644 index 00000000000..532bb42706f --- /dev/null +++ b/framework/src/test/java/org/tron/core/services/http/GetContractInfoServletTest.java @@ -0,0 +1,60 @@ +package org.tron.core.services.http; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import com.google.protobuf.ByteString; +import org.junit.Test; +import org.springframework.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; +import org.tron.api.GrpcAPI; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.protos.contract.SmartContractOuterClass.SmartContract; +import org.tron.protos.contract.SmartContractOuterClass.SmartContractDataWrapper; + +public class GetContractInfoServletTest extends BaseHttpTest { + + private GetContractInfoServlet servlet; + private final byte[] address = new ECKey().getAddress(); + private final String addrStr = ByteArray.toHexString(address); + private final GrpcAPI.BytesMessage expectedRequest = GrpcAPI.BytesMessage.newBuilder() + .setValue(ByteString.copyFrom(address)) + .build(); + + @Override + protected void setUpMocks() throws Exception { + servlet = new GetContractInfoServlet(); + injectWallet(servlet); + } + + @Test + public void testGetContractInfoPost() throws Exception { + when(wallet.getContractInfo(eq(expectedRequest))).thenReturn( + SmartContractDataWrapper.newBuilder() + .setSmartContract(SmartContract.newBuilder().setName("TestContract").build()) + .build()); + String jsonParam = "{\"value\": \"" + addrStr + "\"}"; + MockHttpServletRequest request = postRequest(jsonParam); + + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + assertEquals(200, response.getStatus()); + assertTrue(response.getContentAsString().contains("TestContract")); + } + + @Test + public void testGetContractInfoGet() throws Exception { + when(wallet.getContractInfo(eq(expectedRequest))).thenReturn(null); + MockHttpServletRequest request = getRequest("value", addrStr); + + MockHttpServletResponse response = newResponse(); + servlet.doGet(request, response); + verify(wallet).getContractInfo(eq(expectedRequest)); + assertEquals(200, response.getStatus()); + assertEquals("{}", response.getContentAsString().trim()); + } +} diff --git a/framework/src/test/java/org/tron/core/services/http/GetContractServletTest.java b/framework/src/test/java/org/tron/core/services/http/GetContractServletTest.java new file mode 100644 index 00000000000..074093de2a1 --- /dev/null +++ b/framework/src/test/java/org/tron/core/services/http/GetContractServletTest.java @@ -0,0 +1,71 @@ +package org.tron.core.services.http; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import com.google.protobuf.ByteString; +import org.junit.Test; +import org.springframework.mock.web.MockHttpServletResponse; +import org.tron.api.GrpcAPI; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.protos.contract.SmartContractOuterClass.SmartContract; + +public class GetContractServletTest extends BaseHttpTest { + + private final byte[] address = new ECKey().getAddress(); + private final String addrStr = ByteArray.toHexString(address); + private final GrpcAPI.BytesMessage expectedRequest = GrpcAPI.BytesMessage.newBuilder() + .setValue(ByteString.copyFrom(address)) + .build(); + + private GetContractServlet servlet; + + @Override + protected void setUpMocks() throws Exception { + servlet = new GetContractServlet(); + injectWallet(servlet); + } + + @Test + public void testPostFound() throws Exception { + when(wallet.getContract(eq(expectedRequest))).thenReturn( + SmartContract.newBuilder().setName("TestContract").build()); + + MockHttpServletResponse response = newResponse(); + servlet.doPost(postRequest("{\"value\": \"" + addrStr + "\"}"), response); + verify(wallet).getContract(eq(expectedRequest)); + String content = response.getContentAsString(); + assertFalse("Should not contain error", content.contains("\"Error\"")); + assertTrue("Should contain contract name", content.contains("TestContract")); + } + + @Test + public void testPostNotFound() throws Exception { + when(wallet.getContract(eq(expectedRequest))).thenReturn(null); + + MockHttpServletResponse response = newResponse(); + servlet.doPost(postRequest("{\"value\": \"" + addrStr + "\"}"), response); + verify(wallet).getContract(eq(expectedRequest)); + assertEquals(200, response.getStatus()); + assertEquals("{}" + System.lineSeparator(), response.getContentAsString()); + assertEquals("{}", response.getContentAsString().trim()); + } + + @Test + public void testGetNotFound() throws Exception { + when(wallet.getContract(eq(expectedRequest))).thenReturn(null); + + MockHttpServletResponse response = newResponse(); + servlet.doGet(getRequest("value", addrStr), response); + verify(wallet).getContract(eq(expectedRequest)); + assertEquals(200, response.getStatus()); + assertEquals("{}" + System.lineSeparator(), response.getContentAsString()); + assertEquals("{}", response.getContentAsString().trim()); + + } +} diff --git a/framework/src/test/java/org/tron/core/services/http/GetDelegatedResourceAccountIndexServletTest.java b/framework/src/test/java/org/tron/core/services/http/GetDelegatedResourceAccountIndexServletTest.java new file mode 100644 index 00000000000..21a455c108f --- /dev/null +++ b/framework/src/test/java/org/tron/core/services/http/GetDelegatedResourceAccountIndexServletTest.java @@ -0,0 +1,56 @@ +package org.tron.core.services.http; + +import static org.junit.Assert.assertFalse; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import com.google.protobuf.ByteString; +import org.junit.Test; +import org.springframework.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.protos.Protocol.DelegatedResourceAccountIndex; + +public class GetDelegatedResourceAccountIndexServletTest extends BaseHttpTest { + + private GetDelegatedResourceAccountIndexServlet servlet; + private final byte[] address = new ECKey().getAddress(); + private final String addrStr = ByteArray.toHexString(address); + private final ByteString expectedAddress = ByteString.copyFrom(address); + + @Override + protected void setUpMocks() throws Exception { + servlet = new GetDelegatedResourceAccountIndexServlet(); + injectWallet(servlet); + when(wallet.getDelegatedResourceAccountIndex(any())) + .thenReturn(DelegatedResourceAccountIndex.getDefaultInstance()); + } + + @Test + public void testGetDelegatedResourceAccountIndexPost() throws Exception { + String jsonParam = "{\"value\": \"" + addrStr + "\"}"; + MockHttpServletRequest request = postRequest(jsonParam); + + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + verify(wallet).getDelegatedResourceAccountIndex(eq(expectedAddress)); + String content = response.getContentAsString(); + assertFalse("Should not be empty", content.trim().isEmpty()); + assertFalse("Should not contain error", content.contains("\"Error\"")); + } + + @Test + public void testGetDelegatedResourceAccountIndexGet() throws Exception { + MockHttpServletRequest request = getRequest("value", addrStr); + + MockHttpServletResponse response = newResponse(); + servlet.doGet(request, response); + verify(wallet).getDelegatedResourceAccountIndex(eq(expectedAddress)); + String content = response.getContentAsString(); + assertFalse("Should not be empty", content.trim().isEmpty()); + assertFalse("Should not contain error", content.contains("\"Error\"")); + } +} diff --git a/framework/src/test/java/org/tron/core/services/http/GetDelegatedResourceAccountIndexV2ServletTest.java b/framework/src/test/java/org/tron/core/services/http/GetDelegatedResourceAccountIndexV2ServletTest.java new file mode 100644 index 00000000000..d45aa4baa3e --- /dev/null +++ b/framework/src/test/java/org/tron/core/services/http/GetDelegatedResourceAccountIndexV2ServletTest.java @@ -0,0 +1,57 @@ +package org.tron.core.services.http; + +import static org.junit.Assert.assertFalse; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import com.google.protobuf.ByteString; +import org.junit.Test; +import org.springframework.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; +import org.tron.common.utils.ByteArray; +import org.tron.protos.Protocol.DelegatedResourceAccountIndex; + +public class GetDelegatedResourceAccountIndexV2ServletTest extends BaseHttpTest { + + private GetDelegatedResourceAccountIndexV2Servlet servlet; + ByteString expectedAddress = ByteString.copyFrom( + ByteArray.fromHexString( + Util.getHexAddress("TBxSocpujP6UGKV5ydXNVTDQz7fAgdmoaB"))); + + @Override + protected void setUpMocks() throws Exception { + servlet = new GetDelegatedResourceAccountIndexV2Servlet(); + injectWallet(servlet); + when(wallet.getDelegatedResourceAccountIndexV2(any())) + .thenReturn(DelegatedResourceAccountIndex.getDefaultInstance()); + } + + @Test + public void testPost() throws Exception { + String jsonParam = "{\"visible\": true, \"value\": \"TBxSocpujP6UGKV5ydXNVTDQz7fAgdmoaB\"}"; + MockHttpServletRequest request = postRequest(jsonParam); + + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + + verify(wallet).getDelegatedResourceAccountIndexV2(eq(expectedAddress)); + String postContent = response.getContentAsString(); + assertFalse(postContent.contains("\"Error\"")); + assertFalse(postContent.trim().isEmpty()); + } + + @Test + public void testGet() throws Exception { + MockHttpServletRequest request = + getRequest("visible", "true", "value", "TBxSocpujP6UGKV5ydXNVTDQz7fAgdmoaB"); + + MockHttpServletResponse response = newResponse(); + servlet.doGet(request, response); + verify(wallet).getDelegatedResourceAccountIndexV2(eq(expectedAddress)); + String getContent = response.getContentAsString(); + assertFalse(getContent.contains("\"Error\"")); + assertFalse(getContent.trim().isEmpty()); + } +} diff --git a/framework/src/test/java/org/tron/core/services/http/GetEnergyPricesServletTest.java b/framework/src/test/java/org/tron/core/services/http/GetEnergyPricesServletTest.java index 6c208c59d39..f0fe69fe450 100644 --- a/framework/src/test/java/org/tron/core/services/http/GetEnergyPricesServletTest.java +++ b/framework/src/test/java/org/tron/core/services/http/GetEnergyPricesServletTest.java @@ -4,7 +4,6 @@ import static org.junit.Assert.fail; import static org.tron.common.utils.client.utils.HttpMethed.createRequest; -import com.alibaba.fastjson.JSONObject; import java.io.UnsupportedEncodingException; import javax.annotation.Resource; import org.apache.http.client.methods.HttpGet; @@ -16,6 +15,7 @@ import org.tron.common.BaseTest; import org.tron.common.TestConstants; import org.tron.core.config.args.Args; +import org.tron.json.JSONObject; public class GetEnergyPricesServletTest extends BaseTest { diff --git a/framework/src/test/java/org/tron/core/services/http/GetExchangeByIdServletTest.java b/framework/src/test/java/org/tron/core/services/http/GetExchangeByIdServletTest.java new file mode 100644 index 00000000000..f67072e9856 --- /dev/null +++ b/framework/src/test/java/org/tron/core/services/http/GetExchangeByIdServletTest.java @@ -0,0 +1,52 @@ +package org.tron.core.services.http; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import com.google.protobuf.ByteString; +import org.junit.Test; +import org.springframework.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; +import org.tron.protos.Protocol.Exchange; + +public class GetExchangeByIdServletTest extends BaseHttpTest { + + private GetExchangeByIdServlet servlet; + private final ByteString exchangeId = + ByteString.copyFrom(org.tron.common.utils.ByteArray.fromLong(1L)); + + @Override + protected void setUpMocks() throws Exception { + servlet = new GetExchangeByIdServlet(); + injectWallet(servlet); + when(wallet.getExchangeById(eq(exchangeId))) + .thenReturn(Exchange.newBuilder().setExchangeId(1L).build()); + } + + @Test + public void testPost() throws Exception { + String jsonParam = "{\"id\": 1}"; + MockHttpServletRequest request = postRequest(jsonParam); + + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + verify(wallet).getExchangeById(eq(exchangeId)); + assertEquals(200, response.getStatus()); + assertTrue(response.getContentAsString().contains("exchange_id")); + } + + @Test + public void testGet() throws Exception { + MockHttpServletRequest request = getRequest("id", "1"); + + MockHttpServletResponse response = newResponse(); + servlet.doGet(request, response); + verify(wallet).getExchangeById(eq(exchangeId)); + assertEquals(200, response.getStatus()); + assertTrue(response.getContentAsString().contains("exchange_id")); + } +} diff --git a/framework/src/test/java/org/tron/core/services/http/GetMarketOrderByAccountServletTest.java b/framework/src/test/java/org/tron/core/services/http/GetMarketOrderByAccountServletTest.java new file mode 100644 index 00000000000..a1895231f8a --- /dev/null +++ b/framework/src/test/java/org/tron/core/services/http/GetMarketOrderByAccountServletTest.java @@ -0,0 +1,55 @@ +package org.tron.core.services.http; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import com.google.protobuf.ByteString; +import org.junit.Test; +import org.springframework.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; + +public class GetMarketOrderByAccountServletTest extends BaseHttpTest { + + private GetMarketOrderByAccountServlet servlet; + private final byte[] address = new ECKey().getAddress(); + private final String addrStr = ByteArray.toHexString(address); + private final ByteString addrBytes = ByteString.copyFrom(address); + + @Override + protected void setUpMocks() throws Exception { + servlet = new GetMarketOrderByAccountServlet(); + injectWallet(servlet); + when(wallet.getMarketOrderByAccount(any())).thenReturn(null); + } + + @Test + public void testPost() throws Exception { + String jsonParam = "{\"value\": \"" + addrStr + "\"}"; + MockHttpServletRequest request = postRequest(jsonParam); + + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + verify(wallet).getMarketOrderByAccount(eq(addrBytes)); + String content = response.getContentAsString(); + assertFalse("Should not contain error", content.contains("\"Error\"")); + assertEquals("{}" + System.lineSeparator(), content); + } + + @Test + public void testGet() throws Exception { + MockHttpServletRequest request = getRequest("value", addrStr); + + MockHttpServletResponse response = newResponse(); + servlet.doGet(request, response); + verify(wallet).getMarketOrderByAccount(eq(addrBytes)); + String content = response.getContentAsString(); + assertFalse("Should not contain error", content.contains("\"Error\"")); + assertEquals("{}" + System.lineSeparator(), content); + } +} diff --git a/framework/src/test/java/org/tron/core/services/http/GetMemoFeePricesServletTest.java b/framework/src/test/java/org/tron/core/services/http/GetMemoFeePricesServletTest.java index df8cda9e15e..b9440aa948f 100644 --- a/framework/src/test/java/org/tron/core/services/http/GetMemoFeePricesServletTest.java +++ b/framework/src/test/java/org/tron/core/services/http/GetMemoFeePricesServletTest.java @@ -4,7 +4,6 @@ import static org.junit.Assert.fail; import static org.tron.common.utils.client.utils.HttpMethed.createRequest; -import com.alibaba.fastjson.JSONObject; import java.io.UnsupportedEncodingException; import javax.annotation.Resource; import org.apache.http.client.methods.HttpGet; @@ -16,6 +15,7 @@ import org.tron.common.BaseTest; import org.tron.common.TestConstants; import org.tron.core.config.args.Args; +import org.tron.json.JSONObject; public class GetMemoFeePricesServletTest extends BaseTest { diff --git a/framework/src/test/java/org/tron/core/services/http/GetNowBlockServletTest.java b/framework/src/test/java/org/tron/core/services/http/GetNowBlockServletTest.java index bf5ab766fb1..1179e914d32 100644 --- a/framework/src/test/java/org/tron/core/services/http/GetNowBlockServletTest.java +++ b/framework/src/test/java/org/tron/core/services/http/GetNowBlockServletTest.java @@ -7,7 +7,6 @@ import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; -import com.alibaba.fastjson.JSONObject; import java.io.UnsupportedEncodingException; import javax.annotation.Resource; import org.junit.Test; @@ -16,6 +15,7 @@ import org.tron.common.BaseTest; import org.tron.common.TestConstants; import org.tron.core.config.args.Args; +import org.tron.json.JSONObject; public class GetNowBlockServletTest extends BaseTest { diff --git a/framework/src/test/java/org/tron/core/services/http/GetProposalByIdServletTest.java b/framework/src/test/java/org/tron/core/services/http/GetProposalByIdServletTest.java new file mode 100644 index 00000000000..cf64adcb1a1 --- /dev/null +++ b/framework/src/test/java/org/tron/core/services/http/GetProposalByIdServletTest.java @@ -0,0 +1,70 @@ +package org.tron.core.services.http; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import com.google.protobuf.ByteString; +import org.junit.Test; +import org.springframework.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; +import org.tron.common.utils.ByteArray; +import org.tron.protos.Protocol.Proposal; + +public class GetProposalByIdServletTest extends BaseHttpTest { + + private GetProposalByIdServlet servlet; + private final ByteString proposalId = + ByteString.copyFrom(ByteArray.fromLong(1L)); + + @Override + protected void setUpMocks() throws Exception { + servlet = new GetProposalByIdServlet(); + injectWallet(servlet); + when(wallet.getProposalById(any())).thenReturn(null); + } + + @Test + public void testPost() throws Exception { + String jsonParam = "{\"id\": 1}"; + MockHttpServletRequest request = postRequest(jsonParam); + + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + verify(wallet).getProposalById(eq(proposalId)); + assertEquals(200, response.getStatus()); + String content = response.getContentAsString(); + assertFalse("Should not contain error", content.contains("\"Error\"")); + assertEquals("{}" + System.lineSeparator(), content); + } + + @Test + public void testGet() throws Exception { + MockHttpServletRequest request = getRequest("id", "1"); + + MockHttpServletResponse response = newResponse(); + servlet.doGet(request, response); + verify(wallet).getProposalById(eq(proposalId)); + assertEquals(200, response.getStatus()); + String content = response.getContentAsString(); + assertFalse("Should not contain error", content.contains("\"Error\"")); + assertEquals("{}" + System.lineSeparator(), content); + } + + @Test + public void testPostReturnsProposalWhenFound() throws Exception { + Proposal proposal = Proposal.newBuilder().setProposalId(1L).build(); + when(wallet.getProposalById(eq(proposalId))).thenReturn(proposal); + + MockHttpServletRequest request = postRequest("{\"id\": 1}"); + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + assertEquals(200, response.getStatus()); + String content = response.getContentAsString(); + assertTrue("Should contain proposal_id", content.contains("proposal_id")); + } +} diff --git a/framework/src/test/java/org/tron/core/services/http/GetRewardServletTest.java b/framework/src/test/java/org/tron/core/services/http/GetRewardServletTest.java index 3de72eb3d45..76f85da5d8f 100644 --- a/framework/src/test/java/org/tron/core/services/http/GetRewardServletTest.java +++ b/framework/src/test/java/org/tron/core/services/http/GetRewardServletTest.java @@ -2,15 +2,9 @@ import static org.tron.common.utils.Commons.decodeFromBase58Check; -import com.alibaba.fastjson.JSONObject; - -import java.io.File; import java.io.UnsupportedEncodingException; import javax.annotation.Resource; - import lombok.extern.slf4j.Slf4j; -import org.apache.commons.lang3.StringUtils; -import org.junit.After; import org.junit.Assert; import org.junit.Before; import org.junit.Test; @@ -18,11 +12,11 @@ import org.springframework.mock.web.MockHttpServletResponse; import org.tron.common.BaseTest; import org.tron.common.TestConstants; -import org.tron.common.utils.FileUtil; import org.tron.core.config.args.Args; import org.tron.core.db.Manager; import org.tron.core.service.MortgageService; import org.tron.core.store.DelegationStore; +import org.tron.json.JSONObject; @Slf4j public class GetRewardServletTest extends BaseTest { diff --git a/framework/src/test/java/org/tron/core/services/http/GetTransactionInfoByBlockNumServletTest.java b/framework/src/test/java/org/tron/core/services/http/GetTransactionInfoByBlockNumServletTest.java index c2c02453cd4..1763e440b48 100644 --- a/framework/src/test/java/org/tron/core/services/http/GetTransactionInfoByBlockNumServletTest.java +++ b/framework/src/test/java/org/tron/core/services/http/GetTransactionInfoByBlockNumServletTest.java @@ -3,12 +3,8 @@ import static java.nio.charset.StandardCharsets.UTF_8; import static org.tron.common.utils.client.utils.HttpMethed.createRequest; -import com.alibaba.fastjson.JSONArray; -import com.alibaba.fastjson.JSONObject; - import java.io.UnsupportedEncodingException; import javax.annotation.Resource; - import org.apache.http.client.methods.HttpPost; import org.junit.Assert; import org.junit.Before; @@ -18,11 +14,12 @@ import org.tron.common.BaseTest; import org.tron.common.TestConstants; import org.tron.common.utils.ByteArray; - import org.tron.core.capsule.TransactionInfoCapsule; import org.tron.core.capsule.TransactionRetCapsule; import org.tron.core.config.args.Args; import org.tron.core.db.TransactionStoreTest; +import org.tron.json.JSONArray; +import org.tron.json.JSONObject; public class GetTransactionInfoByBlockNumServletTest extends BaseTest { diff --git a/framework/src/test/java/org/tron/core/services/http/GetTransactionInfoByIdServletTest.java b/framework/src/test/java/org/tron/core/services/http/GetTransactionInfoByIdServletTest.java index ed1bc19aed6..6793433371d 100644 --- a/framework/src/test/java/org/tron/core/services/http/GetTransactionInfoByIdServletTest.java +++ b/framework/src/test/java/org/tron/core/services/http/GetTransactionInfoByIdServletTest.java @@ -3,12 +3,9 @@ import static java.nio.charset.StandardCharsets.UTF_8; import static org.tron.common.utils.client.utils.HttpMethed.createRequest; -import com.alibaba.fastjson.JSONObject; import com.google.protobuf.ByteString; - import java.io.UnsupportedEncodingException; import javax.annotation.Resource; - import org.apache.http.client.methods.HttpPost; import org.junit.Assert; import org.junit.Before; @@ -27,6 +24,7 @@ import org.tron.core.db.TransactionStore; import org.tron.core.db.TransactionStoreTest; import org.tron.core.store.TransactionRetStore; +import org.tron.json.JSONObject; import org.tron.protos.Protocol; import org.tron.protos.contract.BalanceContract; diff --git a/framework/src/test/java/org/tron/core/services/http/ListProposalsServletTest.java b/framework/src/test/java/org/tron/core/services/http/ListProposalsServletTest.java index 980c6617001..f600f704aa7 100644 --- a/framework/src/test/java/org/tron/core/services/http/ListProposalsServletTest.java +++ b/framework/src/test/java/org/tron/core/services/http/ListProposalsServletTest.java @@ -3,7 +3,6 @@ import static java.nio.charset.StandardCharsets.UTF_8; import static org.junit.Assert.fail; -import com.alibaba.fastjson.JSONObject; import java.io.UnsupportedEncodingException; import javax.annotation.Resource; import org.junit.Test; @@ -12,6 +11,7 @@ import org.tron.common.BaseTest; import org.tron.common.TestConstants; import org.tron.core.config.args.Args; +import org.tron.json.JSONObject; public class ListProposalsServletTest extends BaseTest { diff --git a/framework/src/test/java/org/tron/core/services/http/MarketCancelOrderServletTest.java b/framework/src/test/java/org/tron/core/services/http/MarketCancelOrderServletTest.java new file mode 100644 index 00000000000..7c8e529b275 --- /dev/null +++ b/framework/src/test/java/org/tron/core/services/http/MarketCancelOrderServletTest.java @@ -0,0 +1,50 @@ +package org.tron.core.services.http; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.argThat; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import org.junit.Test; +import org.springframework.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.core.capsule.TransactionCapsule; +import org.tron.protos.Protocol.Transaction.Contract.ContractType; +import org.tron.protos.contract.MarketContract.MarketCancelOrderContract; + +public class MarketCancelOrderServletTest extends BaseHttpTest { + + private MarketCancelOrderServlet servlet; + private final String ownerAddr = ByteArray.toHexString(new ECKey().getAddress()); + + @Override + protected void setUpMocks() throws Exception { + servlet = new MarketCancelOrderServlet(); + injectWallet(servlet); + when(wallet.createTransactionCapsule( + any(MarketCancelOrderContract.class), eq(ContractType.MarketCancelOrderContract))) + .thenReturn(new TransactionCapsule(MINIMAL_TX)); + } + + @Test + public void testMarketCancelOrder() throws Exception { + String jsonParam = "{" + + "\"owner_address\": \"" + ownerAddr + "\"," + + "\"order_id\": \"0000000000000000000000000000000000000000000000000000000000000001\"" + + "}"; + MockHttpServletRequest request = postRequest(jsonParam); + + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + verify(wallet).createTransactionCapsule( + argThat(c -> c instanceof MarketCancelOrderContract + && addressEquals(((MarketCancelOrderContract) c) + .getOwnerAddress(), ownerAddr) + && ((MarketCancelOrderContract) c).getOrderId().size() == 32), + eq(ContractType.MarketCancelOrderContract)); + assertTransactionResponse(response); + } +} diff --git a/framework/src/test/java/org/tron/core/services/http/MarketSellAssetServletTest.java b/framework/src/test/java/org/tron/core/services/http/MarketSellAssetServletTest.java new file mode 100644 index 00000000000..e82178b909a --- /dev/null +++ b/framework/src/test/java/org/tron/core/services/http/MarketSellAssetServletTest.java @@ -0,0 +1,59 @@ +package org.tron.core.services.http; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.argThat; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import org.junit.Test; +import org.springframework.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.core.capsule.TransactionCapsule; +import org.tron.protos.Protocol; +import org.tron.protos.contract.MarketContract; + +public class MarketSellAssetServletTest extends BaseHttpTest { + + private MarketSellAssetServlet servlet; + private final String ownerAddr = ByteArray.toHexString(new ECKey().getAddress()); + + @Override + protected void setUpMocks() throws Exception { + servlet = new MarketSellAssetServlet(); + injectWallet(servlet); + when(wallet.createTransactionCapsule( + any(MarketContract.MarketSellAssetContract.class), + eq(Protocol.Transaction.Contract.ContractType.MarketSellAssetContract))) + .thenReturn(new TransactionCapsule(MINIMAL_TX)); + } + + @Test + public void testMarketSellAsset() throws Exception { + String jsonParam = "{" + + "\"owner_address\": \"" + ownerAddr + "\"," + + "\"sell_token_id\": \"5f\"," + + "\"sell_token_quantity\": 100," + + "\"buy_token_id\": \"60\"," + + "\"buy_token_quantity\": 200" + + "}"; + MockHttpServletRequest request = postRequest(jsonParam); + + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + verify(wallet).createTransactionCapsule( + argThat(c -> c instanceof MarketContract.MarketSellAssetContract + && addressEquals(((MarketContract.MarketSellAssetContract) c) + .getOwnerAddress(), ownerAddr) + && ((MarketContract.MarketSellAssetContract) c).getSellTokenQuantity() == 100 + && ((MarketContract.MarketSellAssetContract) c).getBuyTokenQuantity() == 200 + && ((MarketContract.MarketSellAssetContract) c) + .getSellTokenId().toStringUtf8().equals("_") + && ((MarketContract.MarketSellAssetContract) c) + .getBuyTokenId().toStringUtf8().equals("`")), + eq(Protocol.Transaction.Contract.ContractType.MarketSellAssetContract)); + assertTransactionResponse(response); + } +} diff --git a/framework/src/test/java/org/tron/core/services/http/ParticipateAssetIssueServletTest.java b/framework/src/test/java/org/tron/core/services/http/ParticipateAssetIssueServletTest.java new file mode 100644 index 00000000000..0fbfe73d6fc --- /dev/null +++ b/framework/src/test/java/org/tron/core/services/http/ParticipateAssetIssueServletTest.java @@ -0,0 +1,59 @@ +package org.tron.core.services.http; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.argThat; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import org.junit.Test; +import org.springframework.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.core.capsule.TransactionCapsule; +import org.tron.protos.Protocol; +import org.tron.protos.contract.AssetIssueContractOuterClass; + +public class ParticipateAssetIssueServletTest extends BaseHttpTest { + + private ParticipateAssetIssueServlet servlet; + private final String ownerAddr = ByteArray.toHexString(new ECKey().getAddress()); + private final String toAddr = ByteArray.toHexString(new ECKey().getAddress()); + + @Override + protected void setUpMocks() throws Exception { + servlet = new ParticipateAssetIssueServlet(); + injectWallet(servlet); + when(wallet.createTransactionCapsule( + any(AssetIssueContractOuterClass.ParticipateAssetIssueContract.class), + eq(Protocol.Transaction.Contract.ContractType.ParticipateAssetIssueContract))) + .thenReturn(new TransactionCapsule(MINIMAL_TX)); + } + + @Test + public void testParticipateAssetIssue() throws Exception { + String jsonParam = "{" + + "\"owner_address\": \"" + ownerAddr + "\"," + + "\"to_address\": \"" + toAddr + "\"," + + "\"asset_name\": \"74657374\"," + + "\"amount\": 100" + + "}"; + MockHttpServletRequest request = postRequest(jsonParam); + + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + verify(wallet).createTransactionCapsule( + argThat(c -> c instanceof AssetIssueContractOuterClass.ParticipateAssetIssueContract + && addressEquals(((AssetIssueContractOuterClass.ParticipateAssetIssueContract) c) + .getOwnerAddress(), ownerAddr) + && addressEquals(((AssetIssueContractOuterClass.ParticipateAssetIssueContract) c) + .getToAddress(), toAddr) + && ((AssetIssueContractOuterClass.ParticipateAssetIssueContract) c) + .getAmount() == 100 + && ((AssetIssueContractOuterClass.ParticipateAssetIssueContract) c) + .getAssetName().toStringUtf8().equals("test")), + eq(Protocol.Transaction.Contract.ContractType.ParticipateAssetIssueContract)); + assertTransactionResponse(response); + } +} diff --git a/framework/src/test/java/org/tron/core/services/http/ProposalApproveServletTest.java b/framework/src/test/java/org/tron/core/services/http/ProposalApproveServletTest.java new file mode 100644 index 00000000000..f017b06de24 --- /dev/null +++ b/framework/src/test/java/org/tron/core/services/http/ProposalApproveServletTest.java @@ -0,0 +1,53 @@ +package org.tron.core.services.http; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.argThat; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import org.junit.Test; +import org.springframework.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.core.capsule.TransactionCapsule; +import org.tron.protos.Protocol; +import org.tron.protos.contract.ProposalContract; + +public class ProposalApproveServletTest extends BaseHttpTest { + + private ProposalApproveServlet servlet; + private final String ownerAddr = ByteArray.toHexString(new ECKey().getAddress()); + + @Override + protected void setUpMocks() throws Exception { + servlet = new ProposalApproveServlet(); + injectWallet(servlet); + when(wallet.createTransactionCapsule( + any(ProposalContract.ProposalApproveContract.class), + eq(Protocol.Transaction.Contract.ContractType.ProposalApproveContract))) + .thenReturn(new TransactionCapsule(MINIMAL_TX)); + } + + @Test + public void testProposalApprove() throws Exception { + String jsonParam = "{" + + "\"owner_address\": \"" + ownerAddr + "\"," + + "\"proposal_id\": 1," + + "\"is_add_approval\": true" + + "}"; + MockHttpServletRequest request = postRequest(jsonParam); + + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + verify(wallet).createTransactionCapsule( + argThat(c -> c instanceof ProposalContract.ProposalApproveContract + && ((ProposalContract.ProposalApproveContract) c).getProposalId() == 1 + && ((ProposalContract.ProposalApproveContract) c).getIsAddApproval() + && addressEquals(((ProposalContract.ProposalApproveContract) c) + .getOwnerAddress(), ownerAddr)), + eq(Protocol.Transaction.Contract.ContractType.ProposalApproveContract)); + assertTransactionResponse(response); + } +} diff --git a/framework/src/test/java/org/tron/core/services/http/ProposalCreateServletTest.java b/framework/src/test/java/org/tron/core/services/http/ProposalCreateServletTest.java new file mode 100644 index 00000000000..0057aa7bd2d --- /dev/null +++ b/framework/src/test/java/org/tron/core/services/http/ProposalCreateServletTest.java @@ -0,0 +1,53 @@ +package org.tron.core.services.http; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.argThat; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import org.junit.Test; +import org.springframework.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.core.capsule.TransactionCapsule; +import org.tron.protos.Protocol; +import org.tron.protos.contract.ProposalContract; + +public class ProposalCreateServletTest extends BaseHttpTest { + + private ProposalCreateServlet servlet; + private final String ownerAddr = ByteArray.toHexString(new ECKey().getAddress()); + + @Override + protected void setUpMocks() throws Exception { + servlet = new ProposalCreateServlet(); + injectWallet(servlet); + when(wallet.createTransactionCapsule( + any(ProposalContract.ProposalCreateContract.class), + eq(Protocol.Transaction.Contract.ContractType.ProposalCreateContract))) + .thenReturn(new TransactionCapsule(MINIMAL_TX)); + } + + @Test + public void testProposalCreate() throws Exception { + String jsonParam = "{" + + "\"owner_address\": \"" + ownerAddr + "\"," + + "\"parameters\": [{\"key\": 0, \"value\": 100000}]" + + "}"; + MockHttpServletRequest request = postRequest(jsonParam); + + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + verify(wallet).createTransactionCapsule( + argThat(c -> c instanceof ProposalContract.ProposalCreateContract + && addressEquals(((ProposalContract.ProposalCreateContract) c) + .getOwnerAddress(), ownerAddr) + && ((ProposalContract.ProposalCreateContract) c).getParametersMap().size() == 1 + && ((ProposalContract.ProposalCreateContract) c) + .getParametersMap().get(0L) == 100000), + eq(Protocol.Transaction.Contract.ContractType.ProposalCreateContract)); + assertTransactionResponse(response); + } +} diff --git a/framework/src/test/java/org/tron/core/services/http/ProposalDeleteServletTest.java b/framework/src/test/java/org/tron/core/services/http/ProposalDeleteServletTest.java new file mode 100644 index 00000000000..90a25e5bb68 --- /dev/null +++ b/framework/src/test/java/org/tron/core/services/http/ProposalDeleteServletTest.java @@ -0,0 +1,51 @@ +package org.tron.core.services.http; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.argThat; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import org.junit.Test; +import org.springframework.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.core.capsule.TransactionCapsule; +import org.tron.protos.Protocol; +import org.tron.protos.contract.ProposalContract; + +public class ProposalDeleteServletTest extends BaseHttpTest { + + private ProposalDeleteServlet servlet; + private final String ownerAddr = ByteArray.toHexString(new ECKey().getAddress()); + + @Override + protected void setUpMocks() throws Exception { + servlet = new ProposalDeleteServlet(); + injectWallet(servlet); + when(wallet.createTransactionCapsule( + any(ProposalContract.ProposalDeleteContract.class), + eq(Protocol.Transaction.Contract.ContractType.ProposalDeleteContract))) + .thenReturn(new TransactionCapsule(MINIMAL_TX)); + } + + @Test + public void testProposalDelete() throws Exception { + String jsonParam = "{" + + "\"owner_address\": \"" + ownerAddr + "\"," + + "\"proposal_id\": 1" + + "}"; + MockHttpServletRequest request = postRequest(jsonParam); + + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + verify(wallet).createTransactionCapsule( + argThat(c -> c instanceof ProposalContract.ProposalDeleteContract + && addressEquals(((ProposalContract.ProposalDeleteContract) c) + .getOwnerAddress(), ownerAddr) + && ((ProposalContract.ProposalDeleteContract) c).getProposalId() == 1), + eq(Protocol.Transaction.Contract.ContractType.ProposalDeleteContract)); + assertTransactionResponse(response); + } +} diff --git a/framework/src/test/java/org/tron/core/services/http/SetAccountIdServletTest.java b/framework/src/test/java/org/tron/core/services/http/SetAccountIdServletTest.java new file mode 100644 index 00000000000..6967372c9ac --- /dev/null +++ b/framework/src/test/java/org/tron/core/services/http/SetAccountIdServletTest.java @@ -0,0 +1,51 @@ +package org.tron.core.services.http; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.argThat; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import org.junit.Test; +import org.springframework.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.core.capsule.TransactionCapsule; +import org.tron.protos.Protocol; +import org.tron.protos.contract.AccountContract; + +public class SetAccountIdServletTest extends BaseHttpTest { + + private SetAccountIdServlet servlet; + private final String ownerAddr = ByteArray.toHexString(new ECKey().getAddress()); + + @Override + protected void setUpMocks() throws Exception { + servlet = new SetAccountIdServlet(); + injectWallet(servlet); + when(wallet.createTransactionCapsule(any(AccountContract.SetAccountIdContract.class), eq( + Protocol.Transaction.Contract.ContractType.SetAccountIdContract))) + .thenReturn(new TransactionCapsule(MINIMAL_TX)); + } + + @Test + public void testSetAccountId() throws Exception { + String jsonParam = "{" + + "\"owner_address\": \"" + ownerAddr + "\"," + + "\"account_id\": \"6161616162626262\"" + + "}"; + MockHttpServletRequest request = postRequest(jsonParam); + + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + verify(wallet).createTransactionCapsule( + argThat(c -> c instanceof AccountContract.SetAccountIdContract + && addressEquals(((AccountContract.SetAccountIdContract) c) + .getOwnerAddress(), ownerAddr) + && ((AccountContract.SetAccountIdContract) c) + .getAccountId().toStringUtf8().equals("aaaabbbb")), + eq(Protocol.Transaction.Contract.ContractType.SetAccountIdContract)); + assertTransactionResponse(response); + } +} diff --git a/framework/src/test/java/org/tron/core/services/http/TransferAssetServletTest.java b/framework/src/test/java/org/tron/core/services/http/TransferAssetServletTest.java new file mode 100644 index 00000000000..49652f3361d --- /dev/null +++ b/framework/src/test/java/org/tron/core/services/http/TransferAssetServletTest.java @@ -0,0 +1,58 @@ +package org.tron.core.services.http; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.argThat; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import org.junit.Test; +import org.springframework.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.core.capsule.TransactionCapsule; +import org.tron.protos.Protocol; +import org.tron.protos.contract.AssetIssueContractOuterClass; + +public class TransferAssetServletTest extends BaseHttpTest { + + private TransferAssetServlet servlet; + private final String ownerAddr = ByteArray.toHexString(new ECKey().getAddress()); + private final String toAddr = ByteArray.toHexString(new ECKey().getAddress()); + + @Override + protected void setUpMocks() throws Exception { + servlet = new TransferAssetServlet(); + injectWallet(servlet); + when(wallet.createTransactionCapsule( + any(AssetIssueContractOuterClass.TransferAssetContract.class), + eq(Protocol.Transaction.Contract.ContractType.TransferAssetContract))) + .thenReturn(new TransactionCapsule(MINIMAL_TX)); + } + + @Test + public void testTransferAsset() throws Exception { + String jsonParam = "{" + + "\"owner_address\": \"" + ownerAddr + "\"," + + "\"to_address\": \"" + toAddr + "\"," + + "\"asset_name\": \"74657374\"," + + "\"amount\": 100" + + "}"; + MockHttpServletRequest request = postRequest(jsonParam); + + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + verify(wallet).createTransactionCapsule( + argThat(c -> c instanceof AssetIssueContractOuterClass.TransferAssetContract + && addressEquals(((AssetIssueContractOuterClass.TransferAssetContract) c) + .getOwnerAddress(), ownerAddr) + && addressEquals(((AssetIssueContractOuterClass.TransferAssetContract) c) + .getToAddress(), toAddr) + && ((AssetIssueContractOuterClass.TransferAssetContract) c).getAmount() == 100 + && ((AssetIssueContractOuterClass.TransferAssetContract) c) + .getAssetName().toStringUtf8().equals("test")), + eq(Protocol.Transaction.Contract.ContractType.TransferAssetContract)); + assertTransactionResponse(response); + } +} diff --git a/framework/src/test/java/org/tron/core/services/http/TransferServletTest.java b/framework/src/test/java/org/tron/core/services/http/TransferServletTest.java new file mode 100644 index 00000000000..b04c6255dac --- /dev/null +++ b/framework/src/test/java/org/tron/core/services/http/TransferServletTest.java @@ -0,0 +1,55 @@ +package org.tron.core.services.http; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.argThat; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import org.junit.Test; +import org.springframework.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.core.capsule.TransactionCapsule; +import org.tron.protos.Protocol; +import org.tron.protos.contract.BalanceContract; + +public class TransferServletTest extends BaseHttpTest { + + private TransferServlet servlet; + private final String ownerAddr = ByteArray.toHexString(new ECKey().getAddress()); + private final String toAddr = ByteArray.toHexString(new ECKey().getAddress()); + + @Override + protected void setUpMocks() throws Exception { + servlet = new TransferServlet(); + injectWallet(servlet); + when(wallet.createTransactionCapsule( + any(BalanceContract.TransferContract.class), + eq(Protocol.Transaction.Contract.ContractType.TransferContract))) + .thenReturn(new TransactionCapsule(MINIMAL_TX)); + } + + @Test + public void testTransfer() throws Exception { + String jsonParam = "{" + + "\"owner_address\": \"" + ownerAddr + "\"," + + "\"to_address\": \"" + toAddr + "\"," + + "\"amount\": 100" + + "}"; + MockHttpServletRequest request = postRequest(jsonParam); + + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + verify(wallet).createTransactionCapsule( + argThat(c -> c instanceof BalanceContract.TransferContract + && addressEquals(((BalanceContract.TransferContract) c) + .getOwnerAddress(), ownerAddr) + && addressEquals(((BalanceContract.TransferContract) c) + .getToAddress(), toAddr) + && ((BalanceContract.TransferContract) c).getAmount() == 100), + eq(Protocol.Transaction.Contract.ContractType.TransferContract)); + assertTransactionResponse(response); + } +} diff --git a/framework/src/test/java/org/tron/core/services/http/UnDelegateResourceServletTest.java b/framework/src/test/java/org/tron/core/services/http/UnDelegateResourceServletTest.java new file mode 100644 index 00000000000..fbdb0138c41 --- /dev/null +++ b/framework/src/test/java/org/tron/core/services/http/UnDelegateResourceServletTest.java @@ -0,0 +1,59 @@ +package org.tron.core.services.http; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.argThat; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import org.junit.Test; +import org.springframework.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.core.capsule.TransactionCapsule; +import org.tron.protos.Protocol; +import org.tron.protos.contract.BalanceContract; +import org.tron.protos.contract.Common.ResourceCode; + +public class UnDelegateResourceServletTest extends BaseHttpTest { + + private UnDelegateResourceServlet servlet; + private final String ownerAddr = ByteArray.toHexString(new ECKey().getAddress()); + private final String receiverAddr = ByteArray.toHexString(new ECKey().getAddress()); + + @Override + protected void setUpMocks() throws Exception { + servlet = new UnDelegateResourceServlet(); + injectWallet(servlet); + when(wallet.createTransactionCapsule( + any(BalanceContract.UnDelegateResourceContract.class), + eq(Protocol.Transaction.Contract.ContractType.UnDelegateResourceContract))) + .thenReturn(new TransactionCapsule(MINIMAL_TX)); + } + + @Test + public void testUnDelegateResource() throws Exception { + String jsonParam = "{" + + "\"owner_address\": \"" + ownerAddr + "\"," + + "\"receiver_address\": \"" + receiverAddr + "\"," + + "\"balance\": 1000000," + + "\"resource\": \"ENERGY\"" + + "}"; + MockHttpServletRequest request = postRequest(jsonParam); + + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + verify(wallet).createTransactionCapsule( + argThat(c -> c instanceof BalanceContract.UnDelegateResourceContract + && addressEquals(((BalanceContract.UnDelegateResourceContract) c) + .getOwnerAddress(), ownerAddr) + && addressEquals(((BalanceContract.UnDelegateResourceContract) c) + .getReceiverAddress(), receiverAddr) + && ((BalanceContract.UnDelegateResourceContract) c).getBalance() == 1000000 + && ((BalanceContract.UnDelegateResourceContract) c) + .getResource() == ResourceCode.ENERGY), + eq(Protocol.Transaction.Contract.ContractType.UnDelegateResourceContract)); + assertTransactionResponse(response); + } +} diff --git a/framework/src/test/java/org/tron/core/services/http/UnFreezeAssetServletTest.java b/framework/src/test/java/org/tron/core/services/http/UnFreezeAssetServletTest.java new file mode 100644 index 00000000000..a9c784c38e8 --- /dev/null +++ b/framework/src/test/java/org/tron/core/services/http/UnFreezeAssetServletTest.java @@ -0,0 +1,47 @@ +package org.tron.core.services.http; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.argThat; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import org.junit.Test; +import org.springframework.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.core.capsule.TransactionCapsule; +import org.tron.protos.Protocol; +import org.tron.protos.contract.AssetIssueContractOuterClass; + +public class UnFreezeAssetServletTest extends BaseHttpTest { + + private UnFreezeAssetServlet servlet; + private final String ownerAddr = ByteArray.toHexString(new ECKey().getAddress()); + + @Override + protected void setUpMocks() throws Exception { + servlet = new UnFreezeAssetServlet(); + injectWallet(servlet); + when(wallet.createTransactionCapsule( + any(AssetIssueContractOuterClass.UnfreezeAssetContract.class), + eq(Protocol.Transaction.Contract.ContractType.UnfreezeAssetContract))) + .thenReturn(new TransactionCapsule(MINIMAL_TX)); + } + + @Test + public void testUnFreezeAsset() throws Exception { + String jsonParam = "{\"owner_address\": \"" + ownerAddr + "\"}"; + MockHttpServletRequest request = postRequest(jsonParam); + + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + verify(wallet).createTransactionCapsule( + argThat(c -> c instanceof AssetIssueContractOuterClass.UnfreezeAssetContract + && addressEquals(((AssetIssueContractOuterClass.UnfreezeAssetContract) c) + .getOwnerAddress(), ownerAddr)), + eq(Protocol.Transaction.Contract.ContractType.UnfreezeAssetContract)); + assertTransactionResponse(response); + } +} diff --git a/framework/src/test/java/org/tron/core/services/http/UnFreezeBalanceServletTest.java b/framework/src/test/java/org/tron/core/services/http/UnFreezeBalanceServletTest.java new file mode 100644 index 00000000000..800e5e957dc --- /dev/null +++ b/framework/src/test/java/org/tron/core/services/http/UnFreezeBalanceServletTest.java @@ -0,0 +1,46 @@ +package org.tron.core.services.http; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.argThat; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import org.junit.Test; +import org.springframework.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.core.capsule.TransactionCapsule; +import org.tron.protos.Protocol; +import org.tron.protos.contract.BalanceContract; + +public class UnFreezeBalanceServletTest extends BaseHttpTest { + + private UnFreezeBalanceServlet servlet; + private final String ownerAddr = ByteArray.toHexString(new ECKey().getAddress()); + + @Override + protected void setUpMocks() throws Exception { + servlet = new UnFreezeBalanceServlet(); + injectWallet(servlet); + when(wallet.createTransactionCapsule(any(BalanceContract.UnfreezeBalanceContract.class), + eq(Protocol.Transaction.Contract.ContractType.UnfreezeBalanceContract))) + .thenReturn(new TransactionCapsule(MINIMAL_TX)); + } + + @Test + public void testUnFreezeBalance() throws Exception { + String jsonParam = "{\"owner_address\": \"" + ownerAddr + "\"}"; + MockHttpServletRequest request = postRequest(jsonParam); + + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + verify(wallet).createTransactionCapsule( + argThat(c -> c instanceof BalanceContract.UnfreezeBalanceContract + && addressEquals(((BalanceContract.UnfreezeBalanceContract) c) + .getOwnerAddress(), ownerAddr)), + eq(Protocol.Transaction.Contract.ContractType.UnfreezeBalanceContract)); + assertTransactionResponse(response); + } +} diff --git a/framework/src/test/java/org/tron/core/services/http/UnFreezeBalanceV2ServletTest.java b/framework/src/test/java/org/tron/core/services/http/UnFreezeBalanceV2ServletTest.java new file mode 100644 index 00000000000..cb27bc0df69 --- /dev/null +++ b/framework/src/test/java/org/tron/core/services/http/UnFreezeBalanceV2ServletTest.java @@ -0,0 +1,55 @@ +package org.tron.core.services.http; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.argThat; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import org.junit.Test; +import org.springframework.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.core.capsule.TransactionCapsule; +import org.tron.protos.Protocol; +import org.tron.protos.contract.BalanceContract; +import org.tron.protos.contract.Common.ResourceCode; + +public class UnFreezeBalanceV2ServletTest extends BaseHttpTest { + + private UnFreezeBalanceV2Servlet servlet; + private final String ownerAddr = ByteArray.toHexString(new ECKey().getAddress()); + + @Override + protected void setUpMocks() throws Exception { + servlet = new UnFreezeBalanceV2Servlet(); + injectWallet(servlet); + when(wallet.createTransactionCapsule( + any(BalanceContract.UnfreezeBalanceV2Contract.class), + eq(Protocol.Transaction.Contract.ContractType.UnfreezeBalanceV2Contract))) + .thenReturn(new TransactionCapsule(MINIMAL_TX)); + } + + @Test + public void testUnFreezeBalanceV2() throws Exception { + String jsonParam = "{" + + "\"owner_address\": \"" + ownerAddr + "\"," + + "\"unfreeze_balance\": 1000000," + + "\"resource\": \"ENERGY\"" + + "}"; + MockHttpServletRequest request = postRequest(jsonParam); + + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + verify(wallet).createTransactionCapsule( + argThat(c -> c instanceof BalanceContract.UnfreezeBalanceV2Contract + && addressEquals(((BalanceContract.UnfreezeBalanceV2Contract) c) + .getOwnerAddress(), ownerAddr) + && ((BalanceContract.UnfreezeBalanceV2Contract) c).getUnfreezeBalance() == 1000000 + && ((BalanceContract.UnfreezeBalanceV2Contract) c) + .getResource() == ResourceCode.ENERGY), + eq(Protocol.Transaction.Contract.ContractType.UnfreezeBalanceV2Contract)); + assertTransactionResponse(response); + } +} diff --git a/framework/src/test/java/org/tron/core/services/http/UpdateAssetServletTest.java b/framework/src/test/java/org/tron/core/services/http/UpdateAssetServletTest.java new file mode 100644 index 00000000000..18fbdb84a28 --- /dev/null +++ b/framework/src/test/java/org/tron/core/services/http/UpdateAssetServletTest.java @@ -0,0 +1,59 @@ +package org.tron.core.services.http; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.argThat; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import org.junit.Test; +import org.springframework.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.core.capsule.TransactionCapsule; +import org.tron.protos.Protocol; +import org.tron.protos.contract.AssetIssueContractOuterClass; + +public class UpdateAssetServletTest extends BaseHttpTest { + + private UpdateAssetServlet servlet; + private final String ownerAddr = ByteArray.toHexString(new ECKey().getAddress()); + + @Override + protected void setUpMocks() throws Exception { + servlet = new UpdateAssetServlet(); + injectWallet(servlet); + when(wallet.createTransactionCapsule( + any(AssetIssueContractOuterClass.UpdateAssetContract.class), + eq(Protocol.Transaction.Contract.ContractType.UpdateAssetContract))) + .thenReturn(new TransactionCapsule(MINIMAL_TX)); + } + + @Test + public void testUpdateAsset() throws Exception { + String jsonParam = "{" + + "\"owner_address\": \"" + ownerAddr + "\"," + + "\"description\": \"746573745f64657363\"," + + "\"url\": \"746573745f75726c\"," + + "\"new_limit\": 100," + + "\"new_public_limit\": 200" + + "}"; + MockHttpServletRequest request = postRequest(jsonParam); + + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + verify(wallet).createTransactionCapsule( + argThat(c -> c instanceof AssetIssueContractOuterClass.UpdateAssetContract + && addressEquals(((AssetIssueContractOuterClass.UpdateAssetContract) c) + .getOwnerAddress(), ownerAddr) + && ((AssetIssueContractOuterClass.UpdateAssetContract) c).getNewLimit() == 100 + && ((AssetIssueContractOuterClass.UpdateAssetContract) c).getNewPublicLimit() == 200 + && ((AssetIssueContractOuterClass.UpdateAssetContract) c) + .getDescription().toStringUtf8().equals("test_desc") + && ((AssetIssueContractOuterClass.UpdateAssetContract) c) + .getUrl().toStringUtf8().equals("test_url")), + eq(Protocol.Transaction.Contract.ContractType.UpdateAssetContract)); + assertTransactionResponse(response); + } +} diff --git a/framework/src/test/java/org/tron/core/services/http/UpdateBrokerageServletTest.java b/framework/src/test/java/org/tron/core/services/http/UpdateBrokerageServletTest.java new file mode 100644 index 00000000000..378690e9bdc --- /dev/null +++ b/framework/src/test/java/org/tron/core/services/http/UpdateBrokerageServletTest.java @@ -0,0 +1,51 @@ +package org.tron.core.services.http; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.argThat; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import org.junit.Test; +import org.springframework.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.core.capsule.TransactionCapsule; +import org.tron.protos.Protocol; +import org.tron.protos.contract.StorageContract; + +public class UpdateBrokerageServletTest extends BaseHttpTest { + + private UpdateBrokerageServlet servlet; + private final String ownerAddr = ByteArray.toHexString(new ECKey().getAddress()); + + @Override + protected void setUpMocks() throws Exception { + servlet = new UpdateBrokerageServlet(); + injectWallet(servlet); + when(wallet.createTransactionCapsule( + any(StorageContract.UpdateBrokerageContract.class), + eq(Protocol.Transaction.Contract.ContractType.UpdateBrokerageContract))) + .thenReturn(new TransactionCapsule(MINIMAL_TX)); + } + + @Test + public void testUpdateBrokerage() throws Exception { + String jsonParam = "{" + + "\"owner_address\": \"" + ownerAddr + "\"," + + "\"brokerage\": 20" + + "}"; + MockHttpServletRequest request = postRequest(jsonParam); + + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + verify(wallet).createTransactionCapsule( + argThat(c -> c instanceof StorageContract.UpdateBrokerageContract + && addressEquals(((StorageContract.UpdateBrokerageContract) c) + .getOwnerAddress(), ownerAddr) + && ((StorageContract.UpdateBrokerageContract) c).getBrokerage() == 20), + eq(Protocol.Transaction.Contract.ContractType.UpdateBrokerageContract)); + assertTransactionResponse(response); + } +} diff --git a/framework/src/test/java/org/tron/core/services/http/UpdateEnergyLimitServletTest.java b/framework/src/test/java/org/tron/core/services/http/UpdateEnergyLimitServletTest.java new file mode 100644 index 00000000000..b54407c7ab0 --- /dev/null +++ b/framework/src/test/java/org/tron/core/services/http/UpdateEnergyLimitServletTest.java @@ -0,0 +1,54 @@ +package org.tron.core.services.http; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.argThat; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import org.junit.Test; +import org.springframework.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.core.capsule.TransactionCapsule; +import org.tron.protos.Protocol.Transaction.Contract.ContractType; +import org.tron.protos.contract.SmartContractOuterClass.UpdateEnergyLimitContract; + +public class UpdateEnergyLimitServletTest extends BaseHttpTest { + + private UpdateEnergyLimitServlet servlet; + private final String ownerAddr = ByteArray.toHexString(new ECKey().getAddress()); + private final String contractAddr = ByteArray.toHexString(new ECKey().getAddress()); + + @Override + protected void setUpMocks() throws Exception { + servlet = new UpdateEnergyLimitServlet(); + injectWallet(servlet); + when(wallet.createTransactionCapsule( + any(UpdateEnergyLimitContract.class), eq(ContractType.UpdateEnergyLimitContract))) + .thenReturn(new TransactionCapsule(MINIMAL_TX)); + } + + @Test + public void testUpdateEnergyLimit() throws Exception { + String jsonParam = "{" + + "\"owner_address\": \"" + ownerAddr + "\"," + + "\"contract_address\": \"" + contractAddr + "\"," + + "\"origin_energy_limit\": 10000000" + + "}"; + MockHttpServletRequest request = postRequest(jsonParam); + + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + verify(wallet).createTransactionCapsule( + argThat(c -> c instanceof UpdateEnergyLimitContract + && addressEquals(((UpdateEnergyLimitContract) c) + .getOwnerAddress(), ownerAddr) + && addressEquals(((UpdateEnergyLimitContract) c) + .getContractAddress(), contractAddr) + && ((UpdateEnergyLimitContract) c).getOriginEnergyLimit() == 10000000), + eq(ContractType.UpdateEnergyLimitContract)); + assertTransactionResponse(response); + } +} diff --git a/framework/src/test/java/org/tron/core/services/http/UpdateSettingServletTest.java b/framework/src/test/java/org/tron/core/services/http/UpdateSettingServletTest.java new file mode 100644 index 00000000000..cd33306f50c --- /dev/null +++ b/framework/src/test/java/org/tron/core/services/http/UpdateSettingServletTest.java @@ -0,0 +1,56 @@ +package org.tron.core.services.http; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.argThat; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import org.junit.Test; +import org.springframework.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.core.capsule.TransactionCapsule; +import org.tron.protos.Protocol; +import org.tron.protos.contract.SmartContractOuterClass; + +public class UpdateSettingServletTest extends BaseHttpTest { + + private UpdateSettingServlet servlet; + private final String ownerAddr = ByteArray.toHexString(new ECKey().getAddress()); + private final String contractAddr = ByteArray.toHexString(new ECKey().getAddress()); + + @Override + protected void setUpMocks() throws Exception { + servlet = new UpdateSettingServlet(); + injectWallet(servlet); + when(wallet.createTransactionCapsule( + any(SmartContractOuterClass.UpdateSettingContract.class), + eq(Protocol.Transaction.Contract.ContractType.UpdateSettingContract))) + .thenReturn(new TransactionCapsule(MINIMAL_TX)); + } + + @Test + public void testUpdateSetting() throws Exception { + String jsonParam = "{" + + "\"owner_address\": \"" + ownerAddr + "\"," + + "\"contract_address\": \"" + contractAddr + "\"," + + "\"consume_user_resource_percent\": 50" + + "}"; + MockHttpServletRequest request = postRequest(jsonParam); + + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + verify(wallet).createTransactionCapsule( + argThat(c -> c instanceof SmartContractOuterClass.UpdateSettingContract + && addressEquals(((SmartContractOuterClass.UpdateSettingContract) c) + .getOwnerAddress(), ownerAddr) + && addressEquals(((SmartContractOuterClass.UpdateSettingContract) c) + .getContractAddress(), contractAddr) + && ((SmartContractOuterClass.UpdateSettingContract) c) + .getConsumeUserResourcePercent() == 50), + eq(Protocol.Transaction.Contract.ContractType.UpdateSettingContract)); + assertTransactionResponse(response); + } +} diff --git a/framework/src/test/java/org/tron/core/services/http/UpdateWitnessServletTest.java b/framework/src/test/java/org/tron/core/services/http/UpdateWitnessServletTest.java new file mode 100644 index 00000000000..52c0e5ede91 --- /dev/null +++ b/framework/src/test/java/org/tron/core/services/http/UpdateWitnessServletTest.java @@ -0,0 +1,52 @@ +package org.tron.core.services.http; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.argThat; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import org.junit.Test; +import org.springframework.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.core.capsule.TransactionCapsule; +import org.tron.protos.Protocol; +import org.tron.protos.contract.WitnessContract; + +public class UpdateWitnessServletTest extends BaseHttpTest { + + private UpdateWitnessServlet servlet; + private final String ownerAddr = ByteArray.toHexString(new ECKey().getAddress()); + + @Override + protected void setUpMocks() throws Exception { + servlet = new UpdateWitnessServlet(); + injectWallet(servlet); + when(wallet.createTransactionCapsule( + any(WitnessContract.WitnessUpdateContract.class), + eq(Protocol.Transaction.Contract.ContractType.WitnessUpdateContract))) + .thenReturn(new TransactionCapsule(MINIMAL_TX)); + } + + @Test + public void testUpdateWitness() throws Exception { + String jsonParam = "{" + + "\"owner_address\": \"" + ownerAddr + "\"," + + "\"update_url\": \"746573745f75726c\"" + + "}"; + MockHttpServletRequest request = postRequest(jsonParam); + + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + verify(wallet).createTransactionCapsule( + argThat(c -> c instanceof WitnessContract.WitnessUpdateContract + && addressEquals(((WitnessContract.WitnessUpdateContract) c) + .getOwnerAddress(), ownerAddr) + && ((WitnessContract.WitnessUpdateContract) c) + .getUpdateUrl().toStringUtf8().equals("test_url")), + eq(Protocol.Transaction.Contract.ContractType.WitnessUpdateContract)); + assertTransactionResponse(response); + } +} diff --git a/framework/src/test/java/org/tron/core/services/http/UtilMockTest.java b/framework/src/test/java/org/tron/core/services/http/UtilMockTest.java index 221c5a7a165..1f6bd88ba79 100644 --- a/framework/src/test/java/org/tron/core/services/http/UtilMockTest.java +++ b/framework/src/test/java/org/tron/core/services/http/UtilMockTest.java @@ -1,12 +1,9 @@ package org.tron.core.services.http; -import com.alibaba.fastjson.JSONObject; import com.google.protobuf.ByteString; - import java.security.InvalidParameterException; import java.util.ArrayList; import java.util.List; - import org.apache.commons.lang3.StringUtils; import org.junit.After; import org.junit.Assert; @@ -16,6 +13,7 @@ import org.tron.common.utils.Sha256Hash; import org.tron.core.capsule.BlockCapsule; import org.tron.core.capsule.TransactionCapsule; +import org.tron.json.JSONObject; import org.tron.p2p.utils.ByteArray; import org.tron.protos.Protocol; import org.tron.protos.contract.BalanceContract; @@ -240,4 +238,4 @@ public void testGetJsonString() { Assert.assertEquals(expect, ret2); } -} \ No newline at end of file +} diff --git a/framework/src/test/java/org/tron/core/services/http/ValidateAddressServletTest.java b/framework/src/test/java/org/tron/core/services/http/ValidateAddressServletTest.java new file mode 100644 index 00000000000..a74f04765a8 --- /dev/null +++ b/framework/src/test/java/org/tron/core/services/http/ValidateAddressServletTest.java @@ -0,0 +1,58 @@ +package org.tron.core.services.http; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; + +import org.junit.Test; +import org.springframework.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; + +public class ValidateAddressServletTest extends BaseHttpTest { + + private ValidateAddressServlet servlet; + private final String validAddr = ByteArray.toHexString(new ECKey().getAddress()); + + @Override + protected void setUpMocks() throws Exception { + servlet = new ValidateAddressServlet(); + } + + @Test + public void testValidateAddressGet() throws Exception { + MockHttpServletRequest request = getRequest("address", validAddr); + + MockHttpServletResponse response = newResponse(); + servlet.doGet(request, response); + assertEquals(200, response.getStatus()); + String content = response.getContentAsString(); + assertTrue("Should report valid", content.contains("\"result\":true")); + assertFalse("Should not contain Error", content.contains("\"Error\"")); + } + + @Test + public void testValidateAddressPost() throws Exception { + String json = "{\"address\": \"" + validAddr + "\"}"; + MockHttpServletRequest request = postRequest(json); + + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + assertEquals(200, response.getStatus()); + String content = response.getContentAsString(); + assertTrue("Should report valid", content.contains("\"result\":true")); + } + + @Test + public void testValidateInvalidAddress() throws Exception { + MockHttpServletRequest request = getRequest("address", "invalid_address"); + + MockHttpServletResponse response = newResponse(); + servlet.doGet(request, response); + assertEquals(200, response.getStatus()); + String content = response.getContentAsString(); + assertTrue("Should report invalid", content.contains("\"result\":false")); + assertFalse("Should not report valid", content.contains("\"result\":true")); + } +} diff --git a/framework/src/test/java/org/tron/core/services/http/VoteWitnessAccountServletTest.java b/framework/src/test/java/org/tron/core/services/http/VoteWitnessAccountServletTest.java new file mode 100644 index 00000000000..8166a001ce7 --- /dev/null +++ b/framework/src/test/java/org/tron/core/services/http/VoteWitnessAccountServletTest.java @@ -0,0 +1,54 @@ +package org.tron.core.services.http; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.argThat; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import org.junit.Test; +import org.springframework.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.core.capsule.TransactionCapsule; +import org.tron.protos.Protocol.Transaction.Contract.ContractType; +import org.tron.protos.contract.WitnessContract.VoteWitnessContract; + +public class VoteWitnessAccountServletTest extends BaseHttpTest { + + private VoteWitnessAccountServlet servlet; + private final String ownerAddr = ByteArray.toHexString(new ECKey().getAddress()); + private final String voteAddr = ByteArray.toHexString(new ECKey().getAddress()); + + @Override + protected void setUpMocks() throws Exception { + servlet = new VoteWitnessAccountServlet(); + injectWallet(servlet); + when(wallet.createTransactionCapsule( + any(VoteWitnessContract.class), eq(ContractType.VoteWitnessContract))) + .thenReturn(new TransactionCapsule(MINIMAL_TX)); + } + + @Test + public void testVoteWitnessAccount() throws Exception { + String jsonParam = "{" + + "\"owner_address\": \"" + ownerAddr + "\"," + + "\"votes\": [{\"vote_address\": \"" + voteAddr + "\"," + + "\"vote_count\": 1}]" + + "}"; + MockHttpServletRequest request = postRequest(jsonParam); + + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + verify(wallet).createTransactionCapsule( + argThat(c -> c instanceof VoteWitnessContract + && addressEquals(((VoteWitnessContract) c).getOwnerAddress(), ownerAddr) + && ((VoteWitnessContract) c).getVotesCount() == 1 + && ((VoteWitnessContract) c).getVotes(0).getVoteCount() == 1 + && addressEquals(((VoteWitnessContract) c).getVotes(0) + .getVoteAddress(), voteAddr)), + eq(ContractType.VoteWitnessContract)); + assertTransactionResponse(response); + } +} diff --git a/framework/src/test/java/org/tron/core/services/http/WithdrawBalanceServletTest.java b/framework/src/test/java/org/tron/core/services/http/WithdrawBalanceServletTest.java new file mode 100644 index 00000000000..f793265f9bc --- /dev/null +++ b/framework/src/test/java/org/tron/core/services/http/WithdrawBalanceServletTest.java @@ -0,0 +1,46 @@ +package org.tron.core.services.http; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.argThat; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import org.junit.Test; +import org.springframework.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.core.capsule.TransactionCapsule; +import org.tron.protos.Protocol; +import org.tron.protos.contract.BalanceContract; + +public class WithdrawBalanceServletTest extends BaseHttpTest { + + private WithdrawBalanceServlet servlet; + private final String ownerAddr = ByteArray.toHexString(new ECKey().getAddress()); + + @Override + protected void setUpMocks() throws Exception { + servlet = new WithdrawBalanceServlet(); + injectWallet(servlet); + when(wallet.createTransactionCapsule(any(BalanceContract.WithdrawBalanceContract.class), + eq(Protocol.Transaction.Contract.ContractType.WithdrawBalanceContract))) + .thenReturn(new TransactionCapsule(MINIMAL_TX)); + } + + @Test + public void testWithdrawBalance() throws Exception { + String jsonParam = "{\"owner_address\": \"" + ownerAddr + "\"}"; + MockHttpServletRequest request = postRequest(jsonParam); + + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + verify(wallet).createTransactionCapsule( + argThat(c -> c instanceof BalanceContract.WithdrawBalanceContract + && addressEquals(((BalanceContract.WithdrawBalanceContract) c) + .getOwnerAddress(), ownerAddr)), + eq(Protocol.Transaction.Contract.ContractType.WithdrawBalanceContract)); + assertTransactionResponse(response); + } +} diff --git a/framework/src/test/java/org/tron/core/services/http/WithdrawExpireUnfreezeServletTest.java b/framework/src/test/java/org/tron/core/services/http/WithdrawExpireUnfreezeServletTest.java new file mode 100644 index 00000000000..9e733018452 --- /dev/null +++ b/framework/src/test/java/org/tron/core/services/http/WithdrawExpireUnfreezeServletTest.java @@ -0,0 +1,47 @@ +package org.tron.core.services.http; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.argThat; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import org.junit.Test; +import org.springframework.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; +import org.tron.common.crypto.ECKey; +import org.tron.common.utils.ByteArray; +import org.tron.core.capsule.TransactionCapsule; +import org.tron.protos.Protocol; +import org.tron.protos.contract.BalanceContract; + +public class WithdrawExpireUnfreezeServletTest extends BaseHttpTest { + + private WithdrawExpireUnfreezeServlet servlet; + private final String ownerAddr = ByteArray.toHexString(new ECKey().getAddress()); + + @Override + protected void setUpMocks() throws Exception { + servlet = new WithdrawExpireUnfreezeServlet(); + injectWallet(servlet); + when(wallet.createTransactionCapsule( + any(BalanceContract.WithdrawExpireUnfreezeContract.class), + eq(Protocol.Transaction.Contract.ContractType.WithdrawExpireUnfreezeContract))) + .thenReturn(new TransactionCapsule(MINIMAL_TX)); + } + + @Test + public void testWithdrawExpireUnfreeze() throws Exception { + String jsonParam = "{\"owner_address\": \"" + ownerAddr + "\"}"; + MockHttpServletRequest request = postRequest(jsonParam); + + MockHttpServletResponse response = newResponse(); + servlet.doPost(request, response); + verify(wallet).createTransactionCapsule( + argThat(c -> c instanceof BalanceContract.WithdrawExpireUnfreezeContract + && addressEquals(((BalanceContract.WithdrawExpireUnfreezeContract) c) + .getOwnerAddress(), ownerAddr)), + eq(Protocol.Transaction.Contract.ContractType.WithdrawExpireUnfreezeContract)); + assertTransactionResponse(response); + } +} diff --git a/framework/src/test/java/org/tron/core/services/interfaceOnPBFT/http/GetBandwidthPricesOnPBFTServletTest.java b/framework/src/test/java/org/tron/core/services/interfaceOnPBFT/http/GetBandwidthPricesOnPBFTServletTest.java index 5f6558e0bd3..b37a792bc45 100644 --- a/framework/src/test/java/org/tron/core/services/interfaceOnPBFT/http/GetBandwidthPricesOnPBFTServletTest.java +++ b/framework/src/test/java/org/tron/core/services/interfaceOnPBFT/http/GetBandwidthPricesOnPBFTServletTest.java @@ -4,7 +4,6 @@ import static org.junit.Assert.fail; import static org.tron.common.utils.client.utils.HttpMethed.createRequest; -import com.alibaba.fastjson.JSONObject; import java.io.UnsupportedEncodingException; import javax.annotation.Resource; import org.apache.http.client.methods.HttpGet; @@ -16,6 +15,7 @@ import org.tron.common.BaseTest; import org.tron.common.TestConstants; import org.tron.core.config.args.Args; +import org.tron.json.JSONObject; public class GetBandwidthPricesOnPBFTServletTest extends BaseTest { diff --git a/framework/src/test/java/org/tron/core/services/interfaceOnPBFT/http/GetEnergyPricesOnPBFTServletTest.java b/framework/src/test/java/org/tron/core/services/interfaceOnPBFT/http/GetEnergyPricesOnPBFTServletTest.java index a2774095d94..71d7e7e4b0b 100644 --- a/framework/src/test/java/org/tron/core/services/interfaceOnPBFT/http/GetEnergyPricesOnPBFTServletTest.java +++ b/framework/src/test/java/org/tron/core/services/interfaceOnPBFT/http/GetEnergyPricesOnPBFTServletTest.java @@ -4,7 +4,6 @@ import static org.junit.Assert.fail; import static org.tron.common.utils.client.utils.HttpMethed.createRequest; -import com.alibaba.fastjson.JSONObject; import java.io.UnsupportedEncodingException; import javax.annotation.Resource; import org.apache.http.client.methods.HttpGet; @@ -16,6 +15,7 @@ import org.tron.common.BaseTest; import org.tron.common.TestConstants; import org.tron.core.config.args.Args; +import org.tron.json.JSONObject; public class GetEnergyPricesOnPBFTServletTest extends BaseTest { diff --git a/framework/src/test/java/org/tron/core/services/interfaceOnSolidity/http/GetBandwidthPricesOnSolidityServletTest.java b/framework/src/test/java/org/tron/core/services/interfaceOnSolidity/http/GetBandwidthPricesOnSolidityServletTest.java index d1f2e33410f..890528b72e4 100644 --- a/framework/src/test/java/org/tron/core/services/interfaceOnSolidity/http/GetBandwidthPricesOnSolidityServletTest.java +++ b/framework/src/test/java/org/tron/core/services/interfaceOnSolidity/http/GetBandwidthPricesOnSolidityServletTest.java @@ -4,7 +4,6 @@ import static org.junit.Assert.fail; import static org.tron.common.utils.client.utils.HttpMethed.createRequest; -import com.alibaba.fastjson.JSONObject; import java.io.UnsupportedEncodingException; import javax.annotation.Resource; import org.apache.http.client.methods.HttpGet; @@ -16,6 +15,7 @@ import org.tron.common.BaseTest; import org.tron.common.TestConstants; import org.tron.core.config.args.Args; +import org.tron.json.JSONObject; public class GetBandwidthPricesOnSolidityServletTest extends BaseTest { diff --git a/framework/src/test/java/org/tron/core/services/interfaceOnSolidity/http/GetEnergyPricesOnSolidityServletTest.java b/framework/src/test/java/org/tron/core/services/interfaceOnSolidity/http/GetEnergyPricesOnSolidityServletTest.java index 133a4b5cde5..b7310d065f3 100644 --- a/framework/src/test/java/org/tron/core/services/interfaceOnSolidity/http/GetEnergyPricesOnSolidityServletTest.java +++ b/framework/src/test/java/org/tron/core/services/interfaceOnSolidity/http/GetEnergyPricesOnSolidityServletTest.java @@ -4,7 +4,6 @@ import static org.junit.Assert.fail; import static org.tron.common.utils.client.utils.HttpMethed.createRequest; -import com.alibaba.fastjson.JSONObject; import java.io.UnsupportedEncodingException; import javax.annotation.Resource; import org.apache.http.client.methods.HttpGet; @@ -16,6 +15,7 @@ import org.tron.common.BaseTest; import org.tron.common.TestConstants; import org.tron.core.config.args.Args; +import org.tron.json.JSONObject; public class GetEnergyPricesOnSolidityServletTest extends BaseTest { diff --git a/framework/src/test/java/org/tron/core/zksnark/MerkleTreeTest.java b/framework/src/test/java/org/tron/core/zksnark/MerkleTreeTest.java index faea3780135..e21ba8010b5 100644 --- a/framework/src/test/java/org/tron/core/zksnark/MerkleTreeTest.java +++ b/framework/src/test/java/org/tron/core/zksnark/MerkleTreeTest.java @@ -1,6 +1,5 @@ package org.tron.core.zksnark; -import com.alibaba.fastjson.JSONArray; import com.google.common.base.Charsets; import com.google.common.collect.Lists; import com.google.common.io.Files; @@ -21,6 +20,7 @@ import org.tron.core.capsule.IncrementalMerkleVoucherCapsule; import org.tron.core.capsule.PedersenHashCapsule; import org.tron.core.config.args.Args; +import org.tron.json.JSONArray; import org.tron.protos.contract.ShieldContract.PedersenHash; public class MerkleTreeTest extends BaseTest { diff --git a/framework/src/test/java/org/tron/core/zksnark/SendCoinShieldTest.java b/framework/src/test/java/org/tron/core/zksnark/SendCoinShieldTest.java index e7dfa06d094..8693bf0716d 100644 --- a/framework/src/test/java/org/tron/core/zksnark/SendCoinShieldTest.java +++ b/framework/src/test/java/org/tron/core/zksnark/SendCoinShieldTest.java @@ -2,7 +2,6 @@ import static org.tron.core.capsule.TransactionCapsule.getShieldTransactionHashIgnoreTypeException; -import com.alibaba.fastjson.JSONArray; import com.google.common.base.Charsets; import com.google.common.collect.Lists; import com.google.common.io.Files; @@ -80,6 +79,7 @@ import org.tron.core.zen.note.NoteEncryption; import org.tron.core.zen.note.NoteEncryption.Encryption; import org.tron.core.zen.note.OutgoingPlaintext; +import org.tron.json.JSONArray; import org.tron.protos.Protocol; import org.tron.protos.Protocol.AccountType; import org.tron.protos.Protocol.Transaction.Contract.ContractType; diff --git a/framework/src/test/java/org/tron/json/JsonTest.java b/framework/src/test/java/org/tron/json/JsonTest.java new file mode 100644 index 00000000000..25dc62820d6 --- /dev/null +++ b/framework/src/test/java/org/tron/json/JsonTest.java @@ -0,0 +1,107 @@ +package org.tron.json; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertThrows; +import static org.junit.Assert.assertTrue; + +import org.junit.Test; + +/** + * Tests for Jackson {@code JsonReadFeature} compatibility with Fastjson 1.x. + */ +public class JsonTest { + + @Test + public void testUnquotedFieldNames() { + assertEquals(1, JSON.parseObject("{a:1}").getIntValue("a")); + } + + @Test + public void testSingleQuotes() { + assertEquals(1, JSON.parseObject("{'a':'1'}").getIntValue("a")); + } + + @Test + public void testTrailingComma() { + JSONArray array = JSON.parseArray("[1,2,{\"a\":1,},]"); + assertEquals(3, array.size()); + assertEquals(2, array.get(1)); + assertEquals(1, ((JSONObject) array.get(2)).getIntValue("a")); + } + + @Test + public void testNonNumericNumbers() { + JSONObject json = JSON.parseObject("{a:NaN, b:Infinity, c:-Infinity}"); + assertNotNull(json); + double val = ((Number) json.get("a")).doubleValue(); + assertTrue(Double.isNaN(val)); // Fastjson is null, but jackson parses as NaN + val = ((Number) json.get("b")).doubleValue(); + assertTrue(Double.isInfinite(val) && val > 0); // Fastjson will throw an error + val = ((Number) json.get("c")).doubleValue(); + assertTrue(Double.isInfinite(val) && val < 0); // Fastjson will throw an error + } + + @Test + public void testLeadingNumbers() { + JSONObject o = JSON.parseObject("{'a':+1,b:-2,c:.3,d:-.4,e:+.5,f:+6.,h:007}"); + assertNotNull(o); + assertEquals(1, o.getIntValue("a")); + assertEquals(-2, o.getIntValue("b")); + assertEquals("0.3", o.getBigDecimal("c").toPlainString()); // Fastjson will throw an error + assertEquals("-0.4", o.getBigDecimal("d").toPlainString()); + assertEquals("0.5", o.getBigDecimal("e").toPlainString()); + assertEquals(6, o.getIntValue("f")); + assertEquals(7, o.getIntValue("h")); + } + + @Test + public void testUnescapedControlChars() { + JSONObject obj = JSON.parseObject("{'a':'line1\n\tline2'}"); + assertNotNull(obj); + assertEquals("line1\n\tline2", obj.getString("a")); + obj = JSON.parseObject("{\"a\":\"\u0001\"}"); + assertNotNull(obj); + assertEquals("\u0001", obj.getString("a")); + } + + @Test + public void testBackslashEscapeAnyChar() { + JSONObject obj = JSON.parseObject("{\"a\":\"\\q\"}"); // Fastjson will throw an error + assertNotNull(obj); + assertEquals("q", obj.getString("a")); + } + + @Test + public void testComment() { + JSONObject obj = JSON.parseObject("{\"a\":1} \n\t // this is a comment"); + assertNotNull(obj); + assertEquals(1, obj.getIntValue("a")); + obj = JSON.parseObject("{/* comment */\"a\":1}"); + assertNotNull(obj); + assertEquals(1, obj.getIntValue("a")); + } + + + @Test + public void testParseNull() { + assertNull(JSON.parseObject(null)); + assertNull(JSON.parseObject("")); + assertNull(JSON.parseObject(" ")); + assertNull(JSON.parseObject("\n\t")); + assertNull(JSON.parseObject("null")); + assertNull(JSON.parseObject("NULL")); + } + + @Test + public void testThrows() { + assertThrows(JSONException.class, () -> JSON.parseObject("{a:abc}")); + assertThrows(JSONException.class, () -> JSON.parseObject("{a:TRUE}")); + assertThrows(JSONException.class, () -> JSON.parseObject("{a:FALSE}")); + assertThrows(JSONException.class, () -> JSON.parseObject("[1,,3]")); + // NOTE: Fastjson 1.x treats unquoted NULL as null, but jackson throws an error + assertThrows(JSONException.class, () -> JSON.parseObject("{a:NULL}")); + } + +} diff --git a/gradle/verification-metadata.xml b/gradle/verification-metadata.xml index 86880157f35..2692e2005db 100644 --- a/gradle/verification-metadata.xml +++ b/gradle/verification-metadata.xml @@ -70,14 +70,6 @@ - - - - - - - - @@ -187,9 +179,9 @@ - - - + + + @@ -197,9 +189,9 @@ - - - + + + @@ -207,9 +199,9 @@ - - - + + + @@ -217,9 +209,9 @@ - - - + + + @@ -227,15 +219,15 @@ - - - + + + - - + + - - + + @@ -243,15 +235,15 @@ - - - + + + - - + + - - + + @@ -259,15 +251,15 @@ - - - + + + - - + + - - + + @@ -2036,6 +2028,14 @@ + + + + + + + +