The code behind the baskets

// deploys a new basket token and registers it
function createBasket(
    string calldata name,
    string calldata symbol,
    BasketToken.Component[] calldata components,
    uint256 maxPriceAge
) external returns (address basket) {
    basket = address(new BasketToken(name, symbol, components, maxPriceAge));
    _baskets.push(basket);
    isBasket[basket] = true;
    emit BasketCreated(basket, msg.sender, name, symbol);
}

constructor(
    string memory name_,
    string memory symbol_,
    Component[] memory components_,
    uint256 maxPriceAge_
) ERC20(name_, symbol_) {
    uint256 count = components_.length;
    if (count == 0) revert EmptyComponents();
    if (count > 10) revert TooManyComponents(count);

    for (uint256 i = 0; i < count; i++) {
        Component memory c = components_[i];
        if (c.token == address(0) || c.feed == address(0)) revert ZeroAddress();
        if (c.unitsPerShare == 0) revert ZeroUnits(c.token);
        if (_tokenDecimals[c.token] != 0) revert DuplicateToken(c.token);

        uint8 feedDecimals = AggregatorV3Interface(c.feed).decimals();
        if (feedDecimals != USD_DECIMALS) {
            revert UnexpectedFeedDecimals(c.feed, feedDecimals);
        }

        _tokenDecimals[c.token] = IERC20Metadata(c.token).decimals();
        _components.push(c);
    }

    maxPriceAge = maxPriceAge_;
    factory = msg.sender;
}

// deposit the components and mint shares, amounts round up so minters never underpay
function mint(uint256 shares, address to) external nonReentrant {
    if (shares == 0) revert ZeroShares();

    uint256 count = _components.length;
    for (uint256 i = 0; i < count; i++) {
        Component memory c = _components[i];
        uint256 amount = Math.mulDiv(c.unitsPerShare, shares, SHARE_UNIT, Math.Rounding.Ceil);
        IERC20(c.token).safeTransferFrom(msg.sender, address(this), amount);
    }

    _mint(to, shares);
    emit Minted(msg.sender, to, shares);
}

// burn shares and withdraw the components, amounts round down so reserves never overdraw
function redeem(uint256 shares, address to) external nonReentrant {
    if (shares == 0) revert ZeroShares();
    if (to == address(0)) revert ZeroAddress();

    _burn(msg.sender, shares);

    uint256 count = _components.length;
    for (uint256 i = 0; i < count; i++) {
        Component memory c = _components[i];
        uint256 amount = Math.mulDiv(c.unitsPerShare, shares, SHARE_UNIT, Math.Rounding.Floor);
        IERC20(c.token).safeTransfer(to, amount);
    }

    emit Redeemed(msg.sender, to, shares);
}

// usd value of one share with 8 decimals
// feeds price the raw stock token with corporate actions applied so no uiMultiplier here
function sharePriceUsd() public view returns (uint256 price) {
    uint256 count = _components.length;
    for (uint256 i = 0; i < count; i++) {
        Component memory c = _components[i];
        uint256 tokenPrice = _readPrice(c.feed);
        price += Math.mulDiv(tokenPrice, c.unitsPerShare, 10 ** _tokenDecimals[c.token]);
    }
}

function _readPrice(address feed) private view returns (uint256) {
    (, int256 answer,, uint256 updatedAt,) = AggregatorV3Interface(feed).latestRoundData();
    if (answer <= 0) revert InvalidPrice(feed, answer);
    if (block.timestamp > updatedAt + maxPriceAge) revert StalePrice(feed, updatedAt);
    return uint256(answer);
}

function testFuzz_mintRedeemRoundTrip(uint96 rawShares) public {
    uint256 shares = bound(uint256(rawShares), 1, 50e18);
    vm.startPrank(alice);
    basket.mint(shares, alice);
    basket.redeem(shares, alice);
    vm.stopPrank();

    // user can lose at most 1 wei of dust per component to rounding
    assertGe(tsla.balanceOf(alice) + 1, 100e18);
    assertGe(amzn.balanceOf(alice) + 1, 100e18);
    assertLe(tsla.balanceOf(alice), 100e18);
    assertEq(basket.totalSupply(), 0);
}

// erc-8056 scaled ui amount extension implemented by robinhood chain stock tokens
// raw balances never rebase, splits apply through the multiplier instead
// underlying shares = raw balance * uiMultiplier / 1e18
// docs: https://docs.robinhood.com/chain/stock-tokens/
interface IScaledUIAmount {
    // 18 decimal fixed point where 1e18 equals 1.0
    function uiMultiplier() external view returns (uint256);

    function balanceOfUI(address account) external view returns (uint256);

    function totalSupplyUI() external view returns (uint256);

    // pending multiplier that activates at effectiveAt
    function newUIMultiplier() external view returns (uint256);

    function effectiveAt() external view returns (uint256);
}

function run() external {
    vm.startBroadcast();

    BasketFactory factory = new BasketFactory();
    console2.log("FACTORY=%s", address(factory));

    BasketToken.Component[] memory components;
    if (block.chainid == 4663) {
        components = _mainnetComponents();
    } else if (block.chainid == 46630) {
        components = _testnetComponents();
    } else {
        components = _localComponents();
    }

    address basket = factory.createBasket("Tech Trio", "TRIO", components, MAX_PRICE_AGE);
    console2.log("DEMO_BASKET=%s", basket);
    console2.log("CHAIN_ID=%s", block.chainid);

    vm.stopBroadcast();
}

function _mainnetComponents() internal pure returns (BasketToken.Component[] memory c) {
    c = new BasketToken.Component[](3);
    c[0] = BasketToken.Component(MAINNET_TSLA, MAINNET_TSLA_FEED, 0.4e18);
    c[1] = BasketToken.Component(MAINNET_NVDA, MAINNET_NVDA_FEED, 0.3e18);
    c[2] = BasketToken.Component(MAINNET_AAPL, MAINNET_AAPL_FEED, 0.3e18);
}

function setUp() public {
    string memory rpc =
        vm.envOr("ROBINHOOD_RPC_URL", string("https://rpc.mainnet.chain.robinhood.com"));
    vm.createSelectFork(rpc);
    assertEq(block.chainid, 4663);

    factory = new BasketFactory();
    BasketToken.Component[] memory c = new BasketToken.Component[](3);
    c[0] = BasketToken.Component(TSLA, TSLA_FEED, 0.4e18);
    c[1] = BasketToken.Component(NVDA, NVDA_FEED, 0.3e18);
    c[2] = BasketToken.Component(AAPL, AAPL_FEED, 0.3e18);
    basket = BasketToken(factory.createBasket("Tech Trio", "TRIO", c, MAX_PRICE_AGE));
}

function test_mintAndRedeem_withRealStockTokens() public {
    deal(TSLA, alice, 1e18);
    deal(NVDA, alice, 1e18);
    deal(AAPL, alice, 1e18);

    vm.startPrank(alice);
    IERC20Metadata(TSLA).approve(address(basket), type(uint256).max);
    IERC20Metadata(NVDA).approve(address(basket), type(uint256).max);
    IERC20Metadata(AAPL).approve(address(basket), type(uint256).max);

    basket.mint(2e18, alice);
    assertEq(basket.balanceOf(alice), 2e18);
    assertEq(IERC20Metadata(TSLA).balanceOf(address(basket)), 0.8e18);

    basket.redeem(2e18, alice);
    assertEq(basket.totalSupply(), 0);
    assertEq(IERC20Metadata(TSLA).balanceOf(alice), 1e18);
    vm.stopPrank();
}