TrustFlowproject

TrustFlow: AI Builds It. DAO Approves It. NFT Proves It.

Web3 has grown fast — but it’s still built on blind trust. Users click “Sign” on MetaMask without knowing what they’re signing. DAOs approve proposals they barely understand. Even “verified” contracts hide bugs, exploits, and rug‑pull logic.

👉 And now Web3 is evolving toward RWA (Real‑World Assets) like real estate, bonds, and insurance. Without a built‑in trust layer, this shift is a financial and legal time bomb.

---

What We Did at ETHGlobal

We built the trust pipeline itself — and made it real, not theoretical.

✅ AI Smart Contract Builder – Users type “Create an escrow” or “Set up a token swap” in plain English. TrustFlow turns that into Solidity and deploys it instantly.

✅ DAO Approval Layer – Every contract automatically routes through a DAO voting flow before it executes. Governance isn’t optional — it’s built into the lifecycle.

✅ NFT Audit Logs – Each execution mints an NFT proof to IPFS, creating a permanent, tamper‑proof audit trail.

✅ ZK/Oracle Detector + 1inch LOP – Every swap or transaction runs through safety checks and live DeFi integration, proving this works with real protocols.

➡️ The result: One click. One flow. A user writes a contract → DAO votes → contract deploys → NFT proof is minted.

This isn’t “just a demo.” It works today.

---

Why It Matters

TrustFlow isn’t another weekend project — it’s the foundation for Web3’s next phase.

• AgentContract (AC): Smart Contract OS for DeFi, DAO & RWA
• AgentLive (AL): Agent‑powered marketplace — Web3’s Instagram + Shopify
• AgentSecure (AS): Insurance & risk layer to make every Agent and transaction accountable

The MVP already shows that AI → DAO → NFT can turn “black box code” into transparent, auditable, enforceable contracts.

Scaling TrustFlow means every DeFi swap, DAO vote, or RWA deal will carry built‑in trust.

---

How We Built It

• Backend: FastAPI (Python) deployed on Render. Handles AI → Solidity generation, DAO voting logic, NFT/IPFS logging, ZK/Oracle checks, and 1inch Limit Order Protocol integration.
• Frontend: Vite + React + shadcn + TypeScript for a clean UI: a smart contract builder and DAO dashboard that anyone can use.
• AI Layer: LangGraph pipeline with DeepSeek & HuggingFace models turns natural language into Solidity in seconds.
• On‑chain: Contracts deployed on Etherlink testnet. NFT proofs minted to IPFS. DAO approvals wired into every contract flow.

---

What We’re Proud Of

We hard‑wired DAO governance and NFT proof into the smart contract lifecycle. Every single contract TrustFlow creates is pre‑approved, permanently logged, and fully auditable.

No one has ever made contracts this self‑auditing before.

---

🎯 TL;DR: TrustFlow is the first working trust engine for AI‑built smart contracts. AI builds the contract. DAO approves it. NFT proves it happened.

This MVP proves that Web3 can finally have trust built in by default — and that’s the only way RWA can work.

TrustFlow stitches AI, Layer2 smart contracts, and DAO governance into one working “trust engine” — all built during ETHGlobal.

🖥 Backend — the engine room We built our backend with FastAPI (Python) and deployed it to Render. It’s the brain that connects all the moving pieces:

AI → Solidity generator – turns natural language prompts into deployable smart contracts

DAO voting logic – every contract is routed for community pre‑approval before execution

NFT/IPFS logging – every execution automatically mints a permanent proof to IPFS

ZK/Oracle checks – validates conditions before swaps or contract calls

1inch LOP integration – connects our contracts to live DeFi swaps, not just dummy data

🎨 Frontend — the trust dashboard The UI was built using Vite + React + shadcn + TypeScript. It gives users a clean contract builder and a DAO voting dashboard — no Solidity knowledge needed, everything visual and intuitive.

🤖 AI Layer — the magic glue We used a LangGraph pipeline powered by DeepSeek & HuggingFace models to turn plain English like “Make me an escrow contract” into Solidity code. 👉 Result: anyone can create a contract in seconds, without touching a single line of code.

⛓ Blockchain integration Contracts deployed on Etherlink RPC (testnet)

NFT audit proofs minted to IPFS for permanent recordkeeping

ZK/Oracle detector flags unsafe conditions before anything executes

DAO approvals are hard‑wired into every contract lifecycle

🤝 Partner tech we leveraged 1inch Limit Order Protocol: Let our contracts trigger real DeFi swaps.

IPFS: Stores every audit log forever.

Etherlink RPC: Gave us a blazing‑fast testnet to deploy contracts on.

💥 The hacky thing we’re proud of We didn’t just “add” DAO and NFT features — we embedded them into the contract flow itself. Every single contract created with TrustFlow:

✅ auto‑goes through DAO approval ✅ auto‑mints an NFT proof to IPFS

➡️ No one has built contracts this self‑auditing before.

🎯 The result In one seamless flow, a user can: type a contract → DAO votes → deploy → NFT proof minted.

What started as a hackathon sprint turned into the first working trust engine for AI‑built contracts.