Minting and Redeeming

Overview

Folios support permissionless minting and redemption:

Minting: Deposit basket assets to receive Folio shares
Redeeming: Burn Folio shares to receive basket assets

Both operations are proportional to the current basket composition and include fee mechanisms.

Minting and redemption are disabled if the Folio is deprecated. Use folio.isDeprecated() to check status.

Total Supply

The total supply includes:

Circulating shares (held by users)
Pending DAO fee shares (not yet distributed)
Pending fee recipient shares (not yet distributed)

uint256 totalShares = folio.totalSupply();
// Includes all pending fees

Asset Composition

Shares represent proportional ownership of all basket assets:

(address[] memory assets, uint256[] memory amounts) = folio.totalAssets();

// Example output:
// assets = [USDC, WETH, DAI]
// amounts = [1,000,000e6, 100e18, 500,000e18]

Asset composition may be unreliable during trusted fill execution. Check folio.stateChangeActive() before relying on asset data.

Minting Shares

Minting requires depositing all basket assets proportionally.

Query Required Assets

Calculate how many tokens you need for a desired share amount:

uint256 desiredShares = 100e18; // Want 100 shares

(address[] memory assets, uint256[] memory amounts) = folio.toAssets(
    desiredShares,
    Math.Rounding.Ceil // Round up to ensure sufficient amounts
);

// amounts = [USDC: 1000e6, WETH: 1e18, DAI: 1000e18]

Always use Math.Rounding.Ceil when calculating required deposits to avoid “insufficient amount” errors.

Calculate Fees

Understand the fee structure:

uint256 mintFee = folio.mintFee(); // e.g., 0.01e18 = 1%

// Shares received = desiredShares * (1 - mintFee) * (1 - daoSplit)
// Remaining goes to: DAO fee recipient + Folio fee recipients

Fee Distribution:

DAO takes minimum 15bps from all fees
Remaining goes to fee recipients (if configured)
If no fee recipients, DAO gets everything

Approve Token Transfers

Grant allowances for all basket assets:

for (uint256 i = 0; i < assets.length; i++) {
    IERC20(assets[i]).approve(address(folio), amounts[i]);
}

You can also use permit() for gasless approvals if tokens support ERC-2612.

Execute Mint

uint256 minSharesOut = 99e18; // Minimum shares after fees (slippage protection)

(address[] memory returnedAssets, uint256[] memory returnedAmounts) = folio.mint(
    desiredShares,
    msg.sender,      // Recipient of shares
    minSharesOut     // Revert if you receive less than this
);

// You now have shares in your wallet
uint256 yourBalance = folio.balanceOf(msg.sender);

After minting:

Your share balance increased
Your token balances decreased by returnedAmounts
Pending fee shares increased (distributed later)

Set Slippage Protection (Optional)

Use allowances to limit token spend in case of state changes:

// Instead of approving exact amounts, approve maximum acceptable amounts
uint256 maxUSDC = amounts[0] * 1.01e18 / 1e18; // 1% slippage
IERC20(usdc).approve(address(folio), maxUSDC);

Redeeming Shares

Redemption burns shares and returns proportional assets.

Calculate Redemption Output

uint256 sharesToRedeem = 50e18; // Redeem 50 shares

(address[] memory assets, uint256[] memory amounts) = folio.toAssets(
    sharesToRedeem,
    Math.Rounding.Floor // Round down (you receive slightly less)
);

// amounts = [USDC: 500e6, WETH: 0.5e18, DAI: 500e18]

Set Minimum Amounts

Protect against unfavorable state changes:

// Set minimum acceptable amounts (99% of expected)
uint256[] memory minAmountsOut = new uint256[](assets.length);
for (uint256 i = 0; i < assets.length; i++) {
    minAmountsOut[i] = amounts[i] * 99 / 100;
}

Execute Redemption

uint256[] memory actualAmounts = folio.redeem(
    sharesToRedeem,
    msg.sender,      // Recipient of assets
    assets,          // Must match basket exactly
    minAmountsOut    // Minimum amounts to receive
);

// You now have assets in your wallet
// Shares were burned from your balance

The assets parameter must match the current basket exactly (same order, same tokens). Otherwise, the transaction will revert.

Fee Distribution

Fees accumulate as pending shares and are distributed separately.

Manual Distribution

// Anyone can call this to distribute accumulated fees
folio.distributeFees();

This will:

Calculate all pending fee shares from TVL fees and mint fees
Mint shares to fee recipients according to their portions
Mint remaining shares to DAO fee recipient
Reset pending fee counters

Automatic Distribution

Fees are automatically distributed (via poke()) before:

Minting
Redemption
Fee configuration changes
Any state-changing operation

// Happens automatically, but can be called directly:
folio.poke();

The poke() function updates pending fees based on time elapsed since the last update (in full days only).

Fee Types

TVL Fee (Time-Based)

Annual demurrage fee on assets under management

uint256 tvlFee = folio.tvlFee(); // D18{1/s} fee per second

// Convert to annual percentage:
// annualFee = tvlFee * 365 days / 1e18
// Example: 317097919837645 per second ≈ 1% annual

Calculation:

Accrues every full day (24-hour periods)
Causes supply inflation (new shares minted to fee recipients)
Max 10% annually

Mint Fee (One-Time)

Percentage fee charged on minting

uint256 mintFee = folio.mintFee(); // D18{1} e.g., 0.01e18 = 1%

// On a 100 share mint with 1% fee:
// - User receives: ~99 shares
// - Fees: ~1 share (split between DAO and fee recipients)

Characteristics:

One-time charge when minting
Does NOT cause supply inflation (taken from minted shares)
Max 5%

Folio Self Fee

Fraction of fee-recipient shares that are burned

uint256 folioFeeForSelf = folio.folioFeeForSelf(); // D18{1}

// Example: 0.1e18 = 10%
// Of the fee recipient shares, 10% are burned instead of minted

This creates deflationary pressure on supply.

Advanced Minting Strategies

Batch Minting for Multiple Users

contract BatchMinter {
    function mintForUsers(
        Folio folio,
        address[] memory recipients,
        uint256[] memory shares
    ) external {
        for (uint256 i = 0; i < recipients.length; i++) {
            // Calculate required assets
            (address[] memory assets, uint256[] memory amounts) = folio.toAssets(
                shares[i],
                Math.Rounding.Ceil
            );

            // Transfer assets from users to this contract
            for (uint256 j = 0; j < assets.length; j++) {
                IERC20(assets[j]).transferFrom(recipients[i], address(this), amounts[j]);
                IERC20(assets[j]).approve(address(folio), amounts[j]);
            }

            // Mint to recipient
            folio.mint(shares[i], recipients[i], shares[i] * 99 / 100);
        }
    }
}

Mint with Single Asset

Use a DEX aggregator to convert a single asset into the basket:

function mintWithSingleAsset(
    Folio folio,
    IERC20 inputToken,
    uint256 inputAmount,
    uint256 desiredShares
) external {
    // 1. Calculate required basket assets
    (address[] memory assets, uint256[] memory amounts) = folio.toAssets(
        desiredShares,
        Math.Rounding.Ceil
    );

    // 2. Swap input token for each basket asset
    for (uint256 i = 0; i < assets.length; i++) {
        if (address(inputToken) != assets[i]) {
            // Swap on Uniswap/1inch/etc.
            _swapExactOutput(inputToken, IERC20(assets[i]), amounts[i]);
        }
    }

    // 3. Approve and mint
    for (uint256 i = 0; i < assets.length; i++) {
        IERC20(assets[i]).approve(address(folio), amounts[i]);
    }

    folio.mint(desiredShares, msg.sender, desiredShares * 99 / 100);
}

Handling Edge Cases

Rebalancing in Progress

During rebalances, the basket composition may change:

// Check if a rebalance is active
(, , , , IFolio.RebalanceTimestamps memory timestamps, ) = folio.getRebalance();

if (block.timestamp < timestamps.availableUntil) {
    // Rebalance active - basket may change
    // Consider waiting or using larger slippage
}

Folio Deprecation

Deprecated Folios can only be redeemed:

if (folio.isDeprecated()) {
    // Minting is disabled
    // Auctions are disabled
    // Only redemption is available
    folio.redeem(...);
}

Zero Balance Assets

Basket tokens with zero balance are still part of the basket:

(address[] memory assets, uint256[] memory amounts) = folio.totalAssets();

// Some amounts[i] may be 0
// Still required to approve these tokens for minting
// But actual transfer amount will be 0

Fee Accrual Timing

TVL fees accrue in full days only:

uint256 lastPoke = folio.lastPoke();
uint256 nextAccrual = ((lastPoke / 1 days) + 1) * 1 days;

// Fees will next accrue at nextAccrual timestamp

Querying Fee Information

// Get pending fee shares
uint256 pendingFees = folio.getPendingFeeShares();

// Get fee recipients
for (uint256 i = 0; i < recipientCount; i++) {
    (address recipient, uint96 portion) = folio.feeRecipients(i);
    // portion is in D18 format (1e18 = 100%)
}

// Get DAO fee configuration
(address daoRecipient, uint256 minFeeBps, uint256 maxFeeBps, uint256 daoSplit) = 
    folio.daoFeeRegistry().getFeeDetails(address(folio));

Gas Optimization Tips

Batch Approvals

If you’ll be minting multiple times, approve max once:

IERC20(token).approve(address(folio), type(uint256).max);

Avoid Small Mints

Minting has fixed gas costs. Mint larger amounts less frequently:

// Expensive: 10 mints of 1 share
// Better: 1 mint of 10 shares

Combine with Fee Distribution

If fees are pending, mint() will trigger distribution automatically. Consider timing mints after fee accrual periods.

Code Reference

Mint function: contracts/Folio.sol:441-476
Redeem function: contracts/Folio.sol:482-508
Asset calculation: contracts/Folio.sol:420-433
Fee distribution: contracts/Folio.sol:521-551

Next Steps

Auction Participation

Provide liquidity by bidding on rebalancing auctions

Deploying Folio

Create your own Folio with custom parameters

Get Started

Core Concepts

Guides

Advanced

Development

Overview

Total Supply

Asset Composition

Minting Shares

Redeeming Shares

Fee Distribution

Manual Distribution

Automatic Distribution

Fee Types

TVL Fee (Time-Based)

Mint Fee (One-Time)

Folio Self Fee

Advanced Minting Strategies

Batch Minting for Multiple Users

Mint with Single Asset

Handling Edge Cases

Querying Fee Information

Gas Optimization Tips

Code Reference

Next Steps

Auction Participation

Deploying Folio

Build docs developers (and LLMs) love

Get Started

Core Concepts

Guides

Advanced

Development

Documentation Index

​Overview

​Understanding Share Accounting

​Total Supply

​Asset Composition

​Minting Shares

​Redeeming Shares

​Fee Distribution

​Manual Distribution

​Automatic Distribution

​Fee Types

​TVL Fee (Time-Based)

​Mint Fee (One-Time)

​Folio Self Fee

​Advanced Minting Strategies

​Batch Minting for Multiple Users

​Mint with Single Asset

​Handling Edge Cases

​Querying Fee Information

​Gas Optimization Tips

​Code Reference

​Next Steps

Auction Participation

Deploying Folio

Build docs developers (and LLMs) love

Overview

Understanding Share Accounting

Total Supply

Asset Composition

Minting Shares

Redeeming Shares

Fee Distribution

Manual Distribution

Automatic Distribution

Fee Types

TVL Fee (Time-Based)

Mint Fee (One-Time)

Folio Self Fee

Advanced Minting Strategies

Batch Minting for Multiple Users

Mint with Single Asset

Handling Edge Cases

Querying Fee Information

Gas Optimization Tips

Code Reference

Next Steps