fl Tokens

fl tokens are Flayer's yield-bearing wrappers around blue chip assets. Each fl token wraps its base asset 1:1: deposit the base asset and receive the same amount of the fl token, redeem at any time for the same amount back. There are currently two:

Flayer products (like Flaunch (opens in a new tab)) use fl tokens as the paired side of their pools. While that liquidity sits in the protocol, the idle reserves are put to work in a lending strategy (currently Aave v3), and the yield flows to the protocol. This is the rationale for fl tokens: revenue shifts to passive yield on reserves, which allows Flayer products to keep their fees low.

How reserves work

An fl token contract holds its reserves in two places:

• Raw balance: a portion of the base asset (10% of supply by default) is kept in the token contract itself so that everyday withdrawals are instant.
• Strategy balance: everything above that threshold is deposited into a yield strategy. Withdrawals that exceed the raw balance automatically pull the difference back out of the strategy in the same transaction.

The token is always fully backed: totalSupply is exactly the amount of base asset users have deposited, and the underlying balance is the raw balance plus the strategy balance. Only the surplus above supply is ever treated as yield:

function yieldAccumulated() public view returns (uint) {
    uint underlying = underlyingBalance(); // raw balance + strategy balance
    uint supply = totalSupply();           // total user deposits
    return underlying > supply ? underlying - supply : 0;
}

harvest() skims only that surplus to the protocol's yield receiver. User deposits are never harvested, so 1 fl token is always redeemable for 1 of the base asset.

Safety

• 1:1 backing is enforced by accounting. Yield is defined as underlying minus supply, clamped at zero. There is no mechanism to pay out more than the surplus.
• Immutable contracts. The fl tokens are plain, non-upgradeable contracts with no proxy. The deposit, withdraw, and harvest logic cannot be changed.
• Reentrancy guarded. deposit, withdraw, rebalance, and harvest are all protected by a reentrancy guard, closing the classic wrapped-native-token attack surface.
• Deposits never depend on the strategy. If the strategy is unavailable (for example Aave is paused or a supply cap is hit), deposits still succeed and the excess simply stays raw until a later permissionless rebalance() moves it.
• Strategies can only be swapped when empty. changeStrategy reverts if the current strategy still holds any balance, so funds cannot be orphaned by a strategy change.
• Limited owner powers. The owner (the protocol multisig) can tune the rebalance threshold, update the yield receiver, and swap the strategy once it is empty. It cannot mint, cannot change the redemption rate, and cannot upgrade the code.

The contracts have been audited, and the verified source code can be read on each chain's block explorer at the addresses below.

Using fl tokens

Wrapping and unwrapping is a single call:

interface IFLETH {
    /// Send ETH as msg.value and/or approved WETH; receive flETH 1:1
    function deposit(uint wethAmount) external payable;
 
    /// Burn flETH; receive ETH 1:1
    function withdraw(uint amount) external;
}
 
interface IFLUSDC {
    /// Pull approved USDC; receive flUSDC 1:1
    function deposit(uint amount) external;
 
    /// Burn flUSDC; receive USDC 1:1
    function withdraw(uint amount) external;
}

Deployment addresses

flETH

flUSDC