Autonomous On-Chain
Yield Management

WealthVille is an autonomous, non-custodial yield-management platform built on Solana.

It continuously discovers, scores, and allocates capital into the best risk-adjusted yield opportunities across decentralized exchanges, liquid-staking protocols, and delta-neutral hedging venues — governed by transparent, programmable logic and enforced by hard on-chain and off-chain safety gates.

A depositor places funds into a non-custodial vault. From that moment, WealthVille’s engine does the work a sophisticated DeFi operator would do by hand, around the clock:

• Discovers new and existing pools across major Solana DEXs.
• Scores every pool on a risk-adjusted basis — liquidity depth, volatility, exit impact, and trap-detection signals.
• Allocates capital across concentrated-liquidity LP positions, Jito liquid staking for idle SOL, and optional Jupiter perpetual hedges for delta control.
• Rebalances and protects positions continuously, with capital-protection exits, cooldowns, no-trade bands, and circuit breakers.
• Reports realized and unrealized PnL with self-healing cost-basis accounting.

The system runs in supervised production with real capital across multiple vaults. WealthVille’s differentiator is not a single clever strategy — it is the full operational stack: a data pipeline that keeps opportunity data fresh, a scoring engine that is honest about risk, a unified allocation planner that makes one consolidated decision per cycle, and a safety architecture designed around the failure modes that actually occur in live DeFi automation.

DeFi yields are real, but capturing them well is a full-time, expert job:

• Opportunity data decays fast. APRs, TVL, and volume shift hour to hour. A pool that looked attractive yesterday can be a trap today. Most dashboards show stale or naively-computed numbers.
• Concentrated liquidity is hard. Modern DEXs (Meteora DLMM, Orca Whirlpools, Raydium CLMM) are far more capital-efficient — but only if your range is set correctly and maintained as price moves.
• Idle capital is wasted. SOL waiting to be deployed earns nothing unless it is staked; naive staking strands capital you later need for an LP entry.
• Directional risk is unmanaged. LP positions carry token-price exposure. Without a hedge, an LP’s “yield” can be entirely erased by the underlying asset’s drawdown.
• Automation fails in ways humans don’t anticipate. Churn loops, flip-flop rebalancing, phantom positions, and cost-basis drift are the recurring failure modes of naive DeFi bots.

The market does not lack yield. It lacks a trustworthy, automated operator that captures yield and survives the edge cases.

WealthVille treats yield management as an end-to-end operational system, not a strategy. Five principles define it:

WealthVille is composed of five cooperating layers:

1. 1Data Pipeline — discovers, collects, and enriches pool data across DEXs and chains.
2. 2Scoring Engine — turns raw signals into risk-adjusted pool verdicts.
3. 3Allocation Planner — combines programmable logic, optional AI, and allocation weights into one consolidated capital plan.
4. 4Execution Layer — translates the plan into on-chain transactions and reconciles the result.
5. 5Vault Program — the non-custodial Solana smart contract that holds user funds and enforces on-chain permissions.

A content/SEO layer sits on top, publishing the same scored data as public pool pages and educational content.

The pipeline answers one question continuously: what is true, right now, about every pool worth knowing about?

Discovery

WealthVille enumerates pools across major Solana DEXs — Raydium (AMM & CLMM), Orca (including Whirlpools), and Meteora (including DLMM) — plus liquid-staking and lending venues, so fresh opportunities become visible to scoring and whitelisting.

Collection

For each pool, the collector fetches TVL, APR/fees, volume, and structural metadata directly from DEX APIs and on-chain accounts — hardened against real-world quirks such as using the correct protocol-version endpoint so TVL is not inflated, and chunking batch requests to respect per-request result caps.

Enrichment

Raw metrics are converted into normalized signals with consistent units (APR-as-fraction vs. percent is a notorious footgun the pipeline normalizes explicitly), adding liquidity-depth and exit-impact estimates, volatility measures, and the derived risk terms the scorer consumes.

Tiered cadence (T0–T6)

Pools are assigned to staleness tiers. The most important — including every pool a live vault is allowed to touch (T0) — are refreshed most aggressively; the long tail refreshes on a slower rotation. A staleness-ordered scheduler ensures no pool starves.

Data-quality gates

When inputs for a pool are missing or self-inconsistent, the pipeline marks the data incomplete — and downstream, incomplete data blocks vault execution on that pool rather than letting the engine act on a guess.

The scoring engine converts signals into a risk-adjusted verdict per pool. Today the model is fully heuristic and transparent — every term is inspectable — with a supervised machine-learning model (gradient-boosted trees on realized signal outcomes) planned to run shadow-first alongside the heuristic before it ever influences capital.

Scoring rewards genuine, sustainable yield and penalizes the things that destroy it:

• Yield quality — fee APR and its sustainability, not just headline APR.
• Liquidity & exit impact — a pool you cannot exit without slippage is discounted, with correct orientation for stable-vs-token pools and across DEX types.
• Volatility & stability — coefficient-of-variation and volume behavior.
• Trap detection — explicit risk terms for exit-depth collapse, abnormal volume, TVL crashes, and volatility dry-ups that pull obviously-dangerous pools sharply down even when nominal APR looks enormous.

The output is written to a reconciled verdict store the Allocation Planner consumes, so the decision layer always reads one coherent view of pool quality. The scorer is not biased toward any single DEX.

A vault is a non-custodial Solana program account. Users deposit; the protocol manages; the user retains ownership and the right to withdraw. Vaults are the unit of autonomy — each has its own configuration, risk profile, and logic.

What a vault can do with capital:

• Provide concentrated liquidity on Meteora DLMM, Orca Whirlpools, and Raydium/Orca CLMM pools, with ranges sized from a configurable range-percentage and the pool’s tick/bin geometry.
• Stake idle SOL with Jito (JitoSOL) so waiting capital still earns — with unstake-to-fund logic so staking never strands capital needed for an LP entry.
• Hold delta-neutral hedges via Jupiter perpetuals to offset the directional token exposure of LP positions (opt-in, hard-gated per vault).

Each vault carries an aggressiveness profile — conservative, balanced, or aggressive — that tunes over-allocation thresholds, the weight of APR in ranking, and rotation behavior. A vault only ever touches pools on its on-chain whitelist (allowed-pool PDAs), and only takes actions its feature flags enable. Each tick reads the vault’s real on-chain state, the latest scored data, and the vault’s logic, then proposes and (if enabled) executes a consolidated plan.

Earlier generations of DeFi automation use a greedy loop: look at each pool, decide in isolation, act, repeat. That design is the root of most pathological behavior — it over-invests, fights its own previous actions, and churns.

WealthVille replaced the greedy loop with a unified Allocation Planner: a single decision layer that ranks the whole opportunity set and produces one consolidated plan across all capital uses — LP, Jito staking, and perp hedging — per tick.

1. 1Programmable logic — the vault’s rules: fund-distribution weights and method, reserve targets for Jito and perp, entry/exit/rotation conditions.
2. 2Optional AI — when enabled per vault, an LLM-assisted layer refines action parameters within hard-coded bounds. It is off by default and never escapes the safety envelope.
3. 3Allocation weights & ranking — the risk-adjusted scores combined with the vault’s aggressiveness profile.

The output is a deduplicated, gated plan: each (pool, action) appears once, and each action clears minimum-net-benefit and safety checks before admission. The result deploys capital decisively, rotates only when the APR gap justifies the cost, and does not thrash.

The execution layer turns an approved plan into on-chain reality, then reconciles what actually happened against what was intended.

• LP execution across DLMM (bin-based), CLMM, and Whirlpool (including v2 token accounts), sizing deposits to the intended range band and pinning to existing positions when adding.
• Jito stake/unstake, with on-chain balance clamps so a stake request can never exceed native SOL, and graceful handling of missing wrapped-SOL accounts.
• Jupiter perp hedging, delegated to a dedicated hedge manager, hard-gated on the vault’s perp-enabled flag, with force-sync escalation to recover from on-chain hedge-state deadlocks.
• Fee harvesting on a configurable cadence, sweeping claimable fees the per-tick logic would otherwise be blind to, and booking them into realized PnL.
• Reconciliation & self-healing — the executor auto-burns and retries empty “shell” position NFTs from failed transactions, and cost basis self-heals against on-chain reality.

Real position state is read from on-chain reality — decoded position NFTs and protocol metrics — not solely from a database, because databases drift and on-chain truth does not.

Safety is the part of WealthVille with the most engineering invested in it, because in live automation the edge cases are the product. The engine wraps every plan in a fixed set of gates that cannot be disabled by per-vault logic:

• Capital-protection exits — exit rules driven by realized trailing APR that pull capital out of structurally deteriorated pools.
• No-trade bands & hysteresis — symmetric bands that prevent re-adjusting over trivial moves, eliminating flip-flop churn.
• Cooldowns — enforced minimum intervals, correctly keyed by transaction type, so the system cannot re-act on the same lever every minute.
• Circuit breakers — repeated genuine failures halt a vault until reviewed; no-op ticks are not counted as failures.
• Slippage & size caps — bounds on per-action slippage and sizing, including liquidity-aware caps so the system never oversizes into thin pools.
• Re-entry quarantine — after an exit, a pool is quarantined from immediate re-investment to break EXIT→reinvest loops.
• Data-quality gates — incomplete or inconsistent pool data blocks execution on that pool.

Each gate corresponds to a failure mode observed and fixed in live operation. The safety architecture is, in a real sense, the distilled experience of running real capital through real DeFi.

Vault behavior is programmable through a rule-builder DSL. Each vault has its own logic definition describing how it distributes funds, what reserves it keeps for staking and hedging, and the conditions under which it enters, exits, rotates, stakes, or hedges.

• Fund distribution — configurable weights and method for splitting capital across ranked pools, with Jito and perp reserve targets folded into the same plan.
• Conditions & actions — Jito staking bands, perp-hedge triggers, rotation thresholds, and collection cadence are all expressible.
• Global safety gates — editable platform-wide gates that wrap every vault’s logic, regardless of its custom rules.
• Observability — every tick emits a logic trace, so an operator can see exactly why a vault did (or did not) act.

The default logic is a well-tested standard policy; advanced operators can author custom logic without redeploying code. The engine always wraps custom logic in the fixed safety gates, so programmability never compromises safety.

WealthVille accounts PnL from on-chain reality, and is deliberately conservative about it.

• Realized PnL is booked from actual fee harvests and position exits, with cost basis tracked per position and self-healed against on-chain state to eliminate phantom gains or losses.
• Unrealized PnL is derived from NAV deltas, with care taken on dust-sized balances where price noise dominates.
• A consolidated PnL view spans all three capital systems (LP, staking, hedging) and both “dry” (simulated) and “wet” (live) modes.
• Per-user accounting — deposits are recorded with correct decimals and pricing, and share accounting is verified consistent.

The same data that drives decisions drives reporting; there is no separate “marketing” number.

Cross-chain data

Beyond Solana, WealthVille ingests EVM-chain yield data (via aggregated sources) into the same pipeline and scorer, with chain context threaded through the shared scoring and reconciliation code. EVM coverage is informational — surfaced for research and content — and is isolated from the execution path; the product does not execute on EVM chains today.

Content & SEO

The scored data is published as public-facing pool pages and educational content — per-pool pages, a learning hub, “best pools” rankings, and cross-chain yield comparisons — with structured data, canonical domains, and sitemaps. This layer is both a user-acquisition channel and a transparency surface: the same scoring the vaults rely on is visible to anyone.

WealthVille is secure by construction: trust comes from design, not from promises.

• Non-custodial. User funds are held in on-chain vault accounts. The protocol operates within on-chain permissions; it does not take custody. Your keys, your coins.
• On-chain permissioning. A vault can only touch pools explicitly whitelisted via allowed-pool PDAs. Feature flags gate which actions are even possible.
• Supervised autonomy. Live vaults run with global dry-run and per-vault autonomy controls; high-impact recovery actions are gated behind operator review. The system is designed to degrade safely — when in doubt, it does nothing rather than something harmful.
• Defense against its own failure modes. The engine is hardened against the specific ways DeFi automation goes wrong: churn, flip-flop, phantom positions, cost-basis drift, and alert storms.

• Scoring → ML. Ship the supervised gradient-boosted scoring model in shadow mode; promote to live influence only after it demonstrably beats the heuristic.
• Allocation Planner Phase 2. Fold perpetual hedging fully into the unified planner and retire the legacy action-plan builder.
• Pool discovery. Keep the opportunity universe expanding automatically.
• Lending integration. Bring Kamino (and similar) lending venues into the capital plan.
• Broader vault rollout. Graduate from supervised multi-vault production to broader availability.
• Cross-chain execution. Evaluate extending execution (not just data) to EVM venues.

DLMM

Meteora’s Dynamic Liquidity Market Maker; concentrated liquidity in discrete bins.

CLMM

Concentrated Liquidity Market Maker (e.g. Raydium); concentrated liquidity over tick ranges.

Whirlpool

Orca’s concentrated-liquidity pool design.

JitoSOL

Jito’s liquid-staking token; staking SOL yields JitoSOL while remaining liquid.

Perp / perpetual

A perpetual futures position; used here (via Jupiter) to hedge LP token exposure toward delta-neutral.

Tick (vault)

One cycle of the vault management loop.

PDA

Program Derived Address; deterministic on-chain account used for permissions such as allowed-pool whitelisting.

Verdict

The scoring engine’s risk-adjusted assessment of a pool.

Dry / wet mode

Simulated vs. live (real-capital) execution.

NAV

Net asset value of a vault.

This document is for informational purposes only. It is not investment advice, financial advice, or an offer or solicitation to buy or sell any asset or security. DeFi involves substantial risk, including smart-contract risk, market risk, impermanent loss, and total loss of capital. Past or simulated performance does not guarantee future results. Forward-looking statements (including any token-related discussion) are subject to change and are not commitments. Consult your own legal, tax, and financial advisors.