What Is RheoFi Protocol? XRPL EVM DeFi Money Market

What Is RheoFi Protocol?

RheoFi Protocol is an algorithmic money-market protocol deployed on XRPL EVM Sidechain, derived from a hardened isolated-pool codebase. As of June 2026, XRPL EVM Sidechain DeFi TVL sits under $50M (DeFiLlama, June 2026), making RheoFi among the first structured lending primitives on the chain. The protocol uses isolated pools, a Jump Rate Model, and a three-tier oracle.

What Does "Algorithmic Money Market" Mean in Practice?

A money market protocol lets users deposit assets to earn yield and borrow other assets against collateral. The word "algorithmic" means interest rates adjust automatically based on utilization, no human sets rates per epoch.

RheoFi's Jump Rate Model keeps rates low when utilization is below 80% (the kink). Above that threshold, rates jump sharply toward 250% per year. This creates a market signal that rebalances supply and demand without admin intervention. (RheoFi Whitepaper v1.0, April 2026)

What Chain Does RheoFi Deploy On?

RheoFi deploys exclusively on XRPL EVM Sidechain. The chain reached mainnet on June 30, 2025, bringing full EVM compatibility to the XRP ecosystem. (Ripple Insights, June 2025)

Transaction finality lands in roughly 3-5 seconds. Gas costs average approximately $0.0002. XRP serves as the native gas token, and the underlying ledger carries a market cap of approximately $65B (CoinGecko, June 2026). Those economics change what "DeFi UX" means for end users, frequent rebalancing and liquidation bot operations become economically viable at a scale they aren't on Ethereum mainnet.

XRPL EVM chain mechanics

---

RheoFi vs Shared-Pool and Single-Market Lending: Architecture Comparison

Protocol architecture determines risk containment. Shared-liquidity money markets collectively hold over $18B in TVL across 15+ EVM chains as of June 2026 (DeFiLlama, June 2026), while single-market lending designs use per-asset silos of a different flavor. RheoFi takes the isolated-pool path, where each asset deploys its own Comptroller. Zero cross-pool contagion is the direct result.

Why Isolated Pools Matter More Than They Sound

Shared-liquidity protocols allow a price manipulation in one asset to cascade into liquidity crises in unrelated markets. The isolated-pool model eliminates that attack surface by design. (RheoFi Whitepaper v1.0, April 2026)

RheoFi inherits this architecture directly. Each market's Comptroller is its own contract. Governance sets collateral factors per pool, ranging from 40% to 90% depending on asset risk profiles.

rTokens vs Rebasing Receipts: Why the Distinction Matters for Integrators

Rebasing receipt tokens grow your wallet balance in real time as interest accrues. RheoFi's rTokens hold a fixed quantity in your wallet. Value accrues through the exchange rate, which the protocol updates each block. This distinction affects how you account for positions in downstream contracts, vaults, and front-end displays.

rToken exchange rate mechanics

---

Why RheoFi Matters for XRPL EVM in 2026?

XRPL EVM Sidechain launched mainnet June 30, 2025 (Ripple Insights, June 2025), yet one year later ecosystem DeFi TVL sits under $50M (DeFiLlama, June 2026) against XRP's ~$65B market cap (CoinGecko, June 2026). RheoFi positions itself as the base lending layer for XRP capital holders seeking on-chain yield.

Capital Efficiency on a Low-Fee Chain

On Ethereum mainnet, gas costs often exceed the yield benefit of small positions. At $0.0002 per transaction on XRPL EVM, a $100 deposit earns net yield from day one. That economics shift opens DeFi participation to a broader user tier.

Frequent interest accrual, position management, and automated liquidation bots all become viable at that fee level. RheoFi is specifically designed to run in that environment, not retrofitted from a higher-fee chain.

First-Mover Dynamics in a Sub-$50M Ecosystem

RheoFi enters as the first algorithmic money-market protocol on XRPL EVM, a DeFi ecosystem under $50M in total TVL with limited competing lending protocols at launch. Early lending primitives on new EVM chains have historically established dominant market share by becoming the base layer other protocols build on. The pattern played out repeatedly across new L1 and L2 chains in 2021-2022.

Whether that pattern repeats depends on audit completion, liquidity bootstrapping, and integrator adoption. But the structural opportunity is real.

---

How Does RheoFi Protocol Work?

RheoFi's core mechanism follows the cToken model that isolated-pool protocols extended with per-market Comptrollers and improved risk controls. DeFi lending protocols collectively hold $36.2B in TVL as of June 2026 (DeFiLlama, June 2026). RheoFi adapts that proven model for XRPL EVM's specific throughput and fee characteristics.

The Exchange Rate Formula

When you deposit assets, you receive rTokens. The quantity you receive depends on the current exchange rate. That rate grows over time as interest accumulates:

exchangeRate = (totalCash + totalBorrows + badDebt - totalReserves) × 1e18 / totalSupply

Borrow interest accrues using a stored index, not per-account loops. The complexity is O(1) per account interaction, not O(n) across all borrowers. That distinction matters at scale, it keeps gas costs predictable regardless of protocol size. (RheoFi Whitepaper v1.0, April 2026)

The Jump Rate Model in Detail

The Jump Rate Model controls the cost of borrowing at every utilization point:

• Base rate: 0% per year at 0% utilization
• Slope below kink: 10% per year, reaching 8% APR at 80% utilization
• Kink: 80% utilization, the inflection point
• Jump multiplier: 250% per year above the kink, making capital expensive when the pool is nearly drained

The Two-Kinks variant adds a second inflection point for assets that need finer rate control at intermediate utilization levels. Governance can configure parameters per pool without touching the base model contract.

How Liquidations Work

When a borrower's collateral falls below the required threshold, any address can trigger a partial liquidation. The close factor, set between 5% and 90% by governance, determines what fraction of the position can be closed in one call. A governance-configured percentage of the seized collateral routes to the Risk Fund. The remainder goes to the liquidator as incentive. (RheoFi Whitepaper v1.0, April 2026)

liquidation mechanics deep-dive

---

Core Contract Interfaces: RheoFi Integration Surface

Smart contract security vulnerabilities drove $2.62B in DeFi exploit losses in 2022, a single-year record (Immunefi, January 2025). RheoFi's integration surface is deliberately narrow, four primary interfaces cover 95% of builder use cases. The upstream isolated-pool interface conventions are well-documented and carry the weight of 15 independent audits. (RheoFi Whitepaper v1.0, April 2026)

Supplying Assets: The Mint Flow

Supplying assets requires two transactions: an ERC-20 approval and a mint call on the rToken contract.

// Compatible with Solidity ^0.8.x | SPDX-License-Identifier: MIT
// Supply USDC to the rUSDC market
IERC20(usdc).approve(address(rUSDC), supplyAmount);
uint mintError = IRToken(rUSDC).mint(supplyAmount);
require(mintError == 0, "mint failed"); // upstream ABI returns uint error code, 0 = success

// Receive rUSDC tokens proportional to the current exchange rate
uint256 rTokenBalance = IRToken(rUSDC).balanceOf(msg.sender);

The rToken balance stays fixed. Value grows as the exchange rate climbs. Redeeming calls redeem(rTokenAmount) or redeemUnderlying(underlyingAmount) depending on whether you want to specify the output or input side of the redemption.

Borrowing: The Comptroller Gate

Borrowing flows through the Comptroller before touching the rToken. Your contract must call enterMarkets to register collateral, then call borrow on the target rToken market.

// Compatible with Solidity ^0.8.x | SPDX-License-Identifier: MIT
// Enter the rUSDC market to use rUSDC as collateral
address[] memory markets = new address[](1);
markets[0] = address(rUSDC);
uint[] memory errs = IComptroller(comptroller).enterMarkets(markets);
require(errs[0] == 0, "enterMarkets failed"); // Always validate return codes

// Borrow XRP against USDC collateral
uint borrowError = IRToken(rXRP).borrow(borrowAmount);
require(borrowError == 0, "borrow failed"); // Non-zero = Comptroller rejection

The Comptroller checks account liquidity before allowing the borrow. If collateral value minus existing borrows would fall below zero after the new borrow, the transaction reverts.

Checking Account Health

Monitoring position health requires a single read call:

(uint err, uint liquidity, uint shortfall) = IComptroller(comptroller).getAccountLiquidity(account);

A non-zero shortfall means the account is eligible for liquidation. Liquidation bots should poll this function or index the BorrowEvent and LiquidateBorrowEvent to maintain an efficient watch list.

full integration walkthrough with test harness

---

Build on the First XRPL EVM Money Market

RheoFi deploys cToken-compatible interfaces on XRPL EVM Sidechain, so any Solidity team familiar with isolated-pool money markets can integrate without relearning the interaction model.

Testnet is live. Connect your contracts and test supply, borrow, and liquidation flows against XRPL EVM's sub-cent fee environment today.

Backed by 15 inherited audit engagements (PeckShield, Hacken, CertiK, Quantstamp, FairyProof, Pessimistic). RheoFi-specific audit in progress before mainnet.

Launch App → | Read the Docs →

---

How to Integrate RheoFi Into Your Protocol?

DeFi lending protocols collectively held $36.2B in TVL as of June 2026, with cToken-compatible interfaces powering a plurality of that stack (DeFiLlama, June 2026). RheoFi implements the same IRToken and IComptroller interfaces on XRPL EVM Sidechain, meaning any Solidity developer familiar with cToken-style money markets can integrate without relearning the interaction model.

Step-by-Step Integration Guide

The integration sequence below reflects the common path taken by teams onboarding to isolated-pool money markets. Steps 1-4 handle read/write access. Steps 5-7 handle production-readiness.

Step 1: Connect to XRPL EVM Sidechain. Configure your RPC endpoint to the XRPL EVM Sidechain network using public endpoints from xrplevm.org or a dedicated node. Chain ID and RPC details are available in the RheoFi docs.

Step 2: Obtain deployed contract addresses. Pull the live rToken addresses, Comptroller proxy, oracle proxy, and Risk Fund address from docs.rheofi.com. Use proxy addresses, never hardcode implementation addresses.

Step 3: Import interface ABIs. Clone the rheofi-contracts repository and import IRToken.sol and IComptroller.sol into your integration contracts.

Step 4: Approve and supply collateral. Call IERC20.approve on the underlying asset, then call IRToken.mint. Confirm the returned rToken balance using balanceOf.

Step 5: Enter markets and borrow. Call IComptroller.enterMarkets with your collateral rToken addresses. Then call IRToken.borrow on the asset market you want to draw from. Always check the returned error code, a non-zero value signals a Comptroller rejection.

Step 6: Monitor health factor continuously. Poll IComptroller.getAccountLiquidity for managed accounts. Build alerting around the shortfall return value.

Step 7: Implement or connect a liquidation bot. When shortfall is non-zero, call IRToken.liquidateBorrow with the borrower address, repay amount, and collateral rToken to seize. Set repay amount below closeFactor * totalBorrow to stay within governance-set limits.

complete Solidity test suite and deployment scripts

---

Attack Surface Analysis: Known Vectors and Mitigations

DeFi protocol exploits dropped from $2.62B in 2022 to $680M in 2025, with oracle manipulation and reentrancy remaining among the costliest attack classes (Immunefi, January 2025). RheoFi addresses both vectors through its three-tier oracle design and inherited reentrancy guards, backed by 15 documented audit engagements. (RheoFi Whitepaper v1.0, April 2026)

Oracle Manipulation: The Three-Tier Defense

Single-oracle protocols face a well-understood attack: if you can move the price on the oracle's reference source, you can drain the lending pool. RheoFi's Resilient Oracle cross-validates the MAIN price (Chainlink) against a PIVOT source before accepting any price. BoundValidator enforces a maximum permitted deviation between sources.

If the MAIN oracle returns a price outside the accepted deviation from the PIVOT, the system uses the FALLBACK. If FALLBACK also fails validation, the protocol pauses that market rather than accepting a suspect price. That behavior contains the blast radius of an oracle incident to one pool, not the entire protocol.

Isolated Pool Contagion Risk

Traditional shared-pool protocols suffer from contagion: a bad debt event in one asset forces socialized losses across all depositors. RheoFi's per-pool Comptroller means losses in one market stay in that market. The Risk Fund absorbs bad debt from each pool independently. Shortfall auctions clear residual bad debt without touching other pools.

Reentrancy and Flash Loan Vectors

The upstream isolated-pool codebase carries reentrancy guards across all state-changing functions. The isolated-pool design further limits flash loan attack vectors, an attacker manipulating price within a single block would need to overcome the BoundValidator check before any price-sensitive action resolves. The 5-90% close factor also limits how much an attacker can extract in a single liquidation call. (RheoFi Whitepaper v1.0, April 2026)

Governance Risk and Timelock Mitigations

ACM/Timelock governance means no parameter change, collateral factor, close factor, rate model, executes immediately. Every governance action queues in the Timelock contract. Integrators and users get a window to review and exit before changes take effect. No DAO token also means no governance token price attack can push through malicious proposals.

governance architecture detail

---

On-Chain Compliance Architecture: Access Control and Governance

MiCA Regulation 2023/1114, effective across the EU's 450M+ person market, defines crypto-asset service providers under Article 3(1), a classification non-custodial on-chain protocols may avoid (EUR-Lex, June 2023). RheoFi's ACM/Timelock with no tradeable governance token removes both token-classification risk and the governance attack surface (RheoFi Whitepaper v1.0, April 2026).

MiCA applies specifically to EU/EEA-based operators; builders in other jurisdictions face different regulatory frameworks and should obtain jurisdiction-specific legal counsel before determining compliance posture.

Access Control Manager: Role-Based Permissions

The Access Control Manager (ACM) defines which addresses hold which roles. Protocol admin functions, pausing a market, updating oracle configuration, changing rate model parameters, all route through ACM checks. No single private key can execute privileged functions without holding the correct ACM role.

This is a meaningful security property. Compromising one team member's key doesn't grant protocol control unless that address also holds the relevant ACM role.

Timelock: The Enforcement Layer

Timelock queues all parameter changes before execution. The delay window gives the community, auditors, and integrators time to review any proposed change. If a change looks malicious or incorrect, integrators can update their integrations or notify the team before it takes effect.

The combination of ACM + Timelock without a DAO token is a deliberate design choice. Token-weighted governance creates a governance attack surface: accumulate enough token supply and you can push through any proposal. ACM/Timelock without a tradeable governance token removes that vector entirely during the protocol's early phase.

Upgrade Paths for Integrators

Because RheoFi uses proxy patterns on its core contracts, integrators should subscribe to on-chain events from the proxy admin contract. Any upgrade emits an event before execution. Build monitoring around those events so your integration can react if a new implementation changes interface signatures.

---

Conclusion: Why RheoFi Is the Right Lending Primitive for XRPL EVM

XRPL EVM DeFi remains under $50M in TVL (DeFiLlama, June 2026) against XRP's ~$65B market cap native asset (CoinGecko, June 2026). RheoFi Protocol brings a proven, 15-audit-backed lending architecture to fill that gap on XRPL EVM Sidechain. The structural opportunity is documented.

Three Reasons RheoFi Fits XRPL EVM

Three things make RheoFi the sensible lending primitive for XRPL EVM right now. First, the isolated-pool model contains risk better than shared-liquidity alternatives. Second, the three-tier Resilient Oracle addresses the most common DeFi exploit vector before mainnet. Third, ACM/Timelock governance keeps upgrade authority transparent without creating a governance token attack surface.

The protocol is pre-mainnet, with testnet live and a RheoFi-specific audit in progress. That timing creates a window for early integrators to build and test against a stable interface before mainnet liquidity arrives.

Builders interested in deploying on XRPL EVM with a structured risk model, documented audit history, and an O(1) interest accrual architecture have a concrete option in RheoFi. The testnet is the right place to start. start building