How to Build a DeFi Staking Platform: Reward Design, Contracts, and Security
Build a DeFi staking platform step by step: reward math, a staking contract pattern, attack surface, audit scope, cost, and launch.
Nov 20, 2026
14 mins read
- Build a staking platform in 6 steps: reward design, staking mechanics, contracts, attack-surface review, test and audit, launch and operations.
- Design the reward system before you write any code.
- Use an accumulator for reward math. Looping over stakers breaks at scale.
- Audit before mainnet and cap TVL for the first weeks.
A DeFi staking platform lets users lock tokens in a smart contract and earn rewards for it. The contract holds the funds and pays out rewards on a schedule you define.
The build is small compared to a lending protocol or an exchange. The hard part is the economics. If the reward math is wrong, the pool drains early, or the APR collapses. If the contract is wrong, the funds go.
We run these 6 steps in this order on client projects. If you want a team to build it, see our DeFi staking platform development service.
Pick a Staking Model
Choose the model before the math, because each one changes the contract.
|
Model |
How it works |
Reward source |
Main risk |
Best fit |
|---|---|---|---|---|
|
Fixed-term |
Lock for 30, 90, or 180 days at a set rate |
Emissions or treasury |
Pool runs dry if TVL outgrows the budget |
Token projects that want to cut sell pressure |
|
Flexible |
Stake and unstake any time |
Emissions |
Short-term capital leaves after each reward cut |
Early TVL growth |
|
LP staking |
Stake DEX liquidity tokens |
Emissions, trading fees |
Impermanent loss for users |
Projects that need market depth |
|
Liquid staking |
User gets a receipt token that trades while staked |
Protocol yield, emissions |
Receipt token depegs, contract complexity |
Larger platforms with a DeFi ecosystem |
|
NFT staking |
Stake NFTs to earn tokens |
Emissions |
Rarity and reward weighting bugs |
Gaming and collectible projects |
Pick by goal. Retention points to fixed-term. TVL growth points to flexible. Market depth points to LP staking. For a yield-focused product, read about DeFi yield farming development.
Step 1: Design the Reward System
Start here. Everything else follows from 3 decisions.
Reward sources:
- Emissions: you mint or allocate new tokens. Simple and dilutive.
- Fees: the platform shares revenue with stakers. Sustainable and capped by real usage.
- Treasury: you fund a fixed pool. Predictable and finite.
Most projects start with a treasury pool and add fees later.
Fixed emission vs fixed APR. This choice decides whether the pool survives.
|
Scenario |
Staked |
Annual rewards |
APR |
Pool lasts |
|---|---|---|---|---|
|
Fixed emission, base |
10M |
1.2M |
12% |
12 months |
|
Fixed emission, TVL doubles |
20M |
1.2M |
6% |
12 months |
|
Fixed emission, TVL halves |
5M |
1.2M |
24% |
12 months |
|
Fixed 12% APR promised, TVL doubles |
20M |
2.4M |
12% |
6 months |

A fixed emission protects the pool and lets APR float. A fixed APR protects the marketing number and drains the pool when TVL grows. Success breaks the second model. Pick fixed emission unless you fund the pool for peak TVL.
APR is simple interest. APY includes compounding. Show APR unless users compound automatically in the contract. Quoting APY for a pool that doesn't auto-compound overstates what users earn.
Lock tiers and multipliers. Longer locks earn higher weight, for example, 1x at 30 days and 2x at 180 days. Each multiplier adds a code path to test. Keep the table to 3 or 4 tiers.
Plan the end state. Decide now what happens when the pool is empty. Options: top up from fees, stop rewards and keep principal withdrawable, or migrate stakers to a new pool. Write it in the docs before launch.

Stress-Test Your Reward Model
Send us your emission plan and lock tiers. Our engineers review the reward design before you write any code.
Review My Reward ModelStep 2: Define the Staking Mechanics
Write the rules as a state machine before the contract exists. List every user action and what it does:
- Stake: deposit tokens, start earning from the next block.
- Unstake: withdraw principal. Instant, or after a cooldown.
- Claim: withdraw earned rewards without touching principal.
- Compound: claim and restake in one transaction.
- Early exit: withdraw before a lock ends. Allow with a penalty or block entirely.
Settle these on paper:
- Decide whether rewards keep accruing during a cooldown. (Usually no.)
- Decide where an early-exit penalty goes: burn it, redistribute it, or send it to the treasury.
- Decide whether users get partial withdrawal from a locked position.
- Decide what happens to accrued rewards if the admin pauses the pool.
Each unanswered question becomes a bug or a support ticket.
Step 3: Write the Staking Contracts
A basic platform needs 4 contracts:
- Staking pool: holds principal, tracks shares.
- Reward distributor: holds the reward tokens and sets the emission rate.
- Token contracts: the stake token and reward token, or a receipt token for liquid staking.
- Timelock and admin: a multisig with a delay on parameter changes.

Build on OpenZeppelin for tokens, access control, and reentrancy protection. For tooling and framework choices, see our DeFi tech stack guide and the DeFi smart contract development guide.
Use an Accumulator for Reward Math
The naive design loops over every staker each block to update their balance. Gas cost grows with the number of stakers, and the contract becomes unusable.
The accumulator pattern fixes this. The contract stores one number: total reward per staked token, growing over time. Each user stores the value of that number when they last interacted. Their pending reward is their stake times the difference. No loops.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
// Illustrative. Omits admin funding, pause, and events. Needs tests and an audit before use.
contract StakingPool is ReentrancyGuard {
using SafeERC20 for IERC20;
IERC20 public immutable stakeToken;
IERC20 public immutable rewardToken;
uint256 public rewardRate; // reward tokens per second
uint256 public periodFinish; // timestamp when funded rewards end
uint256 public lastUpdate;
uint256 public rewardPerTokenStored; // scaled by 1e18
uint256 public totalStaked;
mapping(address => uint256) public staked;
mapping(address => uint256) public paidPerToken;
mapping(address => uint256) public pending;
constructor(IERC20 _stakeToken, IERC20 _rewardToken) {
stakeToken = _stakeToken;
rewardToken = _rewardToken;
}
function _applicable() internal view returns (uint256) {
return block.timestamp < periodFinish ? block.timestamp : periodFinish;
}
function rewardPerToken() public view returns (uint256) {
if (totalStaked == 0) return rewardPerTokenStored;
return rewardPerTokenStored +
((_applicable() - lastUpdate) * rewardRate * 1e18) / totalStaked;
}
function earned(address user) public view returns (uint256) {
return (staked[user] * (rewardPerToken() - paidPerToken[user])) / 1e18
+ pending[user];
}
modifier updateReward(address user) {
rewardPerTokenStored = rewardPerToken();
lastUpdate = _applicable();
pending[user] = earned(user);
paidPerToken[user] = rewardPerTokenStored;
_;
}
function stake(uint256 amount) external nonReentrant updateReward(msg.sender) {
require(amount > 0, "zero amount");
totalStaked += amount;
staked[msg.sender] += amount;
stakeToken.safeTransferFrom(msg.sender, address(this), amount);
}
function withdraw(uint256 amount) external nonReentrant updateReward(msg.sender) {
require(amount > 0 && amount <= staked[msg.sender], "bad amount");
totalStaked -= amount;
staked[msg.sender] -= amount;
stakeToken.safeTransfer(msg.sender, amount);
}
function claim() external nonReentrant updateReward(msg.sender) {
uint256 reward = pending[msg.sender];
pending[msg.sender] = 0;
rewardToken.safeTransfer(msg.sender, reward);
}
}
Know these 3 behaviors:
- When
totalStakedis 0, emitted rewards go nowhere. Seed the pool with a small team stake at launch. - The contract tracks
rewardPerTokenStored. ReadingbalanceOffor reward math invites donation attacks (see Step 4). - Rewards stop at
periodFinish. A separate admin function must fund the pool and set the rate. Use a timelock and a multisig on it.
Upgradeable vs immutable. Immutable contracts earn more user trust and remove an admin attack. Upgradeable proxies let you fix bugs and add lock tiers. If you use a proxy, put the upgrade key behind a multisig and a timelock of 48 hours or more, and publish both.
Step 4: Review the Staking-Specific Attack Surface
Staking pools fail in specific ways. Review each before you pay an auditor.
|
Attack |
How it works |
Fix |
|---|---|---|
|
Reentrancy on claim or withdraw |
Malicious token or hook re-enters before state updates |
|
|
Reward inflation via donation |
Reward math reads |
Track rewards in storage, never read raw balance |
|
Flash-stake capture |
Attacker stakes a huge amount for one block, claims a share, exits |
Minimum lock or warm-up period, time-weighted accrual |
|
Rounding drift |
Integer division leaves dust, rewards owed exceed rewards held |
Scale by 1e18, test with extreme ratios, add a sweep for dust |
|
Fee-on-transfer tokens |
Contract credits |
Credit the balance difference, or reject such tokens |
|
Admin key abuse |
One key changes rates or drains rewards |
Multisig, timelock, hard caps on rate changes |
|
Upgrade risk |
A malicious or buggy upgrade replaces logic |
Timelock, public upgrade queue, upgrade tests on a fork |

Add oracle checks only if your reward or collateral logic reads a price. A plain staking pool shouldn't.
Step 5: Test and Audit
Tests to write:
- Unit tests: every function, every revert path.
- Fuzz tests: random stake, withdraw, and claim sequences from many accounts.
- Invariant tests: total rewards paid out never exceeds total rewards funded. Sum of user stakes always equals totalStaked. These catch the bugs that unit tests miss. Foundry runs them well.
- Fork tests: run the pool against real mainnet tokens, including odd ones.
- Testnet dry run: 1 to 2 weeks with real wallets and a front end.
Run a bug bounty after the audit and before you lift TVL caps.

Get Your Staking Contracts Reviewed
Our engineers check reward math, access control, and the attack surface above before your audit starts.
Contact UsStep 6: Launch and Operate
Treat launch as a staged release.
- Cap TVL. Start at a low ceiling, such as a few hundred thousand dollars, and raise it in steps as the contract proves itself.
- Fund the rewards on a schedule. Keep a calendar of top-ups. A pool that runs dry without notice costs trust.
- Monitor. Alert on large stakes, large withdrawals, reward balance below 30 days of runway, and any admin transaction.
- Write an incident plan. Who holds pause rights, who decides, who talks to users, and where updates go.
- Publish your parameters. Emission rate, lock tiers, penalties, admin addresses, and audit reports.
Front End, Indexing, and Chain Choice
Staking adds 3 front-end points:
- Show pending rewards live. Call
earned()and refresh it each block or every few seconds. - Index stake positions with a subgraph or custom indexer so the UI doesn't scan the chain on every load.
- Pick the chain by the gas cost of claim and compound. A $20 claim fee on a $15 reward kills the product. Layer 2 networks and low-fee chains fit small stakers.
For wallet libraries, RPC providers, and the rest of the stack, for the user wallet side, see DeFi wallet development. If your platform needs its own stake token, see DeFi token development.
What It Costs to Build a DeFi Staking Platform
A Troniex DeFi staking platform build starts from $15,000. Full platforms range from $30,000 to $85,000+, depending on scope. Troniex scopes each build individually and returns a fixed-scope quote within 24 hours.
What moves the number:
|
Factor |
Starts from $15,000 |
Reaches $85,000+ |
|---|---|---|
|
Staking model |
One flexible or fixed-term pool |
Liquid staking with a receipt token, multiple pools |
|
Chains |
One chain |
Multi-chain deployment |
|
Contract scope |
Standard lock logic, immutable contracts |
Custom lock tiers, upgradeable proxies, governance modules |
|
Front end and admin |
Standard staking interface |
Custom dashboard with analytics |
On time, our full custom DeFi builds take 4 to 8 months, and audited-fork builds take 2 to 4 months. A single staking pool is a smaller scope than a full protocol. For general contract pricing factors.

Get a Fixed-Scope Quote in 24 Hours
Share your staking model and target chains. Builds start from $15,000.
Get My QuoteCompliance Basics
Rules differ by jurisdiction and change often. Two reference points:
- United States: In 2023, the SEC settled with Kraken over its staking-as-a-service program, alleging it was an unregistered securities offering. In May 2025, SEC staff said certain protocol staking activities are not securities transactions. That statement doesn't cover liquid staking or restaking, and it carries no legal force. A platform that pays rewards from a treasury or emissions needs its own analysis.
- United Kingdom: The FCA's financial promotion rules for cryptoassets (PS23/6) took effect on 8 October 2023. They require risk warnings and ban incentives to invest, including refer-a-friend and new-joiner bonuses. They apply to overseas firms that market to UK users.
If you accept fiat, add KYC and AML for the on-ramp. This article isn't legal advice. Hire counsel before launch.
Conclusion: Start Small, Audit, Then Raise the Cap
Before you contact a development team, write down 4 things: the reward source, the emission schedule, the lock rules, and what happens when the pool is empty. A team that receives those 4 answers quotes faster and builds the right contract the first time.
Start with one pool on one chain. Add lock tiers, a second chain, or liquid staking after the first pool proves itself under a TVL cap. Every addition adds code, test scope, and audit scope, so add them one at a time.
Decide who owns what. If your team has shipped audited Solidity before, build in-house and buy the audit. If it hasn't, hire the contract work and keep the reward design in your own hands, because only you know your token's supply plan and goals.
Troniex builds staking platforms from the first reward model to an audited mainnet launch. Share your pool design, and we return a fixed-scope quote within 24 hours.