World's first premiumless and claimless insurance with tokenized & tradeable on-chain risk
Problem: $2 Billion lost in 2025 so far due to on-chain risks. No available solution to recover lost funds.
For this hackathon, I focused on insurance of yield protocols. Users deposit yield-bearing assets (like aUSDC or cUSDT) and receive dual-tier risk tokens that can be traded on Uniswap. The more risk tokens sold in the market, the more insurance coverage is provided to the community.
Here is a more concrete use-case:
I built CoverVault as a full-stack DeFi protocol that transforms insurance into a liquid, tradeable market. It combines innovative smart contract design, a modern web3 frontend, and thoughtful tokenomics. The core of the protocol is a phase-based insurance vault system with automatic lifecycle transitions. The main contract, RiskVault.sol, manages the full insurance flow from deposit to coverage, claims, and redemption. I implemented phase transitions by checking timestamps during user interactions, which removes the need for external keepers and keeps things gas-efficient and decentralized. RiskToken.sol handles ERC20 tokens for senior and junior risk tiers. I also designed a proportional redemption mechanism that fairly distributes assets between tiers without relying on external oracles. For demo purposes, I added a forcePhaseForward() function to simulate time-based transitions instantly.
Initially, I planned to use ERC-4626 to represent yield-bearing vaults, but I also wanted the tokens to be Omnichain Fungible Tokens (OFTs) to enable unified pricing and liquidity across chains. The idea was to solve a core problem in on-chain insurance: fragmented, shallow liquidity. If users could access the same pool of risk tokens across chains with consistent pricing, trading costs would drop significantly. But I quickly found that building reliable OFTs was much more complex than expected, especially when maintaining pricing parity. Even with more time, this would be a difficult challenge. I still laid the foundation with a multichain architecture, which is why I deployed to Flow, Hedera, and Mantle testnets with chain-specific RPC handling and refresh logic.
The stack includes Hardhat and TypeScript for smart contracts, using OpenZeppelin for security. The frontend was built with Vite, React 18, and TypeScript. I originally used the Lovable UI to get started quickly, but it introduced a lot of bloat — unused components, redundant styles, and general heaviness. Midway through development, I did a full cleanup and refactored everything using shadcn/ui (Radix-based) and Tailwind CSS, which gave me a much more minimal, accessible, and maintainable UI. For wallet connectivity, I used ethers.js v6 and integrated Privy for seamless social login with email and Google, lowering the barrier for non-crypto-native users.
I deployed the protocol on Flow’s EVM Testnet for its high throughput and low fees, and verified all contracts on Flowscan. I also deployed on Hedera and Mantle, and accounted for each chain’s RPC behavior with dynamic polling intervals (e.g. Flow can handle fast refreshes, Hedera requires slower ones).
Some technical highlights: I built a script to auto-generate frontend config files from contract artifacts to keep the UI in sync with deployments. I implemented clean phase-based access control with Solidity modifiers. The risk engine fairly allocates assets during redemptions based on token holdings and vault state. I also created mock yield-bearing tokens like MockAUSDC and MockCUSDT for realistic testing and demos.
My development workflow included Hardhat Ignition for reproducible deployments, a comprehensive test suite with reasonable coverage on critical paths, automated contract verification, and frontend deployment via Netlify with environment-based configuration.
In summary, CoverVault reimagines DeFi insurance as a composable, accessible, and eventually cross-chain protocol. While the OFT-based vision for unified liquidity was too complex to fully implement in this timeframe, the multichain foundation and lessons learned shaped the architecture. The combination of technical experimentation and practical refactoring — including cutting bloat from the frontend — made this one of the most rewarding builds I’ve done.