Case study
The Smurfs Society™
A Web3 gaming platform and NFT experience for a global IP, 80,000+ wallets connected.
- next.js
- tailwindcss
- solidity
- hardhat
- graphQL
Services - Smart contract development, tested like money depends on it
A smart contract is a program deployed on a blockchain that holds and moves value by its own rules, and cannot be patched once users rely on it. We write, test, and deploy Solidity contracts for tokens, NFT collections, and custom protocols on any EVM chain, and Solana programs when the product lives there.
Our contracts already run in production: the ERC721 and ERC1155 contracts behind The Smurfs Society, which connected more than 80,000 wallets and processed over 3 million Polygon transactions, and the SpyCoin ERC20 token live on Hedera Mainnet for SpyClub, a Telegram game with more than 100,000 players.
What we build - Contracts for every stage of a product
Most products need a small number of contracts, done very well. These are the ones we are asked for most often.
- Tokens (ERC20). Fixed or mintable supply, roles, pausing, and permits (EIP-2612), plus the contracts that come with a launch: vesting with cliffs and linear unlocks, airdrops, and claim pages.
- NFT collections (ERC721, ERC1155). Mint and reveal flows, allowlists, royalties (ERC-2981), and metadata on IPFS or your own server, deployed on one chain or several, as we shipped for The Smurfs Society on Ethereum and Polygon.
- Custom protocol logic. Vaults, staking, rewards, escrow, auctions, and governance with votes, timelocks, and delegation. The rules of your product, written as code your users can read on a block explorer.
- Upgradeable contracts. Proxy patterns (UUPS or transparent) when the product needs to evolve, with storage-layout checks and an upgrade runbook. Immutable contracts when trust matters more than flexibility.
- Protocol integrations. Contracts that work with the protocols your product depends on: Uniswap v3 and v4 positions and hooks, Circle USDC and CCTP, and x402 payments for APIs and AI agents.
- Solana programs. When the product lives on Solana, we build with Rust and Anchor, from Orca Whirlpool integrations to NFT mints such as The Haughty Mummies.
Proof - Contracts that already carry real users
We would rather show deployed contracts than describe a process. These products run on contracts we wrote and tested.
- wallets connected to The Smurfs Society
- 80,000+
- Polygon transactions processed
- 3M+
- SpyClub players, rewarded in an ERC20 on Hedera
- 100,000+
Case study
SpyClub
A real-time multiplayer Telegram game that onboarded 100,000+ players with on-chain rewards.
- node.js
- supabase
- react.js
- websockets
- solidity
Case study
Kleek
A blockchain event platform that cuts no-shows, 2nd place at the WalletConnect Hackathon.
- next.js
- foundry
- solidity
- wagmi
- supabase
Case study
Paralleelium
An NFT collection of unique art pieces with a Tallinn design studio.
- solidity
- hardhat
- react.js
How we work - From specification to mainnet
Contract bugs are expensive because they are permanent. Our process is built to catch them before deployment, not after.
- Specification first. Before any code, we write down every role, state, and invariant: who can mint, what must never happen, what a failed call leaves behind. The specification becomes the test plan.
- Tested in Foundry. Unit tests for every function, fuzz tests for the maths, and fork tests against live mainnet state for every external protocol the contracts call.
- Readable code. OpenZeppelin building blocks where they fit, NatSpec comments on every public function, and no clever tricks a reviewer has to reverse-engineer.
- Audit-ready handoff. A test suite, a coverage report, and a written threat model. When the contracts will hold significant value, an external auditor then spends their time on your logic, not on our setup.
- Deployments you control. Scripted, reproducible deployments, source code verified on the block explorer, and admin rights handed to your multisig instead of a single key.
- The rest of the stack. The dApp, indexer, and backend around the contracts, so one team owns the whole path from the wallet to the chain.
Pricing - What smart contract development costs
We publish our ranges. At a blended rate of $500 to $700 per engineer-day, project management, QA, and deployment included:
- A standard ERC20 token: $3,000 to $4,500.
- A token with vesting and distribution contracts: $6,500 to $14,000.
- An NFT collection with mint and reveal pages: $6,500 to $12,000.
- Custom protocol contracts are scoped per project. The calculator itemizes them in about a minute.
- External security audits are not included in these ranges. We prepare the code for one.
From the blog - How we write and integrate contracts
Tutorials from our own contract work, with the code.