DAILY NEWS

Stay Ahead, Stay Informed – Every Day

Advertisement
TECH & AI
What is a bonding‑curve reward token? Inside Immute’s on‑chain dividend mechanic
jackminion 0



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

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



Source link

TECH & AI
29 Zapier + Make automations replaced in four weeks
jackminion 0


The bill that I no longer understood One morning in March, I reread the list of recurring direct debits from L’Atelier Palissy, and I came across a line that surprised me by its regularity: Zapier Pro, $73.50, every month for eighteen months. Next to it, a smaller but equally discreet Make Pro. I count: twenty-one active Zaps, nine Make scenarios, a few stopped, a few obviously broken for weeks. Nobody noticed, because each automation lived on its own dashboard, with its own history, its own logs that no one ever looked at. I didn’t know exactly what each one did. I knew there were about thirty of them, that they passed data from Formidable to Mailchimp, from Meta Lead Ads to a shared Google Sheet, from Stripe to a confirmation email, that they triggered on webhook, on polling, on schedule, and that half of the silent system failures probably came from there. I didn’t have the energy to go look, because going to look meant opening a tool in which I wasn’t at home. Twenty-eight days later, it was gone. Zero Zap, zero Make scenario, everything replaced by three hundred lines of TypeScript running in my Rembrandt ERP, under Sentry, under tests, with a single overview that I look at in the morning at coffee. If you have 30 seconds. Zapier/Make automations pay three invisible debts: they live outside your database, they log elsewhere than your monitoring, and they are triggered by rules that we end up no longer reading. Replacing thirty automations with a single event pipeline takes four weeks, not six months, provided you follow a golden rule: never cut a Zap before having validated its replacement in double writing for three to five days. The article gives the method, timetable and cost avoided. Three invisible debts The first debt that no-code tools produce is called, in internal literature which does not yet exist, distributed debt. Your data lives in three places at once, and none of the three are canonical. My CRM thought the truth was in Google Sheets. Mailchimp believed the truth came from Zapier. Supabase didn’t think anything because I only wrote part of what was happening there. The day a lead lands in three different tabs with three different spellings, no one knows which record is the real one. The only way to decide is to choose a place that wins by construction, and do everything else as a slave. The second debt is the absence of unified monitoring. A broken Zap sends an email to the address that created the Zapier account, possibly to no one. A Make scenario that fails in its third step leaves the first two consuming quotas, and the only trace is a small red number in a dashboard that no one opens. Sentry, Datadog, Grafana — none aggregate. You learn that your automation is dead when a customer calls to say that they have not received their confirmation email. The third debt is the most silent, and it is that of the rules that we forget to have written. A Zap created eleven months ago to manage a particular case of the summer season continues to run the following winter, and it routes a Paris lead to the email address of a colleague who has left the house. You don’t see it, because the lead is still coming, apparently. Nobody rereads a Zap. It’s done so that we don’t have to read it. This is precisely what makes it a debt. The golden rule that took me two weeks to accept. My first attempt, at the beginning of April, was naive. I’d write a Rembrandt replacement, cut the Zap, move on to the next one. My third attempt ended in Slack at 11 p.m., a Meta lead lost because my webhook was not deployed on the correct Vercel environment, and the certainty that if I continued like this, I was going to break at least one critical element before the end of the week. I set the following rule, which I kept until the last Zap. Never cut a Zap before having validated its replacement in double writing for three to five days. Concretely: I write the replacement, I deploy it, it runs at the same time as the Zap. Each lead arrives in duplicate in my Supabase, and in the email address of the team that receives the notification. For three to five days, I compare: same lead, same data, same timings, same emails sent? If so, I cut the Zap. If not, I disable my code and I still have a spinning net while I figure out what broke. The worst possible side effect during the transition is a lead received twice by the sales team. It’s an annoyance, not a disaster. A lost lead is a silent catastrophe that we discover a month later. The architecture that replaced the thirty automations The target is of a simplicity that was not visible as long as I stayed in the no-code tools. Meta Ads ──┐ Formidable ──┤ Stripe ──┤──► Webhooks Rembrandt ──► Supabase (single source) Manual ──┘ │ ├── Gmail SMTP (internal notifications) ├── Slack (team alerts) ├── Meta CAPI (campaign feedback) ├── automation_logs (traceability) └── Cron → Mailchimp then Brevo Enter fullscreen mode Exit fullscreen mode A single entry point per source, a single storage location, a parallel fan-out to the notification tools. The core is contained in a file called lib/lead-pipeline.ts which executes the outgoing integrations in parallel after each insert in the contacts table. export async function runLeadPipeline(lead: Lead) { await Promise.allSettled(( syncMailchimp(lead), notifySlack(lead), notifyGmail(lead), sendMetaCapi(lead), generateFirstContactDraft(lead), )) await logAutomation(lead, /* status by tool */) } Enter fullscreen mode Exit fullscreen mode Promise.allSettled rather than Promise.all because if Slack is down, I still want to send the email. Each result feeds an automation_logs table which is the only thing I look at in the morning: how many leads arrived, which tools succeeded, which failed, over what time window. The schedule as it really happened Week What I did Zaps cut S1 Central pipeline + Slack client + automation_logs table 0 S2 Great direct in double write 0 S3 Cut of ten Zaps Great + webhook Meta in duplicate 10 S4 Cut of eight Zaps Meta + webhook Stripe 18 S5 Scenarios Make (PDFs, crons) and cleanup 21 S6 Kill Zapier Pro, planned downgrade 21/21 The day of the final cut, I didn’t sleep the night before, and the next day I opened my automation_logs dashboard every hour. Thirteen days later, nothing had broken. Today I still maintain a dead route, sync-gsheets-leads, which I never call but which serves as a reactivable net until the end of the month. What we gain that we never suspected The economic gain is obvious – around a hundred euros per month in consolidated subscriptions. But what surprised me was a gain in understanding. The first week after the cut, I found that I understood my system for the first time in eighteen months. I could open a file, reread a routing rule, modify it, test it, deploy it in twenty minutes. Before, even a trivial modification – changing the recipient address of a notification email – went through five Zapier tabs and a dull fear of breaking one by moving another. Two short scenes come to mind. The first, I had to call Gaspard, our IT service provider, to retrieve the password for the Zapier account. He had it, he gave it to me, he didn’t ask why I wanted to go. The second, earlier in the morning, Françoise came out of her office with her cup in her hand and stood in front of mine: “Good. How long do you plan to keep your Meta duplicates? Because Hélène receives two emails for the same lead, she is starting to get annoyed. » It was the third week, I told her “Two more days”, she agreed, put down her cup, and the cup was made the next evening. I learned that double writing has a cost in team patience that should neither be minimized nor stretched beyond what is necessary. There is a particular hygiene to having a system held in one place. We underestimate it until it is there, because no-code tools sell precisely the promise that it is everywhere, that it no longer has to be thought about. The truth is that if it’s not thought of in one place, it’s just buried. It costs less to write, and much more expensive to live. What you can copy into your project Reusable patterns extracted from this migration, independent of my stack: The golden rule — double writing three to five days before cutting. Not negotiable. A duplicate lead is better than a lost lead. The additional time is paid once and is reimbursed for each incident avoided A unique event pipeline — a runPipeline(event) function called after each insert, which executes the outgoing integrations in parallel (Promise.allSettled) and traces the result of each in a dedicated table An automation_logs table — one row per event, one column per outgoing tool with its status. It’s the only dashboard we look at in the morning, and it replaces all the separate dashboards for no-code tools. A reactivable post-cut net — keeps the road dead for two more weeks. The day a bug surprises you, it takes fifteen seconds of vercel.json to put the net back together. Afterwards, you delete for good And a broader discipline: any tool that houses your business logic outside your database makes you pay three debts — distributed, without monitoring, unreadable. Zapier and Make are useful for prototyping. They become dangerous as soon as serious activity depends on them. How many no-code automations are running on your system right now, and when was the last time someone reread them all? I read the comments. Companion code: rembrandt-samples/lead-pipeline/ — runLeadPipeline with Promise.allSettled, automation_logs schema, hub-and-spoke diagram, MIT, ready to copy.



Source link

TECH & AI
Join the Gemma 4 Challenge: $3,000 prize pool for TEN winners!
jackminion 0



Local AI is having a moment, and we want you to be part of it!

Running through May 24, the Gemma 4 Challenge invites you to explore open models. With the release of Gemma 4, Google’s most capable open model family yet, we now have access to native multimodal capabilities, advanced reasoning, a 128K context window, and models that range from running on a Raspberry Pi, to phones, to powering large-scale deployments.

Whether you love to build or love to write, there’s a prompt for you and a $3,000 prize pool up for grabs!

Read on to learn more.

Our Prompts

Build With Gemma 4

Your mandate is to build something useful or creative with any Gemma 4 model. The scope is wide open — you can build anything from an IoT integration to a multimodal tool to a long-context reasoning app. What matters is that Gemma 4 is doing real work at the heart of your project. 

Build With Gemma 4 Submission Template

 

The most compelling submissions will make a clear case for why you chose the model you did and what that model unlocked.

Write About Gemma 4

Your mandate is to publish a post about Gemma 4 that educates, inspires, or sparks curiosity. There’s no single right format — what matters is that your post offers something genuine and useful to the community.

Not sure what to write about? Here are some ideas:

How-to guide: Walk through setting up and running a Gemma 4 model locally, fine-tuning it for a specific task, or integrating it into a real project

Comparison piece: Break down the three Gemma 4 model variants and help readers decide which one is right for their use case

Personal essay or opinion piece: Share your experience building with Gemma 4, or make a case for something — what does a model this capable running locally mean for the future of AI?

Deep technical breakdown: Explore a specific capability like multimodal input, the 128K context window, or reasoning mode

 

Write About Gemma 4 Submission Template

 

Need inspiration? Check out how Google’s own team fine-tuned Gemma 4 with Cloud Run Jobs. That’s the kind of hands-on, shareable knowledge is exactly what we’re looking for.

Note: If you are primarily showing off a project, please submit to the Build with Gemma 4 prompt instead! Each submission is only allowed to be eligible for one of the two categories.

Which Model Is Right for You? 🤔

Gemma 4 model family spans three distinct architectures tailored for specific hardware requirements:

Small Sizes: 2B and 4B effective parameter models built for ultra-mobile, edge, and browser deployment (e.g., Pixel).

Dense: A powerful 31B parameter dense model that bridges the gap between server-grade performance and local execution.

Mixture-of-Experts: A highly efficient 26B MoE model designed for high-throughput, advanced reasoning.

No matter which you choose, judges will be looking for intentional model selection — show us why your model was the right tool for the job.

Prizes 🏆

Five winners from the “Build with Gemma 4” prompt will receive:

$500 USD cash prize

DEV++ Membership
Exclusive DEV Badge

Five winners from the “Write About Gemma 4” prompt will receive:

$100 USD cash prize

DEV++ Membership
Exclusive DEV Badge

All participants with a valid submission will receive a completion badge on their DEV profile.

Judging Criteria

Build With Gemma 4 submissions will be evaluated for:

Intentional and effective use of the chosen Gemma 4 model
Technical implementation and code quality
Creativity and originality
Usability and user experience

Write About Gemma 4 submissions will be evaluated for:

Clarity and depth of explanation
Originality of perspective or insight
Practical value to the community
Quality of writing

Getting Started With Gemma 4 🚀

Gemma 4 is open — you have several ways to get started, including completely free options:

Gemini API via Google AI Studio: Access Gemma 4 through the Gemini API.

Run locally (free, no credit card required): Download any Gemma 4 model directly from Hugging Face or Kaggle. The E2B model runs on high-end phones — or even a Raspberry Pi 5.

OpenRouter (free tier available): Access Gemma 4 31B via OpenRouter’s free tier — no credit card required.

Important Dates

May 6: Gemma 4 Challenge begins!

May 24: Submissions due at 11:59 PM PDT

June 4: Winners Announced

We can’t wait to see what you build and write! Questions about the challenge? Drop them in the comments below.

Good luck and happy coding!



Source link