How Cairn works

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

/// @title Cairn — stack several Robinhood stock tokens into one ERC-20.
/// @notice A cairn is a basket with FIXED contents: one whole cairn share (1e18) is backed by exactly `units[i]` raw
/// units of each stock `tokens[i]`, forever. Anyone can:
///   • mint in kind  — hand over each stock (rounded UP) and receive shares;
///   • redeem in kind — burn shares and receive each stock (rounded DOWN), so every share stays fully backed;
///   • buy with USDG — the cairn buys each stock through its Uniswap v3 pool (exact output) and mints, refunding
///     whatever of the caller's maximum was not spent, all in one transaction;
///   • sell for USDG — burn shares, sell each stock through its pool, and pay out at least the caller's minimum.
/// There is no owner, no fee, no upgrade, no oracle and nothing anyone can change after a cairn is made.
interface IERC20 {
    function transferFrom(address, address, uint256) external returns (bool);
    function transfer(address, uint256) external returns (bool);
    function approve(address, uint256) external returns (bool);
}
interface IRouter {
    struct ExactOutputSingleParams {
        address tokenIn; address tokenOut; uint24 fee; address recipient;
        uint256 amountOut; uint256 amountInMaximum; uint160 sqrtPriceLimitX96;
    }
    struct ExactInputSingleParams {
        address tokenIn; address tokenOut; uint24 fee; address recipient;
        uint256 amountIn; uint256 amountOutMinimum; uint160 sqrtPriceLimitX96;
    }
    function exactOutputSingle(ExactOutputSingleParams calldata) external payable returns (uint256);
    function exactInputSingle(ExactInputSingleParams calldata) external payable returns (uint256);
}

address constant USDG = 0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168;
address constant ROUTER = 0xCaf681a66D020601342297493863E78C959E5cb2; // Uniswap SwapRouter02

error Refused();          // a transfer or approval the token did not accept
error BadBasket();        // the factory refused those contents
error TooExpensive();     // a buy would cost more than the caller's maximum
error TooLittle();        // a sale would pay less than the caller's minimum
error Reentrant();
error NoShares();

contract CairnBasket {
    string public name;
    string public symbol;
    uint8 public constant decimals = 18;
    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    address[] internal _tokens;
    uint256[] internal _units;   // raw units of _tokens[i] behind one whole share (1e18)
    uint24[] internal _fees;     // the Uniswap v3 fee tier of the USDG pool each token is bought and sold through
    uint256 private _entered;    // 0 = free, 1 = inside mint/redeem/buy/sell

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
    event Minted(address indexed by, address indexed to, uint256 shares, uint256 usdgSpent);
    event Redeemed(address indexed by, address indexed to, uint256 shares, uint256 usdgReceived);

    constructor(string memory name_, string memory symbol_, address[] memory tokens_, uint256[] memory units_, uint24[] memory fees_) {
        name = name_; symbol = symbol_;
        _tokens = tokens_; _units = units_; _fees = fees_;
    }

    modifier lock() { if (_entered != 0) revert Reentrant(); _entered = 1; _; _entered = 0; }

    // ------------------------------------------------------------------ the basket
    function contents() external view returns (address[] memory tokens, uint256[] memory units, uint24[] memory fees) {
        return (_tokens, _units, _fees);
    }
    /// @notice Raw units of each stock that `shares` cost to mint (rounded up) or return on redeem (rounded down).
    function amountsFor(uint256 shares, bool roundUp) public view returns (uint256[] memory out) {
        out = new uint256[](_tokens.length);
        for (uint256 i; i < out.length; i++) {
            uint256 p = _units[i] * shares;
            out[i] = p / 1e18 + (roundUp && p % 1e18 != 0 ? 1 : 0);
        }
    }

    // ------------------------------------------------------------------ in kind
    function mint(uint256 shares, address to) external lock {
        if (shares == 0) revert NoShares();
        uint256[] memory amt = amountsFor(shares, true);
        for (uint256 i; i < amt.length; i++) _call(_tokens[i], abi.encodeCall(IERC20.transferFrom, (msg.sender, address(this), amt[i])));
        _mint(to, shares);
        emit Minted(msg.sender, to, shares, 0);
    }
    function redeem(uint256 shares, address to) external lock {
        if (shares == 0) revert NoShares();
        _burn(msg.sender, shares);
        uint256[] memory amt = amountsFor(shares, false);
        for (uint256 i; i < amt.length; i++) if (amt[i] != 0) _call(_tokens[i], abi.encodeCall(IERC20.transfer, (to, amt[i])));
        emit Redeemed(msg.sender, to, shares, 0);
    }

    // ------------------------------------------------------------------ with dollars, through Uniswap
    /// @notice Buy `shares` for at most `maxUsdg`: every stock is bought at exactly the amount a mint needs, and
    /// every unspent dollar goes back to the caller in the same transaction.
    function buy(uint256 shares, uint256 maxUsdg, address to) external lock returns (uint256 spent) {
        if (shares == 0) revert NoShares();
        _call(USDG, abi.encodeCall(IERC20.transferFrom, (msg.sender, address(this), maxUsdg)));
        _call(USDG, abi.encodeCall(IERC20.approve, (ROUTER, maxUsdg)));
        uint256[] memory amt = amountsFor(shares, true);
        for (uint256 i; i < amt.length; i++) {
            spent += IRouter(ROUTER).exactOutputSingle(IRouter.ExactOutputSingleParams(
                USDG, _tokens[i], _fees[i], address(this), amt[i], maxUsdg - spent, 0));
        }
        if (spent > maxUsdg) revert TooExpensive();   // the router already refuses this per leg; kept for clarity
        _call(USDG, abi.encodeCall(IERC20.approve, (ROUTER, 0)));
        if (maxUsdg > spent) _call(USDG, abi.encodeCall(IERC20.transfer, (msg.sender, maxUsdg - spent)));
        _mint(to, shares);
        emit Minted(msg.sender, to, shares, spent);
    }
    /// @notice Sell `shares` for at least `minUsdg`, paid to `to`.
    function sell(uint256 shares, uint256 minUsdg, address to) external lock returns (uint256 got) {
        if (shares == 0) revert NoShares();
        _burn(msg.sender, shares);
        uint256[] memory amt = amountsFor(shares, false);
        for (uint256 i; i < amt.length; i++) {
            if (amt[i] == 0) continue;
            _call(_tokens[i], abi.encodeCall(IERC20.approve, (ROUTER, amt[i])));
            got += IRouter(ROUTER).exactInputSingle(IRouter.ExactInputSingleParams(
                _tokens[i], USDG, _fees[i], to, amt[i], 0, 0));
        }
        if (got < minUsdg) revert TooLittle();
        emit Redeemed(msg.sender, to, shares, got);
    }

    // ------------------------------------------------------------------ ERC-20
    function transfer(address to, uint256 v) external returns (bool) { _move(msg.sender, to, v); return true; }
    function approve(address s, uint256 v) external returns (bool) { allowance[msg.sender][s] = v; emit Approval(msg.sender, s, v); return true; }
    function transferFrom(address f, address to, uint256 v) external returns (bool) {
        uint256 a = allowance[f][msg.sender];
        if (a != type(uint256).max) allowance[f][msg.sender] = a - v;
        _move(f, to, v); return true;
    }
    function _move(address f, address to, uint256 v) private { balanceOf[f] -= v; balanceOf[to] += v; emit Transfer(f, to, v); }
    function _mint(address to, uint256 v) private { totalSupply += v; balanceOf[to] += v; emit Transfer(address(0), to, v); }
    function _burn(address f, uint256 v) private { balanceOf[f] -= v; totalSupply -= v; emit Transfer(f, address(0), v); }
    function _call(address token, bytes memory data) private {
        (bool ok, bytes memory ret) = token.call(data);
        if (!ok || (ret.length != 0 && !abi.decode(ret, (bool)))) revert Refused();
    }
}

/// @notice Makes cairns. The same contents always make the same cairn at the same address (CREATE2 over a hash of the
/// name, symbol and contents), so a basket can be linked to before anyone has made it, and nobody can make a second
/// cairn with identical contents under the same name.
contract Cairn {
    address[] public all;
    event Made(address indexed cairn, address indexed by, string name, string symbol, address[] tokens, uint256[] units, uint24[] fees);

    function saltOf(string calldata name, string calldata symbol, address[] calldata tokens, uint256[] calldata units, uint24[] calldata fees) public pure returns (bytes32) {
        return keccak256(abi.encode(name, symbol, tokens, units, fees));
    }
    function addressOf(string calldata name, string calldata symbol, address[] calldata tokens, uint256[] calldata units, uint24[] calldata fees) external view returns (address) {
        bytes32 h = keccak256(abi.encodePacked(type(CairnBasket).creationCode, abi.encode(name, symbol, tokens, units, fees)));
        return address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), saltOf(name, symbol, tokens, units, fees), h)))));
    }
    function make(string calldata name, string calldata symbol, address[] calldata tokens, uint256[] calldata units, uint24[] calldata fees) external returns (address c) {
        uint256 n = tokens.length;
        if (n == 0 || n > 8 || units.length != n || fees.length != n || bytes(name).length == 0 || bytes(name).length > 40
            || bytes(symbol).length == 0 || bytes(symbol).length > 12) revert BadBasket();
        for (uint256 i; i < n; i++) {
            if (tokens[i] == address(0) || tokens[i] == USDG || units[i] == 0) revert BadBasket();
            if (fees[i] != 100 && fees[i] != 500 && fees[i] != 3000 && fees[i] != 10000) revert BadBasket();
            for (uint256 j; j < i; j++) if (tokens[j] == tokens[i]) revert BadBasket();
        }
        c = address(new CairnBasket{salt: saltOf(name, symbol, tokens, units, fees)}(name, symbol, tokens, units, fees));
        all.push(c);
        emit Made(c, msg.sender, name, symbol, tokens, units, fees);
    }
    function count() external view returns (uint256) { return all.length; }
}