CivicChain

Project Overview

CivicChain is voting software for DAOs and member groups that care about outcomes you can verify. Proposals go up, people vote with their wallets, and the tally lives on-chain so nobody has to take the admin’s word for it. Delegation is part of the deal: if your rules allow it, someone can vote on your behalf, but the chain still records what happened, and you can see it later. The app side is a Next.js front end that meets people where they are: connect a wallet, read the proposal, vote, and watch results update as blocks confirm. We kept the fancy stuff where it belongs. Long proposal text and attachments do not need to sit in expensive storage on Ethereum; hashes point to IPFS, and the contract stores what actually has to be binding.

Problem

Off-chain polls are fast to set up, but they are also easy to argue about. “Who voted?” “Did we count abstentions?” “Did someone change the totals after the fact?” If the answer is “trust the person who ran the poll,” you do not really have governance, you have a nice conversation. Some teams tried half-measures: a vote in Discord and a snapshot in a sheet. That breaks the moment someone deletes a message, or two people maintain two different copies of the member list. On-chain voting fixes the integrity part, but raw contracts are not a product. Members still need plain language, a clear ballot, and a way to see results without reading hex. And when gas spikes, nobody wants to pay rent just to say yes or no, so the design has to be practical, not a purity contest. Delegation matters for real organizations: not everyone wants to babysit every proposal. Without it, you either get low turnout or quiet centralization, where someone votes “for the group” with no paper trail anyone trusts.

Solution

We wrote the core rules in Solidity: create a proposal, open and close voting, count choices, and support delegation where the client’s governance model allows it. The contract is the source of truth for what counts as a valid vote, not a database row someone can edit. The web app is Next.js with Ethers.js handling wallet connect, signing, and reading state back from the chain. We focused on flows people can follow when they are tired: connect, pick a proposal, vote once, see confirmation, done. Proposal bodies and rich text live off-chain on IPFS; we store hashes on-chain so the vote still references something fixed, without stuffing megabytes into a transaction. For history and leaderboards, we added an indexer that watches events and fills a normal database for search and paging. Users get snappy screens; the chain stays the judge of truth.

Technology Stack

SolidityEthereumNext.jsEthers.jsIPFS

Architecture

At the bottom: Ethereum holds proposals (by hash), votes, and delegation edges. Wallets talk to the contract through the app; we do not ask users to paste ABI calls by hand. IPFS holds the human-readable proposal. The contract stores a content id or hash so if someone swaps the text later, it does not match what voters signed up for. Above that sits the Next.js app for UX, plus an indexer service that listens for contract events and projects them into Postgres (or similar) for “show me everything we voted on last quarter.” Gas-heavy paths use batching where it made sense so routine governance does not feel like buying a car every time you click vote.

Results

• 10+ DAOs migrated to the platform
• 100% verifiable on-chain results
• Zero disputed elections since launch