TrustChain

The spark

It started with a simple frustration: how do you trust someone in a Bitcoin transaction?

There’s no review page. No support system. No refund button. If a deal goes bad - good luck.
I wanted to build something that brings accountability to peer-to-peer Bitcoin interactions without compromising decentralization.

That’s when the idea for TrustChain was born.

What I Set Out to Solve

I asked myself:

• What if a person could build a visible, evolving reputation from every Bitcoin deal they complete?
• What if you could signal trust or distrust, and it would actually shape that person’s credibility over time?
• And most of all, what if both sides had skin in the game?

That last question led me to the concept of staking: an amount held until the service is completed. If one side defaults, the victim gets compensated. Simple. Fair. Real stakes.

Reputation shouldn’t last forever. If someone disappears for a long time or stops transacting, their reputation should gradually fade. That’s how the decay mechanism works: it keeps trust fresh and earned, not permanent and stale.

Building the Trust Engine

To make the system dynamic, I introduced a concept inspired by radioactive decay. Yes, actual half-lives.

In nature, radioactive substances lose their potency over time. I thought: why not apply the same principle to trust?

Each user’s reputation score decays gradually over time, following an exponential decay formula just like how carbon-14 depletes or how medicine dosage weakens.

This means:

• If someone is consistently active and trustworthy, their score stays strong.
• But if they vanish or stop being vouched for, their score decays naturally even if no new distrust is added.
• This creates an environment where fresh, active credibility matters more than historic glory.

I implemented this with a custom function that calculates score reduction over time, using a fixed half-life period. The further back in time a vote was cast, the less weight it carries in today’s reputation.

This small piece of math added a huge layer of realism and fairness to the system. Trust, just like in real life, doesn’t last forever unless you earn it.

What I Built

I created a full backend that handles:

• Identity creation (with pubkey mapping)
• Trust/distrust voting
• Stake and unstake logic
• A transparent audit log
• Reputation decay over time

I also designed a frontend dashboard that mirrors all backend features though it’s not fully integrated yet.

From the trust graph visualizations to the staking flows and reputation meters, the UI was crafted to help users see the entire lifecycle of trust at a glance.

The Challenges

I ran into some major roadblocks:

• Lightning/LNbits integration wasn’t feasible within the time frame, but I made sure the system is modular enough to plug into it later.
• I couldn’t finish frontend-backend integration, but I developed both side-by-side. Every visual in the frontend is directly inspired by working backend logic.
• The hardest part? Designing something that feels simple, even though the underlying logic is anything but.

What I Learned

This wasn’t just about building features. I learned to think like a system designer about human behavior, trust incentives, and how math and code can reinforce honesty.

I also learned that reputation, like trust itself, has to be earned, tested, and allowed to fade.

What’s Next

The foundation is ready.
With Lightning integration and real transaction data, TrustChain can evolve into a native layer of reputation for the Bitcoin ecosystem.

This was more than a hackathon build.
It’s my answer to a broken trust problem and a glimpse of how we can solve it.

Built With

• chart.js
• express.js
• github
• javascript
• markdown
• node.js
• postman
• react.js
• sqlite
• tailwind