The problem StreamYield solves

The problem it solves

Managing subscriptions sounds simple, but in reality it’s a mess.

In Web2, people constantly deal with:

• Forgetting to pay their monthly bills

• Auto-debits they don’t remember setting

• Sharing card details with multiple platforms

• Losing money on subscriptions they barely use

• Payments failing at the worst possible time

Even in Web3, things aren’t much better.
You still have to:

• Approve tokens to external contracts (which is risky if that contract gets hacked)

• Manually send payments every month

• Keep track of which creator or service you owe

• Watch your crypto sit idle without being used efficiently

So the overall experience of “paying every month” is still painful, repetitive, and unsafe.

How StreamYield fixes this

StreamYield turns subscriptions into something effortless.

Instead of paying every month, the user deposits some yield-generating asset (like stETH or aDAI) once.
The deposit stays fully under their control — the principal is never touched.

Only the yield generated from that deposit is used to pay subscriptions automatically.

If enough yield is generated → all subscriptions get paid

If yield is low → the system prioritizes important ones first

If the highest-priority subscription still can’t be paid → it simply gets skipped for that month (no penalties, no surprises)

The user keeps full ownership of their funds and can withdraw anytime.

Why it actually matter

This solves a bunch of real problems at once:

• No more monthly manual payments

• No need to trust anyone with token approvals

• No surprise auto-charges

• No losing track of what you’re subscribed to

• Your money keeps earning yield instead of sitting idle

Subscriptions “pay themselves” from the interest

It basically creates a safe, automated, capital-preserving subscription wallet, powered by yield and secured by Aave V3 + Octant-style routing.

Challenges we ran into

While building StreamYield, I ran into a few unexpected issues that slowed me down more than I expected.

1. Understanding how yield-bearing tokens actually accumulate yield

At first, it was confusing how assets like stETH or aTokens accrue yield without manually triggering anything. I kept expecting a function like updateYield() but the balance just grows automatically.
I had to read Lido, Aave docs, and Octant’s examples to finally understand that the yield comes from the token itself and not from my contract.
Once this clicked, the vault logic became much simpler.

2. Structuring the vault so the principal never gets touched

The main idea of the project is “principal stays, yield streams.”
But implementing that safely was tricky.
Initially, my contract logic mixed the user’s deposit with the subscription payouts, which defeated the whole purpose.

I fixed it by separating two things:

• • principal balance
• • unclaimed yield buffer

This solved a lot of confusion in the payout logic.

3. Handling multiple subscriptions with different priorities

The logic got complicated quickly:

• What if there’s enough yield for subscription A, but not B?

• What if none of them can be paid this month?

• How do I prevent partial/incorrect payouts?

I eventually solved it by implementing a simple priority queue:

1. Sort subscriptions by priority

2. Pay the highest-priority ones first

3. Skip the month if yield is insufficient

This kept the logic predictable and easy to reason about.

4. Integrating Aave V3 correctly
The hardest technical part was getting the Aave deposit/withdraw flow right.
The approvals, the aToken minting, and mapping yield inside the vault took time to understand.
A lot of trial and error, debugging, and staring at transaction traces finally got it working.

5. Building a clean frontend for the demo

The UI had to:

• connect a wallet
• show the user’s deposit
• show active subscriptions
• let them add/remove recipients and percentages

Getting wagmi, RainbowKit, and contract interactions to cooperate was another hurdle, especially when ABI mismatches happened.
Refreshing ABIs and rewriting the hooks fixed most of the issues.