Forem: Version 6 LLC

What is a bonding-curve reward token? Inside Immute's on-chain dividend mechanic

Version 6 LLC — Mon, 11 May 2026 14:02:13 +0000

The simplest way to understand a bonding curve reward token is to compare it to the market infrastructure most DeFi users interact with daily: automated market makers (AMMs) running on liquidity pools. Both systems provide continuous liquidity and price discovery, but they achieve these properties through fundamentally different mechanisms—and the implications for token holders are substantial.

The mechanics of a bonding curve reward token

A bonding curve defines a deterministic relationship between a token's price and its circulating supply. Unlike order-book markets or AMMs that rely on external liquidity providers, a bonding curve mints or burns tokens directly from a smart contract as trades execute. The price function can take several forms:

Linear: ( P = k \times S ) (price scales linearly with supply)
Exponential: ( P = k \times S^\alpha ) (price accelerates as supply grows)

In both cases, ( S ) represents the current circulating supply, and ( k ) is a protocol-defined constant. When a user buys tokens, the contract mints new supply, pushing the price upward along the curve. When a user sells, the contract burns tokens, pulling the price downward. There is no counterparty waiting on the other side of the trade—the contract itself absorbs all liquidity risk.

This design ensures instant liquidity. Traders never face slippage from thin order books or suffer from the bid-ask spreads inherent to centralized exchanges. The price at any moment is a deterministic function of supply, calculable by any external observer without relying on oracles or off-chain data feeds.

How fee distribution compounds over time

Immute implements a bonding curve reward token variant where every buy and sell action triggers a 10% fee. Unlike protocols that accumulate fees in a treasury or distribute them to a small set of insiders, Immute routes the entire fee pool pro-rata to every current holder.

For a holder ( h ) with token balance ( b_h ), total supply ( S ), and trade value ( V ), the fee distribution follows:

[
\text{Reward}_h = 0.10 \times V \times \frac{b_h}{S}
]

This calculation runs entirely on-chain. Every trade recalculates holder balances and credits accumulated rewards. Because fees trigger on every transaction—not just on a schedule or under specific conditions—the compounding effect scales with protocol activity. A holder who accumulates IMT and leaves it in their wallet automatically accrues dividends from all subsequent trades across the network [1].

The key distinction from inflationary emissions: rewards derive from actual trading activity rather than token printing. The token supply grows only when the bonding curve mints new tokens on buys, and shrinks when the curve burns tokens on sells. There is no inflationary dilution of holder value to fund protocol incentives.

Bonding curves vs. LP-based AMMs

To appreciate the design trade-offs, consider how traditional AMMs handle liquidity and fees:

Aspect	Bonding Curve Reward Token (e.g., Immute)	LP-AMMs
Liquidity	Built-in via smart contract; no IL	External pools; impermanent loss risk
Fees	Pro-rata to all holders per trade	Shared with liquidity providers
Pricing	Deterministic formula; no pool dependency	Pool-depth dependent; sandwichable
Token supply	Dynamic via mint/burn	Fixed (except for liquidity mining)

In an LP-AMM, liquidity providers must actively manage their positions to capture fees while managing impermanent loss. The net return depends on trade volume, pool composition, and market conditions. In contrast, a bonding curve reward token holder receives dividends passively—the mechanics are encoded, requiring no active management.

Furthermore, LP-based protocols often allocate significant token supplies to team members, investors, or early supporters. Immute takes a different approach: there is no team allocation and no venture round. Every IMT token in circulation originates from on-curve issuance—tokens are minted only when someone buys and burned when someone sells [2].

Immute's architecture: IMT token and the Feeder contract

The Immute system comprises two primary smart contracts on Sepolia testnet:

IMT V8 (0xB575A8760c66F09a26A03bc215D612EA2486373C): the bonding curve token contract implementing the price function and fee distribution logic.
FeederV9 (0xa87e7c25c2f754C7D6bFc9b4472E0c36096E4bF6): a primitive that integrates external products into the IMT economy.

The Feeder contract enables partner platforms to route payments through Immute's curve. When a user pays 1 ETH on a supported platform, the Feeder splits the transaction: 1% flows on-curve (funding IMT holder dividends), while 99% enters the product's own treasury. This design creates what Immute calls "product-powered tokenomics"—the token's reward mechanism derives from actual product usage rather than speculative trading alone.

Planned integrations include Neptime.io (creator monetization), Valiep.com (subscription purchases), Discovire.com (discovery-layer payments), and ByteOdyssey (in-game transactions). Each integration routes payments through the Feeder, adding real utility to the IMT economy while maintaining the 10% fee distribution that rewards all holders.

Testing the mechanics on Sepolia testnet

Immute is currently live on Sepolia testnet (chainId 11155111), with mainnet launch planned after validation completes. This testnet deployment serves as a proving ground for the protocol's core mechanics—and an invitation for builders to interact with the system directly.

To participate:

Acquire free Sepolia ETH from a faucet such as https://sepolia-faucet.pk910.de/ (proof-of-work, no signup required) or https://www.alchemy.com/faucets/ethereum-sepolia (free Alchemy account).
Connect a wallet (MetaMask, Rainbow, or similar) to the Sepolia network.
Navigate to https://immute.io and connect.
Execute buys, sells, and observe fee distribution. Claim accumulated dividends. Test the Feeder if supported by the interface.

The goal is to stress-test the bonding curve pricing, verify fee distribution accuracy, and identify edge cases before mainnet deployment. Every trade you execute contributes to the protocol's on-chain history, providing real data for the development team to analyze.

What's coming next

As Immute approaches mainnet, the focus shifts from mechanical validation to ecosystem growth. The Feeder contract's design enables frictionless integration for any product seeking to add a reward layer to their payment flow. Creators, platforms, and developers building on Ethereum can plug into IMT's dividend system without managing liquidity or building custom fee distribution logic.

The architecture is intentionally composable. A bonding curve reward token that accumulates fees from product revenue—rather than relying solely on speculative trading—represents a different category of tokenomics. Whether this model gains adoption depends on the integrations that deploy it and the communities that engage with those products.

For now, the opportunity is to explore the mechanics, stress-test the contracts, and provide feedback that shapes the protocol before it operates with real economic value. Immute is live on Sepolia testnet; mainnet launch is coming soon.

Sources:

What is a bonding‑curve reward token? Inside Immute's on‑chain dividend mechanic

Version 6 LLC — Thu, 07 May 2026 14:01:55 +0000

A bonding‑curve reward token is a cryptoeconomic primitive where token price is a deterministic function of circulating supply, defined directly in a smart contract rather than by an external order book. Every trade mints or burns tokens, automatically adjusting price and distributing a built‑in fee to all existing holders. Immute implements exactly this model on Ethereum Sepolia testnet, offering a live experiment where you can earn IMT by interacting with on‑curve mechanics—mainnet launch coming soon.

The price function: linear vs. exponential

Bonding curves typically follow one of two families:

Linear: (P(s) = k \cdot s) where k is a constant slope.
Exponential: (P(s) = P_0 \cdot e^{r s}) where r controls the rate of price increase.

Both formulas give a continuous price‑supply relationship. When you buy Δs tokens, the contract calculates the total cost by integrating the price function over the current supply:

[
\text{Cost} = \int_{s}^{s+\Delta s} P(u)\,du
]

For a linear curve this reduces to (\frac{k}{2}\big[(s+\Delta s)^2 - s^2\big]); for exponential it becomes (\frac{P_0}{r}\big(e^{r(s+\Delta s)} - e^{r s}\big)). The integral ensures that price rises smoothly as supply expands, eliminating the slippage inherent in AMM‑style liquidity pools.

The 10 % fee and pro‑rata dividend distribution

On Immute, every buy or sell incurs a flat 10 % fee on the collateral transferred. If a user sends C ETH to purchase IMT, the contract splits it as follows:

Fee calculation: (f = 0.10 \times C).
Holder reward pool: The entire fee f is added to a global dividend pool.
Pro‑rata distribution: Each holder’s share of the pool is proportional to their IMT balance at the moment the trade settles:

[
\text{Claimable reward for holder } h = f \times \frac{\text{balance}_h}{\text{totalSupply}}
]

Because the fee is distributed on every trade, the effective yield scales with market activity. In simulations, a 10× increase in trade volume translates to roughly a 2.59× increase in effective APY when rewards are auto‑compounded back into the curve [4]. This compounding effect is why the model is described as a bonding‑curve reward token: holders earn dividends simply by holding, without any external liquidity provision or inflation‑based emissions.

Why bonding curves beat LP‑based markets

Aspect	Bonding‑curve model (Immute)	LP‑based AMM
Liquidity source	Instant, built‑in; no external pool required	External liquidity pools prone to impermanent loss
Team allocation	None; 100 % of tokens issued on‑curve	Often allocated to teams, investors, or incentives
Fee distribution	Directly to holders per trade	Liquidity providers split fees, sometimes with protocol cut
Price discovery	Continuous, deterministic via formula	Continuous, but depends on pool depth and arbitrage
Impermanent loss	None—holders never provide liquidity	Present when token price diverges from entry

These properties make bonding‑curve reward tokens especially attractive for product‑powered tokenomics: revenue generated by an application flows through the curve, automatically rewarding every participant. The model has been explored academically as an efficient fundraising mechanism and as a foundation for real‑world asset tokenization [2][3].

The Feeder primitive: turning payments into rewards

Immute’s Feeder contract is the integration bridge that brings external products onto the curve. When a user pays through a partner platform:

1 % of each payment is routed on‑curve, executing a trade that adds to the dividend pool.
99 % of the payment is forwarded to the product’s treasury.

Planned integrations include:

Neptime.io – a creator‑monetization platform where viewers donate or tip creators in IMT. The on‑curve 1 % flows to all IMT holders.
Valiep.com – subscription purchases routed through the Feeder.
Discovire.com – discovery‑layer purchases, also Feeder‑routed.
ByteOdyssey – upcoming game payments through the Feeder.

All of these use the same FeederV9 contract (0xa87e7c25c2f754C7D6bFc9b4472E0c36096E4bF6) to guarantee that every transaction, regardless of the product, contributes to the holder dividend pool. This design is what makes Immute a product‑powered reward token rather than a speculative vehicle.

How to test the mechanics on Sepolia

Immute is live on Sepolia testnet (chainId 11155111). To explore the on‑chain dividend engine:

Obtain free test ETH
- PoW faucet: https://sepolia-faucet.pk910.de/ (no signup)
- Alchemy faucet: https://www.alchemy.com/faucets/ethereum-sepolia (free account required)
Connect a wallet (MetaMask, Rainbow, or any Web3 wallet) and set the network to Sepolia.
Visit the interface at https://immute.io and connect your wallet.
Buy, sell, or reinvest dividends to see the 10 % fee flow directly to your balance.
- The IMT token contract is 0xB575A8760c66F09a26A03bc215D612EA2486373C.
Test the Feeder by simulating a payment through any of the planned partner integrations (when they become available in testnet).

There is no monetary value on testnet—ETH is free—so you can experiment without risk. Your feedback helps us burn in the contracts and refine the mechanics before mainnet launch.

Roadmap: mainnet and beyond

Testnet validation – ongoing, with a focus on fee distribution accuracy and Feeder integrations.
Mainnet launch – planned after testnet validation completes; IMT will retain the same curve mechanics but operate on Ethereum mainnet.
Product integrations – Neptime, Valiep, Discovire, and ByteOdyssey are all slated to go live alongside mainnet, turning every payment into a holder reward.
Potential extensions – exponential curve variants, DAO‑governed fee splits, and RWA collateralization (as explored in the broader token‑engineering literature) [3].

Conclusion: try it, earn IMT, and shape the curve

The bonding‑curve reward token model offers a clean, mathematically precise alternative to LP‑based markets, delivering instant liquidity, deterministic pricing, and direct dividend distribution to every holder. Immute’s live Sepolia testnet gives you a hands‑on environment to:

Buy and sell IMT and watch the 10 % fee distribute to your balance.
Reinvest dividends to experience compound growth.
Test the Feeder and provide feedback on how product‑powered payments can reward the entire holder base.

Head to https://immute.io, connect your wallet, and start exploring the on‑chain dividend mechanic today. Mainnet launch is coming soon, and your testnet experience will help us ship a robust, product‑powered reward token.

References

[1] “What is a bonding‑curve reward token? Inside Immute's on‑chain dividend mechanic.” Dev.to, Oct 2025. https://dev.to/version_6llc_b4d52bd440b/what-is-a-bonding-curve-reward-token-inside-immutes-on-chain-dividend-mechanic-5b7h

[2] Mechanism Institute. “Token Bonding Curve.” https://mechanism.institute/library/token-bonding-curve/

[3] RWA.io. “Understanding What is Bonding Curve Crypto and its Role in Tokenomics.” Feb 2026. https://www.rwa.io/post/understanding-what-is-bonding-curve-crypto-and-its-role-in-tokenomics

[4] Immute Community. “Trade‑triggered rewards outperform LP yields by avoiding IL.” Dev.to, Oct 2025. https://dev.to/version_6llc_b4d52bd440b/what-is-a-bonding-curve-reward-token-inside-immutes-on-chain-dividend-mechanic-5b7h

Product-Powered Tokens: Why Most Reward Tokens Fail and Immute's Bet Against That

Version 6 LLC — Mon, 04 May 2026 14:01:02 +0000

The reward token landscape is littered with projects that looked promising until the speculative winds shifted. Issuance rails ignited hype cycles, driving spot and derivatives flows, but without underlying value accrual, liquidity evaporated as attention moved to the next shiny thing. This isn't a bug in human psychology—it's an structural flaw in how most reward tokens are designed. They depend on the willingness of speculators to hold, and that willingness is finite.

Immute is built on a different premise: a product-powered reward token where real economic activity—customer payments from integrating products—perpetually drives on-chain buys, paying holders indefinitely. The mechanism is called the Feeder, and it represents our bet that durability beats hype.

The Speculation Collapse Pattern

History documents the fragility of purely speculative reward tokens with uncomfortable precision. Tokens pumped by mining rewards or algorithmic incentives rely on endless inflows. When those inflows slow—whether due to market cycles, competitor launches, or simple attention fatigue—the token's value proposition collapses. Holders who accumulated during the hype phase find themselves holding an asset that no longer generates meaningful yield, and they exit. This creates a death spiral: falling prices reduce holder incentives, which further accelerates exit.

The pattern isn't unique to crypto. It's the same dynamics that undid countless "growth at all costs" startups. Build a user base on subsidies and incentives, and when the subsidies end, the users leave. The difference in crypto is that the collapse happens on-chain, atomically, with no middle management to negotiate retention.

2025's DeFi evolution illustrated this sharply. Tokens tied to governance narratives or unchecked emissions faltered, while sustainable models emphasizing revenue sharing, buybacks, and disciplined payouts outperformed. The market began pricing durability explicitly, rewarding protocols that could demonstrate continuous value capture rather than speculative premium.

Enter the Feeder: Revenue as Infinite Holder Yield

The Feeder is a durability mechanism that transforms customer payments from integrating products into perpetual on-chain buys. Every transaction—whether a subscription, a purchase, a service fee—mints a tiny, automated buy of IMT directly on Immute's bonding curve. This isn't discretionary airdrop farming or incentive-driven liquidity mining. It's product revenue as infinite holder yield, indexed to real-world usage rather than market sentiment.

The mechanics are precise. When an integrating product processes a payment—say, a viewer donates IMT to a creator on Neptime.io, or a subscriber purchases through Valiep.com—the Feeder route kicks in. One percent of every payment executes a buy of IMT on Immute's bonding curve. Ninety-nine percent flows to the integrating product's treasury, funding development, operations, and growth. The one percent on-curve buy pays every current IMT holder their pro-rata dividend from real economic activity.

This is the key insight: holders earn IMT not because speculators are bidding, but because customers are paying for products they value. The reward token's yield is backed by product revenue, not by the greater fool theory.

Why This Survives When Speculation Fails

Speculation-driven reward tokens have a halving problem by design. As initial incentive schedules exhaust and early adopter yields dilute, the economic case for holding weakens. Participants do the math: expected yield from speculation is lower than alternative opportunities, so they rotate. The token price falls, which further reduces holder yield, which accelerates rotation.

The Feeder breaks this cycle because product revenue doesn't halve. If the integrating products—Neptime.io, Valiep.com, Discovire.com, ByteOdyssey—generate genuine utility that customers pay for, the payment flows remain stable or grow. Customer acquisition doesn't depend on token incentives; it depends on product value. And every payment, regardless of size, contributes a tiny on-curve buy that pays holders.

The flywheel is straightforward: payments from products generate on-chain buys, which provide price support and holder yields, which improve holder retention, which strengthens network effects, which attracts more products, which generates more payments. No halvings, no peg breaks—just compounding utility.

The Testnet Phase: Validating the Mechanics

Immute is currently live on Sepolia testnet (chainId 11155111). This is intentional. We want builders, developers, and sophisticated users to test the mechanics before mainnet launch. The bonding curve is operating; the 10% buy/sell fee distributes pro-rata to IMT holders; the Feeder contract routes payments as designed. But there are no monetary stakes—IMT has no dollar value yet, and ETH used is free testnet ETH.

The testnet phase serves a specific purpose: burn in the contracts under real usage patterns. We want to see how the Feeder handles payment flows, how the bonding curve responds to varied buy/sell pressure, how the dividend distribution performs with diverse holder wallets. This validation is prerequisites for mainnet launch.

Participating is straightforward. Acquire free Sepolia ETH from a faucet—https://sepolia-faucet.pk910.de/ offers PoW mining without signup, or https://www.alchemy.com/faucets/ethereum-sepolia provides free ETH with an Alchemy account. Connect a wallet (MetaMask or Rainbow) to Sepolia at https://immute.io. Then buy, sell, reinvest dividends, test the Feeder, and watch the on-curve economics in action. No speculation required—just hands-on engagement with the mechanism.

The Integration Roadmap

The Feeder is already designed to integrate with planned products. Neptime.io will enable creator monetization—viewers donate or transfer IMT to creators on uploaded videos, and the bonding curve's 10% fee flows to all holders from every transaction. Valiep.com will route subscription-based purchases through the Feeder. Discovire.com will handle discovery-layer purchases via the same mechanism. ByteOdyssey will process in-game payments through the Feeder primitive for an upcoming game development platform.

Each integration follows the same pattern: 1% of customer payment goes on-curve (paying holders), 99% goes to the product's treasury. This is what makes Immute a product-powered reward token rather than a speculative one. The yield is funded by real product revenue, not by token incentives or emission schedules.

The Thesis for 2026

Pure speculation-driven reward tokens collapse when speculators leave. History demonstrates this pattern across market cycles and protocol generations. The 2025 DeFi evolution confirmed that sustainable models emphasizing revenue sharing and disciplined value capture outperform hype-driven issuance.

The Feeder represents our response to this fragility. By routing customer payments through an on-chain mechanism that perpetually executes tiny buys, Immute decouples holder yield from speculative sentiment. Holders earn from product revenue, not from the greater fool theory.

This isn't theoretical. It's the thesis for 2026's durable protocols. Build products that pay users eternally, or watch speculators ghost.

Try Immute on Sepolia testnet. Mainnet launch is coming soon. The mechanics are live; the integrations are planned; the thesis is stated. What remains is validation—and that's why we're here.

Product-Powered Tokens: Why Most Reward Tokens Fail and Immute's Bet Against That

Version 6 LLC — Fri, 01 May 2026 03:41:14 +0000

The reward token model is broken. Not technically — the contracts work, the distributions happen, the wallets fill up. The failure is economic: most reward tokens are built on speculation, and speculation is a finite resource. When the traders leave, the token collapses, the dividends dry up, and the holders are left holding an asset with no floor.

This isn't a prediction. It's an observable pattern across dozens of chains and hundreds of tokens. The anatomy is consistent: a token launches, early buyers accumulate, the hype cycle peaks, volume spikes, and early holders earn meaningful dividends. Then the speculation cycle inverts. Holders start selling to capture gains, liquidity thins, trading volume drops, and the dividend yield collapses. New buyers have no reason to enter a declining yield environment. The token enters a slow death spiral.

Immute was designed to break this cycle. It's a product-powered reward token where the dividend stream isn't derived from trading fees or speculative volume — it's derived from real economic activity flowing through a primitive called the Feeder. Every customer payment from integrating products mint a tiny on-curve buy, paying holders forever. That's the core thesis.

The Speculation Trap

To understand why the product-powered model is different, you need to understand why the speculative model fails. Consider a typical reward token: a percentage of every buy and sell is redistributed to holders. The dividend yield depends entirely on trading volume. High volume, high yield. Low volume, low yield.

Speculators are drawn to high yield. But they're also the first to leave when the yield drops. The mechanism is self-reinforcing in the wrong direction: declining price → lower yield → speculative capital exits → price falls further. There's no escape valve because the dividend stream has no independent source of demand.

The irony is that speculators are often the loudest early adopters. They provide the initial volume that makes the yield look attractive, drawing in longer-term holders who believe the dividends are sustainable. When the speculators rotate out, those holders are left holding a token whose yield has cratered.

This isn't a failure of the reward token mechanism itself — it's a failure of the economic foundation. You're rewarding holders with fees from other holders, not from any external economic activity. The token exists in a closed loop with no way to break out.

How the Feeder Changes the Equation

Immute's Feeder contract is designed to break that closed loop. The mechanism is straightforward: any integrating product routes a portion of customer payments through the Feeder, which executes a buy on the bonding curve. One percent of every payment goes on-curve. Ninety-nine percent goes to the integrating product's treasury.

The implication is significant: every customer transaction in any integrated product creates a small, autonomous buy pressure on the curve. This isn't trading volume — it's product revenue being converted into dividend-generating buy pressure. The dividend yield is now tied to real economic activity, not speculative churn.

The products currently in development illustrate the breadth of this model. Neptime.io is a creator-monetization platform where viewers donate or transfer IMT to creators on uploaded videos. Every donation routes through the Feeder, generating a micro-buy that pays every IMT holder. Valiep.com handles subscription-based purchases, routing them through the Feeder. Discovire.com is a discovery-layer integration with the same flow. ByteOdyssey is a game development platform where in-game payments pass through the Feeder.

In every case, the economic activity is primary and the token dividend is secondary. The IMT you're holding isn't generating yield because traders are exchanging it — it's generating yield because customers are paying for services that happen to route through the curve.

Why This Is Durable

Durability in a reward token comes down to one question: what happens when speculative interest fades? With a pure-speculation model, the answer is collapse. With a product-powered reward token, the answer is: nothing changes. Customer payments continue. The Feeder continues to mint micro-buys. Dividends continue flowing.

This doesn't mean the IMT price is insulated from all market dynamics — it's still a tradeable asset on a bonding curve. But the dividend yield is no longer hostage to trading volume. A holder who bought in during the testnet phase doesn't need to hope that speculators keep rotating through the token. They need the integrated products to be used.

That's a fundamentally different risk profile. Speculative yield requires continuous new capital entering the ecosystem to maintain volume. Product-powered yield requires the integrated products to be valuable enough that customers use them. That's a testable proposition, not a momentum trade.

Immute's Current Position

This architecture is live on Sepolia testnet. Immute V8 and FeederV9 are deployed and functional. The contract addresses are publicly verifiable on Etherscan. You can connect a wallet to the app, interact with the bonding curve, and observe how dividends flow to holders as you trade. The Feeder is integrated into the contract architecture and can be exercised by any product that writes to it.

Mainnet launch is coming soon, after testnet validation completes. The goal of the current phase is to stress-test the mechanics with real activity on testnet before anchoring economic value to the contracts.

If you're a developer evaluating this model, the invitation is to look at the contracts directly. Read the Feeder implementation. Trace how customer payments become on-curve buys. Model what the dividend yield looks like under different product usage assumptions. The thesis is verifiable — it's not a narrative about future potential, it's a mechanism you can test right now.

The reward token category has been dominated by speculation because speculation is easy to generate and easy to market. The product-powered variant requires actual product-market fit to generate meaningful dividends. That's a harder problem, but it's also a more durable one. When the speculators rotate out, the product activity remains.

That's the bet. Whether it pays depends on whether the integrated products — Neptime, Valiep, Discovire, ByteOdyssey — become genuinely useful enough that customers keep paying through the Feeder. Test the contracts. Watch the integrations develop. Form your own view on whether the mechanism holds.

Product-Powered Reward Tokens: Why Most Reward Tokens Fail and Immute's Bet Against That

Version 6 LLC — Thu, 30 Apr 2026 14:01:59 +0000

The reward token model has a structural flaw that becomes obvious only after the hype fades. Projects launch, distribute tokens to early users, watch the price pump as speculation compounds, then collapse when the speculative cycle exhausts itself and real usage never materializes. This pattern repeats so consistently that it's become a cliché: speculative reward tokens crash when speculators leave, leaving holders with assets that accumulated no intrinsic cashflow.

This is not a bug in token design. It's the predictable result of building a reward token without a corresponding product that generates on-chain revenue. The token becomes a vehicle for speculation rather than a share in something that actually earns money. When the speculators move on, the value collapses because nothing is generating demand.

The alternative is a product-powered reward token: a token where holding is rewarded by actual cashflows from a functioning product, not by the hope that more speculators arrive. Immute is built around this thesis. It's live on Sepolia testnet now, with mainnet launch coming soon, and every design decision reflects a commitment to earning revenue before earning a price.

Why Pure Speculation Reward Tokens Collapse

The history of Web3 reward tokens reads like a series of case studies in this failure mode. Liquidity mining programs from Compound and Synthetix distributed transferable tokens to bootstrap participation, but these programs bred plutocracy and hype dependency. As a16z Crypto documented, many projects moved toward non-transferable reputation systems precisely because transferable reward tokens couldn't sustain value after the initial distribution phase. The tokens created participation, but the participation wasn't anchored to anything that would generate revenue for holders.

The unlock problem compounds this failure. When a token has a team allocation or investor vested tokens, the unlock schedule creates a perpetual overhang. Holders know that a large supply is coming onto the market, and rational actors price in that future selling pressure. The token appreciates while unlock is distant and crashes when it arrives. This dynamic makes it nearly impossible to build a stable holder base, because every holder has a financial incentive to exit before the next unlock cliff.

Perhaps most critically, speculative reward tokens derive their entire value from the expectation that future speculators will pay more. This is a fragile foundation. When market attention rotates to a newer project, when a bear market reduces retail participation, or when regulatory uncertainty makes crypto markets less attractive, the speculative demand dries up and the token price follows. There's no underlying revenue engine to sustain the value while markets reorganize.

Delphi Digital's analysis of token unlock mechanics showed that many projects fail because tokens provide "trivial utility" without threading into a viable product. The token exists, it may have some governance or discount functionality, but it doesn't participate in a cashflow-generating process. When the unlock happens and early holders sell, the remaining holders are left with a governance token in a protocol that never built the product depth to justify governance participation.

The historical record is clear: reward tokens that rely purely on speculative demand trend toward zero when speculation fades.

The Feeder Mechanism: Revenue That Never Stops

Immute's answer to this structural problem is the Feeder, a contract that intercepts product revenue and routes a small percentage through the bonding curve before it reaches the product treasury. This isn't a yield farm or a staking reward—it's a direct financial claim on real business activity.

When a user pays for something on an integrating product—whether that's a subscription on Valiep.com, a creator donation on Neptime.io, or an in-game purchase on ByteOdyssey—99% of that payment flows to the product's treasury as normal. But 1% is captured and used to execute an on-curve buy of IMT. This micro-buy happens atomically within the transaction. The IMT is purchased from the bonding curve, which means the price rises by a tiny increment, which means every IMT holder earns a small dividend on their position.

This mechanism is durable because it doesn't depend on speculators. The buy pressure comes from product revenue, which is generated by people buying something they actually want. As long as people use the products that integrate with Immute, the Feeder keeps executing micro-buys. The reward to holders is proportional to real economic activity, not to the enthusiasm of the crypto market.

The integrating products benefit from this arrangement too. The Feeder gives them a way to offer tokenized revenue share to their user base without building their own token economy from scratch. When a creator receives IMT donations on Neptime.io, they're holding a token that pays them every time any transaction happens on any integrated product. This creates a compounding incentive: the more the product grows, the more the token rewards early adopters, which attracts more users, which generates more revenue, which funds more micro-buys. It's a self-reinforcing loop that doesn't require perpetual token emissions or emission schedules.

The technical implementation is worth understanding precisely. The Feeder contract executes a buy function on the IMT bonding curve, which uses a bonding curve algorithm to price the purchase and update the state. Every IMT holder sees their balance increase in real-time as these micro-transactions accumulate. There's no waiting for staking periods or claim transactions—the rewards are immediate and automatic.

Why Immute Is Structured to Test This Thesis

Most reward tokens fail because they optimize for token distribution before they have a product that generates revenue. Immute takes the opposite approach. There is no team allocation, no investor round, no seed token sale. The entire token supply comes from bonding curve interactions—people buying and selling, with the curve providing liquidity and price discovery.

This design eliminates the unlock overhang entirely. When you hold IMT, you know that no batch of locked tokens will hit the market at a predetermined date. The supply is fully circulating, and the price reflects actual demand. If you want to exit, you can sell on the curve. If you want to hold, you earn dividends from every transaction.

The testnet deployment on Sepolia exists so that builders can validate these mechanics before mainnet launch. With free testnet ETH from faucets like sepolia-faucet.pk910.de or Alchemy's Sepolia faucet, developers can connect a wallet, interact with the IMT bonding curve at https://immute.io, and observe how the Feeder responds to simulated product revenue. The contracts are public and auditable—the IMT V8 contract at 0xB575A8760c66F09a26A03bc215D612EA2486373C and the FeederV9 contract at 0xa87e7c25c2f754C7D6bFc9b4472E0c36096E4bF6 are both verified on Etherscan.

This is not a whitepaper promise. It's live code that can be tested today. The integrations with Neptime.io, Valiep.com, Discovire.com, and ByteOdyssey are planned for after mainnet launch, but the Feeder mechanism is already functional on testnet and ready to be exercised.

The Product-Powered Reward Token Thesis

The core argument is straightforward: tokens that are backed by product revenue survive speculative cycles because they earn their value rather than borrowing it. A product-powered reward token generates continuous buy pressure from actual business activity, not from the hope that future speculators will arrive. When markets are bullish, the token benefits from speculative amplification on top of product-backed demand. When markets are bearish, the product revenue keeps the Feeder executing buys, sustaining holder rewards through the downturn.

This is structurally different from yield farm tokens that distribute protocol revenue, because those distributions are denominated in the token itself, creating inflation pressure. The Feeder buys IMT from the market, which means the buy pressure is net-new demand rather than a distribution of existing supply. The token economics are additive rather than dilutive.

It's also different from loyalty points that aren't transferable, because transferable tokens can be priced by the market, providing price discovery and liquidity that non-transferable systems lack. The NBER research on loyalty tokens shows that issuers prefer non-transferability to avoid speculation, but the cost is illiquidity and fragmented markets. Immute captures the revenue-share benefit of loyalty programs while enabling the liquidity and price discovery of a public token market.

The testnet phase exists to prove this mechanism works before the stakes are real. Mainnet launch is coming soon, and when it arrives, the Feeder will begin capturing revenue from integrating products. Until then, builders can test whether the mechanics hold, whether the dividend distribution scales, and whether the bonding curve provides sufficient liquidity for the volume the integrations will eventually generate.

The thesis is simple: build the product, earn the revenue, distribute it to holders through the Feeder, and let the compounding work. Speculators can participate, but they can't sustain a token economy on their own. Only products can do that.

BUY_LOCK_BLOCKS: How Immute Blocks Same-Block Sandwich Attacks

Version 6 LLC — Mon, 27 Apr 2026 14:01:09 +0000

In decentralized finance, few attack vectors are as well-documented—and yet as persistently exploitable—as the sandwich attack. When a victim's trade sits in the public mempool, opportunistic miners or MEV bots can exploit transaction ordering to extract value at the expense of the honest trader. For bonding-curve reward tokens like Immute, where every buy and sell distributes fees pro-rata to holders, this vulnerability is particularly acute. If attackers can reliably sandwich-protect their own trades while sandwiching others, they effectively skim value from the holder community without contributing fairly to the ecosystem. This article examines Immute's per-address buy-lock window mechanism—a smart contract sandwich attack prevention technique that forces would-be sandwichers to wait before executing the sell side of their attack, neutralizing same-block profitability and restoring fair execution order.

Understanding the Sandwich Attack Vector

A sandwich attack operates by exploiting the transparent nature of the public mempool. The attacker monitors the pending transaction pool for victims submitting swaps, particularly large ones that will meaningfully shift pool reserves. When detected, the attacker executes two transactions in rapid succession: a front-run buy that inflates the token price, followed by a back-run sell that captures the victim's slippage-induced price movement [1][3][4][5].

In AMM-based DEXs like Uniswap, a victim's large swap shifts pool reserves according to the constant product formula (x · y = k), creating measurable price impact. The attacker exploits this by placing their buy transaction with a higher gas fee, ensuring it executes immediately before the victim's trade, and their sell transaction immediately after, harvesting the spread [5][7]. Traditional prevention strategies have focused on private order flow, batch auctions, and slippage tolerance warnings—but these are user-side mitigations that don't fundamentally alter contract-level vulnerabilities.

The Per-Address Buy-Lock Window: A Contract-Level Defense

Immute implements a smart contract sandwich attack prevention mechanism that operates at the protocol level rather than relying on off-chain ordering solutions. The core innovation is the per-address buy-lock window, which enforces a cooldown period after any purchase, preventing the same address from immediately executing a sell.

The mechanism centers on two storage variables: a lockedUntil mapping that records the timestamp when an address's lock expires, and an isLocked() view function that returns whether a given address is currently prevented from selling. When a user buys IMT, the contract sets lockedUntil[msg.sender] = block.timestamp + LOCK_WINDOW, where LOCK_WINDOW is a protocol-defined duration—sufficiently long to prevent same-block exploitation but short enough to preserve liquidity access for legitimate traders.

The sell function includes a guard clause that queries isLocked(msg.sender) and reverts if true. This means that after buying, a user cannot sell back through the contract until the lock window expires—even if they submit the transaction in the same block. The critical insight is that block.timestamp is consistent within a block, so an attacker attempting to front-run-buy and back-run-sell within the same block will find their sell reverted by the lock check, even though the timestamps appear identical from the transaction ordering perspective.

Mechanics: Same-Block Prevention in Practice

Consider a concrete attack scenario demonstrating why the per-address buy-lock window constitutes effective smart contract sandwich attack prevention:

The victim submits a buy transaction to an AMM pool. The attacker's MEV bot detects this pending transaction and constructs a sandwich in the same block. The attacker first executes a buy transaction—which sets lockedUntil[attacker] = block.timestamp + WINDOW. The victim's transaction then executes at the now-inflated price. Finally, the attacker attempts to execute their back-run sell to capture the slippage. However, when the sell function checks isLocked(attacker), it returns true because block.timestamp < lockedUntil[attacker]. The sell reverts [2][8].

The attacker cannot bypass this check by submitting with higher gas or different ordering—the lock is enforced at the contract level and is indifferent to transaction sequencing. To successfully execute a sandwich, the attacker would need to wait through the entire lock window before selling. By that time, arbitrageurs and natural market activity have typically closed the artificial price gap, eliminating the profit opportunity that motivated the attack.

This design preserves multi-user liquidity because the lock is address-specific. Only the attacking address is locked; other participants can freely buy and sell. The mechanism targets the specific threat model of MEV bots exploiting mempool transparency without introducing friction for legitimate protocol users who don't attempt sandwich attacks [8].

Why Contract-Level Enforcement Matters

Traditional smart contract audits often focus on access control, reentrancy guards, and arithmetic overflow checks—important vulnerabilities, but they miss the off-chain ordering threats that enable MEV exploitation. Sandwich attacks are not contract bugs in the traditional sense; they're emergent behaviors from the interaction between public mempool transparency, transaction ordering economics, and AMM pricing mechanics [5].

By implementing the per-address buy-lock window at the contract level, Immute shifts the defense burden from user-side privacy solutions to protocol-level enforcement. This is a more robust approach because it doesn't require users to adopt specific wallet configurations, use privacy-preserving RPC endpoints, or understand MEV mechanics. The protection is automatic and compulsory—any address attempting a sandwich attack within the same block will be rejected, regardless of their sophistication or gas bidding power.

Implementation Considerations for Developers

Immute is live on Sepolia Testnet (chainId 11155111) for developers and security researchers to analyze and test this mechanism. The IMT V8 contract at 0xB575A8760c66F09a26A03bc215D612EA2486373C and FeederV9 at 0xa87e7c25c2f754C7D6bFc9b4472E0c36096E4bF6 are publicly verifiable on Sepolia Etherscan [5].

For developers integrating Immute or building similar defenses, several implementation details warrant attention:

The lockedUntil timestamp should be set to a duration that exceeds typical block time variance while remaining short enough to avoid liquidity lockup complaints. The choice involves tradeoff analysis: too short, and MEV bots can potentially sandwich across multiple transactions with minimal delay; too long, and legitimate traders face meaningful access friction.

The isLocked() function should be a pure view function with no gas overhead for callers—this ensures the check doesn't introduce significant gas costs for non-attacking users. The lock state should be per-address, not global, to avoid disrupting legitimate trading activity from unrelated addresses.

Finally, the mechanism should be documented and publicized. Sandwich attack profitability depends on victim unawareness; if participants understand that same-block sandwiching is prevented, rational attackers won't attempt it, and the defense becomes self-enforcing.

Looking Toward Mainnet

The per-address buy-lock window is one component of Immute's broader security architecture for a product-powered reward token. As the protocol moves toward mainnet launch—pending testnet validation—these contract-level defenses will face increased scrutiny from a live, value-bearing adversary environment.

The testnet deployment at https://immute.io invites developers to interact with the contracts, test the lock mechanism, and identify any edge cases the current implementation might miss. Free Sepolia ETH is available from faucets like https://sepolia-faucet.pk910.de/ or https://www.alchemy.com/faucets/ethereum-sepolia, removing financial barriers to participation.

For the developer community, Immute represents an opportunity to engage with novel token economics—the bonding curve's 10% fee distribution to holders, the Feeder contract's 1% on-curve routing for integrated products—while also stress-testing a practical smart contract sandwich attack prevention mechanism. The per-address buy-lock window demonstrates that protocol-level defenses against off-chain ordering threats are viable, and Immute's open testnet deployment makes this research accessible to anyone with a wallet and curiosity.

Web3 Creator Monetization Beyond NFTs: The Feeder Primitive

Version 6 LLC — Sun, 26 Apr 2026 04:58:41 +0000

The promise of blockchain-based creator monetization has long been touted as a paradigm shift—a direct connection between creators and their audience, bypassing traditional intermediaries and their revenue splits. Yet for all the initial excitement around NFT royalties and token-gated content, the reality has been more nuanced. NFT markets have proven volatile, creator royalties have become optional rather than enforced, and the "community" tokens that were supposed to align incentives have largely served speculative rather than productive purposes.

Immute takes a different approach. Rather than relying on speculative demand to generate creator revenue, Immute is designed as a product-powered reward token—a system where real economic activity flowing through the Feeder primitive generates consistent, measurable value for every IMT holder. This is creator monetization web3 that works because it's tied to actual usage, not just holding.

The Bonding Curve Foundation

At its core, IMT operates on a bonding curve contract deployed on Sepolia testnet. Every buy and sell transaction executes a 10% fee that gets distributed pro-rata across all current holders. There's no team allocation, no VC round, and no pre-mined supply waiting to be dumped on the market. The economics are transparent and on-chain from day one.

This structure means that as usage grows, the dividend stream for holders grows proportionally. But the critical insight is that usage doesn't come from speculation—it comes from the Feeder.

The Feeder Primitive: A Technical Overview

The Feeder is a smart contract interface that allows external products to route payments through Immute's economics. When a creator receives a payment through any Feeder-integrated platform, the transaction splits automatically: 1% flows through the bonding curve (paying dividends to all IMT holders), while 99% goes directly to the creator or the integrating product's treasury.

The integration surface is deliberately minimal. A developer needs a single function call:

Feeder(feederAddress).feed{value: amount}(recipient, metadata); This one call handles the payment routing, the on-curve purchase that generates holder dividends, and the treasury distribution. For a platform like NepTime.io, where viewers donate IMT to creators on uploaded videos, this means the creator receives their funds immediately while the 1% on-curve purchase happens automatically in the same transaction. Every holder benefits from the activity without any additional action required.

Why 1% Matters More Than It Sounds

A 1% on-curve purchase might seem trivial, but consider the mechanics. When that 1% hits the bonding curve, it triggers the same 10% distribution mechanism that applies to all trades. So if a creator receives 99 ETH through the Feeder, the 1 ETH that goes on-curve generates a dividend that's distributed across the entire holder base. The more activity flowing through integrated products, the more consistent the dividend stream becomes.

This is fundamentally different from ad-share models. When you monetize through YouTube or Twitch, the platform takes a substantial cut—typically 45-55%—and the remaining revenue is based on engagement metrics that creators don't directly control. With Immute's Feeder model, creators retain 99% of every payment. The on-curve 1% isn't a fee taken from creators—it's a small percentage that flows to all holders, which could include the creators themselves if they choose to hold IMT.

Integration Landscape

Several platforms are building with the Feeder primitive in mind:

NepTime.io focuses on creator-monetization web3 for video content. The platform allows viewers to donate or transfer IMT directly to creators, with every transaction routing through the Feeder. The 10% fee that flows to all holders applies to these creator payments, creating a sustainable economic loop.

Valiep.com and Discovire.com are building subscription and discovery-layer purchase flows through the Feeder. Both platforms route payments through the same primitive, meaning consistent on-curve activity regardless of the specific use case—whether it's a monthly subscription or a discovery-based purchase.

ByteOdyssey represents the gaming angle: in-game payments and purchases routed through the Feeder. As players spend IMT within the game ecosystem, the 1% on-curve activity generates dividends for holders, including potentially the game developers themselves if they participate in the token economy.

The architectural pattern is consistent across all integrations: the Feeder contract handles the complexity of the on-curve mechanics, while integrating products focus on their core value proposition.

The Testnet Phase

Immute is currently live on Sepolia testnet, which means developers can experiment with Feeder integrations using free testnet ETH. This validation phase serves a critical function: the contracts are live, the mechanics are operational, and the economics can be tested in a real environment before mainnet launch.

For developers interested in building with the Feeder, this is the time to test. The IMT V8 contract and FeederV9 are deployed and verified on Sepolia. You can interact with them directly, stress-test the routing logic, and verify that the economics work as designed.

The Sepolia deployment addresses are:

IMT V8: 0xB575A8760c66F09a26A03bc215D612EA2486373C - FeederV9: 0xa87e7c25c2f754C7D6bFc9b4472E0c36096E4bF6

Both contracts are verified on Etherscan, allowing full inspection of the implementation.

Comparing Models: Feeder vs. Traditional Creator Monetization

Traditional creator monetization web3 has relied on a few mechanisms: NFT sales with royalties, community token issuance, and speculative trading volume. Each has limitations.

NFT royalties have become optional in practice—creators who built businesses around secondary sale royalties have seen those revenues evaporate as marketplaces removed enforcement. Community tokens often require active community management and can devolve into speculative trading with no connection to actual product usage. And trading-volume-based models require someone to be actively trading, which creates incentive structures that favor speculation over usage.

The Feeder model sidesteps these issues because the revenue is tied to actual payments, not trading activity. A creator on NepTime.io receives revenue when viewers actually donate or tip. A subscription through Valiep.com generates activity when payments are made. The dividend stream for IMT holders grows as real economic activity increases, not when traders move the price.

Looking Forward

The integration roadmap includes all four announced partners, each using the same Feeder primitive. This consistency means that as the ecosystem grows, the on-curve activity compounds across multiple products. A user who discovers content on Discovire.com, tips a creator on NepTime.io, and plays a ByteOdyssey game generates on-curve activity across three different use cases—all benefiting IMT holders.

Mainnet launch will follow testnet validation, bringing the same mechanics to production ETH. The contracts are designed to be chain-agnostic in their logic, with Sepolia serving as the proving ground.

For developers evaluating the creator monetization web3 space, the Feeder represents a different kind of opportunity—not a token to speculate on, but a primitive to build with. The architecture is open, the contracts are verified, and the integration surface is minimal. Test it on Sepolia, and watch for mainnet launch coming soon.

Want to dig deeper into how Immute works on-chain?

Read the whitepaper — full technical spec of the bonding curve, fee distribution, and Feeder primitive.
Audit + V4 postmortem — every finding ever raised against the contracts and how it was resolved.
Live leaderboard — top holders, dividend earnings, referral payouts.
On-chain charts — supply curve, ETH balance, Feeder fee flow.
immute.io — connect a wallet and try the mechanics on Sepolia testnet (mainnet launch coming soon).

BUY_LOCK_BLOCKS: How Immute Blocks Same-Block Sandwich Attacks

Version 6 LLC — Sun, 26 Apr 2026 04:53:20 +0000

Sandwich attacks remain one of the most exploitative patterns in decentralized finance. A malicious actor identifies a pending transaction, front-runs it with a higher gas bid to buy the same asset, then back-runs with a sell after the victim's transaction completes—all within the same block. The victim pays more for their purchase, the attacker pockets the spread, and the protocol's integrity degrades. For a bonding-curve reward token like Immute, where every buy and sell directly impacts the curve's state and every holder's dividend distribution, preventing this vector isn't optional. It's structural.

This post walks through the smart contract sandwich attack prevention mechanisms built into Immute's IMT token, specifically the per-address buy-lock window that blocks front-run-buy and back-run-sell sequences within a single block. The implementation uses two complementary functions—isLocked() and lockedUntil()—to enforce temporal constraints that make same-block exploitation economically nonviable.

What Makes Sandwich Attacks Possible on Bonding Curves

A bonding curve defines price as a function of supply. When a user buys IMT, the contract mints new tokens at the current curve price, increasing supply and raising the price for subsequent buyers. When a user sells, the contract burns tokens, decreasing supply and lowering the price for subsequent sellers.

This mechanism is transparent and deterministic—and that's the problem. An attacker watching the mempool sees a pending buy transaction. They can:

Front-run: Buy IMT just before the victim's transaction, driving the price up. 2. Victim's transaction executes at the elevated price, costing more for the same amount of IMT. 3. Back-run: Sell immediately after, capturing the spread between their lower buy price and the victim's higher execution price.

For a standard bonding curve without countermeasures, this attack is straightforward to execute. The profit margin depends on transaction size and gas costs, but for sufficiently large trades, the economics are favorable.

The Per-Address Buy-Lock Window

Immute's defense centers on a constraint that most bonding curve implementations ignore: temporal coupling between buy and sell operations for the same address.

When an address executes a buy transaction on IMT, the contract records the current block timestamp and sets a lock period. During this lock window, that specific address cannot execute a sell transaction. The lock expires after a configurable duration (measured in blocks), at which point the address regains full trading capability.

This approach breaks the sandwich attack in its tracks. Consider the sequence:

Attacker submits a front-run buy. 2. Victim's buy transaction executes. 3. Attacker attempts to back-run sell—but the contract rejects it because the lock from step 1 hasn't expired.

The attacker is now holding IMT purchased at the elevated price with no immediate exit. They must wait for the lock window to expire, during which the price may revert, gas costs accumulate, and the entire attack vector collapses.

The Implementation: isLocked() and lockedUntil()

The lock mechanism is exposed through two view functions that any wallet, dApp, or audit tool can query.

The isLocked(address user) function returns a boolean indicating whether the specified address is currently subject to a buy-lock. It checks if the current block timestamp is less than the stored lockedUntil value for that address.

The lockedUntil(address user) function returns the exact timestamp (or block number, depending on the implementation) when the lock expires. If the address is not locked, this returns zero or the current timestamp, depending on the contract's convention.

A typical integration looks like this:

if (imt.isLocked(msg.sender)) { revert BuyLockActive(); } Front-end applications can query these functions before rendering trading interfaces, giving users feedback on whether they're subject to a lock. On-chain, the check executes atomically within the buy transaction's execution context, ensuring that even if a user submits a transaction through a mempool-aware mechanism, the contract enforces the constraint.

Why This Works Against Same-Block Attacks

The key insight is that same-block sandwich attacks require rapid back-to-back transactions from the same address: buy, victim transaction, sell. The lock window is measured in blocks or time, not in individual transactions. A single buy initiates a lock that persists across multiple subsequent blocks.

If an attacker attempts to sandwich within a single block:

The front-run buy triggers the lock. - The victim's transaction executes. - The back-run sell fails because the lock is still active. - The attacker cannot exit their position within the same block.

Even if the attacker spreads operations across consecutive blocks, the lock still applies until it expires. This transforms the attack from a low-risk, high-reward exploit into a timed position with uncertain exit conditions.

The design doesn't prevent front-running entirely—nothing can block an attacker from buying before a victim's transaction if they submit it with higher gas. But it eliminates the same-block exit, which is the critical component that makes sandwich attacks profitable. Without the guaranteed back-run, front-running becomes speculation: buy now, wait for price appreciation, exit later. This removes the risk-free arb structure that makes mempool monitoring profitable.

Integration Considerations for Builders

If you're building on Immute or integrating the IMT token into a frontend, you should query isLocked() before displaying trading controls. Users who are locked can still buy (the lock only blocks sells within the window), but attempting to sell during a lock period will revert with BuyLockActive().

For protocols integrating through the Feeder contract—the primitive that routes 99% of payments to the integrating product's treasury while committing 1% on-curve—the lock mechanism remains consistent. A user who buys IMT through the Feeder triggers the same lock. Creators earning IMT through Neptime.io or players spending through ByteOdyssey will encounter the same constraints if they attempt same-window buy-then-sell sequences.

This consistency matters for price stability. Without the lock mechanism, sophisticated traders could move IMT in and out of positions rapidly, extracting value from the curve while diluting holder dividends. The lock forces longer holding periods, which means more IMT volume stays on-curve longer, which means more fee distribution to existing holders.

Mainnet Planning

Currently live on Sepolia testnet, Immute's lock mechanism has been validated through repeated testing cycles. The contract code is public on Etherscan, and developers are encouraged to review the implementation directly. Once mainnet launch completes, the same mechanisms will apply to production IMT transactions.

For developers interested in building with Immute's smart contract sandwich attack prevention architecture, the testnet environment provides a frictionless sandbox. Free Sepolia ETH is available from faucets like Sepolia PoW Faucet, and the contracts are accessible at standard Ethereum JSON-RPC endpoints. No team allocation exists, no VC rounds have occurred—the token economy is fully community-driven from genesis.

The lock mechanism is one component of a broader security posture that includes the Feeder's 1% on-curve commitment on every integration payment, deterministic bonding curve pricing, and transparent on-chain state. For a reward token where every holder earns from every transaction, protecting the curve's integrity isn't a feature. It's the foundation.

Want to dig deeper into how Immute works on-chain?

Read the whitepaper — full technical spec of the bonding curve, fee distribution, and Feeder primitive.
Audit + V4 postmortem — every finding ever raised against the contracts and how it was resolved.
Live leaderboard — top holders, dividend earnings, referral payouts.
On-chain charts — supply curve, ETH balance, Feeder fee flow.
immute.io — connect a wallet and try the mechanics on Sepolia testnet (mainnet launch coming soon).

BUY_LOCK_BLOCKS: How Immute Achieves Smart Contract Sandwich Attack Prevention

Version 6 LLC — Sun, 26 Apr 2026 04:47:37 +0000

yaml style: blog status: draft generated_at: 2026-01-25T12:00:00Z

Smart contract sandwich attack prevention is a core design goal of Immute, a bonding‑curve reward token live on the Sepolia testnet. By introducing a per‑address mutual‑exclusion mechanism, Immute makes it impossible for any single wallet to execute a buy‑followed‑by‑sell (or sell‑followed‑by‑buy) inside the same block, thereby neutralising the classic front‑run‑buy / back‑run‑sell pattern that plagues AMM‑style DEXes. This article dissects the attack vector, explains the logic behind the isLocked() and lockedUntil() primitives, and shows how the contract enforces the lock at the EVM level.

What Is a Sandwich Attack?

A sandwich attack is a form of maximal‑extractable value (MEV) exploitation that relies on ordering two transactions around a victim trade in a single block:

Front‑run buy – the attacker sees a pending large buy and places his own buy just before it, pushing the curve price up. 2. Victim execution – the victim's buy settles at the higher price, absorbing the artificial slippage. 3. Back‑run sell – the attacker immediately sells his position in the same block, capturing the spread.

The profitability of this pattern depends entirely on the attacker’s ability to buy and sell within the same block. If a contract can enforce that a wallet cannot both buy and sell in the same block, the attack surface disappears.

Why Traditional AMM Contracts Remain Vulnerable

Most AMM contracts treat each transaction as independent. The swap function simply checks the reserves, updates them, and returns the output. There is no per‑address state that persists across the block, so a single wallet can:

Call swap to buy tokens. - Immediately call swap again to sell the same tokens.

Both calls are processed in the same block, so the attacker enjoys the same price impact and can pocket the spread with negligible risk. The only cost is the gas for two transactions, which is often outweighed by the extracted value.

Immute’s Per‑Address Buy‑Lock Mechanism

Immute introduces two simple but powerful state variables:

solidity mapping(address => uint256) public lockedUntil;

lockedUntil[addr] stores the timestamp (or block‑relative value) after which the address is allowed to perform the opposite action. The contract provides a view function:

solidity function isLocked(address addr) external view returns (bool) { return block.timestamp < lockedUntil[addr]; }

When an address executes a buy, the contract sets:

solidity lockedUntil[msg.sender] = block.timestamp + 1; // zero‑duration lock for the remainder of the block

When the same address attempts a sell in the same block, the first line of the sell function checks:

solidity if (isLocked(msg.sender)) revert BuyLockActive();

Because block.timestamp has not advanced, the check evaluates to true, reverting the transaction. Conversely, after a sell, the lock is set on the buy side:

solidity lockedUntil[msg.sender] = block.timestamp + 1;

Thus a user cannot immediately buy after selling, nor sell after buying, within the same block.

Why a 1‑second Lock Works

Ethereum blocks are produced roughly every 12 seconds, but block.timestamp advances only when a new block is mined. By setting lockedUntil to block.timestamp + 1, we guarantee that any subsequent transaction in the same block will see the lock still active, while a transaction in the next block will see block.timestamp equal to or greater than lockedUntil, lifting the restriction. This effectively creates a one‑block cool‑down without altering the global throughput of the contract.

Implementation Details

The IMT V8 contract (0xB575A8760c66F09a26A03bc215D612EA2486373C) implements the lock in the buy and sell entry points. Below is a simplified pseudocode representation of the guard:

```solidity function buy(address recipient, uint256 minOut) external payable { // 1. Validate curve parameters, compute output, apply 10% fee. require(!isLocked(recipient), "Buy locked"); // 2. Execute transfer and update internal accounting. _processBuy(recipient, msg.value); // 3. Set lock to prevent a sell in this block. lockedUntil[recipient] = block.timestamp + 1; }

function sell(address payable seller, uint256 amount, uint256 minOut) external { // 1. Validate allowance, compute output, apply 10% fee. require(!isLocked(seller), "Sell locked"); // 2. Execute transfer and update internal accounting. _processSell(seller, amount); // 3. Set lock to prevent a buy in this block. lockedUntil[seller] = block.timestamp + 1; } ```

The Feeder contract (`0xa87e7c25

Want to dig deeper into how Immute works on-chain?

Read the whitepaper — full technical spec of the bonding curve, fee distribution, and Feeder primitive.
Audit + V4 postmortem — every finding ever raised against the contracts and how it was resolved.
Live leaderboard — top holders, dividend earnings, referral payouts.
On-chain charts — supply curve, ETH balance, Feeder fee flow.
immute.io — connect a wallet and try the mechanics on Sepolia testnet (mainnet launch coming soon).

What is a bonding-curve reward token? Inside Immute's on-chain dividend mechanic

Version 6 LLC — Sun, 26 Apr 2026 04:47:32 +0000

yaml style: blog status: draft generated_at: 2025-01-31

A bonding-curve reward token is a smart-contract mechanism where token price is a deterministic function of supply, and every trade generates automatic dividends distributed to all existing holders. Immute implements this pattern on Sepolia testnet, where a 10% fee on every buy and sell flows pro-rata to every IMT holder. Mainnet launch is coming soon — but developers can test the mechanics today at https://immute.io.

The price formula

Traditional token markets rely on order books or liquidity pools to discover price. A bonding curve replaces that external infrastructure with a mathematical function embedded in the contract itself.

Immute's curve follows:

P = k × S

Where: - P is the current price of one IMT in ETH - S is the total supply of IMT - k is a constant coefficient that defines the curve's slope

When someone buys IMT, the contract mints new tokens. The supply S increases, the price P increases, and the buyer receives tokens at the current on-curve price. When someone sells, tokens are burned, supply decreases, and price decreases accordingly.

This means price discovery is instantaneous and endogenous — no waiting for a market to clear, no slippage from shallow order books, no dependency on external liquidity providers.

Fee distribution: how the 10% compounds

On Immute, every buy incurs a 10% fee and every sell incurs a 10% fee. This fee is not a protocol tax or a team reserve — it is distributed automatically to every current IMT holder in proportion to their balance.

If the total IMT supply is S and your wallet holds b tokens, your share of any fee is:

Your share = b / S

If 1 ETH in fees is distributed and you hold 5% of supply, you receive 0.05 ETH. This happens on every transaction — buys and sells — automatically, via the contract's dividend logic.

The compounding effect is direct: as the token economy grows and trade volume increases, the fees distributed to holders scale proportionally. A holder who maintains their position through periods of activity accumulates rewards continuously, regardless of whether the token's USD price goes up, down, or sideways.

Contrasting with LP-based markets

In a typical AMM LP model, a token trades against another asset in a liquidity pool. Market makers must provide capital to both sides of the pool. Returns come from LP fees — but those fees are captured by liquidity providers, not by all token holders. Furthermore, liquidity providers face impermanent loss when the token's price diverges from the paired asset.

A bonding-curve reward token eliminates the need for external LPs. Price is a function of supply; no one needs to provision the other side of a trade. The capital efficiency is structural — every ETH that enters buys IMT at the on-curve price, and every ETH that exits sells IMT at the on-curve price.

The tradeoff is that bonding curves concentrate price exposure on the curve itself. A large sell moves the price down more significantly than in a deep LP pool. This is a design choice, not a flaw — and it's one that suits token models where the primary value accrual is the dividend mechanic rather than speculative price discovery.

Contrasting with team-allocated tokens

Most token launches distribute supply to teams, advisors, and early investors before or at genesis. This creates structural misalignment: insiders receive tokens at favorable prices while public participants pay market price. The 10% fee in such models flows partly to insiders who paid nothing or little for their positions.

Immute has no team allocation and no VC round. Supply starts at zero and grows organically as participants interact with the curve. There is no pre-mine, no allocation for founders, no hidden vesting schedules. Every IMT in existence was purchased through the contract — no one received tokens at preferential terms.

This means fee distribution flows exclusively to participants who bought at the curve — including early testers who entered when supply was minimal and latecomers who entered when the curve had climbed. All of them receive pro-rata dividends on equal terms.

The Feeder primitive and product-powered rewards

The dividend mechanic becomes more powerful when external products route value through the curve. Immute exposes a Feeder contract (address 0xa87e7c25c2f754C7D6bFc9b4472E0c36096E4bF6 on Sepolia) that any integrating product calls to process payments.

When a product accepts IMT as payment:

99% of the payment goes to the product's own treasury — this is the integrating platform's revenue - 1% of the payment is routed through the bonding curve — this triggers the 10% fee, which distributes to all IMT holders

This makes Immute a product-powered reward token. The dividends aren't funded by speculative trading alone — they're underwritten by real product transactions. Planned integrations include:

Neptime.io — creator monetization where viewers tip IMT on uploaded videos, driving fee distribution through the Feeder - Valiep.com — subscription purchases routed through the Feeder - Discovire.com — discovery-layer purchases, also Feeder-routed - ByteOdyssey — in-game payments on a game development platform, routed through the Feeder

Each integration adds transaction volume that flows through the curve, generating dividend events that reward all IMT holders — regardless of which product originated the trade.

Testing the mechanics on testnet

If you're a developer or an informed participant who wants to see how the fee distribution, price curve, and Feeder interactions work in practice, IMT is live on Sepolia (chainId 11155111).

Testnet ETH is free. You can get some from:

https://sepolia-faucet.pk910.de/ — proof-of-work faucet, no signup required - https://www.alchemy.com/faucets/ethereum-sepolia — requires a free Alchemy account

Connect a wallet (MetaMask, Rainbow, or any EOA-compatible wallet) to Sepolia, navigate to https://immute.io, and interact with the IMT V8 contract (0xB575A8760c66F09a26A03bc215D612EA2486373C) to buy, sell, and watch the dividend mechanics in real time. Both the IMT contract and the FeederV9 contract are verified on Sepolia Etherscan — review the source, trace the events, and test the math yourself.

Mainnet launch is coming soon. The goal of this testnet phase is validation — not speculation. Help us stress the contracts, surface edge cases, and confirm that the bonding-curve reward token mechanic behaves exactly as the design specifies. Every interaction on testnet is a contribution to that validation.

The contract source is open. The math is deterministic. The fee distribution is on-chain and verifiable. If you're building in DeFi or evaluating reward-token models, this is a structure worth understanding from the inside — not just from documentation.

Want to dig deeper into how Immute works on-chain?

Read the whitepaper — full technical spec of the bonding curve, fee distribution, and Feeder primitive.
Audit + V4 postmortem — every finding ever raised against the contracts and how it was resolved.
Live leaderboard — top holders, dividend earnings, referral payouts.
On-chain charts — supply curve, ETH balance, Feeder fee flow.
immute.io — connect a wallet and try the mechanics on Sepolia testnet (mainnet launch coming soon).

Forem: Version 6 LLC

What is a bonding-curve reward token? Inside Immute's on-chain dividend mechanic

The mechanics of a bonding curve reward token

How fee distribution compounds over time

Bonding curves vs. LP-based AMMs

Immute's architecture: IMT token and the Feeder contract

Testing the mechanics on Sepolia testnet

What's coming next

What is a bonding‑curve reward token? Inside Immute's on‑chain dividend mechanic

The price function: linear vs. exponential

The 10 % fee and pro‑rata dividend distribution

Why bonding curves beat LP‑based markets

The Feeder primitive: turning payments into rewards

How to test the mechanics on Sepolia

Roadmap: mainnet and beyond

Conclusion: try it, earn IMT, and shape the curve

Product-Powered Tokens: Why Most Reward Tokens Fail and Immute's Bet Against That

The Speculation Collapse Pattern

Enter the Feeder: Revenue as Infinite Holder Yield

Why This Survives When Speculation Fails

The Testnet Phase: Validating the Mechanics

The Integration Roadmap

The Thesis for 2026

Product-Powered Tokens: Why Most Reward Tokens Fail and Immute's Bet Against That

The Speculation Trap

How the Feeder Changes the Equation

Why This Is Durable

Immute's Current Position

Product-Powered Reward Tokens: Why Most Reward Tokens Fail and Immute's Bet Against That

Why Pure Speculation Reward Tokens Collapse

The Feeder Mechanism: Revenue That Never Stops

Why Immute Is Structured to Test This Thesis

The Product-Powered Reward Token Thesis

BUY_LOCK_BLOCKS: How Immute Blocks Same-Block Sandwich Attacks

Understanding the Sandwich Attack Vector

The Per-Address Buy-Lock Window: A Contract-Level Defense

Mechanics: Same-Block Prevention in Practice

Why Contract-Level Enforcement Matters

Implementation Considerations for Developers

Looking Toward Mainnet

Web3 Creator Monetization Beyond NFTs: The Feeder Primitive

The Bonding Curve Foundation

The Feeder Primitive: A Technical Overview

Why 1% Matters More Than It Sounds

Integration Landscape

The Testnet Phase

Comparing Models: Feeder vs. Traditional Creator Monetization

Looking Forward

BUY_LOCK_BLOCKS: How Immute Blocks Same-Block Sandwich Attacks

What Makes Sandwich Attacks Possible on Bonding Curves

The Per-Address Buy-Lock Window

The Implementation: isLocked() and lockedUntil()

Why This Works Against Same-Block Attacks

Integration Considerations for Builders

Mainnet Planning

BUY_LOCK_BLOCKS: How Immute Achieves Smart Contract Sandwich Attack Prevention

What Is a Sandwich Attack?

Why Traditional AMM Contracts Remain Vulnerable

Immute’s Per‑Address Buy‑Lock Mechanism

Why a 1‑second Lock Works

Implementation Details

What is a bonding-curve reward token? Inside Immute's on-chain dividend mechanic

The price formula

Fee distribution: how the 10% compounds

Contrasting with LP-based markets

Contrasting with team-allocated tokens

The Feeder primitive and product-powered rewards

Testing the mechanics on testnet

The 10 % fee and pro‑rata dividend distribution