DEV Community: Pratik Pangeni

Building PangeniAI: A Decentralized AI dApp on Polygon

Pratik Pangeni — Sun, 16 Aug 2026 16:23:33 +0000

Building PangeniAI: A Decentralized AI dApp on Polygon

AI that actually cares — no tricks, no hidden fees, and none of your data in someone else's hands.

For the better part of a year, the conversations I kept having with builders were always the same: "I love what AI can do, but I don't love what it costs me." Not just in money — in privacy, in control, in trust. Every major AI product runs on someone else's servers, stores your conversations in someone else's database, and can change the rules whenever it pleases.

So I set out to build something different. PangeniAI — a fully decentralized AI application where the wallet, the contracts, and the data all belong to the user. No backend server. No central authority. Just you, your keys, and the blockchain.

This post walks through the architecture, the smart contracts, the hard trade-offs, and the lessons learned along the way.

The Problem: AI Without Ownership

Modern AI platforms are convenient, but convenience often comes with a quiet surrender. You don't own your conversations. You can't move them. You can't prove what happened. And if the platform changes its terms — or disappears entirely — your data goes with it.

The web3 thesis is simple: ownership isn't a feature, it's the baseline. When you hold your private keys, you hold the authority. PangeniAI is an attempt to apply that thesis to AI seriously — not as a marketing tagline, but as an architectural constraint.

The Idea

A dApp with no backend where AI agents are minted as NFTs, conversations live on IPFS, and every interaction is recorded on-chain.

Two modes, one philosophy:

Free Chat — immediate, honest AI help. No signup, no wallet, no strings. AI should be accessible to anyone, full stop.
Web3 Pro — the full ownership experience. Mint your AI agents as ERC-721 NFTs, store data on IPFS, and keep custody of everything you create.

Everything is client-side. MetaMask signs, IPFS stores, the chain settles. If you have the keys, you have the app.

Architecture

┌──────────────────────────────────────────────┐
│              Frontend (React)                 │
│   ┌──────────┐ ┌────────┐ ┌───────────────┐  │
│   │ MetaMask │ │ Pinata │ │ OpenAI /      │  │
│   │  Wallet  │ │  IPFS  │ │ Pollinations  │  │
│   └────┬─────┘ └───┬────┘ └──────┬────────┘  │
│        │           │             │           │
│   ┌────▼───────────▼─────────────▼─────────┐ │
│   │        Smart Contracts (Solidity)       │ │
│   │  • PangeniAI      — ERC-721 NFT agents │ │
│   │  • PangeniStorage — IPFS CID tracking  │ │
│   │  • PangeniRegistry — ratings, history  │ │
│   └────────────────────────────────────────┘ │
└──────────────────────────────────────────────┘
         │                  │
    Polygon Chain       IPFS Network
    (Amoy Testnet)   (via Pinata Gateway)

There is no server in this diagram, and that is the entire point. The "backend" is a distributed ledger and a distributed filesystem — both of which anyone can verify and no one can quietly delete.

The Smart Contracts

The heart of PangeniAI is three Solidity contracts, deployed with Hardhat and audited by the OpenZeppelin standard library they're built on:

Contract	Purpose
PangeniAI	An ERC-721 collection where every token is an AI agent — name, description, IPFS metadata, creator, visibility toggle.
PangeniStorage	A per-user data registry tracking IPFS CIDs — every backup and file reference, recorded and verifiable.
PangeniRegistry	The public agent ledger — registration, ratings, and a permanent interaction count for every agent.

Three contracts, three responsibilities, one idea: identity, storage, and reputation should be public, permanent, and provable.

Why ERC-721 for agents?

An AI agent with its own wallet address, personality, and track record is, in a very real sense, a thing. NFTs give things a global identity that can be owned, transferred, and shown off. Minting an agent turns a configurable prompt into a collectible — it stops being a line in a database and becomes an asset in your wallet.

Why IPFS for content?

Blockchain storage is expensive and public in the wrong way. IPFS gives us content-addressed, censorship-resistant storage with a fingerprint (the CID) that proves the data hasn't been tampered with. The chain stores the proof; IPFS stores the payload. It's the best of both worlds — durability on-chain, cost-efficiency off-chain.

What It Feels Like to Use

Open the app. You're greeted by a welcome screen with two paths.

Free Chat is immediate — ask about code, science, writing, anything. The underlying model routing (currently Pollinations) rotates and falls back gracefully across providers, so even free users get a resilient experience. Rate limits are detected and handled without drama.

Web3 Pro starts the moment you connect MetaMask. The app detects the network, prompts a switch to Polygon Amoy, and then the real fun begins:

Mint agents. Give your agent a name, a description, a personality. Sign the transaction. Your agent is now a token on-chain.
Chat with your agents. Stream responses from OpenAI (bring your own key — a deliberate privacy choice).
Generate images. One click, and FLUX Schnell renders from your prompt.
Store everything. Conversations and backups go to IPFS, with the CID anchored on-chain. Your data survives any server, any company, any apocalypse short of the internet itself.
Backup & restore. Encrypted backups pinned to IPFS, tracked on-chain. Lose your phone, keep your agents.

Every meaningful action is a signed transaction. You're not asking a platform for permission — you're instructing the blockchain.

The Tech Stack

Layer	Choice
Frontend	React 18, TypeScript, Vite, Tailwind CSS, Zustand
Blockchain	Solidity 0.8.20, Hardhat, ethers.js v6
Standards	ERC-721, OpenZeppelin
Storage	Pinata IPFS (pinning + gateway)
Network	Polygon Amoy Testnet (chain 80002)
AI	OpenAI (BYOK), Pollinations, Replicate / FLUX Schnell

The whole thing compiles, deploys, and tests through a single npm script surface — contracts:compile, contracts:test, contracts:deploy:amoy — keeping the local and testnet workflows identical.

Lessons Learned

Building this taught me more about constraints than about features.

1. "No backend" is a discipline, not a convenience. Every time you reach for a server, you import trust. The discipline is asking, "can the chain or IPFS do this?" — and surprisingly often, the answer is yes.

2. Keys belong to users — even API keys. Letting users bring their own OpenAI and Pinata keys isn't just cost-saving; it's philosophically consistent. The app holds no secrets, so the app has no power over you.

3. Resilience beats one perfect provider. For free chat, multi-endpoint fallback (with model rotation, history trimming, and rate-limit detection) matters more than any single model choice. Production AI is a reliability problem as much as a quality problem.

4. Testnets are where trust is earned. Shipping on Polygon Amoy means the invariants are verified in a live, adversarial environment before anything matters. The address of every deployed contract is checked, committed, and verifiable.

What's Next

PangeniAI is, at its core, an argument: that the next decade of AI doesn't have to repeat the mistakes of the last one. The roadmap is to push further — stronger agent-to-agent communication, a public agent marketplace on the registry, and eventually mainnet.

But even today, the important thing is that anyone can verify the claim. The contracts are public. The addresses are committed. The data is on IPFS. Skepticism isn't an insult — it's the correct default for web3, and I welcome it.

Conclusion

The most common objection to decentralized apps is that they're complex. And honestly — they are. But the complexity is the cost of freedom, and it's falling every year. The wallets are better, the tooling is better, and the user experience is finally catching up.

PangeniAI is my small contribution to a world where AI is a thing you own, not a thing that owns you.

PangeniAI is open source and live on Polygon Amoy Testnet. Repo: github.com/Pratikeeyyyy/ai.

"Free forever. Yours always."

Splitting the Bill, On-Chain: Building ExpenseShare, a Decentralized Expense Tracker

Pratik Pangeni — Fri, 14 Aug 2026 08:07:24 +0000

Splitting the Bill, On-Chain: Building ExpenseShare, a Decentralized Expense Tracker

How I built a trustless, blockchain-powered expense-sharing app — from Solidity smart contracts to a live React frontend.

The Problem

Every group trip, dinner, or shared apartment comes with the same awkward ritual: someone pays, someone tracks, and someone always forgets to pay back. The spreadsheet becomes a mess, text-message IOUs get lost, and "who owes whom" is always a guessing game.

What if the tracking, the splitting, and the settlement all happened automatically — with a permanent, tamper-proof record that nobody can dispute?

That's exactly what ExpenseShare does. It's a decentralized application (DApp) built on the Ethereum Sepolia testnet where expenses are split, tracked, and settled transparently on the blockchain.

The Solution

ExpenseShare lets you:

Connect your MetaMask wallet and start splitting expenses instantly
Create expenses with multiple participants — the smart contract calculates everyone's share automatically
Track who owes whom in real-time with live dashboard stats
Send payment requests and settle debts directly on-chain
Flag bad debtors when people don't pay up
Mint NFT receipts as permanent proof that an expense was settled

The whole thing runs with zero backend. There's no server, no central database — just a smart contract doing all the heavy lifting.

Tech Stack

Layer	Technology
Frontend	React 19, Vite 8, Tailwind CSS 3
Web3	ethers.js v5, MetaMask
Smart Contracts	Solidity 0.8, Foundry (Forge)
NFT Standard	OpenZeppelin ERC721
Storage	IPFS via Pinata
Network	Ethereum Sepolia testnet
CI/CD	GitHub Actions, Vercel

The Smart Contracts

1. `Storage.sol` — The Expense Manager

This contract is the heart of the app. Every expense lives on-chain as an immutable record:

enum Status { pending, paid, rejected, badDebt }

struct Expense {
    string expname;
    string paidby;
    address payerAddress;
    string paddress;
    uint256 amt;
    uint256 shareamount;
    Status status;
    address[] participants;
    string[] participantNames;
    mapping(address => bool) hasPaid;
}

Key mechanics:

Equal splitting — the share is computed on-chain: amt / (participants + 1).
Lifecycle tracking — every expense moves through pending → paid, or falls into rejected / badDebt.
Payment requests — a participant who wants their money back can create an on-chain request, and the debtor can settle it by sending ETH directly through the contract.
Bad debt detection — getBadDebtors() scans participants who haven't paid, so defaulters are always identifiable.
Events everywhere — ExpenseAdded, ParticipantPaid, PaymentRequested, PaymentCompleted, and StatusUpdated let the frontend react to state changes in real time.

2. `ExpenseNFT.sol` — Proof of Settlement

Each fully-paid expense can be minted into an NFT receipt:

contract ExpenseNFT is ERC721, ERC721URIStorage, ERC721Pausable, Ownable, ERC721Burnable

Only the payer (the actual owner) can mint, and only after the expense is fully paid — it's a genuine receipt, not a participation trophy.
NFT metadata and images are uploaded to IPFS via Pinata, so the receipt lives permanently on decentralized storage.
The NFT contract tracks which expense maps to which token, and users can even import their receipts straight into MetaMask via wallet_watchAsset.

The Frontend

The React app is deliberately simple in structure but rich in features:

Landing page with a full marketing story, feature grid, and "how it works" section
Auth pages (register/login) gated by a route guard
Dashboard showing summary stats — pending, paid, received, and payment due (what you owe others)
Dynamic participant forms — add up to 10 people with names and wallet addresses
Live refresh — the dashboard polls the chain every 15 seconds, so statuses update as participants pay
Bad debt section that surfaces defaulters with their addresses and amounts
Dark mode toggled and persisted via localStorage

One nice touch: payments are processed in two steps. The participant sends ETH directly to the payer via signer.sendTransaction, then the payer marks them as paid in the contract. This keeps real value flowing between wallets while the contract maintains the trusted record.

Testing & CI

The project ships with 7 Foundry tests covering the full business logic:

Adding a single-expense and verifying stored details
Multi-participant splitting
Marking participants as paid and confirming the remaining bad debtor
Creating and verifying payment requests
Updating expense status
Extracting all bad debtors from a 4-person expense
A complete end-to-end flow: add → pay → all settled

GitHub Actions runs forge fmt --check, forge build --sizes, and forge test -vvv on every push, so the contract logic is continuously verified.

Deployment

Frontend: live on Vercel
Smart contracts: deployed on the Sepolia testnet

Deployed contract addresses are available in the repo's src/Expenseapp.jsx and broadcast logs.

Challenges & Lessons Learned

Wallet ↔ contract coordination. Making real ETH transfers while keeping the on-chain ledger accurate required a careful two-step design — direct wallet-to-wallet payment, then an on-chain status update. It's the difference between a "ledger app" and a real settlement tool.
Gas-conscious events. Converting view functions into event-emitting functions (e.g., getStatus) taught me that on-chain state changes cost gas, and events are the cheap, standard way to surface state to the UI.
NFT gating logic. Deciding who can mint a receipt NFT and when (only the payer, only after full payment) forced me to think hard about what an NFT receipt should actually represent.
Sepolia chain management. The app auto-switches users to Sepolia via wallet_switchEthereumChain and gracefully handles the case where the network isn't added yet.

What's Next

🔔 Notification system for due payments
💳 ERC20 token support instead of raw ETH
📊 Analytics dashboard with spending insights
🔄 Automatic escrow settlement
📱 Mobile app version
🤖 AI-based expense prediction
Fix SPA routing on Vercel (currently direct URL navigation to /login or /register returns 404 — a simple rewrite config fixes this)

Try It Yourself

Install MetaMask and connect to the Sepolia testnet (the app does this for you).
Grab some free test ETH from a Sepolia faucet.
Open the live app, create an expense, split it with friends, and mint your first receipt NFT.

Final Thoughts

Building ExpenseShare showed me how blockchain genuinely solves a real-world coordination problem. There's no middleman, no spreadsheet, no "I'll pay you back later" — just transparent, immutable, trustless expense tracking.

Transparency. Trustless execution. Accountability. Immutable records. That's what happens when you put a bill on the blockchain.

Repo: github.com/Pratikeeyyyy/metaapk

DEV Community: Pratik Pangeni

Building PangeniAI: A Decentralized AI dApp on Polygon

Building PangeniAI: A Decentralized AI dApp on Polygon

The Problem: AI Without Ownership

The Idea

Architecture

The Smart Contracts

Why ERC-721 for agents?

Why IPFS for content?

What It Feels Like to Use

The Tech Stack

Lessons Learned

What's Next

Conclusion

Splitting the Bill, On-Chain: Building ExpenseShare, a Decentralized Expense Tracker

Splitting the Bill, On-Chain: Building ExpenseShare, a Decentralized Expense Tracker

The Problem

The Solution

Tech Stack

The Smart Contracts

1. Storage.sol — The Expense Manager

2. ExpenseNFT.sol — Proof of Settlement

The Frontend

Testing & CI

Deployment

Challenges & Lessons Learned

What's Next

Try It Yourself

Final Thoughts

1. `Storage.sol` — The Expense Manager

2. `ExpenseNFT.sol` — Proof of Settlement