Drips Wave

Fix. Merge. Earn — every month.

Drips Wave turns an ecosystem's funding into a recurring sprint of merged pull requests. Maintainers clear their backlog. Contributors get paid for shipping. Ecosystems get measurable progress, not promises.

How it works

The anatomy of a Wave

One predictable rhythm. Three roles, each with their own job to do. Most Waves run on a monthly cycle.

1 Maintainers add issues

Maintainers pull issues from their backlog into the Wave Program and assign each a complexity — Trivial, Medium, or High — that determines its Points value.

200 Points

#847 Add cross-pool token swap routing to the AMM contract

lumenflow/amm-contracts
150 Points

#612 Fix XDR decoding edge case in indexer ingestion pipeline

horizonpath/indexer
150 Points

#743 Document the new transaction-builder helpers in the wallet SDK

stelka-wallet/app
100 Points

#409 Typo in README install snippet

lumenflow/sdk-js
200 Points

#921 Add retry-with-backoff to Horizon client subscriptions

lumenflow/sdk-js
150 Points

#158 Surface validation errors in the transaction builder UI

stelka-wallet/app

#847 Add cross-pool token swap routing to the AMM contract

lumenflow/amm-contracts

Today the AMM only supports single-pool swaps. To compete with other DEXs on Soroban, we need a router that finds the best path across two or three pools and atomically executes the trade in a single transaction.

Implementation should live alongside the existing pool contract under contracts/router/, with TypeScript bindings regenerated so the frontend can call it through our existing SDK without ceremony.

Scope

  • A Rust router contract supporting up to 3-hop paths between SAC pairs.
  • Slippage protection (min-out parameter) with a clear revert reason.
  • A test harness covering happy path, deep slippage, and price-impact edge cases.

Bonus points for benchmarking against a single-pool swap to confirm the routing overhead is acceptable, and updating the docs with a short trader-facing walkthrough.

2 Contributors solve issues

Contributors browse, apply, and merge PRs over one week. Every resolved issue awards Points and pushes the leaderboard live.

horizon42

Done a few similar things in side projects. Should be doable within the Wave.


OSS Activity Score Medium
Total Merged PRs 42
PR Merge Rate 78%

mira-codes

Strong Rust + Soroban background. Will follow up on slippage design first.


OSS Activity Score High
Total Merged PRs 312
PR Merge Rate 88%

kovri-h

Have written 3-hop routers on EVM. The Soroban version should be similar in shape.


OSS Activity Score High
Total Merged PRs 167
PR Merge Rate 85%

orbit-jay

Could do this over the weekend. I have a working slippage-protected router locally.


OSS Activity Score Medium
Total Merged PRs 58
PR Merge Rate 71%

meridian-dev

Shipped a similar Soroban router last Wave with full test coverage. Can wrap this in 2 days — slippage math sketched out already.


OSS Activity Score High
Total Merged PRs 184
PR Merge Rate 92%

pasta-stream

First time touching Soroban but built a Uniswap V2 router clone in Rust last year.


OSS Activity Score Medium
Total Merged PRs 21
PR Merge Rate 64%

horizon42

Familiar with the AMM space — wrote a fee-on-transfer router fork last quarter.


OSS Activity Score Medium
Total Merged PRs 96
PR Merge Rate 80%

kovri-h

I can pair on this with my colleague — we’d split research and implementation cleanly.


OSS Activity Score High
Total Merged PRs 220
PR Merge Rate 90%

mira-codes

I’ve audited two Soroban DEXs already. Would prefer to start with the test harness.


OSS Activity Score High
Total Merged PRs 410
PR Merge Rate 94%

3 Rewards are distributed

When the Wave closes, the reward pool splits by Points share. Contributors withdraw on-chain — no spreadsheets, no manual accounting.

mira-codes
$0
Withdrawable
meridian-dev
$0
Withdrawable
horizon42
$0
Withdrawable
kovri-h
$0
Withdrawable
orbit-jay
$0
Withdrawable
pasta-stream
$0
Withdrawable
sora-builds
$0
Withdrawable
lattice-rs
$0
Withdrawable
velorum
$0
Withdrawable
nyx-eth
$0
Withdrawable
spire-dev
$0
Withdrawable
kepler-77
$0
Withdrawable
aurorae
$0
Withdrawable
ophelia.dev
$0
Withdrawable
wren-rs
$0
Withdrawable
nodemonk
$0
Withdrawable
cinder-x
$0
Withdrawable
reverb-dev
$0
Withdrawable
okto-codes
$0
Withdrawable
helio-77
$0
Withdrawable
corvid
$0
Withdrawable
fern-net
$0
Withdrawable
tinder-rs
$0
Withdrawable
lattice-fox
$0
Withdrawable
zephyr-stack
$0
Withdrawable
mantle-rs
$0
Withdrawable
drift-codes
$0
Withdrawable
nexa-77
$0
Withdrawable
prism-dev
$0
Withdrawable
basilisk
$0
Withdrawable
vortex-x
$0
Withdrawable
ember-cs
$0
Withdrawable
photon-9
$0
Withdrawable
citrine
$0
Withdrawable
glade-rs
$0
Withdrawable
mango-builds
$0
Withdrawable
aspen-rs
$0
Withdrawable
crimson
$0
Withdrawable
indigo-dev
$0
Withdrawable
helix-77
$0
Withdrawable
lumen-codes
$0
Withdrawable
mosaic
$0
Withdrawable
nettle
$0
Withdrawable
omega-z
$0
Withdrawable
parallax
$0
Withdrawable
quill-rs
$0
Withdrawable
raven-codes
$0
Withdrawable
sterling-dev
$0
Withdrawable
Reward pool $50,000

Three ways to get involved

Whether you're funding a Wave, running a repo in one, or shipping PRs to earn — start here.

For ecosystems

Run a Wave Program

Convert your ecosystem budget into a recurring cycle of merged PRs across approved repos.

For maintainers

Clear your backlog

Apply your Stellar repos to a Wave and let funded contributors ship the issues you've been sitting on.

For contributors

Fix, merge, earn

Browse curated issues from top-tier ecosystems, merge PRs, and earn a share of every Wave's pool.

Live on Stellar

The first Wave Program runs on Stellar

Stellar Development Foundation runs a monthly Wave across the Stellar open-source ecosystem. Maintainers across the network apply their repos, contributors ship issues, and the pool pays out at the end of each cycle.

$400k+ Distributed to contributors
50k+ Issues resolved across Waves
200+ Repos in the program