Project Story: RiskyBisky

💡 Inspiration

We all suffer from the same problem: Talk is cheap. How many times have we said, "I'll go to the gym tomorrow" or "I'll finish that project this weekend," only to push it back again?

The inspiration for RiskyBisky came from behavioral economics, specifically the concept of "Loss Aversion." Studies show that humans are much more motivated by the fear of losing money than by the prospect of gaining it. We realized that existing to-do lists don't work because there are no immediate consequences for failure.

We wanted to build a protocol that forces you to "put your money where your mouth is."

🚀 What it does

RiskyBisky is a decentralized accountability protocol.

1. Stake: Users create a goal (e.g., "Run 5k") and stake real ETH on it.
2. Commit: The funds are locked in a Smart Contract. The user cannot withdraw them.
3. Verify: A designated "Verifier" (a friend or colleague) tracks the progress.
   • Success: If the user completes the goal, the Verifier approves it, and 100% of the ETH is refunded.
   • Failure: If the user slacks off, the Verifier marks it as failed, and the ETH is sent to a charity.
4. Expiration: If the user "ghosts" their goal and the deadline passes without verification, the contract allows the donation account (or anyone) to execute a function that flushes the funds to charity.

⚙️ How we built it

• Smart Contract: Written in Solidity. We implemented a robust state machine (Active, Completed, Failed, Withdrawn) to track the lifecycle of every goal.
• Frontend: Built with React.js. We used standard hooks to manage the dApp state.
• Integration: We used Ethers.js to connect the frontend to the blockchain, handling wallet connections, transaction signing, and reading/writing data to the Sepolia Testnet.
• Network: Deployed on Ethereum Sepolia Testnet.

🛑 Challenges we ran into

• The "Zombie" Goal Problem: One of the biggest challenges was figuring out what happens if a user sets a goal and then just disappears. We didn't want funds locked in the contract forever. We had to write specific logic (releaseAfterDeadline) to ensure that once a deadline timestamp is passed, the funds are no longer reclaimable by the user and can be pushed to the charity address.
• UX & Gas Estimation: connecting the frontend to MetaMask often resulted in "Internal JSON-RPC" errors when inputs weren't perfectly formatted. We spent a lot of time cleaning data (like handling empty strings for charity addresses) to prevent the app from crashing before the transaction even reached the wallet.
• Network Switching: Ensuring users were on the correct testnet (Sepolia) was tricky. We implemented a "Force Switch" feature that programmatically adds the network to the user's wallet if it's missing.

🧠 What we learned

• Trustless Logic: Building on blockchain requires a different mindset. You can't just "edit the database" if something goes wrong. The code is law.
• State Management: synchronizing the local React state with the asynchronous nature of Blockchain transactions (waiting for block confirmations) taught us a lot about handling asynchronous UI.

🔮 What's next for RiskyBisky

• Multi-Chain Support: We plan to deploy on Base and Polygon to lower gas fees for users.
• Social Proof: Auto-generating an NFT or a "Badge of Honor" for users who successfully complete high-stake goals.
• Group Goals: Allowing multiple people to pool ETH into a single "Group Pot" (e.g., a gym group) where the last person standing wins the pot.

Built With

• blockchain
• create-react-app
• css3
• es6+)
• frameworks
• html5
• javascript
• metamask
• react.js
• remix
• rpc
• solidity