How TRON resource delegation works on-chain
TRON does not charge gas the way Ethereum does. Every account has two resource pools, energy and bandwidth. Smart contract execution consumes energy; every transaction consumes bandwidth, whether or not it touches a contract. When the account runs out of either, the network burns TRX from its balance to cover the deficit, and that burn is what makes transactions expensive.
Resources come from two places. You can stake TRX, and the network credits your account with a proportional share of the global energy or bandwidth pool, refreshed every 24 hours. Or another account stakes TRX and assigns the resulting resources to your address, which is a delegation. Your account spends delegated resources exactly as if you had staked yourself; the VM makes no distinction. Delegation is not a payment channel or a wrapper. It is a direct assignment of on-chain resource entitlements from one account to another.
What Stake 2.0 changed
Under Stake 1.0 you chose at stake time whether your TRX produced energy or bandwidth, and you could only unfreeze the whole amount at once after a 3-day lock. Delegation existed but was blunt: the TRX produced one resource type, and you could point that output at one other address.
Stake 2.0, activated on mainnet in April 2023, restructured this. For delegation the relevant changes are:
- Proportional splitting. The resources from one staked position can be split and delegated to several addresses at the same time. No TRX moves; you are routing the resource output.
- Partial unstaking. You can unstake part of a position without touching the rest, so whoever holds the stake can manage liquidity without disturbing active delegations.
- A 14-day unstaking delay. After
unfreezeBalanceV2the TRX sits in a withdrawal queue for about 14 days beforewithdrawExpireUnfreezereleases it. Delegated TRX cannot be unstaked at all until the delegator reclaims the delegation withunDelegateResource.
For the receiving side this means one thing: if the delegation is not locked, the delegator can take it back at any moment with unDelegateResource, and your available energy drops by that amount on the next block. There is no grace period, no cooldown on your side and no compensation at the protocol level.
What a delegation transaction records
A delegateResource transaction records three things: the delegator's address, the receiver's address and the amount of energy (or bandwidth) delegated. The network then adjusts the resource limits in the receiver's account state.
Nodes track delegated and self-owned resources separately. Query an account with wallet/getaccount on the HTTP API and you will see delegated_frozenV2_balance_for_energy, what the account has delegated out, and acquired_delegated_frozenV2_balance_for_energy, what it has received. Neither moves TRX; the stake stays in the delegator's balance.
When a transaction runs, the VM checks the executing account's available energy, self-staked plus received. If that covers the call, it deducts from this one combined pool: self-staked and delegated energy share a single limit and a single usage counter, with no order between them. If the pool is exhausted, TRX is burned from the account's free balance at the current network rate, which is not fixed but computed from total network energy and the burn price set by on-chain parameters.
How energy recovers
Energy is not a one-time credit. Used energy recovers linearly over a 24-hour window. If your limit is 100,000 and you spend 65,000 on a contract call, you are back to full after 24 hours; at the halfway point, 12 hours in, about 32,500 has recovered, so about 67,500 is available. This applies to self-staked and delegated energy alike. The rate is tied to the account's own limit rather than to a global clock, so two accounts with different limits recover different absolute amounts per hour, though both refill completely in 24 hours.
For high-frequency operations this 24-hour cycle is the binding constraint. A delegation sized for one transfer a day will not cover ten a day, even if the total looks sufficient on paper. Plan for the recovery cadence, not just the total.
Reassigning and splitting delegations
Reassigning the same resource output to a different receiver takes two transactions: revoke from the current receiver, then delegate to the new one. They are separate on-chain operations, each consuming bandwidth, and even though Stake 2.0 lets you batch them more efficiently than before, they are not atomic.
Partial delegation is fine. If a delegator's stake generates 200,000 energy and 150,000 is delegated to address A, the remaining 50,000 can go to address B without touching A. Total delegated energy cannot exceed total generated energy; an attempt to over-delegate fails at the transaction level.
What this means for rented energy
Energy rental services such as tronenergyrent.com work entirely inside this model. When you rent energy, the service stakes TRX, generates energy and calls delegateResource to your address. You receive acquired_delegated_frozenV2_balance_for_energy exactly as described above: not TRX, a temporary resource allocation. The rental duration is how long the service keeps that delegation active. 65,000 energy covers one standard USDT transfer; the calculator gives the current price per duration and the exact cost for your volume. Per day, short rentals cost more than long ones; a longer rental trades a lower daily price for a longer commitment.
Bandwidth works the same way
Everything above applies to bandwidth, with one difference: every account gets 600 free bandwidth a day regardless of staking. That covers basic TRX transfers but not the bandwidth of high-frequency TRC-20 transfers; staked or delegated bandwidth raises the limit above the 600 baseline. Consumption order is staked bandwidth first (own and delegated, counted as one limit), then the free daily bandwidth, then TRX burn, which matters when you want to calculate exactly when burn kicks in for an account.
Reading delegation state from the API
For tooling or monitoring, three calls matter:
wallet/getaccount: full account state, including delegated and received resource fieldswallet/getdelegatedresourcev2: the delegation record between two addresses, with the exact amount and the lock expiry if a lock was setwallet/getcanwithdrawunfreezeamount: how much of a delegator's queued unstake is already withdrawable
getdelegatedresourcev2 is the one to call before executing a transaction that depends on a delegation. Do not assume it is still in place because it was set up yesterday; confirm the on-chain state first.