2025 was the year Hoops stopped being “a promising idea” and started looking like what it really is: a compounding infrastructure company that ships.
We built with a (very) small team, under real constraints, in a market that rewards hype more than proof. And we still left the year with a stronger product, a sharper narrative, and a much clearer path to mainnet.
This is our 2025 recap - the wins, the experiments, the lessons, and what we’re preparing to launch next.
The core theme of 2025: make DeFi legible (and safe) at scale
Our mission didn’t change:
Make DeFi transparent (real-time market + liquidity truth).
Make it usable (onboarding that doesn’t punish new users).
Make it programmable (APIs and smart accounts so strategies can run without constant babysitting).
What changed in 2025 is we turned that mission into systems investors can actually underwrite: repeatable shipping, measurable traction, and infrastructure that holds up under protocol upgrades and real-world weirdness.
Product wins: foundations that unlock mainnet
1) Dashboard v0.5.0 - identity, wallets, and developers in one place
In October, we shipped v0.5.0, a major step forward that unified identity, wallets, and developer access into a single, coherent platform.

Our mascot, Hoopy, celebrating our milestone
What shipped:
Passkeys + zero-knowledge login (SRP)
Stronger session security (token rotation, device management, CSRF hardening)
Stellar wallet linking (SEP-10) for in-dashboard signing
Cleaner developer experience (API keys, standardized endpoints, fresher data)
Why it mattered: this finished our foundation layer. Secure onboarding, identity, and wallet rails are the prerequisites for everything that comes next on mainnet — smart accounts, vault rewards, reputation, and automated strategies.
2) Authentication rebuild — boring, provable, durable
We didn’t just “add passkeys.” We rebuilt auth so it’s something you can reason about and trust:
Passwords never leave the browser (SRP-6a)
Memory-hard key derivation by default (Argon2id)
Single-use, time-bound challenges
End-to-end session correlation for auditability and debugging
This is the kind of work users never notice and the kind that prevents existential failures later. It’s also a signal: we don’t ship fast by borrowing risk from the future
3) Indexer hardening — when protocol upgrades break assumptions
Blockchains evolve. Protocols upgrade. State management gets more sophisticated.
When indexers don’t adapt, they don’t usually crash — they quietly drift away from the truth.
Before Protocol 24, we had already invested in:
Protocol 23 / Soroban v4 compatibility (without breaking v3)
Resumable ingestion (no re-indexing the universe)
Historical contract code + spec resolution (old transactions stay meaningful)
That work paid off - because in October, a state archival bug surfaced.
In short:
Some unused contract state was archived correctly
But outdated versions were sometimes restored
Ledger state could temporarily diverge from canonical history
(transactions stayed immutable, but state could be wrong)
The impact was limited, and the network responded quickly. But for infrastructure builders, the lesson was clear: “almost correct” data is still wrong.
Because we had replay-first ingestion, raw transaction storage, and historical context baked in, we could:
detect anomalous state
quarantine ambiguous reads
deterministically re-derive correct results
Teams without those safeguards would never know they were off.
We treated this not as an edge case, but as a design constraint going forward:
state-aware ingestion
execution-context parsing
deterministic replay as a requirement, not a luxury
It wasn’t flashy - but it significantly raised the reliability bar under everything we build.
4) Markets system + arbitrage engine overhaul (reality-first)
We also rebuilt our markets stack from the ground up:
One shared source of truth for market logic
Cleaner historical snapshots, with ledger-pinned state when needed
A two-stage arbitrage engine focused on executable paths, not paper profits
(capacity-aware routing, flow clipping, real liquidity constraints)
Traction wins: proof that builders and users show up
Even while heads-down building, we saw signals that matter:
API usage: ~40–200 unique devs/day
Throughput: ~1,200 requests/day average, ~1,800 peak requests/hour
Frontend: 670+ unique users and 10,650 views in a 24h window (snapshot)
Data scale: ~1M blockchain events indexed, 73 AMM pairs, sub-second query speeds
Market visibility: $50M+ TVL tracked, $21M+ daily volume tracked (ecosystem-level data visibility)
We’re careful with numbers because we care about trust - but the direction is clear: Hoops is already becoming an infrastructure primitive people rely on.
Community + ecosystem wins: Grants, accelerators, stages, and credibility
1) Accelerator momentum (and why it mattered)
We completed our second accelerator in 2025 (Myosin x BuildOnStellar GTM), and won Best Go-To-Market Strategy for the cohort.
The real value wasn’t the recognition. It was the forcing function:
clarity beats complexity
a sharp story compounds faster than a cluttered roadmap
build → share → feedback → iterate is a system, not a vibe

Hoops Finance takes 1st Place in the Myosin x Stellar accelerator
2) Draper Founder Residency - pressure-testing the company, not just the pitch
Around the same time, we were selected for the Draper University Founder Residency, where the focus shifted from messaging to company-building under pressure and fundraising constraints.
The value here wasn’t demo days or optics - it was proximity and the network effect:
rapid-fire feedback from founders and operators who’ve scaled through chaos
direct exposure to investor thinking around timing, risk, and durability
stress-testing Hoops as a business, not just a product
It reinforced something we already believed: strong infrastructure companies aren’t built by chasing momentum - they’re built by surviving friction and still shipping.
3) Meridian + industry events: the narrative got sharper under scrutiny
Meridian 2025 mattered because it exposed our story to serious ecosystem scrutiny -the kind that forces a company to mature quickly.
We pitched, took real questions, and left with stronger positioning:
Hoops is not “another dashboard”
Hoops is risk-aware market infrastructure + smart account automation + developer primitives
and we’re building it on a network where speed and cost actually make consumer-grade DeFi possible
Experiments that validated our product even more: Trustfall
Trustfall didn’t start as “let’s build a game.” It started with a more deliberate question:
Can we use the lessons of game theory to study real user behavior, strengthen our algorithms, test core product assumptions with near-zero friction, and uncover an entirely new market for Hoops?
What emerged was far more than an experiment. Trustfall became a parallel expression of the Hoops product - one that attracted a different type of user, generated high-signal behavioral data, and validated core mechanics long before mainnet risk was involved.

Screenshot of Trustfall by Hoops Finance in action
In 2025, we shipped:
Season 0 foundations - a playable Prisoner’s Dilemma with vault scores, reputation, and faction alignment
Real-time multiplayer - wallet-based identity, WebSockets, matchmaking, and server-authoritative timers
The Arbiter (CPU) - a persistent, memory-driven agent that models reputation over time and adapts to player behavior
None of this was ornamental. Every system mirrored a real Hoops primitive: identity, incentives, persistence, trust, and long-term outcomes.
The key insight was translation.
The same underlying product can be understood through multiple frameworks:
For DeFi-native users, Hoops is smart accounts and market insights.
For developers, it’s APIs, data, and infrastructure.
For a completely new audience, Trustfall turned Hoops into a game - one that let users experience risk, cooperation, and reputation instead of reading about them.
And it worked.
Trustfall drove strong engagement, repeat participation, and unusually high-quality feedback. More importantly, it gave us a safe, low-friction environment to:
observe real decision-making under incentives
stress-test reputation mechanics
refine how our algorithms respond to behavior, not theory
Trustfall became a live research surface - one that feeds directly into how we design onboarding, reputation, risk signaling, and automation for mainnet.
Different interface. Same system. Stronger product.
Adversity: Choosing durability over shortcuts
If 2025 taught us anything, it’s that financial infrastructure rarely fails from a single dramatic bug. It fails from accumulated compromises. Many small “we’ll fix it later” decisions that compound into fragility.
We made a different call.
Across the year, we consistently chose paths that were slower in the moment but meaningfully faster over the long run:
correctness-first data ingestion with full replayability
authentication systems designed to be auditable and resilient to credential-risk collapse
capacity-aware routing logic grounded in real liquidity, not paper arbitrage
system design that anticipates protocol changes, contract upgrades, and uncomfortable edge cases
This is what building mainnet-ready infrastructure with a small team actually looks like: fewer headlines, more compounding. The payoff isn’t hype, but trust earned quietly, one invariant at a time.
Mainnet preparation: what we can say
Our path to mainnet has been deliberate by design. The priority has never been speed for its own sake, but readiness that holds up under real usage.
Today, our preparation is anchored around four principles:
Security and correctness as non-negotiables
Operational resilience through deterministic ingestion, replays, and observability
Onboarding that reduces cognitive load without pushing risk onto users
Product flows that feel consumer-grade, not “crypto-native by default” (passkeys, wallet linking, identity)
We won’t commit to public dates here. The standard is simple: ship when it’s ready, and prove it through behavior, not timelines.
That said, the sequencing is clear:
Foundation rails (identity, wallets, authentication) → ✅ Complete
Durable market data and price truth → ✅ Complete
Programmable strategy surface (smart accounts, vault logic) → ⌛️ In progress
Partner integrations and mainnet-grade distribution channels → ⚙️ Actively in motion
This is not exploratory work anymore. It’s execution against a well-defined target state.
2026: Fundraising + Partnerships
Fundraising
In 2026, we expect to explore a Seed round - selectively. We’ll share more when it’s real. Until then, the focus stays where it belongs: product proof, reliability, and distribution leverage.
Partnerships
We’re also excited about a set of partnerships we’ve been quietly building to make Hoops more useful immediately, not someday:
integrations that surface our data and routing in more user touchpoints
builders looking for a reliable market layer they don’t have to second-guess
ecosystem collaborators who value transparency, safety, and long-term alignment
When these land, the signal will be obvious: more places where Hoops shows up, more volume and strategies flowing through the stack, and more developers choosing us as default infrastructure.
Closing: why we’re confident going into 2026
Hoops isn’t growing because we got lucky.
It’s growing because we built a loop:
ship real systems
publish proof
listen to users
harden the product
repeat

With a small team, we proved we can:
execute under constraints
withstand protocol changes and market volatility
turn experiments into product leverage
and keep building through adversity without losing the plot
If you’re a builder: we’re here, we’re shipping, and the platform is getting sharper.
If you’re an investor: 2025 is the year we proved we can turn ambition into infrastructure. 2026 is about making that infrastructure unavoidable.
Onward.
— Hoops Finance








