Connect to the TRON network

const { TronWeb } = require('tronweb');

const privateKey = process.env.TRON_PRIVATE_KEY;
const apiKey = process.env.TRON_PRO_API_KEY;
if (privateKey && !/^[0-9a-fA-F]{64}$/.test(privateKey)) {
  throw new Error('Set TRON_PRIVATE_KEY to a 64-character hexadecimal private key');
}

const options = {
  fullHost: 'https://api.shasta.trongrid.io',
  // Mainnet: https://api.trongrid.io
  // Nile testnet: https://nile.trongrid.io
  headers: apiKey ? { 'TRON-PRO-API-KEY': apiKey } : {}
};
if (privateKey) options.privateKey = privateKey;

const tronWeb = new TronWeb(options);

import org.tron.trident.core.ApiWrapper;
import java.util.Locale;

String privateKey = System.getenv("TRON_PRIVATE_KEY");
if (privateKey == null || !privateKey.matches("[0-9a-fA-F]{64}")) {
    throw new IllegalArgumentException("TRON_PRIVATE_KEY must contain 64 hexadecimal characters");
}

String network = System.getenv("TRON_NETWORK");
if (network == null || network.trim().isEmpty()) {
    network = "shasta";
}

ApiWrapper client;
switch (network.trim().toLowerCase(Locale.ROOT)) {
    case "shasta":
        client = ApiWrapper.ofShasta(privateKey);
        break;
    case "nile":
        client = ApiWrapper.ofNile(privateKey);
        break;
    case "mainnet": {
        String apiKey = System.getenv("TRON_PRO_API_KEY");
        if (apiKey == null || apiKey.trim().isEmpty()) {
            throw new IllegalArgumentException("TRON_PRO_API_KEY is required for mainnet");
        }
        client = ApiWrapper.ofMainnet(privateKey, apiKey);
        break;
    }
    case "custom": {
        String fullNode = System.getenv("TRON_FULLNODE_GRPC");
        String solidityNode = System.getenv("TRON_SOLIDITY_GRPC");
        if (fullNode == null || fullNode.trim().isEmpty()
                || solidityNode == null || solidityNode.trim().isEmpty()) {
            throw new IllegalArgumentException(
                "TRON_FULLNODE_GRPC and TRON_SOLIDITY_GRPC are required for a custom network"
            );
        }
        client = new ApiWrapper(fullNode, solidityNode, privateKey);
        break;
    }
    default:
        throw new IllegalArgumentException("Unsupported TRON_NETWORK: " + network);
}