// SPDX-License-Identifier: MIT pragma solidity 0.8.26; interface IERC20Min { function transfer(address to, uint256 amount) external returns (bool); function balanceOf(address account) external view returns (uint256); function symbol() external view returns (string memory); } interface IWETH is IERC20Min { function deposit() external payable; function withdraw(uint256 amount) external; } interface IUniswapV3Pool { function token0() external view returns (address); function token1() external view returns (address); function fee() external view returns (uint24); function liquidity() external view returns (uint128); function slot0() external view returns ( uint160 sqrtPriceX96, int24 tick, uint16 observationIndex, uint16 observationCardinality, uint16 observationCardinalityNext, uint8 feeProtocol, bool unlocked ); function swap( address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96, bytes calldata data ) external returns (int256 amount0, int256 amount1); } /** * @title StockDesk * @notice Turns the pot's ETH into tokenized stock by actually buying it. * * It answers the same three questions the mechanic has always asked a * stock venue - how many names, what each one is, and what a given * amount of ETH buys - so the controller does not know or care that * the answer now comes from a market instead of a shelf. * * What changed underneath is the whole point. The desk this replaces * handed out tokens it issued itself and kept the ETH, which made * every reward a claim against a token anybody could print. This one * wraps the ETH and swaps it in a Uniswap v3 pool. What a miner is * paid is what the desk bought, at the price the market gave it. * * Three properties are load bearing. * * It cannot be moved. Every leg - its token, its pool, its side - is * fixed at deployment. There is no owner and no setter, so the venue * a purchase goes through is a fact of the address rather than a * setting somebody holds. * * It bounds its own price impact. The mechanic asks for a purchase * without naming a worst acceptable price, because it buys on a * schedule rather than on an opinion. So the limit lives here: every * swap carries a price bound, and a pool too thin to fill the whole * amount inside that bound fills part of it and no more. * * It never keeps the change. Whatever the bound stopped short of is * unwrapped and returned in the same call, so ETH the pot could not * spend goes back to the pot rather than resting here. */ contract StockDesk { struct Leg { IERC20Min token; IUniswapV3Pool pool; /// True when the stock is the pool's token1, so ETH in is zeroForOne. bool stockIsToken1; /// Share of a whole-basket purchase, in basis points. Must total 10000. uint16 weightBps; } IWETH public immutable weth; Leg[] private _legs; /** * How far a single purchase may push the price against itself. * * Applied as a bound on the swap rather than as a check afterwards, which * is what makes a thin pool fill partly instead of reverting: a purchase * the mechanic cannot complete must still complete as far as it can, or * the pot stops spending on exactly the days a shift most needs it to. */ uint16 public immutable maxSlipBps; uint256 private constant Q96 = 1 << 96; /// Set only around a swap this desk started; the callback is refused otherwise. bool private _inFlight; event Bought(address indexed token, address indexed to, uint256 ethSpent, uint256 units); event Returned(address indexed to, uint256 amount); error NoInput(); error BadWeights(uint256 total); error BadLeg(uint256 index); error NotAPool(); error SendFailed(); constructor(address weth_, address[] memory tokens, address[] memory pools, uint16[] memory weights, uint16 maxSlipBps_) { require(tokens.length == pools.length && tokens.length == weights.length, "length"); require(maxSlipBps_ > 0 && maxSlipBps_ <= 2_000, "slippage"); weth = IWETH(weth_); maxSlipBps = maxSlipBps_; uint256 total; for (uint256 i; i < tokens.length; ++i) { IUniswapV3Pool p = IUniswapV3Pool(pools[i]); address t0 = p.token0(); address t1 = p.token1(); // The pool has to be the pair this leg claims it is, and one side // of it has to be the wrapped native token. A leg that does not // check out is a leg that would send the pot's money nowhere. bool stockIsOne = (t1 == tokens[i] && t0 == weth_); if (!stockIsOne && !(t0 == tokens[i] && t1 == weth_)) revert BadLeg(i); _legs.push(Leg({ token: IERC20Min(tokens[i]), pool: p, stockIsToken1: stockIsOne, weightBps: weights[i] })); total += weights[i]; } if (total != 10_000) revert BadWeights(total); } /* ------------------------------------------------------------ reading */ function legCount() external view returns (uint256) { return _legs.length; } /** * @notice One leg: its token, its share of a basket buy, and its live rate. * @dev The rate is units per one ETH, read off the pool's current price. * It is a quote and not a promise: what a purchase actually gets is * whatever the swap returns, which is why nothing settles against * this figure. */ function legAt(uint256 i) public view returns (address token, uint16 weightBps, uint256 rate) { Leg storage l = _legs[i]; return (address(l.token), l.weightBps, _rate(l)); } /// @notice The pool a leg buys through, so the venue can be checked on chain. function poolOf(uint256 i) external view returns (address pool, uint24 fee, uint128 liquidity) { Leg storage l = _legs[i]; (, , uint24 f) = (0, 0, l.pool.fee()); return (address(l.pool), f, l.pool.liquidity()); } /// @notice What `ethIn` would buy at the current price, name by name. function quote(uint256 ethIn) public view returns (address[] memory tokens, uint256[] memory amounts) { uint256 n = _legs.length; tokens = new address[](n); amounts = new uint256[](n); for (uint256 i; i < n; ++i) { Leg storage l = _legs[i]; tokens[i] = address(l.token); amounts[i] = (((ethIn * l.weightBps) / 10_000) * _rate(l)) / 1e18; } } function quoteTotal(uint256 ethIn) external view returns (uint256 total) { (, uint256[] memory amounts) = quote(ethIn); for (uint256 i; i < amounts.length; ++i) total += amounts[i]; } /** * Units of stock one ETH buys, from the pool's own price. * * `sqrtPriceX96` squares to token1 per token0. With the wrapped native * token on one side, that is either the rate or its reciprocal, and the * two are split apart here so the caller never has to know which side of * its pool a name sits on. */ function _rate(Leg storage l) private view returns (uint256) { (uint160 sqrtP, , , , , , ) = l.pool.slot0(); if (sqrtP == 0) return 0; /* Split so the intermediate stays inside 256 bits. `half` is the square root of the price carrying nine decimals, so squaring it lands on eighteen: the scaling is already done, and dividing again here cost the figure its whole magnitude. */ uint256 half = (uint256(sqrtP) * 1e9) / Q96; uint256 priceX18 = half * half; // token1 per token0, 18dp if (l.stockIsToken1) return priceX18; return priceX18 == 0 ? 0 : (1e18 * 1e18) / priceX18; } /* -------------------------------------------------------------- buying */ /** * @notice Buy one name. * @return units what arrived * @return spent ETH actually used; the rest has already gone back. */ function swapOne(uint256 index, address to) external payable returns (uint256 units, uint256 spent) { if (msg.value == 0) revert NoInput(); (units, spent) = _buy(_legs[index], msg.value, to); _refund(msg.value - spent); } /** * @notice Buy the whole basket at its weights. * @dev Each leg takes what its own pool can give inside the price bound; * whatever no leg could absorb goes back with the rest. */ function swap(address to) external payable returns (uint256 total, uint256 spent) { if (msg.value == 0) revert NoInput(); uint256 n = _legs.length; for (uint256 i; i < n; ++i) { uint256 want = (msg.value * _legs[i].weightBps) / 10_000; if (want == 0) continue; (uint256 got, uint256 used) = _buy(_legs[i], want, to); total += got; spent += used; } _refund(msg.value - spent); } function _buy(Leg storage l, uint256 ethIn, address to) private returns (uint256 units, uint256 spent) { (uint160 sqrtP, , , , , , ) = l.pool.slot0(); if (sqrtP == 0 || ethIn == 0) return (0, 0); bool zeroForOne = l.stockIsToken1; // wrapped native is token0 then /* The bound, in square root space. Price moves down when token0 is being sold into the pool and up the other way, and the bound is half the slippage in basis points because the number being bounded is a square root. */ uint160 limit = zeroForOne ? uint160(uint256(sqrtP) - (uint256(sqrtP) * maxSlipBps) / 20_000) : uint160(uint256(sqrtP) + (uint256(sqrtP) * maxSlipBps) / 20_000); weth.deposit{ value: ethIn }(); _inFlight = true; (int256 a0, int256 a1) = l.pool.swap( to, zeroForOne, int256(ethIn), limit, abi.encode(address(l.pool)) ); _inFlight = false; // Positive is what the pool took, negative is what it paid out. spent = zeroForOne ? uint256(a0) : uint256(a1); int256 out = zeroForOne ? a1 : a0; units = out < 0 ? uint256(-out) : 0; // Whatever the bound stopped short of is still wrapped; unwrap it so // the caller is handed back native currency, which is what it sent. if (ethIn > spent) weth.withdraw(ethIn - spent); emit Bought(address(l.token), to, spent, units); } /// @dev The pool asks for what it is owed, and only the pool may ask. function uniswapV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes calldata data) external { data; // Only a pool this desk was built around may ask, and only while a // swap it started is in flight. if (!_inFlight) revert NotAPool(); bool known; for (uint256 i; i < _legs.length; ++i) { if (address(_legs[i].pool) == msg.sender) { known = true; break; } } if (!known) revert NotAPool(); uint256 owed = amount0Delta > 0 ? uint256(amount0Delta) : uint256(amount1Delta); weth.transfer(msg.sender, owed); } function _refund(uint256 amount) private { if (amount == 0) return; (bool ok, ) = msg.sender.call{ value: amount }(""); if (!ok) revert SendFailed(); emit Returned(msg.sender, amount); } receive() external payable {} }