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

Keep Reading

No posts found