Reading HEX from the Source

Every fact below was checked against the deployed HEX contract on 2026-07-20 (HEX day 2421), and each fact added on 2026-09-23 (HEX day 2486) was checked that day — token identity by live call, function selectors and event signatures by Keccak, cross-checked against our own production readers. This is our own explainer, written from the source; it is not a rewrite of anyone else’s document.

Why Read the Contract Itself

HEX is fully defined by one smart contract. Everything true about it — how a stake pays, what a penalty costs, what a function returns — is settled by the deployed code, not by any article about it. Secondhand explainers drift over the years: a bit offset gets remembered wrong, a field gets renamed, an approximation hardens into a “fact.” When money rides on the answer, the contract is the only authority worth quoting.

So this guide treats the contract as the standard. Where a plain-language claim could mislead, we say what the code actually does.

Every number below carries its receipt. Citations like (EARLY_PENALTY_MIN_DAYS, L720) point to the constant’s name and line in the verified HEX source — the same source published on Etherscan and PulseChain Scan. Line numbers follow the archived explorer source, which opens with Etherscan’s four-line verification note; Etherscan’s own code viewer starts at pragma solidity, so each line there sits 4 lower (L720 is line 716). Open either explorer, search the constant’s name, and check us in ten seconds. You don’t have to trust this page; that’s the point of it.

The Ten Numbers That Govern Every Stake

The Basics

HEX is two things in one contract: an ordinary ERC-20 token and a staking engine. The token part is unremarkable — name is HEX, symbol is HEX, decimals is 8. The staking part is where everything interesting lives.

• The smallest unit is a Heart. 1 HEX = 100,000,000 Hearts (that’s what 8 decimals means). All internal accounting is in Hearts; the contract never rounds to whole HEX.
• The same contract runs on two chains. The address 0x2b591e99afE9f32eAA6214f7B7629768c40Eeb39 is identical on Ethereum and PulseChain, with identical code — PulseChain copied Ethereum’s state at the fork (Ethereum block 17,232,999, May 2023), so every balance and stake as of that block was copied to the same address on PulseChain. Since then the copies have been separate: eHEX on Ethereum and HEX on PulseChain have their own balances, stakes, share rates and prices, and a stake started on one chain after the fork does not exist on the other. The calls in this guide are identical on both; the network you point them at decides which copy you read.
• HEX keeps its own calendar. Day 0 began 2019-12-03 at 00:00 UTC (the contract’s LAUNCH_TIME), and a new HEX day begins every 00:00 UTC (7 p.m. New York time the evening before in winter, 8 p.m. in summer), so HEX day N begins 2019-12-03 plus N days. Some community tools number days one higher; this site follows the contract’s currentDay, the anchor everything is dated against (it read 2421 on 2026-07-20).

Staking, in Plain Terms

Staking is committing HEX for a chosen number of days. While staked, those Hearts leave your spendable balance; when the stake ends, the contract returns your principal plus everything it earned.

The earning is share-based, and this is the one idea worth slowing down for:

When you stake, your Hearts are converted into Shares (the site calls a trillion shares one T-Share). Each day, the contract fills a payout pool, and your slice of that day is your shares ÷ everyone’s shares. Add up your slice across every day of your stake, and that’s your interest.

Because payout tracks shares, not Hearts, the way to earn more is to earn more shares — which is what the two bonuses below do.

Share Price (Why It Only Goes Up)

How many shares you get per Heart is set by the Share Rate (also called the T-Share Rate or share price). At launch it was 1 share per Heart. When a stake ends at a gain, the contract works out the rate that stake implies and raises the share rate if that figure is higher, so the next staker pays more Hearts per share. It is designed to only ever rise — which is why an earlier stake, at a lower rate, holds shares that later stakers can’t match cheaply.

The rate is stored as an integer scaled by 100,000 (five decimals). Read on Ethereum on 2026-07-20 it was 467677, i.e. 4.67677 Hearts per share, about 46,768 HEX per T-Share (a T-Share is a trillion shares). The two chains have run separately since the 2023 fork, so their rates differ: PulseChain read 461294 at the same moment (about 46,129 HEX per T-Share). There is no way for a clever restake to mint extra shares out of the mechanism; the price math closes that door.

The Daily Payout Pool

The pool each day starts from HEX’s built-in inflation — 3.69% per 364 days (the contract’s own year), compounded daily against the allocated supply — and is topped up by penalties other stakers pay (more on those below). Your stake earns from every day it is active, drawn from that day’s pool in proportion to your shares.

The Two Bonuses (Stated Plainly, Not Sold)

Both bonuses increase your shares, not your Hearts:

• Longer Pays Better — a share bonus of (stakedDays − 1) / 1820, capped at +200% from 3,641 days (~10 years) onward. At the cap your stake earns triple the shares its Hearts alone would buy — a max-length 5,555-day stake gets the full 3×.
• Bigger Pays Better — up to +10% more shares, maxing out at a 150,000,000-HEX stake. The percentage caps; the bonus Hearts keep growing with size.

That’s the whole of it: there is no tier and no multiplier beyond these two. At a given share rate, only stake length and stake size change how many shares each HEX buys.

Worked example, at Ethereum’s share rate (4.67677 Hearts/share, read 2026-07-20): stake 100,000 HEX for the maximum 5,555 days. Longer Pays Better caps out (+200%); Bigger Pays Better adds a sliver (+0.00667% at this size). The contract computes (Hearts + bonus) × 10⁵ ÷ shareRate (L1531; L1826 runs the same math in reverse to set the rate): 100,000 HEX → 3.00007 × 10¹³ effective Hearts → ≈ 6.41 T-Shares. The same 100,000 HEX staked for 1 day gets ≈ 2.14 T-Shares, about one third as many (the Bigger Pays Better sliver is the same in both). The 5,555-day stake’s extra shares come with a 5,555-day lock and a 2,778-day early-end window.

Ending a Stake

This is where secondhand accounts most often go wrong; here is what the contract does. The whole life of a stake, in one picture:

On time. End on or after your stake’s end day and you receive principal plus all earned payout. You get a 14-day grace period after the end day with no penalty.

Early — the Early End Stake (EES). You can end before the committed day, but you forfeit a window of payout. The window is:

penaltyDays = max(90, ⌈stakedDays ÷ 2⌉) — half your committed days rounded up, but never fewer than 90.

How the penalty is computed depends on how far you got (the contract’s branches, L1442-1469 and L1743-1777):

• Served past the window → the penalty is the actual daily payout summed over the window [day 0, penaltyDays). You keep your principal plus everything earned after the window. Ending a 1,000-day stake at day 700: window is 500; you forfeit days 0–500’s earnings, keep days 500–700’s.
• Ended before serving the window → the contract extrapolates: penalty = your earned payout × penaltyDays ÷ servedDays (L1776). In this branch penaltyDays is always larger than servedDays, so the ratio is always above 1 and the penalty always takes principal: the excess over what was earned is payout × (penaltyDays − servedDays) ÷ servedDays. Same 1,000-day stake ended at day 400: penalty = payout × 500/400 = 1.25× everything you earned; you leave with principal minus a quarter of your earnings.
• Ended on the HEX day it was started (before the next 00:00 UTC) → the stake has not begun yet (its first locked day is the next HEX day), so the principal comes back whole, with no payout and no penalty (L1461-1469, L1542-1544).
• Ended on its first locked day, the day after it was started (zero days served) → a day’s payout is estimated and charged for the whole window (L1743-1747). Nothing has been earned yet, so the whole charge comes out of principal. Read on 2026-09-25, a 100,000-HEX stake committed for 5,555 days and ended this way loses 28.2% of its principal on PulseChain and 28.8% on Ethereum; committed for 365 days, it loses 0.74% and 0.76%.

The penalty is capped at your whole stake return — you can be zeroed, never negative (L1710-1719). Half of every penalty is added to the payout pool of the HEX day it was paid in (credited when that day closes, L1257-1259), shared by everyone still staked that day; the other half goes to the Origin Address (_splitPenaltyProceeds, L1801; the address itself is hard-coded at L637).

Late. A finished stake ended after its 14-day grace pays a late penalty of return × lateDays ÷ 700 (L1792-1798): 1/700 of the whole return (principal included) per late day, about 0.143% a day and 1% a week. The penalty is worked out on the day the stake is ended or Good-Accounted; nothing leaves the stake before then. At 700 late days past the grace the penalty equals the whole return. Good Accounting (stakeGoodAccounting, L1353-1406) lets anyone settle a matured stake’s books without ending it. Its shares leave the daily share total, its late penalty (if any) is fixed at that day’s figure and split then, and nothing is paid to the owner. The owner still calls stakeEnd to collect.

Reading a Stake Straight from the Chain

Two read-only calls expose any address’s stakes — and this is exactly how our tools, and anyone recovering stakes, see them:

• stakeCount(address) → how many stakes that address holds.
• stakeLists(address, index) → one stake, returned as seven fields: stakeId, stakedHearts (principal), stakeShares, lockedDay, stakedDays, unlockedDay (0 until someone runs Good Accounting on it, so a matured stake nobody has settled still reads 0; an ended stake leaves the list), isAutoStake.

Indexes run from 0 to stakeCount − 1, and they shift: when any stake on that address ends, the last stake moves into its slot (L1123-1139). So stakeId is the stable name, and stakeEnd takes the index and the stakeId together and refuses a pair that no longer matches (L1068).

An important consequence: the “address” can be a contract — a Gnosis Safe, or a HEX Stake Instance (HSI), tokenized or not — and its stakes read back identically. That’s why stakes made through a wallet app or wrapped as an NFT are never hidden from the chain; they’re just a different address to point the same call at. Ending or moving them still takes the key that controls the Safe or the HSI.

An HSI’s stake sits at the HSI’s own address, so stakeCount on the owner’s wallet does not count it. Hedron’s HEX Stake Instance Manager (0x8BD3d1472A656e312E94fB1BbdD599B8C51D18e3, the same on both chains) gives that address: hsiLists(wallet, index) for an untokenized HSI, and tokenOfOwnerByIndex(wallet, index) then hsiToken(tokenId) for a tokenized one. An HSI started through Actuator or delegated to it sits in neither of the owner’s lists: Actuator’s HEXTimeTokenManager (0x0d5d61FDDf84feFAB26f98164D8009022d740206, PulseChain only) keeps it, and its hsiLists(wallet, index) gives the address. With that address, stakeLists(thatAddress, 0) on the HEX contract returns the stake.

The Functions and Events You’ll Actually Meet

For the exact 4-byte selectors, event topic hashes, the globalInfo() layout, and the dailyDataRange bit-packing, we keep a separate, contract-verified reference (with the re-runnable script that proves it). In everyday terms, the pieces are:

• currentDay() — the on-chain day number, the clock everything anchors to.
• globalInfo() — the protocol’s own totals: share rate, total shares, latest stake id, daily-data count, and more. Our census validates itself against these.
• dailyDataRange(begin, end) — each day’s payout total, shares total, and unclaimed satoshis, packed into one number per day.
• stakeStart / stakeEnd — open and close a stake.
• Events StakeStart, StakeEnd, StakeGoodAccounting — the trail a stake leaves in the logs, which is how the full HEX stake history can be replayed and counted. The penalty that StakeEnd and StakeGoodAccounting record is the uncapped figure; when it exceeds principal plus payout, the stake paid only what it held (stakeEnd L1471-1483, stakeGoodAccounting L1389-1400).

How This Was Verified — Four Layers

1. The source itself. We archived the explorer-verified HEX source (solc 0.5.13, the exact compile the explorers matched against the chain) and every line number on this page cites it.
2. One contract, two chains — measured. eth_getCode returns the byte-identical 20,989-byte runtime on Ethereum and PulseChain (same SHA-256). Not folklore; a hash.
3. Source ties to the deployed code. Every public function in the source, selector-derived and located in the deployed dispatcher: 30 of 30 present.
4. Behavior agrees. Live reads (name, decimals, currentDay, globalInfo, dailyDataRange) match the source’s structures bit-for-bit, cross-checked against our census pipeline and our production stake reader.

If any of this ever stops matching the chain, the chain is right and this page is wrong; re-running the checks is the tiebreaker.

Check One Thing Yourself — Right Now

Layer 4 can be checked first-hand too. On Etherscan’s Read-Contract tab (or PulseChain Scan’s), open currentDay and read the number it shows — no wallet needed, it’s a free read. Compare the number with the Day chip at the top of this site. When they match, you’ve just verified a claim against the chain itself, first-hand — the exact habit this whole site exists to teach. Every other number on this page can be checked the same way: search the constant’s name in the Contract → Code tab.

By hexbonds — read from the deployed HEX contract on HEX day 2421 (2026-07-20), revised on HEX day 2486 (2026-09-23). No affiliation with the HEX project; we quote the contract, nothing more.