docs: audit and update root-level docs and scripts

- gen.sh: fix proto paths, add shebang and -I include flags, split core/api
- build.md: rewrite with current JDK matrix; deduplicate vs README via links
- run.md: rewrite to remove dead links, fix SR private key security issue,
  remove gradle run -Pwitness and 2018-era log output
- quickstart.md: remove deprecated Solidity Node port/references; mark
  docker-tron-quickstart as community-maintained
- CONTRIBUTING.md: replace Travis CI with GitHub Actions; fix commit
  title length from 50 to 10-72 chars to match PR Title Format section

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: Little-Peony

CONTRIBUTING.md

@@ -147,7 +147,7 @@ We would like all developers to follow a standard development flow and coding st
 2. Review the code before submission.
 3. Run standardized tests.
 
-`Sonar`-scanner and `Travis CI` continuous integration scanner will be automatically triggered when a pull request has been submitted. When a PR passes all the checks, the **java-tron** maintainers will then review the PR and offer feedback and modifications when necessary.  Once adopted, the PR will be closed and merged into the `develop` branch.
+`Sonar`-scanner and CI checks (GitHub Actions) will be automatically triggered when a pull request has been submitted. When a PR passes all the checks, the **java-tron** maintainers will then review the PR and offer feedback and modifications when necessary.  Once adopted, the PR will be closed and merged into the `develop` branch.
 
 We are glad to receive your pull requests and will try our best to review them as soon as we can. Any pull request is welcome, even if it is for a typo.
 
@@ -161,7 +161,7 @@ Please make sure your submission meets the following code style:
 - The code must have passed the Sonar scanner test.
 - The code has to be pulled from the `develop` branch.
 - The commit message should start with a verb, whose initial should not be capitalized.
-- The commit message should be less than 50 characters in length.
+- The commit message title should be between 10 and 72 characters in length.
 
 
 
@@ -196,7 +196,7 @@ The message header is a single line that contains succinct description of the ch
 The `scope` can be anything specifying place of the commit change. For example: `framework`, `api`, `tvm`, `db`, `net`. For a full list of scopes, see [Type and Scope Reference](#type-and-scope-reference). You can use `*` if there isn't a more fitting scope.
 
 The subject contains a succinct description of the change:
-1. Limit the subject line, which briefly describes the purpose of the commit, to 50 characters.
+1. Limit the subject line, which briefly describes the purpose of the commit, to 72 characters (minimum 10).
 2. Start with a verb and use first-person present-tense (e.g., use "change" instead of "changed" or "changes").
 3. Do not capitalize the first letter.
 4. Do not end the subject line with a period.

build.md

@@ -1,81 +1,54 @@
 # How to Build
 
-## Prepare dependencies
+## Hardware Requirements
 
-* JDK 1.8 (JDK 1.9+ are not supported yet)
-* On Linux Ubuntu system (e.g. Ubuntu 16.04.4 LTS), ensure that the machine has [__Oracle JDK 8__](https://www.digitalocean.com/community/tutorials/how-to-install-java-with-apt-get-on-ubuntu-16-04), instead of having __Open JDK 8__ in the system. If you are building the source code by using __Open JDK 8__, you will get [__Build Failed__](https://github.com/tronprotocol/java-tron/issues/337) result.
-* Open **UDP** ports for connection to the network
-* **Minimum** 2 CPU Cores
+For mainnet deployment, refer to the [Hardware Requirements for Mainnet](README.md#hardware-requirements-for-mainnet) table in the README.
 
-## Build and Deploy automatically using scripts
+For compilation only (not running a node), a minimum of **4 CPU cores, 16 GB RAM, and 10 GB free disk space** is sufficient.
 
-- Please take a look at the [Tron Deployment Scripts](https://github.com/tronprotocol/TronDeployment) repository.
+## Prerequisites, Source Code, and Console Build
 
-## Getting the code with git
+See [Building the Source Code](README.md#building-the-source-code) in the README for:
+- Hardware/OS/JDK prerequisites
+- Dependency installation (`install_dependencies.sh`)
+- `git clone` and `./gradlew build` instructions
 
-* Use Git from the console, see the [Setting up Git](https://help.github.com/articles/set-up-git/) and [Fork a Repo](https://help.github.com/articles/fork-a-repo/) articles.
-* `develop` branch: the newest code 
-* `master` branch: more stable than develop.
-In the shell command, type:
-  ```bash
-  git clone https://github.com/tronprotocol/java-tron.git
-  git checkout -t origin/master
-  ```
+## Building in IntelliJ IDEA
 
-* For Mac, you can also install **[GitHub for Mac](https://mac.github.com/)** then **[fork and clone our repository](https://guides.github.com/activities/forking/)**. 
+Run `./gradlew build -x test` once from the terminal before opening the project to generate protobuf sources.
 
-* If you'd rather not use Git, **[Download the ZIP](https://github.com/tronprotocol/java-tron/archive/develop.zip)**
+1. Open IntelliJ IDEA and select **File → Open**, locate the `java-tron` directory, and click **Open**.
+2. When prompted, select **Trust Project**.
+3. Wait for Gradle sync to complete.
+4. In **Settings → Build, Execution, Deployment → Compiler → Annotation Processors**, enable **Annotation Processing**.
+5. In the **Gradle** panel, navigate to **Tasks → build** and double-click **build**.
 
-## Including java-tron as dependency
+## Including java-tron as a Dependency
 
-If you don't want to checkout the code and build the project, you can include it directly as a dependency.
+**Gradle:**
 
-**Using gradle:**
-
-```
+```groovy
 repositories {
-   maven { url 'https://jitpack.io' }
+    maven { url 'https://jitpack.io' }
 }
 dependencies {
-   implementation 'com.github.tronprotocol:java-tron:develop-SNAPSHOT'
+    implementation 'com.github.tronprotocol:java-tron:develop-SNAPSHOT'
 }
 ```
-  
-**Using maven:**
+
+**Maven:**
 
 ```xml
 <repositories>
-  <repository>    
-      <id>jitpack.io</id>
-      <url>https://jitpack.io</url>
+  <repository>
+    <id>jitpack.io</id>
+    <url>https://jitpack.io</url>
   </repository>
 </repositories>
 
 <dependency>
     <groupId>com.github.tronprotocol</groupId>
     <artifactId>java-tron</artifactId>
     <version>develop-SNAPSHOT</version>
-    <!--You can use any of the tag/branch name available-->
 </dependency>
 ```
-
-## Building from source code
-
-- **Building using the console:**
-
-  ```bash
-  cd java-tron
-  ./gradlew build
-  ```
-
-- **Building using [IntelliJ IDEA](https://www.jetbrains.com/idea/) (community version is enough):**
-
-  **Please run `./gradlew build` once to build the protocol files**
-
-  1. Start IntelliJ.  
-  Select `File` -> `Open`, then locate to the java-tron folder which you have git cloned to your local drive. Then click `Open` button on the right bottom.
-  2. Check on `Use auto-import` on the `Import Project from Gradle` dialog. Select JDK 1.8 in the `Gradle JVM` option. Then click `OK`.
-  3. IntelliJ will import the project and start gradle syncing, which will take several minutes, depending on your network connection and your IntelliJ configuration
-  4. Enable Annotations, `Preferences` -> Search `annotations` -> check `Enable Annotation Processing`.
-  5. When the syncing finishes, select `Gradle` -> `Tasks` -> `build`, and then double click `build` option.
-  

gen.sh

@@ -1 +1,32 @@
-protoc --java_out=./  ./core/*.proto ./api/*.proto
+#!/usr/bin/env bash
+# Helper script for manually regenerating Java sources from .proto files.
+# The recommended approach is `./gradlew build`, which compiles protos via the
+# Gradle protobuf plugin automatically. Use this script only if you need to run
+# protoc directly (e.g., for a single proto file during development).
+#
+# Requirements: protoc v3.x installed and available on PATH.
+# Proto sources live under protocol/src/main/protos/.
+
+set -e
+
+PROTO_SRC="protocol/src/main/protos"
+JAVA_OUT="protocol/src/main/java"
+
+# Compile core protos (Tron.proto + all contract protos)
+protoc \
+  -I="$PROTO_SRC" \
+  -I="$PROTO_SRC/core" \
+  -I="$PROTO_SRC/core/contract" \
+  --java_out="$JAVA_OUT" \
+  "$PROTO_SRC/core/Tron.proto" \
+  "$PROTO_SRC/core/contract/"*.proto
+
+# Compile API proto
+protoc \
+  -I="$PROTO_SRC" \
+  -I="$PROTO_SRC/core" \
+  -I="$PROTO_SRC/api" \
+  --java_out="$JAVA_OUT" \
+  "$PROTO_SRC/api/api.proto"
+
+echo "Proto compilation complete. Output: $JAVA_OUT"

quickstart.md

@@ -45,7 +45,7 @@ docker pull tronprotocol/java-tron
 
 You can run the command below to start the java-tron:
 ```
-docker run -it -d -p 8090:8090 -p 8091:8091 -p 18888:18888 -p 50051:50051 --restart always tronprotocol/java-tron 
+docker run -it -d -p 8090:8090 -p 18888:18888 -p 50051:50051 --restart always tronprotocol/java-tron 
 ```
 
 The `-p` flag defines the ports that the container needs to be mapped on the host machine. By default the container will start and join in the mainnet
@@ -65,8 +65,9 @@ Note: The directory `/Users/tron/docker/conf` must contain the file `config-loca
 
 ## Quickstart for using docker-tron-quickstart
 
-The image exposes a Full Node, Solidity Node, and Event Server. Through TRON Quickstart, users can deploy DApps, smart contracts, and interact with the TronWeb library.
-Check more information at [Quickstart:](https://github.com/TRON-US/docker-tron-quickstart)
+The image exposes a Full Node and Event Server. Through TRON Quickstart, users can deploy DApps, smart contracts, and interact with the TronWeb library.
+
+> Note: `docker-tron-quickstart` is a community-maintained tool. Check its repository for the latest status: [Quickstart](https://github.com/TRON-US/docker-tron-quickstart)
 
 ### Node.JS Console
   Node.JS is used to interact with the Full and Solidity Nodes via Tron-Web.  
@@ -84,7 +85,7 @@ docker pull trontools/quickstart
 
 ## Setup TRON Quickstart   
 ### TRON Quickstart Run
-Run the "docker run" command to launch TRON Quickstart. TRON Quickstart exposes port 9090 for Full Node, Solidity Node, and Event Server.
+Run the "docker run" command to launch TRON Quickstart. TRON Quickstart exposes port 9090 for Full Node and Event Server.
 ```shell
 docker run -it \
   -p 9090:9090 \