YieldFlow

DeFi is fragmented. Users have positions across protocols and chains but almost no simple, accurate way to know how much they actually earned day-to-day. Protocol-level APYs and portfolio snapshots don’t show net user earnings over time, making it hard to compare strategies or detect value leaks.

YieldFlow automatically detects and snapshots user positions on supported lending dApps, computes real 24h yield per contract/token, stores time series, and displays clear charts. For ETH Global prototype, YieldFlow focuses on Morpho, Aave & Spark on Katana, Base and Unichain to demonstrate multi-chain capability and end-to-end accuracy.

Key user flows:

• Connect a wallet.
• YieldFlow scans the connected wallet address, detects supported positions, and begins daily snapshots automatically.
• View a simple dashboard with time-series charts and per-dApp / per-token daily yields.

What it tracks

• Per-protocol and per-token daily yield (not just balances or TVL).
• Historical daily snapshots so users can see trends and best/worst days.
• Exact balances pulled from the protocol contracts (e.g., balanceOf, maxWithdraw) to compute net changes.

For the hackathon submission the supported surface is:

• Blockchains: Katana, Unichain, Base
• DApps / Protocols: Aave (balanceOf) and Spark (maxWithdraw)
• Tokens: relevant tokens used by these integrations : USDC(Circle)

Current state & traction

• Proof-of-concept complete for Morpho,Aave + Spark on Katana, Base & Unichain.
• End-to-end snapshot pipeline functioning: reads → compute yield → store → display.
• Prototype is optimized for quick onboarding in a demo setting

YieldFlow fills a simple but crucial gap: real, per-user earnings visibility across DeFi. It turns raw balance snapshots into actionable daily yield metrics, enabling users to compare protocols, spot underperforming positions, and make data-driven decisions. For the hackathon, the focused Katana + Unichain and Base build demonstrates a compact, privacy-aware, multi-chain approach that’s easy to demo and extend.

YieldFlow was built as a full-stack DeFi yield tracking platform, with a backend in Node.js and PostgreSQL and a frontend in Next.js + TailwindCSS.

A core snapshot script (snapshot.js) runs daily via a Linux cron job, retrieving user wallet addresses from the PostgreSQL database and querying their balances directly from smartcontracts. This script uses ethers.js to make RPC calls to blockchain nodes, fetching user wallet balances directly from smart contracts.

• For Aave, it calls the balanceOf method.
• For Morpho and Spark, it calls maxWithdraw.

The js script calculates the daily yield by subtracting the previous day’s balance from the current one, then stores both the new balance and daily yield back into the database. A cron job on a Linux server schedules this process.

The backend exposes a Web API built with Express.js that serves this data to the frontend. Users can connect their wallets on the frontend to instantly view detailed yield charts, daily earnings, and cross-protocol comparisons.

Partner technologies We leveraged Katana, Unichain and Base partner technologies by directly reading data from contracts deployed on these blockchains, enabling us to integrate support for their ecosystems early. This allowed us to ensure accurate yield tracking for assets on these chains without requiring users to manually input their positions.

Hacky but notable Given the 24-hour prototype build window:

We currently store only contract addresses in the database. Ideally, we’d store richer metadata (chain, token ticker, decimals, ABI method, associated dApp).

RPC URLs are hardcoded in the snapshot script; these should be moved to a config file with multiple providers for redundancy.

Balances are fetched sequentially per user, which won’t scale. Integrating a Multicall contract will dramatically reduce RPC calls.

API endpoints are currently public; a secure authentication flow using wallet signature-based tokens is planned.