Integrating TRC20-USDT into your Java-based application can significantly reduce transaction fees and improve processing speed compared to older standards like ERC20. This comprehensive guide walks you through the entire process—from setting up dependencies to implementing core blockchain operations such as balance checks, address generation, and token transfers—with ready-to-use code examples.
Whether you're building a wallet service, payment gateway, or crypto settlement system, this tutorial delivers practical solutions for seamless TRON network integration.
Why Choose TRC20-USDT?
Before diving into the technical details, it's important to understand why TRC20-USDT has become a preferred choice for developers and businesses:
- Low transaction fees: Often less than $0.1 per transfer.
- Fast confirmation times: Transactions settle in under 3 seconds on average.
- High scalability: The TRON network supports thousands of transactions per second.
- Wide exchange support: Major platforms like OKX, Binance, and Huobi list TRC20-USDT.
These advantages make TRC20 ideal for high-frequency transactions and automated fund management systems.
👉 Discover how easy it is to manage digital assets using modern blockchain tools.
Setting Up the Development Environment
To interact with the TRON blockchain in Java, you need the official wallet-cli SDK. This library provides essential utilities for key management, contract interaction, and transaction signing.
Add the wallet-cli Dependency
The required JAR file isn’t available on public Maven repositories. You must manually install it from the TRON GitHub repository, though we’ll focus only on the integration steps compliant with content policies.
After downloading the project:
- Build the JAR using
mvn install. Install it locally via:
mvn install:install-file -Dfile=wallet-cli-1.0.0.jar -DgroupId=com.tron -DartifactId=wallet-cli -Dversion=1.0.0 -Dpackaging=jarInclude in your
pom.xml:<dependency> <groupId>com.tron</groupId> <artifactId>wallet-cli</artifactId> <version>1.0.0</version> </dependency>
With this setup complete, you're ready to start coding.
Core Functionalities with Sample Code
Below are essential functions for working with TRC20-USDT, each explained clearly and optimized for production use.
Generate a New Wallet Address (Offline)
You can create a new TRON address offline without connecting to any node:
private static SecureRandom random = new SecureRandom();
public static Map<String, String> createAddress() {
ECKey eCkey = new ECKey(random);
String privateKey = ByteArray.toHexString(eCkey.getPrivKeyBytes());
byte[] addressBytes = eCkey.getAddress();
String hexAddress = ByteArray.toHexString(addressBytes);
Map<String, String> addressInfo = new HashMap<>(3);
addressInfo.put("address", toViewAddress(hexAddress));
addressInfo.put("hexAddress", hexAddress);
addressInfo.put("privateKey", privateKey);
return addressInfo;
}
public static String toViewAddress(String hexAddress) {
return encode58Check(ByteArray.fromHexString(hexAddress));
}
public static String encode58Check(byte[] input) {
try {
byte[] hash0 = hash(true, input);
byte[] hash1 = hash(true, hash0);
byte[] inputCheck = new byte[input.length + 4];
System.arraycopy(input, 0, inputCheck, 0, input.length);
System.arraycopy(hash1, 0, inputCheck, input.length, 4);
return Base58.encode(inputCheck);
} catch (Throwable t) {
logger.error("Data encoding error", t);
}
return null;
}🔐 Security Note: Always encrypt private keys before storing them in databases or logs.
Check TRC20-USDT Balance
Query the USDT balance of any address using the /wallet/triggerconstantcontract endpoint:
private static final String tronUrl = "https://api.trongrid.io";
public BigDecimal balanceOfTrc20(String address) {
String url = tronUrl + "/wallet/triggerconstantcontract";
JSONObject param = new JSONObject();
param.put("owner_address", TronUtils.toHexAddress(address));
param.put("contract_address", TronUtils.toHexAddress("TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t"));
param.put("function_selector", "balanceOf(address)");
List<Object> inputParameters = new ArrayList<>();
inputParameters.add(new Address(TronUtils.toHexAddress(address).substring(2)));
param.put("parameter", FunctionEncoder.encodeConstructor(inputParameters));
String result = HttpClientUtils.postJson(url, param.toJSONString());
if (StringUtils.isNotEmpty(result)) {
JSONObject obj = JSONObject.parseObject(result);
JSONArray results = obj.getJSONArray("constant_result");
if (results != null && results.size() > 0) {
BigInteger amount = new BigInteger(results.getString(0), 16);
return new BigDecimal(amount).divide(BigDecimal.TEN.pow(6), 6, RoundingMode.FLOOR);
}
}
return BigDecimal.ZERO;
}📌 Replace the contract address if working with other TRC20 tokens.
Retrieve Address from Private Key
Use this method to derive an address from an existing private key:
public static String getAddressByPrivateKey(String privateKey) {
byte[] privateBytes = Hex.decode(privateKey);
ECKey ecKey = ECKey.fromPrivate(privateBytes);
byte[] from = ecKey.getAddress();
return toViewAddress(Hex.toHexString(from));
}This is useful for validating user-provided keys or restoring wallets.
Transfer TRC20-USDT Tokens
Transferring USDT involves calling the smart contract’s transfer function:
public String sendTrc20(String privateKey, String toAddress, BigDecimal amount) throws Throwable {
String ownerAddress = TronUtils.getAddressByPrivateKey(privateKey);
JSONObject jsonObject = new JSONObject();
jsonObject.put("contract_address", TronUtils.toHexAddress("TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t"));
jsonObject.put("function_selector", "transfer(address,uint256)");
List<Object> inputParameters = new ArrayList<>();
inputParameters.add(new Address(TronUtils.toHexAddress(toAddress).substring(2)));
inputParameters.add(new Uint256(amount.multiply(BigDecimal.TEN.pow(6)).toBigInteger()));
jsonObject.put("parameter", FunctionEncoder.encodeConstructor(inputParameters));
jsonObject.put("owner_address", TronUtils.toHexAddress(ownerAddress));
jsonObject.put("call_value", 0);
jsonObject.put("fee_limit", 6000000L);
String response = HttpClientUtils.postJson(tronUrl + "/wallet/triggersmartcontract", jsonObject.toString());
JSONObject result = JSONObject.parseObject(response);
if (result.containsKey("Error")) {
throw new RuntimeException("Transaction preparation failed");
}
JSONObject tx = result.getJSONObject("transaction");
tx.getJSONObject("raw_data").put("data", Hex.toHexString("Transfer USDT".getBytes()));
return signAndBroadcast(tronUrl, privateKey, tx);
}👉 Learn how to securely handle blockchain transactions in real-world applications.
Query Latest Block & Transaction Status
Stay synchronized with the blockchain by fetching the latest block number:
public BigInteger getNowBlock() {
String url = tronUrl + "/wallet/getnowblock";
String response = HttpRequest.get(url).execute().body();
JSONObject jsonObject = JSONObject.parseObject(response);
return jsonObject.getJSONObject("block_header")
.getJSONObject("raw_data")
.getBigInteger("number");
}Verify a transaction’s success status:
public boolean transactionStatus(String hash) {
String txData = getTransactionById(hash);
JSONObject obj = JSON.parseObject(txData);
if (obj.isEmpty()) return false;
String status = obj.getJSONArray("ret").getJSONObject(0).getString("contractRet");
return "SUCCESS".equals(status);
}Frequently Asked Questions
Q: Do I need TRX to send TRC20 tokens?
A: Yes. Every TRC20 transaction requires energy or bandwidth, which is powered by holding or burning TRX. Without sufficient resources, transactions will fail.
Q: Can I use this code in production?
A: The provided snippets are functional but require error handling enhancements, logging improvements, and security hardening (e.g., key encryption) before deployment.
Q: Is there a rate limit on Trongrid API?
A: Yes. Public endpoints have usage limits. For high-volume services, consider running your own node or using premium API tiers.
Q: How long does a TRC20 transfer take?
A: Typically confirmed within 1–3 seconds under normal network conditions.
Q: What is the decimal precision of USDT on TRON?
A: TRC20-USDT uses 6 decimal places (1 USDT = 1,000,000 units).
Q: Can I monitor incoming transactions?
A: Yes. Use getTransactionInfoByBlockNum() to scan blocks for transfers to your addresses—ideal for auto-deposit systems.
Final Thoughts
Integrating TRC20-USDT into Java applications opens doors to fast, low-cost digital asset transfers. With proper implementation of wallet creation, balance queries, and secure transaction broadcasting, you can build robust financial infrastructure capable of handling real-time crypto operations.
Always test thoroughly on the Shasta testnet before going live. And remember—private keys are irreversible; protect them at all costs.
👉 Explore advanced tools that simplify blockchain development and asset tracking.