GALU · Polygon

Token transparency

A single contract is both the ERC-20 token and the reward pool. Every number on this page is read live from Polygon, straight from the contract — not from our database.

0x9d797D0E642D9EADdbDbD34ACFCFd07bf0043c6C
Polygonscan Source code Whitepaper Live epoch audit

Token metadata (logo, symbol) is published in the Token Lists standard: https://sensmos.com/galu.tokenlist.json — for wallets and tools that support token list imports.

Live state

The contract in numbers — right now

total supply
—
GALU minted so far
% of hard cap
—
of the 40,000,000 cap
pool balance
—
GALU held by the contract
outstanding claims
—
users' unclaimed rewards
claimed to date
—
withdrawn to wallets
deposited
—
deposited by users
burned
—
burned (deflation)
epoch / status
—
—
Supply concentration

Why the contract holds most of the supply

Because that's how the model works. Node rewards exist first as entitlements (Merkle tree leaves), and the tokens backing them physically sit in the contract until their owner claims them. The contract balance is not a team treasury — it is collateral for other people's not-yet-claimed rewards, plus user deposits and recycled network spending.

You don't have to take our word for it — compare pool balance with outstanding claims above. Solvency is enforced by the contract itself: after every mint it checks that balanceOf(pool) ≥ entitlement − claimed, and any claim exceeding the pool balance is rejected on-chain.

Hard limits

What nobody can do — including us

No premine

The constructor mints nothing. Supply started at zero; every GALU in existence came from the daily reward emission.

Mint goes only into the pool

The only mint in the code is _mint(address(this)) — fresh tokens can only land in the contract. The minter physically cannot mint to its own (or any other) address.

40M cap — immutable

Hard cap via ERC20Capped (OpenZeppelin), declared constant. There is no function that can change it.

Emission throttle

Max 40,000 GALU per epoch and at least 10 h between mints — constants in the code. Even a stolen minter key cannot emit more.

Immutable code

This is not a proxy — the contract has no upgrade path. The rules you see in the source are final.

The only outflow: claim

Tokens leave the pool only via claim with a Merkle proof, to the address the entitlement belongs to. A "withdraw the pool" function does not exist.

Privileged roles

Who can do what — exactly

owner
Can: pause/unpause the contract, set the minter address, transfer ownership (two-step, Ownable2Step).
Cannot: mint, withdraw the pool, alter anyone's balance or the claim rules. Pause halts mint/deposits/claims (an emergency brake); funding the pool works even while paused.
minter
Can: call mintEpoch — settle the daily epoch: mint into the pool (within limits), burn from the pool, set the new Merkle root.
Cannot: mint to an arbitrary address, exceed 40,000 GALU/epoch or the 10 h spacing, or violate the solvency guard.
team
No special path at all. The team share is an ordinary address in the Merkle tree — it earns from the same pool and claims exactly like any node. There is no separate team mint.
everyone
claim (with a Merkle proof), deposit (your own GALU to spend in the network), fundPool (top up the pool), ERC-20 transfers, burning your own tokens.
Live audit: the /epochs page shows every epoch — deposits, spending, accruals and the on-chain transaction hash. You can compare each epoch's Merkle root with the one in the contract.