Traditional dividend distribution in the crypto space has long relied on off-chain claim portals—centralized intermediaries that track entitlements, publish merkle roots, and require users to actively claim their rewards. This approach introduces trust assumptions that contradict the core promise of decentralized systems. Immute takes a different approach: an on-chain dividend token Ethereum implementation where every holder can verify their claimable dividends directly from contract state, without depending on any portal operator or centralized registry staying online.
The distinction matters for builders evaluating reward-token architectures. When distribution logic lives entirely on-chain, the contract itself becomes the single source of truth for what each holder is owed. No off-chain distribution file can be manipulated, no portal can selectively block a legitimate claim, and no team needs to manually process payouts. This is the design principle Immute's V8 contract implements through a pull-based dividend accounting model.
ProfitPerShare: the core accounting primitive
At the heart of Immute's on-chain dividend token Ethereum mechanics lies the profitPerShare variable—a cumulative accounting counter that tracks how much dividend value has been attributed to each token over the contract's lifetime. When the contract receives ETH from buy/sell fees, it distributes that value across all current IMT holders by increasing profitPerShare proportionally to each holder's token balance.
This pattern avoids the expensive problem of iterating over all holders during each distribution event. Instead of the contract sending tiny amounts to thousands of addresses (which would be gas-prohibitive and create rounding errors), it updates a single global counter. Individual entitlement is then computed on-demand: claimable = balance * (profitPerShare - cumulativeDividendsAtTimeOfLastClaim).
The math is elegant in its simplicity. Each holder's claimable amount grows automatically as the contract accumulates fees, and it scales correctly when balances change. When a holder buys more IMT, their new tokens immediately start accruing dividends at the current rate. When they transfer tokens, the receiving address inherits the claimable amount associated with those tokens at that moment. The contract never needs to know the total holder count or iterate through any list.
This is pull-based distribution at its finest: the contract pushes the math forward, and holders pull their entitlements when they choose to do so.
Withdraw vs. Reinvest: two paths from the same entitlement
Immute exposes two entry points for consuming claimable dividends: withdraw() and reinvest(). Both operate on the same underlying accounting—they read the holder's current claimable balance and decrement it—but they differ in what happens to those funds.
Calling withdraw() sends the ETH directly to the holder's address. Their IMT token balance remains unchanged; they've simply converted accumulated dividend entitlements into spendable ETH while maintaining their position on the bonding curve. This is the cash-out path for holders who want liquidity without exiting their IMT exposure.
Calling reinvest() instead uses the claimable amount to purchase additional IMT at the current bonding-curve price. The contract mathematically divides the claimable ETH by the current curve rate and credits the resulting IMT tokens to the holder's address. This compounds the holder's exposure: they end up with more IMT, which means their future dividend entitlements will be calculated against a larger balance.
The strategic choice between these paths depends on the holder's goals, and the contract intelligently supports both without requiring duplicate accounting logic. The dividend math happens once; the holder decides what to do with the result.
Why on-chain accounting removes the trust requirement
Off-chain claim portals have been the standard approach for dividend token implementations for years. Projects publish a merkle root, users submit claims with proof, and a centralized service handles the actual distribution. This works adequately when the portal operator remains honest and operational, but it introduces failure modes that on-chain accounting eliminates entirely.
Consider the failure modes of off-chain claims: the portal operator goes offline and claims stop processing; a centralized registry gets compromised and payouts get redirected; a governance attack changes the distribution rules after the merkle root was published. Each of these scenarios represents a trust assumption that a fully on-chain system never makes. With Immute's on-chain dividend token Ethereum implementation, no operator exists to go offline, no registry exists to compromise, and the distribution rules are enforced immutably by the contract code.
The pull-based pattern also naturally handles edge cases that plague push-based distribution. If a holder's balance changes between the time dividends are accrued and the time they claim, the math correctly reflects their position at each moment. There's no window where a holder can claim more than they're entitled to, and there's no scenario where the contract runs out of gas trying to distribute to a large holder set.
This is why on-chain dividend accounting represents a fundamentally different trust model. Holders verify their claimable amounts by reading contract state—something any wallet or blockchain explorer can do—rather than trusting an external service to report accurately.
Immute's live implementation on Sepolia
Immute's V8 contract currently runs on Sepolia testnet, where the dividend accounting, bonding-curve mechanics, and feeder integration are all operational and verifiable. The contract address 0xB575A8760c66F09a26A03bc215D612EA2486373C is publicly accessible on Sepolia Etherscan, and the profitPerShare counter, holder balances, and claimable amounts can all be read directly from on-chain state.
The companion FeederV9 contract at 0xa87e7c25c2f754C7D6bFc9b4472E0c36096E4bF6 handles integration payments from partner platforms. When a user pays through a Feeder integration, 1% of the transaction routes on-curve to pay dividend holders, while 99% flows to the integrating product's treasury. This is the mechanism that makes Immute a product-powered reward token rather than a purely speculative one—the Feeder creates real payment flows that generate dividend income for IMT holders.
Planned integrations with platforms like Neptime.io (creator monetization), Valiep.com (subscription purchases), Discovire.com (discovery-layer purchases), and ByteOdyssey (in-game payments) will route payments through the Feeder, expanding the dividend-generating activity on the curve.
Testing the mechanics yourself
The best way to understand on-chain dividend accounting is to interact with it directly. If you haven't already, grab some free Sepolia ETH from a faucet like https://sepolia-faucet.pk910.de/ or the Alchemy Sepolia faucet, connect your wallet to https://immute.io, and execute a buy transaction. Watch the profitPerShare counter update in the contract state after your trade, then check your claimable balance.
From there, try calling withdraw() to see ETH flow to your address while your IMT balance stays constant. Then call reinvest() and observe your IMT balance increase by the claimable amount's equivalent on the curve. The entire flow is trustless and verifiable—you're not trusting any portal or team to process your claim.
Mainnet launch is coming soon, after the testnet validation period confirms the mechanics at scale. Help us burn in the contracts now, and the on-chain dividend model will be battle-tested by the time IMT reaches a network with real economic activity.
The on-chain dividend token Ethereum pattern Immute implements represents a mature approach to reward distribution—one where contract state is the ultimate source of truth, and where every holder can verify their entitlement without relying on any intermediary. For builders evaluating this architecture, the pull-based model offers significant advantages in gas efficiency, correctness guarantees, and trustlessness. Test it on Sepolia, review the contract logic directly, and see how dividend accounting should work.
Top comments (0)