Dev ex/cf build script

package.json

@@ -40,6 +40,7 @@
     ]
   },
   "scripts": {
+    "cf-build": "yarn && run-s build:dev-frontend",
     "build": "run-s build:*",
     "build:dev-frontend": "yarn workspace @liquity/dev-frontend build",
     "build:subgraph": "yarn workspace @liquity/subgraph build",
@@ -53,10 +54,7 @@
     "prepare:lib-base": "yarn workspace @liquity/lib-base prepare",
     "prepare:lib-ethers": "yarn workspace @liquity/lib-ethers prepare",
     "prepare:lib-react": "yarn workspace @liquity/lib-react prepare",
-    "prepare:lib-subgraph": "yarn workspace @liquity/lib-subgraph prepare",
     "prepare:providers": "yarn workspace @liquity/providers prepare",
-    "prepare:subgraph": "yarn workspace @liquity/subgraph prepare",
-    "prepare:docs": "run-s docs",
     "rebuild": "run-s prepare build",
     "release": "run-s release:*",
     "release:delete-dev-deployments": "yarn workspace @liquity/lib-ethers delete-dev-deployments",

packages/contracts/contracts/B.Protocol/BAMM.sol

@@ -0,0 +1,231 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.6.11;
+
+import "./../StabilityPool.sol";
+import "./CropJoinAdapter.sol";
+import "./PriceFormula.sol";
+import "./../Interfaces/IPriceFeed.sol";
+import "./../Dependencies/IERC20.sol";
+import "./../Dependencies/SafeMath.sol";
+import "./../Dependencies/Ownable.sol";
+import "./../Dependencies/AggregatorV3Interface.sol";
+
+
+contract BAMM is CropJoinAdapter, PriceFormula, Ownable {
+    using SafeMath for uint256;
+
+    AggregatorV3Interface public immutable priceAggregator;
+    IERC20 public immutable LUSD;
+    StabilityPool immutable public SP;
+
+    address payable public immutable feePool;
+    uint public constant MAX_FEE = 100; // 1%
+    uint public fee = 0; // fee in bps
+    uint public A = 20;
+    uint public constant MIN_A = 20;
+    uint public constant MAX_A = 200;    
+
+    uint public immutable maxDiscount; // max discount in bips
+
+    address public immutable frontEndTag;
+
+    uint constant public PRECISION = 1e18;
+
+    event ParamsSet(uint A, uint fee);
+    event UserDeposit(address indexed user, uint lusdAmount, uint numShares);
+    event UserWithdraw(address indexed user, uint lusdAmount, uint ethAmount, uint numShares);
+    event RebalanceSwap(address indexed user, uint lusdAmount, uint ethAmount, uint timestamp);
+
+    constructor(
+        address _priceAggregator,
+        address payable _SP,
+        address _LUSD,
+        address _LQTY,
+        uint _maxDiscount,
+        address payable _feePool,
+        address _fronEndTag)
+        public
+        CropJoinAdapter(_LQTY)
+    {
+        priceAggregator = AggregatorV3Interface(_priceAggregator);
+        LUSD = IERC20(_LUSD);
+        SP = StabilityPool(_SP);
+
+        feePool = _feePool;
+        maxDiscount = _maxDiscount;
+        frontEndTag = _fronEndTag;
+    }
+
+    function setParams(uint _A, uint _fee) external onlyOwner {
+        require(_fee <= MAX_FEE, "setParams: fee is too big");
+        require(_A >= MIN_A, "setParams: A too small");
+        require(_A <= MAX_A, "setParams: A too big");
+
+        fee = _fee;
+        A = _A;
+
+        emit ParamsSet(_A, _fee);
+    }
+
+    function fetchPrice() public view returns(uint) {
+        uint chainlinkDecimals;
+        uint chainlinkLatestAnswer;
+        uint chainlinkTimestamp;
+
+        // First, try to get current decimal precision:
+        try priceAggregator.decimals() returns (uint8 decimals) {
+            // If call to Chainlink succeeds, record the current decimal precision
+            chainlinkDecimals = decimals;
+        } catch {
+            // If call to Chainlink aggregator reverts, return a zero response with success = false
+            return 0;
+        }
+
+        // Secondly, try to get latest price data:
+        try priceAggregator.latestRoundData() returns
+        (
+            uint80 /* roundId */,
+            int256 answer,
+            uint256 /* startedAt */,
+            uint256 timestamp,
+            uint80 /* answeredInRound */
+        )
+        {
+            // If call to Chainlink succeeds, return the response and success = true
+            chainlinkLatestAnswer = uint(answer);
+            chainlinkTimestamp = timestamp;
+        } catch {
+            // If call to Chainlink aggregator reverts, return a zero response with success = false
+            return 0;
+        }
+
+        if(chainlinkTimestamp + 1 hours < now) return 0; // price is down
+
+        uint chainlinkFactor = 10 ** chainlinkDecimals;
+        return chainlinkLatestAnswer.mul(PRECISION) / chainlinkFactor;
+    }
+
+    function deposit(uint lusdAmount) external {        
+        // update share
+        uint lusdValue = SP.getCompoundedLUSDDeposit(address(this));
+        uint ethValue = SP.getDepositorETHGain(address(this)).add(address(this).balance);
+
+        uint price = fetchPrice();
+        require(ethValue == 0 || price > 0, "deposit: chainlink is down");
+
+        uint totalValue = lusdValue.add(ethValue.mul(price) / PRECISION);
+
+        // this is in theory not reachable. if it is, better halt deposits
+        // the condition is equivalent to: (totalValue = 0) ==> (total = 0)
+        require(totalValue > 0 || total == 0, "deposit: system is rekt");
+
+        uint newShare = PRECISION;
+        if(total > 0) newShare = total.mul(lusdAmount) / totalValue;
+
+        // deposit
+        require(LUSD.transferFrom(msg.sender, address(this), lusdAmount), "deposit: transferFrom failed");
+        SP.provideToSP(lusdAmount, frontEndTag);
+
+        // update LP token
+        mint(msg.sender, newShare);
+
+        emit UserDeposit(msg.sender, lusdAmount, newShare);        
+    }
+
+    function withdraw(uint numShares) external {
+        uint lusdValue = SP.getCompoundedLUSDDeposit(address(this));
+        uint ethValue = SP.getDepositorETHGain(address(this)).add(address(this).balance);
+
+        uint lusdAmount = lusdValue.mul(numShares).div(total);
+        uint ethAmount = ethValue.mul(numShares).div(total);
+
+        // this withdraws lusd, lqty, and eth
+        SP.withdrawFromSP(lusdAmount);
+
+        // update LP token
+        burn(msg.sender, numShares);
+
+        // send lusd and eth
+        if(lusdAmount > 0) LUSD.transfer(msg.sender, lusdAmount);
+        if(ethAmount > 0) {
+            (bool success, ) = msg.sender.call{ value: ethAmount }(""); // re-entry is fine here
+            require(success, "withdraw: sending ETH failed");
+        }
+
+        emit UserWithdraw(msg.sender, lusdAmount, ethAmount, numShares);            
+    }
+
+    function addBps(uint n, int bps) internal pure returns(uint) {
+        require(bps <= 10000, "reduceBps: bps exceeds max");
+        require(bps >= -10000, "reduceBps: bps exceeds min");
+
+        return n.mul(uint(10000 + bps)) / 10000;
+    }
+
+    function getSwapEthAmount(uint lusdQty) public view returns(uint ethAmount, uint feeEthAmount) {
+        uint lusdBalance = SP.getCompoundedLUSDDeposit(address(this));
+        uint ethBalance  = SP.getDepositorETHGain(address(this)).add(address(this).balance);
+
+        uint eth2usdPrice = fetchPrice();
+        if(eth2usdPrice == 0) return (0, 0); // chainlink is down
+
+        uint ethUsdValue = ethBalance.mul(eth2usdPrice) / PRECISION;
+        uint maxReturn = addBps(lusdQty.mul(PRECISION) / eth2usdPrice, int(maxDiscount));
+
+        uint xQty = lusdQty;
+        uint xBalance = lusdBalance;
+        uint yBalance = lusdBalance.add(ethUsdValue.mul(2));
+
+        uint usdReturn = getReturn(xQty, xBalance, yBalance, A);
+        uint basicEthReturn = usdReturn.mul(PRECISION) / eth2usdPrice;
+
+        if(ethBalance < basicEthReturn) basicEthReturn = ethBalance; // cannot give more than balance 
+        if(maxReturn < basicEthReturn) basicEthReturn = maxReturn;
+
+        ethAmount = addBps(basicEthReturn, -int(fee));
+        feeEthAmount = basicEthReturn.sub(ethAmount);
+    }
+
+    // get ETH in return to LUSD
+    function swap(uint lusdAmount, uint minEthReturn, address payable dest) public returns(uint) {
+        (uint ethAmount, uint feeAmount) = getSwapEthAmount(lusdAmount);
+
+        require(ethAmount >= minEthReturn, "swap: low return");
+
+        LUSD.transferFrom(msg.sender, address(this), lusdAmount);
+        SP.provideToSP(lusdAmount, frontEndTag);
+
+        if(feeAmount > 0) feePool.transfer(feeAmount);
+        (bool success, ) = dest.call{ value: ethAmount }(""); // re-entry is fine here
+        require(success, "swap: sending ETH failed");
+
+        emit RebalanceSwap(msg.sender, lusdAmount, ethAmount, now);
+
+        return ethAmount;
+    }
+
+    // kyber network reserve compatible function
+    function trade(
+        IERC20 /* srcToken */,
+        uint256 srcAmount,
+        IERC20 /* destToken */,
+        address payable destAddress,
+        uint256 /* conversionRate */,
+        bool /* validate */
+    ) external payable returns (bool) {
+        return swap(srcAmount, 0, destAddress) > 0;
+    }
+
+    function getConversionRate(
+        IERC20 /* src */,
+        IERC20 /* dest */,
+        uint256 srcQty,
+        uint256 /* blockNumber */
+    ) external view returns (uint256) {
+        (uint ethQty, ) = getSwapEthAmount(srcQty);
+        return ethQty.mul(PRECISION) / srcQty;
+    }
+
+    receive() external payable {}
+}

packages/contracts/contracts/B.Protocol/BLens.sol

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.6.11;
+
+import "./BAMM.sol";
+import "./../Dependencies/SafeMath.sol";
+
+
+contract BLens {
+    function add(uint256 x, uint256 y) public pure returns (uint256 z) {
+        require((z = x + y) >= x, "ds-math-add-overflow");
+    }
+    function sub(uint256 x, uint256 y) public pure returns (uint256 z) {
+        require((z = x - y) <= x, "ds-math-sub-underflow");
+    }
+    function mul(uint256 x, uint256 y) public pure returns (uint256 z) {
+        require(y == 0 || (z = x * y) / y == x, "ds-math-mul-overflow");
+    }
+    function divup(uint256 x, uint256 y) internal pure returns (uint256 z) {
+        z = add(x, sub(y, 1)) / y;
+    }
+    uint256 constant WAD  = 10 ** 18;
+    function wmul(uint256 x, uint256 y) public pure returns (uint256 z) {
+        z = mul(x, y) / WAD;
+    }
+    function wdiv(uint256 x, uint256 y) public pure returns (uint256 z) {
+        z = mul(x, WAD) / y;
+    }
+    function wdivup(uint256 x, uint256 y) public pure returns (uint256 z) {
+        z = divup(mul(x, WAD), y);
+    }
+    uint256 constant RAY  = 10 ** 27;
+    function rmul(uint256 x, uint256 y) public pure returns (uint256 z) {
+        z = mul(x, y) / RAY;
+    }
+    function rmulup(uint256 x, uint256 y) public pure returns (uint256 z) {
+        z = divup(mul(x, y), RAY);
+    }
+    function rdiv(uint256 x, uint256 y) public pure returns (uint256 z) {
+        z = mul(x, RAY) / y;
+    }
+
+    function getUnclaimedLqty(address user, BAMM bamm, ERC20 token) external returns(uint) {
+        // trigger bamm (p)lqty claim
+        bamm.withdraw(0);
+
+        if(bamm.total() == 0) return 0;
+
+        // duplicate harvest logic
+        uint crop = sub(token.balanceOf(address(bamm)), bamm.stock());
+        uint share = add(bamm.share(), rdiv(crop, bamm.total()));
+
+        uint last = bamm.crops(user);
+        uint curr = rmul(bamm.stake(user), share);
+        if(curr > last) return curr - last;
+        return 0;
+    }
+}

packages/contracts/contracts/B.Protocol/ChainlinkTestnet.sol

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.6.11;
+
+import "./../TestContracts/PriceFeedTestnet.sol";
+
+/*
+* PriceFeed placeholder for testnet and development. The price is simply set manually and saved in a state 
+* variable. The contract does not connect to a live Chainlink price feed. 
+*/
+contract ChainlinkTestnet {
+
+    PriceFeedTestnet feed;
+    uint time = 0;
+
+    constructor(PriceFeedTestnet _feed) public {
+        feed = _feed;
+    }
+
+    function decimals() external pure returns(uint) {
+        return 18;
+    }
+
+    function setTimestamp(uint _time) external {
+        time = _time;
+    }
+
+    function latestRoundData() external view returns
+     (
+        uint80 /* roundId */,
+        int256 answer,
+        uint256 /* startedAt */,
+        uint256 timestamp,
+        uint80 /* answeredInRound */
+    )
+    {
+        answer = int(feed.getPrice());
+        if(time == 0 ) timestamp = now;
+        else timestamp = time;
+    }
+}