@dolomite-exchange/dolomite-margin 0.2.6 → 0.2.7

package/contracts/external/traders/Expiry.sol

@@ -0,0 +1,532 @@
+/*
+
+    Copyright 2019 dYdX Trading Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+
+*/
+
+pragma solidity ^0.5.7;
+pragma experimental ABIEncoderV2;
+
+import { SafeMath } from "@openzeppelin/contracts/math/SafeMath.sol";
+import { Ownable } from "@openzeppelin/contracts/ownership/Ownable.sol";
+import { Address } from "@openzeppelin/contracts/utils/Address.sol";
+import { IAutoTrader } from "../../protocol/interfaces/IAutoTrader.sol";
+import { ICallee } from "../../protocol/interfaces/ICallee.sol";
+import { IDolomiteMargin } from "../../protocol/interfaces/IDolomiteMargin.sol";
+import { ILiquidationCallback } from "../../protocol/interfaces/ILiquidationCallback.sol";
+import { Account } from "../../protocol/lib/Account.sol";
+import { Decimal } from "../../protocol/lib/Decimal.sol";
+import { Math } from "../../protocol/lib/Math.sol";
+import { Monetary } from "../../protocol/lib/Monetary.sol";
+import { Require } from "../../protocol/lib/Require.sol";
+import { SafeLiquidationCallback } from "../../protocol/lib/SafeLiquidationCallback.sol";
+import { Time } from "../../protocol/lib/Time.sol";
+import { Types } from "../../protocol/lib/Types.sol";
+import { OnlyDolomiteMargin } from "../helpers/OnlyDolomiteMargin.sol";
+import { IExpiry } from "../interfaces/IExpiry.sol";
+
+
+/**
+ * @title Expiry
+ * @author dYdX
+ *
+ * Expiry contract that also allows approved senders to set expiry to be 28 days in the future.
+ */
+contract Expiry is
+    Ownable,
+    OnlyDolomiteMargin,
+    IExpiry,
+    ICallee,
+    IAutoTrader
+{
+    using Address for address;
+    using Math for uint256;
+    using SafeMath for uint32;
+    using SafeMath for uint256;
+    using Types for Types.Par;
+    using Types for Types.Wei;
+
+    // ============ Constants ============
+
+    bytes32 constant FILE = "Expiry";
+
+    // ============ Events ============
+
+    event ExpirySet(
+        address owner,
+        uint256 number,
+        uint256 marketId,
+        uint32 time
+    );
+
+    event LogExpiryRampTimeSet(
+        uint256 expiryRampTime
+    );
+
+    event LogSenderApproved(
+        address approver,
+        address sender,
+        uint32 minTimeDelta
+    );
+
+    // ============ Storage ============
+
+    // owner => number => market => time
+    mapping (address => mapping (uint256 => mapping (uint256 => uint32))) g_expiries;
+
+    // owner => sender => minimum time delta
+    mapping (address => mapping (address => uint32)) public g_approvedSender;
+
+    // time over which the liquidation ratio goes from zero to maximum
+    uint256 public g_expiryRampTime;
+
+    // ============ Constructor ============
+
+    constructor (
+        address dolomiteMargin,
+        uint256 expiryRampTime
+    )
+        public
+        OnlyDolomiteMargin(dolomiteMargin)
+    {
+        g_expiryRampTime = expiryRampTime;
+    }
+
+    // ============ Admin Functions ============
+
+    function ownerSetExpiryRampTime(
+        uint256 newExpiryRampTime
+    )
+        external
+        onlyOwner
+    {
+        emit LogExpiryRampTimeSet(newExpiryRampTime);
+        g_expiryRampTime = newExpiryRampTime;
+    }
+
+    // ============ Approval Functions ============
+
+    function approveSender(
+        address sender,
+        uint32 minTimeDelta
+    )
+        external
+    {
+        _setApproval(msg.sender, sender, minTimeDelta);
+    }
+
+    // ============ Only-DolomiteMargin Functions ============
+
+    function callFunction(
+        address /* sender */,
+        Account.Info memory account,
+        bytes memory data
+    )
+        public
+        onlyDolomiteMargin(msg.sender)
+    {
+        CallFunctionType callType = abi.decode(data, (CallFunctionType));
+        if (callType == CallFunctionType.SetExpiry) {
+            _callFunctionSetExpiry(account.owner, data);
+        } else {
+            _callFunctionSetApproval(account.owner, data);
+        }
+    }
+
+    function getTradeCost(
+        uint256 inputMarketId,
+        uint256 outputMarketId,
+        Account.Info memory makerAccount,
+        Account.Info memory /* takerAccount */,
+        Types.Par memory oldInputPar,
+        Types.Par memory newInputPar,
+        Types.Wei memory inputWei,
+        bytes memory data
+    )
+        public
+        onlyDolomiteMargin(msg.sender)
+        returns (Types.AssetAmount memory)
+    {
+        // return zero if input amount is zero
+        if (inputWei.isZero()) {
+            return Types.AssetAmount({
+                sign: true,
+                denomination: Types.AssetDenomination.Par,
+                ref: Types.AssetReference.Delta,
+                value: 0
+            });
+        }
+
+        (uint256 owedMarketId, uint32 maxExpiry) = abi.decode(data, (uint256, uint32));
+
+        uint32 expiry = getExpiry(makerAccount, owedMarketId);
+
+        // validate expiry
+        Require.that(
+            expiry != 0,
+            FILE,
+            "Expiry not set",
+            makerAccount.owner,
+            makerAccount.number,
+            owedMarketId
+        );
+        Require.that(
+            expiry <= Time.currentTime(),
+            FILE,
+            "Borrow not yet expired",
+            expiry
+        );
+        Require.that(
+            expiry <= maxExpiry,
+            FILE,
+            "Expiry past maxExpiry",
+            expiry
+        );
+
+        return _getTradeCostInternal(
+            DOLOMITE_MARGIN,
+            inputMarketId,
+            outputMarketId,
+            makerAccount,
+            oldInputPar,
+            newInputPar,
+            inputWei,
+            owedMarketId,
+            expiry
+        );
+    }
+
+    // ============ Getters ============
+
+    function getExpiry(
+        Account.Info memory account,
+        uint256 marketId
+    )
+        public
+        view
+        returns (uint32)
+    {
+        return g_expiries[account.owner][account.number][marketId];
+    }
+
+    function getSpreadAdjustedPrices(
+        uint256 heldMarketId,
+        uint256 owedMarketId,
+        uint32 expiry
+    )
+        public
+        view
+        returns (
+            Monetary.Price memory,
+            Monetary.Price memory
+        )
+    {
+        return _getSpreadAdjustedPrices(
+            DOLOMITE_MARGIN,
+            heldMarketId,
+            owedMarketId,
+            expiry
+        );
+    }
+
+    // ============ Private Functions ============
+
+    function _getSpreadAdjustedPrices(
+        IDolomiteMargin dolomiteMargin,
+        uint256 heldMarketId,
+        uint256 owedMarketId,
+        uint32 expiry
+    )
+        private
+        view
+        returns (
+            Monetary.Price memory,
+            Monetary.Price memory
+        )
+    {
+        Decimal.D256 memory spread = dolomiteMargin.getLiquidationSpreadForPair(
+            heldMarketId,
+            owedMarketId
+        );
+
+        uint256 expiryAge = Time.currentTime().sub(expiry);
+
+        if (expiryAge < g_expiryRampTime) {
+            spread.value = Math.getPartial(spread.value, expiryAge, g_expiryRampTime);
+        }
+
+        Monetary.Price memory heldPrice = dolomiteMargin.getMarketPrice(heldMarketId);
+        Monetary.Price memory owedPrice = dolomiteMargin.getMarketPrice(owedMarketId);
+        owedPrice.value = owedPrice.value.add(Decimal.mul(owedPrice.value, spread));
+
+        return (heldPrice, owedPrice);
+    }
+
+    function _callFunctionSetExpiry(
+        address sender,
+        bytes memory data
+    )
+        private
+    {
+        (
+            CallFunctionType callType,
+            SetExpiryArg[] memory expiries
+        ) = abi.decode(data, (CallFunctionType, SetExpiryArg[]));
+
+        assert(callType == CallFunctionType.SetExpiry);
+
+        for (uint256 i = 0; i < expiries.length; i++) {
+            SetExpiryArg memory exp = expiries[i];
+            if (exp.account.owner != sender) {
+                // don't do anything if sender is not approved for this action
+                uint32 minApprovedTimeDelta = g_approvedSender[exp.account.owner][sender];
+                if (minApprovedTimeDelta == 0 || exp.timeDelta < minApprovedTimeDelta) {
+                    continue;
+                }
+            }
+
+            // if timeDelta is zero, interpret it as unset expiry
+            if (
+                exp.timeDelta != 0 &&
+                DOLOMITE_MARGIN.getAccountPar(exp.account, exp.marketId).isNegative()
+            ) {
+                // only change non-zero values if forceUpdate is true
+                if (exp.forceUpdate || getExpiry(exp.account, exp.marketId) == 0) {
+                    uint32 newExpiryTime = Time.currentTime().add(exp.timeDelta).to32();
+                    _setExpiry(exp.account, exp.marketId, newExpiryTime);
+                }
+            } else {
+                // timeDelta is zero or account has non-negative balance
+                _setExpiry(exp.account, exp.marketId, 0);
+            }
+        }
+    }
+
+    function _callFunctionSetApproval(
+        address sender,
+        bytes memory data
+    )
+        private
+    {
+        (
+            CallFunctionType callType,
+            SetApprovalArg memory approvalArg
+        ) = abi.decode(data, (CallFunctionType, SetApprovalArg));
+        assert(callType == CallFunctionType.SetApproval);
+        _setApproval(sender, approvalArg.sender, approvalArg.minTimeDelta);
+    }
+
+    function _getTradeCostInternal(
+        IDolomiteMargin dolomiteMargin,
+        uint256 inputMarketId,
+        uint256 outputMarketId,
+        Account.Info memory makerAccount,
+        Types.Par memory oldInputPar,
+        Types.Par memory newInputPar,
+        Types.Wei memory inputWei,
+        uint256 owedMarketId,
+        uint32 expiry
+    )
+        private
+        returns (Types.AssetAmount memory)
+    {
+        Types.AssetAmount memory output;
+        Types.Wei memory maxOutputWei = dolomiteMargin.getAccountWei(makerAccount, outputMarketId);
+
+        if (inputWei.isPositive()) {
+            Require.that(
+                inputMarketId == owedMarketId,
+                FILE,
+                "inputMarket mismatch",
+                inputMarketId
+            );
+            Require.that(
+                !newInputPar.isPositive(),
+                FILE,
+                "Borrows cannot be overpaid",
+                newInputPar.value
+            );
+            assert(oldInputPar.isNegative());
+            Require.that(
+                maxOutputWei.isPositive(),
+                FILE,
+                "Collateral must be positive",
+                outputMarketId,
+                maxOutputWei.value
+            );
+            output = _owedWeiToHeldWei(
+                dolomiteMargin,
+                inputWei,
+                outputMarketId,
+                inputMarketId,
+                expiry
+            );
+
+            // clear expiry if borrow is fully repaid
+            if (newInputPar.isZero()) {
+                _setExpiry(makerAccount, owedMarketId, 0);
+            }
+        } else {
+            Require.that(
+                outputMarketId == owedMarketId,
+                FILE,
+                "outputMarket mismatch",
+                outputMarketId
+            );
+            Require.that(
+                !newInputPar.isNegative(),
+                FILE,
+                "Collateral cannot be overused",
+                newInputPar.value
+            );
+            assert(oldInputPar.isPositive());
+            Require.that(
+                maxOutputWei.isNegative(),
+                FILE,
+                "Borrows must be negative",
+                outputMarketId,
+                maxOutputWei.value
+            );
+            output = _heldWeiToOwedWei(
+                dolomiteMargin,
+                inputWei,
+                inputMarketId,
+                outputMarketId,
+                expiry
+            );
+
+            // clear expiry if borrow is fully repaid
+            if (output.value == maxOutputWei.value) {
+                _setExpiry(makerAccount, owedMarketId, 0);
+            }
+        }
+
+        Require.that(
+            output.value <= maxOutputWei.value,
+            FILE,
+            "outputMarket too small",
+            output.value,
+            maxOutputWei.value
+        );
+        assert(output.sign != maxOutputWei.sign);
+
+        SafeLiquidationCallback.callLiquidateCallbackIfNecessary(
+            makerAccount,
+            owedMarketId == inputMarketId ? outputMarketId : inputMarketId,
+            owedMarketId == inputMarketId ? Types.Wei(output.sign, output.value) : inputWei,
+            owedMarketId,
+            owedMarketId == inputMarketId ? inputWei : Types.Wei(output.sign, output.value)
+        );
+
+        return output;
+    }
+
+    function _setExpiry(
+        Account.Info memory account,
+        uint256 marketId,
+        uint32 time
+    )
+        private
+    {
+        g_expiries[account.owner][account.number][marketId] = time;
+        emit ExpirySet(
+            account.owner,
+            account.number,
+            marketId,
+            time
+        );
+    }
+
+    function _setApproval(
+        address approver,
+        address sender,
+        uint32 minTimeDelta
+    )
+        private
+    {
+        g_approvedSender[approver][sender] = minTimeDelta;
+        emit LogSenderApproved(approver, sender, minTimeDelta);
+    }
+
+    function _heldWeiToOwedWei(
+        IDolomiteMargin dolomiteMargin,
+        Types.Wei memory heldWei,
+        uint256 heldMarketId,
+        uint256 owedMarketId,
+        uint32 expiry
+    )
+        private
+        view
+        returns (Types.AssetAmount memory)
+    {
+        (
+            Monetary.Price memory heldPrice,
+            Monetary.Price memory owedPrice
+        ) = _getSpreadAdjustedPrices(
+            dolomiteMargin,
+            heldMarketId,
+            owedMarketId,
+            expiry
+        );
+
+        uint256 owedAmount = Math.getPartialRoundUp(
+            heldWei.value,
+            heldPrice.value,
+            owedPrice.value
+        );
+
+        return Types.AssetAmount({
+            sign: true,
+            denomination: Types.AssetDenomination.Wei,
+            ref: Types.AssetReference.Delta,
+            value: owedAmount
+        });
+    }
+
+    function _owedWeiToHeldWei(
+        IDolomiteMargin dolomiteMargin,
+        Types.Wei memory owedWei,
+        uint256 heldMarketId,
+        uint256 owedMarketId,
+        uint32 expiry
+    )
+        private
+        view
+        returns (Types.AssetAmount memory)
+    {
+        (
+            Monetary.Price memory heldPrice,
+            Monetary.Price memory owedPrice
+        ) = _getSpreadAdjustedPrices(
+            dolomiteMargin,
+            heldMarketId,
+            owedMarketId,
+            expiry
+        );
+
+        uint256 heldAmount = Math.getPartial(
+            owedWei.value,
+            owedPrice.value,
+            heldPrice.value
+        );
+
+        return Types.AssetAmount({
+            sign: false,
+            denomination: Types.AssetDenomination.Wei,
+            ref: Types.AssetReference.Delta,
+            value: heldAmount
+        });
+    }
+}

package/contracts/external/uniswap-v2/UniswapV2ERC20.sol

@@ -0,0 +1,118 @@
+pragma solidity ^0.5.16;
+
+import "@openzeppelin/contracts/math/SafeMath.sol";
+
+
+contract UniswapV2ERC20 {
+    using SafeMath for uint;
+
+    // solium-disable-next-line uppercase
+    string public constant name = "Uniswap V2";
+    // solium-disable-next-line uppercase
+    string public constant symbol = "UNI-V2";
+    // solium-disable-next-line uppercase
+    uint8 public constant decimals = 18;
+    uint  public totalSupply;
+    mapping(address => uint) public balanceOf;
+    mapping(address => mapping(address => uint)) public allowance;
+
+    bytes32 public DOMAIN_SEPARATOR;
+    // keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
+    bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
+    mapping(address => uint) public nonces;
+
+    event Approval(address indexed owner, address indexed spender, uint value);
+    event Transfer(address indexed from, address indexed to, uint value);
+
+    constructor() public {
+        uint chainId;
+        // solium-disable-next-line security/no-inline-assembly
+        assembly {
+            chainId := chainid()
+        }
+        DOMAIN_SEPARATOR = keccak256(
+            abi.encode(
+                keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
+                keccak256(bytes(name)),
+                keccak256(bytes("1")),
+                chainId,
+                address(this)
+            )
+        );
+    }
+
+    function approve(address spender, uint value) external returns (bool) {
+        _approve(msg.sender, spender, value);
+        return true;
+    }
+
+    function transfer(address to, uint value) external returns (bool) {
+        _transfer(msg.sender, to, value);
+        return true;
+    }
+
+    function transferFrom(address from, address to, uint value) external returns (bool) {
+        if (allowance[from][msg.sender] != uint(-1)) {
+            allowance[from][msg.sender] = allowance[from][msg.sender].sub(value);
+        }
+        _transfer(from, to, value);
+        return true;
+    }
+
+    function permit(
+        address owner,
+        address spender,
+        uint value,
+        uint deadline,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    )
+        external
+    {
+        require(deadline >= block.timestamp, "UniswapV2: EXPIRED");
+        bytes32 digest = keccak256(
+            abi.encodePacked(
+                "\x19\x01",
+                DOMAIN_SEPARATOR,
+                keccak256(
+                    abi.encode(
+                        PERMIT_TYPEHASH,
+                        owner,
+                        spender,
+                        value,
+                        nonces[owner]++,
+                        deadline
+                    )
+                )
+            )
+        );
+        // solium-disable-next-line arg-overflow
+        address recoveredAddress = ecrecover(digest, v, r, s);
+        require(recoveredAddress != address(0) && recoveredAddress == owner, "UniswapV2: INVALID_SIGNATURE");
+        _approve(owner, spender, value);
+    }
+
+    function _mint(address to, uint value) internal {
+        totalSupply = totalSupply.add(value);
+        balanceOf[to] = balanceOf[to].add(value);
+        emit Transfer(address(0), to, value);
+    }
+
+    function _burn(address from, uint value) internal {
+        balanceOf[from] = balanceOf[from].sub(value);
+        totalSupply = totalSupply.sub(value);
+        emit Transfer(from, address(0), value);
+    }
+
+    function _approve(address owner, address spender, uint value) private {
+        allowance[owner][spender] = value;
+        emit Approval(owner, spender, value);
+    }
+
+    function _transfer(address from, address to, uint value) private {
+        balanceOf[from] = balanceOf[from].sub(value);
+        balanceOf[to] = balanceOf[to].add(value);
+        emit Transfer(from, to, value);
+    }
+}

package/contracts/external/uniswap-v2/UniswapV2Factory.sol

@@ -0,0 +1,67 @@
+pragma solidity ^0.5.16;
+
+import "./interfaces/IUniswapV2Factory.sol";
+
+import "./UniswapV2Pair.sol";
+
+
+contract UniswapV2Factory is IUniswapV2Factory {
+    address public feeTo;
+    address public feeToSetter;
+
+    mapping(address => mapping(address => address)) public getPair;
+    address[] public allPairs;
+
+    event PairCreated(address indexed token0, address indexed token1, address pair, uint);
+
+    constructor(address _feeToSetter) public {
+        feeToSetter = _feeToSetter;
+    }
+
+    function allPairsLength() external view returns (uint) {
+        return allPairs.length;
+    }
+
+    function createPair(address tokenA, address tokenB) external returns (address pair) {
+        require(tokenA != tokenB, "UniswapV2: IDENTICAL_ADDRESSES");
+        (address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
+        require(token0 != address(0), "UniswapV2: ZERO_ADDRESS");
+        require(getPair[token0][token1] == address(0), "UniswapV2: PAIR_EXISTS"); // single check is sufficient
+        bytes memory bytecode = type(UniswapV2Pair).creationCode;
+        bytes32 salt = keccak256(abi.encodePacked(token0, token1));
+        // solium-disable security/no-inline-assembly
+        assembly {
+            pair := create2(0, add(bytecode, 32), mload(bytecode), salt)
+        }
+        UniswapV2Pair(pair).initialize(token0, token1);
+        getPair[token0][token1] = pair;
+        getPair[token1][token0] = pair; // populate mapping in the reverse direction
+        allPairs.push(pair);
+        emit PairCreated(
+            token0,
+            token1,
+            pair,
+            allPairs.length
+        );
+    }
+
+    function setFeeTo(address _feeTo) external {
+        require(msg.sender == feeToSetter, "UniswapV2: FORBIDDEN");
+        feeTo = _feeTo;
+    }
+
+    function setFeeToSetter(address _feeToSetter) external {
+        require(msg.sender == feeToSetter, "UniswapV2: FORBIDDEN");
+        feeToSetter = _feeToSetter;
+    }
+
+    function getPairInitCodeHash() external pure returns (bytes32) {
+        // This function is not in the IUniswapV2Factory interface because it does not exist in production
+        return keccak256(getPairInitCode());
+    }
+
+    function getPairInitCode() public pure returns (bytes memory) {
+        // This function is not in the IUniswapV2Factory interface because it does not exist in production
+        return type(UniswapV2Pair).creationCode;
+    }
+}