previous
next
Our protocol needed a way for the community to back new projects – not just throw tokens at them and hope, but actually govern them. Stake in a project, vote on whether it’s hitting milestones, earn rewards when it delivers, trade your position if you want out early. A full incubation platform with real accountability built into the contracts.
Nothing like this existed off the shelf. So our team built a DeFi Launchpad (originally named CreatureCLoud) – from the smart contract architecture all the way through to the frontend experience.
Most DeFi platforms are variations on the same pattern: deposit tokens, earn yield, withdraw. Our requirements were different. We needed projects to define milestones, stakers to vote on whether those milestones were met, an emission schedule that rewards early believers more than latecomers, and a marketplace where people could trade their staking positions without unstaking.
That’s five interconnected contract systems that all need to talk to each other, deploy together, and not blow past Ethereum’s 24KB contract size limit. There’s no template for that.
The first real challenge was deployment. A single contract handling staking, governance, emissions, tokens, and a marketplace would be far too large for Ethereum. Splitting it into five contracts solves the size problem but creates a new one – deploying five contracts every time someone launches a project gets expensive fast.
We solved this with EIP-1167 minimal proxies. The idea is simple: deploy each contract once as a “master” implementation, then for every new project, deploy tiny proxy clones (~45 bytes each) that forward all their logic to the master. One transaction creates all five contracts for a new project at roughly 95% less gas than deploying them from scratch.
This was the decision that unlocked the whole platform. It meant project creation was cheap enough to be practical, the core logic only needed to be audited once (every clone runs the same code), and we could keep adding complexity to each contract without worrying about size limits.
The factory deploys five clones per project: a token contract, a staking escrow, an emission vault, a governance system, and a marketplace. An orchestrator contract ties them together and enforces limits – no founder can create more than 10 projects, with a 7-day cooldown between launches to prevent spam.
A flat emission schedule – same rewards every day for 180 days – doesn’t reflect reality. Early stakers take on more risk. They’re backing a project before it’s proven anything. That should be worth more.
We designed an exponential decay model. The vault emits 64 million tokens on day one, decaying steadily so that by day 180 it’s down to around 500K. The math works out to roughly a 4x advantage for staking on day one versus day 90. This creates a natural incentive to get in early and stay committed, which is exactly the behaviour we wanted from incubation participants.
The tricky part was making reward distribution efficient. Looping over every staker to calculate their share would get more expensive as the platform grew — eventually it’d hit gas limits. Instead, we built an accumulator system where each user’s rewards are calculated in constant time from a global state. It doesn’t matter if there are 10 stakers or 10,000 – the cost is the same.
Letting stakers vote on milestones sounds straightforward until you think about flash loans. Someone could borrow a huge amount of tokens, stake them, vote to approve a milestone (triggering bonus payouts), unstake, and return the loan – all in a single block. They’d manipulate governance without ever risking their own capital.
Our protection is a time-lock on voting power. When you stake, your votes don’t activate immediately. Standard positions wait one day. Large positions – anything over a million tokens — wait three days. This makes flash loan attacks economically pointless because you’d need to hold the borrowed position for days, paying interest the entire time.
We also tackled the quorum problem. A fixed voting threshold always breaks eventually – set it too high and proposals never pass, too low and a handful of wallets control everything. Our quorum adjusts dynamically between 10-30% based on how actively the community has been voting over the past 30 days. There’s an absolute floor to prevent edge cases where near-zero participation could let a single vote pass a proposal.
In most staking systems, your capital is locked. If you change your mind or need liquidity, tough luck. We built a secondary marketplace where stakers can sell their positions – including all accumulated voting power and pending rewards – to other users.
It works as a hybrid auction and instant buyout. Sellers set a minimum bid and a buyout price. Auctions run up to seven days, and if a bid comes in during the last five minutes, the clock extends to prevent sniping. When a position sells, everything transfers to the buyer – the staked principal, the voting power, the reward history. They step into the original staker’s shoes.
This was a product decision as much as a technical one. Locked capital scares people away from long-term staking. Giving them an exit – even if they take a haircut on the price – means more people are willing to commit in the first place.
Most DeFi interfaces are functional but lifeless. Connect wallet, see numbers, click buttons. We wanted the experience to feel like you’re interacting with a living system.
When you stake or claim rewards, the confirmation modal plays a custom animation – a hyperspace effect where particles rush toward you through 3D space with glowing trails. It’s built on Canvas, running at 60fps. A small thing, but it turns a moment that’s usually “waiting for transaction…” into something that actually feels good. Every interaction – staking, claiming, navigating between projects – has considered motion and transitions rather than just popping elements on screen.
The dashboard itself is designed around information hierarchy. Global stats at the top, recent projects in a carousel, activity feed below. Individual project pages show staking data, governance status, and community discussion in a layout that works on both desktop and mobile. I designed every screen, built the responsive layouts, and made sure the experience holds up whether you’re on a 27-inch monitor or a phone.
The platform also has role-based access throughout. Guardians can emergency-pause contracts. Moderators manage community discussions. Project owners have admin capabilities. Regular users stake, vote, and chat. All of this is enforced both on-chain (contract-level roles) and in the frontend (protected routes with session-based auth).
The frontend needs to show real-time staking metrics – total value locked, active stakers, reward rates – but querying the blockchain on every page load would be slow and expensive. A backend service polls the deployed contracts every 15 minutes, aggregates the data, and caches it in Supabase. The dashboard reads from the cache, so it loads instantly.
If the RPC provider goes down, the system doesn’t break. There’s exponential backoff retry logic and provider failover, and the frontend gracefully falls back to the last cached data. Users might see metrics that are 15 minutes stale, but they’ll never see a broken page.
When you’re building a platform that holds other people’s money, security isn’t a feature – it’s the foundation. Every state-changing function in the contract system is protected against reentrancy. All token transfers use safe wrappers that handle the weird edge cases of non-standard ERC-20 implementations. State always updates before external calls go out. Withdrawals are pull-based so funds never get stuck if a transfer fails.
At the platform level, critical parameter changes go through a timelock – there’s a mandatory delay before they take effect, giving the community time to react. Multi-signature governance controls admin functions so no single wallet can make unilateral changes.
On the frontend, every user input is sanitized, API endpoints are rate-limited, and all data is validated on both client and server. The auth system uses encrypted HTTP-only session cookies – no tokens sitting in localStorage waiting to be stolen.
This project is the full pipeline. Smart contract architecture and development. Backend data infrastructure. Frontend design and development. Custom animations and interactive elements. Database schema. Authentication and authorization. Security architecture. Deployment across multiple environments.
Every layer connects to every other layer, and every decision – from the clone pattern that made deployment affordable, to the emission curve that incentivises early commitment, to the marketplace that gives stakers liquidity, to the animations that make transactions feel alive — was made to solve a real problem for real users.
Live: defi-launchpad-jade.vercel.app Code: github.com/AaronJCunningham/defi-launchpad