GuidesAPI ReferenceCommunityDiscordBlogFAQBug BountyAnnouncements
Guides
Chinese(中文版)
  1. Getting Started

Tracks by role

Curated reading paths for every common developer role on TRON — from blockchain newcomer to SR operator. Each track lists the pages to read in order, recipes to run hands-on, time budget, prerequisites, and what you should be able to do at the end.

This page is the track catalog for the TRON developer documentation. The Getting started page handles the 5-minute quick start; this page is where you go when you want a curated reading list matched to what you are building. Each track lists pages in order, recipes to run hands-on, a time budget, prerequisites, and what you should be able to do at the end.

📘

Prerequisites

Track 0 — Complete beginner

For: People new to blockchain who want to understand TRON from the ground up.

Outcome: You will understand how TRON works, have a funded testnet account, and have sent your first transaction.

Time: ~2 hours.

Prerequisites: None.

StepDocumentTimeWhat you learn
1What is TRON10 minTRON overview, how it compares to Ethereum, audience-specific entry points
2Architecture overview10 minThe four-layer architecture: consensus, resources, TVM, applications
3Tokenomics10 minTRX supply, distribution, burn mechanism, and the role of TRX in the ecosystem
4Accounts and keys10 minEOA vs contract accounts, key generation, address formats (T-prefix)
5Resource model15 minBandwidth and Energy — TRON's dual-resource system that replaces Ethereum's gas
6Networks5 minMainnet, Shasta Testnet, Nile Testnet — endpoints and purposes
7Connecting to the TRON network10 minSet up TronWeb or Trident and connect to a network node
8Wallets and accounts10 minInstall TronLink, create your first wallet
9Getting testnet tokens5 minUse the Shasta or Nile faucet to fund your account
10Send your first transaction15 minBuild, sign, and broadcast a TRX transfer — then verify it on TRONSCAN
11Blockchain browsers5 minNavigate TRONSCAN to explore transactions, blocks, and accounts
12Token standards overview5 minTRX, TRC-10, TRC-20, TRC-721, TRC-1155 — what they are and when to use them

Done when you can: explain TRON's resource model in your own words, fund a Shasta account, send a TRX transfer, and find it on TRONSCAN.

Next: continue with Track 3 — DApp developer to build applications, or jump to the Recipes for ready-to-use code.

Track 1 — Exchange / custodial-wallet operator

Goal: Detect deposits, broadcast withdrawals, manage balances, optionally support staking and TRC-20s. Production-grade with hot/cold wallet separation.

Time: ~5 hours of reading + setup.

Reading order:

  1. Accounts and keys — address format, key derivation, account model
  2. Transaction protocol — transaction structure, TAPOS, expiration window
  3. Block model and solidification — what "finalized" means for crediting deposits
  4. Resource model — Bandwidth and Energy budgeting for withdrawal volume
  5. Exchange and custodial wallet integration — architecture-level overview
  6. Exchange wallet implementation guide — full implementation reference
  7. Internal transactions — contract-triggered TRX / TRC-10 transfers (don't miss these on deposit detection)
  8. Multi-signature — for hot/cold and multi-sig cold wallet setups
  9. TRC-20 — for listing TRC-20 tokens
  10. TRC-10 — for legacy TRC-10 token support

Hands-on:

Done when you can: detect a TRC-20 deposit including internal transfers, construct + sign a withdrawal offline, broadcast it, and confirm solidification.

Track 2 — Wallet developer

Goal: Ship a TRON-supporting wallet (new wallet, existing multi-chain wallet adding TRON, or specialized institutional wallet).

Time: ~4 hours.

Reading order:

  1. Accounts and keys — BIP-44 derivation, address format
  2. Transaction protocol — raw_data fields and signing
  3. Signature validation — what makes a transaction acceptable to the network
  4. Resource model — show users their Bandwidth and Energy
  5. Wallet developer guide — capability map for what a wallet must implement
  6. Tools & SDKs — pick the SDK matching your stack
  7. WalletConnect TRON — for DApp connectivity from your wallet
  8. Multi-signature — if supporting shared / institutional accounts
  9. Staking on TRON — if exposing staking UX

Hands-on:

Done when you can: derive keys from a BIP-39 mnemonic, sign a transaction offline, broadcast it, display resources, and handle DApp signing requests.

Track 3 — DApp developer (frontend + smart contracts)

Goal: Build, deploy, and ship a DApp end-to-end — Solidity contract + TronLink-using frontend.

Time: ~5–6 hours.

Prerequisite: Familiarity with Solidity and JavaScript. If blockchain-new, complete Track 0 first.

StepDocumentTimeWhat you learn
Understand the differences
1TRON vs Ethereum15 min14-dimension comparison — consensus, fees, addresses, tokens, VM differences
2Resource model15 minBandwidth + Energy — the biggest mental shift from Ethereum's gas
3Paying for resources10 minHow Energy is calculated, consumed, and shared between deployer and caller
4TVM + TVM vs EVM15 minExecution semantics and key differences (CHAINID, SELFDESTRUCT, CREATE2 prefix)
Set up your environment
5Connecting to the TRON network10 minConnect TronWeb to Shasta testnet
6TronWeb SDK10 minThe primary JavaScript SDK — installation and initialization
7TronBox10 minCLI tool for compiling and deploying contracts (Truffle-style for TRON)
8TronIDE5 minBrowser IDE for quick prototyping (Remix-style for TRON)
Build and deploy
9Smart contracts overview10 minThe smart-contract chapter's table of contents
10Solidity on TRON10 minTRON-specific language extensions (trcToken, transferToken)
11Writing and compiling contracts10 minWrite and compile a Solidity contract for TRON
12FeeLimit & Energy cost15 minSet fee_limit correctly — the most common cause of failed deployments
13Deploying a contract15 minDeploy your compiled contract to Shasta
14Contract interaction10 minCall functions on your deployed contract using TronWeb
15Contract verification5 minVerify your contract source code on TRONSCAN
16Quickstart10 minAlternative speedrun — deploy a contract in 10 minutes
Connect to users
17TronLink integration15 minConnect your DApp to TronLink (MetaMask-style for TRON)
18Events and logs10 minEmit and consume events from your contract
19TRC-20 token standard10 minTRON equivalent of ERC-20
Production checklist
20Security best practices10 minSmart contract security on TRON
21Stake and delegate resources10 minHow to acquire Energy for production contract calls
22Broadcast and RPC errors10 minTroubleshoot OUT_OF_ENERGY, BANDWITH_ERROR, and other errors. Note that the proto spelling omits the second D.

Hands-on:

Done when you can: deploy a contract to Shasta, connect a TronLink-using user, listen for emitted events, calibrate fee_limit correctly, and explain why the contract burns more Energy on first interaction with each address (SET vs RESET SSTORE).

Next: Track 4 — Smart-contract author for backend-only deployment patterns, or Build a Web3 App for an end-to-end walkthrough of this same path.

Track 4 — Smart-contract author (server-side, no frontend)

Goal: Deploy and operate smart contracts from a backend — analytics, automation, DeFi protocols.

Time: ~4 hours.

Reading order:

  1. TVM + TVM vs EVM
  2. Resource model
  3. fee_limit and Energy cost
  4. Solidity on TRON
  5. Opcodes — full opcode reference table
  6. Contract-to-contract calls
  7. VM exception handling
  8. Stake 2.0 Solidity API — staking from inside a contract
  9. Parameter encoding and decoding
  10. Smart contract errors — every TVM result code documented
  11. Upgrading smart contracts

SDK choice: Trident (Java), TronWeb (Node.js), GoTron SDK (Go), or TronPy (Python).

Done when you can: deploy and verify a contract, handle exception flows, manage upgrades, and reason about Energy cost per opcode.

Track 5 — Super Representative operator (or aspiring SR)

Goal: Register an SR candidate, run an SR node, participate in proposals.

Time: ~3 hours of reading + node-sync time.

Prerequisite: Linux server administration experience. If you are new to TRON concepts, complete Track 0 first — especially Architecture overview and Networks.

Reading order:

  1. Consensus and DPoS — block production, fork choice, solidification
  2. Super Representatives — role overview, three tiers, voting
  3. Voting for SRs — voter mechanics
  4. Staking, voting, and rewards — end-to-end overview of how votes turn into rewards
  5. Reward calculation — block + voter reward math
  6. Deploy a full node — step-by-step: download java-tron, configure, launch
  7. Main net database snapshots — speed up sync vs syncing from genesis
  8. Becoming a Super Representative — 5-phase application + operation (9,999 TRX burn)
  9. Advanced SR configuration — signing-key delegation, security separation
  10. Recommended SR API config — production API and security settings
  11. SR best practices — production hardening
  12. Committee and proposals — on-chain governance voting

Hands-on:

Done when you can: register as an SR candidate (knowingly paying the 9,999 TRX burn), run a hardened SR node with delegated signing, and submit a chain-parameter proposal.

Track 6 — RPC / infrastructure provider

Goal: Operate TRON nodes that other people use — hosted RPC, indexer service, custody infrastructure.

Time: ~3 hours.

Prerequisite: Linux server administration experience.

Reading order:

  1. Node operations — chapter overview
  2. Nodes and clients — FullNode vs Lite FullNode
  3. Deploy a full node — base setup all infra runs on
  4. Main net database snapshots — bootstrap from snapshot
  5. Building a private chain — staging environment for testing your tooling
  6. Event subscription — Kafka / MongoDB / ZeroMQ pipelines for indexers
  7. Node maintenance toolkit
  8. Node operations issues — sync issues, LevelDB / RocksDB picks, Lite FullNode behavior
  9. API reference — the API surface your customers will use
  10. RPC and indexer providers — compare against existing providers

Hands-on:

Done when you can: bootstrap a node from a snapshot, configure an event-subscription pipeline to Kafka or MongoDB, and explain to your customers when they should hit SolidityNode vs FullNode HTTP.

Track 7 — Hardware wallet integrator

Goal: Add TRON support to a hardware wallet device (Ledger, etc.) or to a software wallet that delegates signing to a device.

Time: ~2 hours.

Reading order:

  1. Accounts and keys — secp256k1 curve, key derivation
  2. Transaction protocol — raw_data signing
  3. Signature validation — wire format r||s||v, signing hash is SHA-256 of protobuf raw_data (not Keccak)
  4. Multi-signature — if device-signed accounts need to participate in multi-sig

Done when you can: implement a hardware-side signing flow that produces a valid TRON signature without round-tripping the raw_data outside the device.

Other roles (one-liner pointers)

Related resources


Updated 7 days ago