Library Patterns

// Internal library — inlined at compile time
library SafeCast {
    error SafeCast_Overflow();

    function toUint128(uint256 value) internal pure returns (uint128) {
        if (value > type(uint128).max) revert SafeCast_Overflow();
        return uint128(value);
    }

    function toUint96(uint256 value) internal pure returns (uint96) {
        if (value > type(uint96).max) revert SafeCast_Overflow();
        return uint96(value);
    }

    function toInt256(uint256 value) internal pure returns (int256) {
        if (value > uint256(type(int256).max)) revert SafeCast_Overflow();
        return int256(value);
    }
}

using SafeCast for uint256;
using FixedPointMathLib for uint256;

function calculateShares(uint256 assets, uint256 totalAssets, uint256 totalShares)
    internal
    pure
    returns (uint256)
{
    return assets.mulDivDown(totalShares, totalAssets);
}

function packTimestamp(uint256 timestamp) internal pure returns (uint48) {
    return timestamp.toUint48();
}

// In a shared file, apply globally to all files that import it
using SafeCast for uint256 global;
using FixedPointMathLib for uint256 global;

import {FixedPointMathLib} from "solmate/utils/FixedPointMathLib.sol";

using FixedPointMathLib for uint256;

// Multiply then divide, rounding down — prevents phantom overflow
uint256 shares = assets.mulDivDown(totalShares, totalAssets);

// Multiply then divide, rounding up — useful for debt calculations
uint256 debt = borrowed.mulDivUp(interestRate, PRECISION);

// WAD math (18 decimal fixed point)
uint256 result = a.mulWadDown(b);  // (a * b) / 1e18, round down
uint256 result = a.divWadUp(b);    // (a * 1e18) / b, round up

// Square root
uint256 sqrtPrice = FixedPointMathLib.sqrt(price);

struct Position {
    uint128 collateral;
    uint128 debt;
    uint48 lastUpdate;
    uint16 healthFactor;
}

library PositionLib {
    using SafeCast for uint256;
    using FixedPointMathLib for uint256;

    error Position_Undercollateralized();

    function addCollateral(Position storage self, uint256 amount) internal {
        self.collateral += amount.toUint128();
        self.lastUpdate = uint48(block.timestamp);
    }

    function addDebt(Position storage self, uint256 amount) internal {
        self.debt += amount.toUint128();
        self.lastUpdate = uint48(block.timestamp);
    }

    function healthFactor(Position storage self, uint256 price)
        internal
        view
        returns (uint256)
    {
        if (self.debt == 0) return type(uint256).max;
        return uint256(self.collateral).mulDivDown(price, uint256(self.debt));
    }

    function isHealthy(Position storage self, uint256 price, uint256 minHealth)
        internal
        view
        returns (bool)
    {
        return healthFactor(self, price) >= minHealth;
    }
}

using PositionLib for Position;

mapping(address => Position) public positions;

function addCollateral(uint256 amount) external {
    positions[msg.sender].addCollateral(amount);
    // ...
}

import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";

using EnumerableSet for EnumerableSet.AddressSet;

EnumerableSet.AddressSet private _whitelistedTokens;

function addToken(address token) external onlyOwner {
    if (!_whitelistedTokens.add(token)) revert AlreadyWhitelisted();
}

function isWhitelisted(address token) external view returns (bool) {
    return _whitelistedTokens.contains(token);
}

function getWhitelistedTokens() external view returns (address[] memory) {
    return _whitelistedTokens.values();
}