FAssets
Bring XRP into programmable finance
FAssets brings XRP into DeFi on Flare, with BTC next through the same native data, interoperability, and execution stack.
Bring XRP into programmable finance
FAssets brings XRP into DeFi on Flare, with BTC next through the same native data, interoperability, and execution stack.
What is the FAssets system
FAssets brings assets like XRP and BTC into DeFi on Flare and beyond.
With FAssets, assets that were not built for smart contracts can be used in programmable markets: trading, lending, vaults, staking, and cross-chain financial applications.
Flare provides the infrastructure around those assets: verified external-chain events through Flare Data Connector, price data through Flare Time Series Oracle, and a path toward richer cross-chain execution through Flare Smart Accounts and Flare Confidential Compute.
What is FXRP
FXRP is the first live FAsset: a 1:1 representation of XRP on Flare, designed to make XRP usable across EVM DeFi while remaining connected to XRPL as the native asset and settlement layer.
In the broader Flare architecture:
- XRPL is where XRP is issued and moved.
- Flare is where XRP becomes programmable.
- FAssets is the system that connects those roles.
That means XRP can be represented, deployed, and used across more complex financial workflows without requiring XRPL itself to become an EVM chain.
FXRP is live today. Future FAssets will extend the same model to other major non-smart-contract assets.
FXRP has already shown real adoption: within its first seven months, more than 155M FXRP had been minted, with most of that supply actively deployed across DeFi.
Mint FAssets on your preferred dApp
How it works
FAssets connects external-chain assets to Flare through verified transactions and protocol-defined minting and redemption rules.
The exact mechanics can evolve across protocol versions and supported assets, but the core pattern remains:
- A user initiates an action on the underlying chain: For FXRP, this begins with an XRP transaction on XRPL.
- Flare verifies the external-chain event: The Flare Data Connector proves that the relevant transaction occurred.
- The FAsset is minted on Flare: A corresponding asset, such as FXRP, is made available on Flare.
- The asset becomes usable in DeFi: Once the collateral is locked and the receipt of XRP is verified via the Flare Data Connector, the system mints the corresponding amount of FXRP and delivers it to the user on Songbird.
- The asset can be redeemed back: FAssets are designed to support redemption back to the underlying asset on its native network.
The system includes verification, minting controls, redemption mechanics, collateral where applicable, and emergency safeguards to support secure operation.
Why FAssets matter
Some of crypto’s largest assets have deep liquidity and large communities, but limited native programmability and composability. FAssets changes that.
With FAssets, assets like XRP can be used to:
Trade and provide liquidity
Use FAssets across Flare-based DEXs and liquidity venues.
Lend and borrow
Use assets like FXRP as collateral, borrow stablecoins and other tokens, or supply liquidity to lending markets.
Access vaults and strategies
Deploy FAssets into curated onchain strategies.
Power exchange-native XRPFi
FXRP is not only for users who bridge manually. With Flare Smart Accounts, wallets, custodians, and exchanges can integrate FXRP-powered products directly into their existing interfaces.
Start building with FAssets
Forge a DeFi hub for XRP, BTC, and DOGE with verifiable economic security.
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IAssetManager} from "@flarelabs/fasset/contracts/userInterfaces/IAssetManager.sol";
contract FAssetArbitrager {
IAssetManager internal assetManager;
IERC20 internal fAsset;
constructor(IAssetManager _assetManager) {
assetManager = _assetManager;
fAsset = _assetManager.fAsset();
}
function arbitrage(address _agentVault) external {
uint256 availableFAsset = fAsset.balanceOf(address(this));
(uint256 liquidatedFAsset, uint256 obtainedVault, uint256 obtainedNative) =
assetManager.liquidate(_agentVault, availableFAsset);
IERC20 agentVaultToken = assetManager.getAgentVaultCollateralToken(_agentVault);
swapToFAsset(agentVaultToken, liquidatedFAsset, obtainedVault, obtainedNative);
}
...
}
