Security Considerations

contract Folio is ReentrancyGuardUpgradeable {
    // All state-changing external functions are protected
    function mint(...) external nonReentrant { ... }
    function redeem(...) external nonReentrant { ... }
    function bid(...) external nonReentrant { ... }
    function createTrustedFill(...) external nonReentrant { ... }
}

function getSafeData() external view returns (uint256) {
    (bool syncActive, bool asyncActive) = folio.stateChangeActive();
    
    // Synchronous state change (reentrancy guard entered)
    require(!syncActive, "Sync state change active");
    
    // Asynchronous state change (trusted fill in progress)
    require(!asyncActive, "Async state change active");
    
    // Safe to read view functions
    return folio.totalSupply();
}

// ❌ Not supported
contract TUSDOld {
    function transfer(address to, uint amount) external;
    function transferProxy(address from, address to, uint amount) external;
}

// ❌ Not supported
contract USDC {
    bool public paused;
    mapping(address => bool) public isBlacklisted;
    
    function transfer(address to, uint amount) external {
        require(!paused, "Paused");
        require(!isBlacklisted[msg.sender], "Blacklisted");
        // ...
    }
}

// ❌ Not supported
contract FeeToken {
    uint256 public transferFee = 100; // 1%
    
    function transfer(address to, uint amount) external {
        uint256 fee = amount * transferFee / 10000;
        balances[to] += amount - fee;
        balances[feeRecipient] += fee;
    }
}

// ❌ Not supported
contract ERC777Token {
    function transfer(address to, uint amount) external {
        // Calls tokensToSend hook on sender
        IERC777Sender(msg.sender).tokensToSend(...);
        
        // Transfer
        balances[to] += amount;
        
        // Calls tokensReceived hook on recipient
        IERC777Recipient(to).tokensReceived(...);
    }
}

// ⚠️ Supported but accounting may be off
contract RebaseToken {
    uint256 public rebaseMultiplier = 1e18;
    
    function balanceOf(address account) external view returns (uint256) {
        return (sharesOf[account] * rebaseMultiplier) / 1e18;
    }
}

using SafeERC20 for IERC20;

// Handles:
// - Missing return values
// - False return values (converts to revert)
// - Zero-value transfers that revert
SafeERC20.safeTransfer(token, to, amount);
SafeERC20.safeTransferFrom(token, from, to, amount);
SafeERC20.forceApprove(token, spender, amount);

// Assumed maximum block time
require(blockTime <= 30 seconds, "Chain not supported");

// Maximum token supply: 1e36
// Folio collateral: 27 decimals max
// StakingVault underlying: 21 decimals max

// Rebalance limits: D18{BU/share} up to 1e27
require(limits.low > 0 && limits.high <= 1e27, "Invalid limits");

// Basket weights: D27{tok/BU} up to 1e54
require(weight.high <= 1e54, "Weight too high");

// Prices: D27{UoA/tok} up to 1e45
require(price.low > 0 && price.high <= 1e45, "Invalid price");

// Price range: Maximum 100x spread
require(price.high / price.low <= 100, "Price range too wide");

// Safe removal process:
1. Announce removal with sufficient warning (days/weeks)
2. Set token weight to zero in next rebalance
3. Complete rebalance to sell all tokens
4. Call removeFromBasket() after balance reaches zero

// AUCTION_LAUNCHER responsibility
if (currentPrice < initialPriceRange.low || 
    currentPrice > initialPriceRange.high) {
    // Value leakage imminent!
    folio.endRebalance();
}

// Price decays over time
// First bidder at profitable price wins
// → Gas war / priority auction

// Sandwich attack pattern:
1. Detect profitable rebalance completion
2. Mint shares at old basket composition
3. Rebalance completes
4. Redeem at new basket composition
5. Profit from composition change

// Permissionless removal requires:
// 1. Token weight set to zero
// 2. Token balance is exactly zero

// Attacker can donate 1 wei to prevent removal
dustToken.transfer(address(folio), 1);

// Attacker can DoS asyncActive check:
while (inCurrentBlock) {
    folio.createTrustedFill(...);
    folio.closeTrustedFill();
}
// asyncActive = true for the entire block

function safeRead() external view returns (uint256) {
    (bool syncActive, bool asyncActive) = folio.stateChangeActive();
    require(!syncActive && !asyncActive, "State changing");
    return folio.totalSupply();
}

// Minting
folio.mint(shares, receiver, minSharesOut);

// Redeeming
folio.redeem(shares, receiver, assets, minAmountsOut);

// Check token compatibility before adding to Folio
if (tokenHasPause || tokenHasBlocklist || tokenIsFeeOnTransfer) {
    revert("Incompatible token");
}

bool deprecated = folio.isDeprecated();
require(!deprecated, "Folio deprecated");

// DEFAULT_ADMIN_ROLE can deprecate
folio.deprecateFolio();

// Effects:
// - Minting disabled
// - Auctions cannot be opened/bid
// - Rebalancing disabled
// - Redemption still works (users can exit)

versionRegistry.deprecateVersion(versionHash);

// Effects:
// - Cannot upgrade TO this version
// - Existing Folios continue working
// - Folio admins should upgrade to new version