@dolomite-exchange/dolomite-margin 0.2.6 → 0.2.7

package/contracts/external/lib/DolomiteAmmLibrary.sol

@@ -0,0 +1,323 @@
+/*
+
+    Copyright 2021 Dolomite.
+
+    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.0;
+
+import "@openzeppelin/contracts/math/SafeMath.sol";
+
+import "../../protocol/lib/Require.sol";
+
+import "../uniswap-v2/interfaces/IUniswapV2Pair.sol";
+
+import "../interfaces/IDolomiteAmmFactory.sol";
+import "../interfaces/IDolomiteAmmPair.sol";
+
+
+library DolomiteAmmLibrary {
+    using SafeMath for uint;
+
+    bytes32 private constant FILE = "DolomiteAmmLibrary";
+    bytes32 private constant PAIR_INIT_CODE_HASH = 0x752b18f9c5dbceeac7339c1e7d27b76a85637748e21b577cfb0b8768a8fd5ce7;
+
+    function getPairInitCodeHash() internal pure returns (bytes32) {
+        return PAIR_INIT_CODE_HASH;
+    }
+
+    function getPools(
+        address factory,
+        address[] memory path
+    ) internal pure returns (address[] memory) {
+        return getPools(factory, PAIR_INIT_CODE_HASH, path);
+    }
+
+    function getPools(
+        address factory,
+        bytes32 initCodeHash,
+        address[] memory path
+    ) internal pure returns (address[] memory) {
+        Require.that(
+            path.length >= 2,
+            FILE,
+            "invalid path length"
+        );
+
+        address[] memory pools = new address[](path.length - 1);
+        for (uint i = 0; i < path.length - 1; i++) {
+            pools[i] = pairFor(
+                factory,
+                path[i],
+                path[i + 1],
+                initCodeHash
+            );
+        }
+        return pools;
+    }
+
+    // returns sorted token addresses, used to handle return values from pairs sorted in this order
+    function sortTokens(address tokenA, address tokenB) internal pure returns (address token0, address token1) {
+        Require.that(
+            tokenA != tokenB,
+            FILE,
+            "identical addresses"
+        );
+        (token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
+        Require.that(
+            token0 != address(0),
+            FILE,
+            "zero address"
+        );
+    }
+
+    // calculates the CREATE2 address for a pair without making any external calls
+    function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
+        return pairFor(
+            factory,
+            tokenA,
+            tokenB,
+            PAIR_INIT_CODE_HASH
+        );
+    }
+
+    function pairFor(
+        address factory,
+        address tokenA,
+        address tokenB,
+        bytes32 initCodeHash
+    ) internal pure returns (address pair) {
+        (address token0, address token1) = sortTokens(tokenA, tokenB);
+        pair = address(
+            uint(
+                keccak256(
+                    abi.encodePacked(
+                        hex"ff",
+                        factory,
+                        keccak256(abi.encodePacked(token0, token1)),
+                        initCodeHash
+                    )
+                )
+            )
+        );
+    }
+
+    // fetches and sorts the reserves for a pair
+    function getReservesWei(
+        address factory,
+        address tokenA,
+        address tokenB
+    ) internal view returns (uint reserveA, uint reserveB) {
+        return getReservesWei(
+            factory,
+            PAIR_INIT_CODE_HASH,
+            tokenA,
+            tokenB
+        );
+    }
+
+    function getReserves(
+        address factory,
+        bytes32 initCodeHash,
+        address tokenA,
+        address tokenB
+    ) internal view returns (uint reserveA, uint reserveB) {
+        (address token0,) = sortTokens(tokenA, tokenB);
+        (uint reserve0, uint reserve1,) = IUniswapV2Pair(
+            pairFor(
+                factory,
+                tokenA,
+                tokenB,
+                initCodeHash
+            )
+        ).getReserves();
+        (reserveA, reserveB) = tokenA == token0 ? (reserve0, reserve1) : (reserve1, reserve0);
+    }
+
+    function getReservesWei(
+        address factory,
+        bytes32 initCodeHash,
+        address tokenA,
+        address tokenB
+    ) internal view returns (uint reserveA, uint reserveB) {
+        (address token0,) = sortTokens(tokenA, tokenB);
+        (uint reserve0, uint reserve1,) = IDolomiteAmmPair(
+            pairFor(
+                factory,
+                tokenA,
+                tokenB,
+                initCodeHash
+            )
+        ).getReservesWei();
+        (reserveA, reserveB) = tokenA == token0 ? (reserve0, reserve1) : (reserve1, reserve0);
+    }
+
+    // given some amount of an asset and pair reserves, returns an equivalent amount of the other asset
+    function quote(uint amountA, uint reserveA, uint reserveB) internal pure returns (uint amountB) {
+        Require.that(
+            amountA > 0,
+            FILE,
+            "insufficient amount"
+        );
+        Require.that(
+            reserveA > 0 && reserveB > 0,
+            FILE,
+            "insufficient liquidity"
+        );
+        amountB = amountA.mul(reserveB) / reserveA;
+    }
+
+    // given an input amount of an asset and pair reserves, returns the maximum output amount of the other asset
+    function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) internal pure returns (uint amountOut) {
+        Require.that(
+            amountIn > 0,
+            FILE,
+            "insufficient input amount"
+        );
+        Require.that(
+            reserveIn > 0 && reserveOut > 0,
+            FILE,
+            "insufficient liquidity"
+        );
+        uint amountInWithFee = amountIn.mul(997);
+        uint numerator = amountInWithFee.mul(reserveOut);
+        uint denominator = reserveIn.mul(1000).add(amountInWithFee);
+        amountOut = numerator / denominator;
+    }
+
+    // given an output amount of an asset and pair reserves, returns a required input amount of the other asset
+    function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) internal pure returns (uint amountIn) {
+        Require.that(
+            amountOut > 0,
+            FILE,
+            "insufficient output amount"
+        );
+        Require.that(
+            reserveIn > 0 && reserveOut > 0,
+            FILE,
+            "insufficient liquidity"
+        );
+        uint numerator = reserveIn.mul(amountOut).mul(1000);
+        uint denominator = reserveOut.sub(amountOut).mul(997);
+        // reverts from the 'sub'
+        amountIn = numerator.div(denominator).add(1);
+    }
+
+    // performs chained getAmountOut calculations on any number of pairs
+    function getAmountsOutWei(
+        address factory,
+        uint amountIn,
+        address[] memory path
+    ) internal view returns (uint[] memory amounts) {
+        Require.that(
+            path.length >= 2,
+            FILE,
+            "invalid path"
+        );
+        amounts = new uint[](path.length);
+        amounts[0] = amountIn;
+        for (uint i; i < path.length - 1; i++) {
+            (uint reserveIn, uint reserveOut) = getReservesWei(factory, path[i], path[i + 1]);
+            amounts[i + 1] = getAmountOut(amounts[i], reserveIn, reserveOut);
+        }
+    }
+
+    // performs chained getAmountOut calculations on any number of pairs
+    function getAmountsOutWei(
+        address factory,
+        bytes32 initCodeHash,
+        uint amountIn,
+        address[] memory path
+    ) internal view returns (uint[] memory amounts) {
+        Require.that(
+            path.length >= 2,
+            FILE,
+            "invalid path"
+        );
+        amounts = new uint[](path.length);
+        amounts[0] = amountIn;
+        for (uint i; i < path.length - 1; i++) {
+            (uint reserveIn, uint reserveOut) = getReservesWei(
+                factory,
+                initCodeHash,
+                path[i],
+                path[i + 1]
+            );
+            amounts[i + 1] = getAmountOut(amounts[i], reserveIn, reserveOut);
+        }
+    }
+
+    function getAmountsInWei(
+        address factory,
+        bytes32 initCodeHash,
+        uint amountOut,
+        address[] memory path
+    ) internal view returns (uint[] memory amounts) {
+        Require.that(
+            path.length >= 2,
+            FILE,
+            "invalid path"
+        );
+        amounts = new uint[](path.length);
+        amounts[amounts.length - 1] = amountOut;
+        for (uint i = path.length - 1; i > 0; i--) {
+            (uint reserveIn, uint reserveOut) = getReservesWei(
+                factory,
+                initCodeHash,
+                path[i - 1],
+                path[i]
+            );
+            amounts[i - 1] = getAmountIn(amounts[i], reserveIn, reserveOut);
+        }
+    }
+
+    function getAmountsIn(
+        address factory,
+        bytes32 initCodeHash,
+        uint amountOut,
+        address[] memory path
+    ) internal view returns (uint[] memory amounts) {
+        Require.that(
+            path.length >= 2,
+            FILE,
+            "invalid path"
+        );
+        amounts = new uint[](path.length);
+        amounts[amounts.length - 1] = amountOut;
+        for (uint i = path.length - 1; i > 0; i--) {
+            (uint reserveIn, uint reserveOut) = getReserves(
+                factory,
+                initCodeHash,
+                path[i - 1],
+                path[i]
+            );
+            amounts[i - 1] = getAmountIn(amounts[i], reserveIn, reserveOut);
+        }
+    }
+
+    // performs chained getAmountIn calculations on any number of pairs
+    function getAmountsInWei(
+        address factory,
+        uint amountOut,
+        address[] memory path
+    ) internal view returns (uint[] memory amounts) {
+        return getAmountsInWei(
+            factory,
+            PAIR_INIT_CODE_HASH,
+            amountOut,
+            path
+        );
+    }
+}

package/contracts/external/lib/TypedSignature.sol

@@ -0,0 +1,120 @@
+/*
+
+    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 { Require } from "../../protocol/lib/Require.sol";
+
+
+/**
+ * @title TypedSignature
+ * @author dYdX
+ *
+ * Library to unparse typed signatures
+ */
+library TypedSignature {
+
+    // ============ Constants ============
+
+    bytes32 constant private FILE = "TypedSignature";
+
+    // prepended message with the length of the signed hash in decimal
+    bytes constant private PREPEND_DEC = "\x19Ethereum Signed Message:\n32";
+
+    // prepended message with the length of the signed hash in hexadecimal
+    bytes constant private PREPEND_HEX = "\x19Ethereum Signed Message:\n\x20";
+
+    // Number of bytes in a typed signature
+    uint256 constant private NUM_SIGNATURE_BYTES = 66;
+
+    // ============ Enums ============
+
+    // Different RPC providers may implement signing methods differently, so we allow different
+    // signature types depending on the string prepended to a hash before it was signed.
+    enum SignatureType {
+        NoPrepend,   // No string was prepended.
+        Decimal,     // PREPEND_DEC was prepended.
+        Hexadecimal, // PREPEND_HEX was prepended.
+        Invalid      // Not a valid type. Used for bound-checking.
+    }
+
+    // ============ Functions ============
+
+    /**
+     * Gives the address of the signer of a hash. Also allows for the commonly prepended string of
+     * '\x19Ethereum Signed Message:\n' + message.length
+     *
+     * @param  hash               Hash that was signed (does not include prepended message)
+     * @param  signatureWithType  Type and ECDSA signature with structure: {32:r}{32:s}{1:v}{1:type}
+     * @return                    address of the signer of the hash
+     */
+    function recover(
+        bytes32 hash,
+        bytes memory signatureWithType
+    )
+        internal
+        pure
+        returns (address)
+    {
+        Require.that(
+            signatureWithType.length == NUM_SIGNATURE_BYTES,
+            FILE,
+            "Invalid signature length"
+        );
+
+        bytes32 r;
+        bytes32 s;
+        uint8 v;
+        uint8 rawSigType;
+
+        /* solium-disable-next-line security/no-inline-assembly */
+        assembly {
+            r := mload(add(signatureWithType, 0x20))
+            s := mload(add(signatureWithType, 0x40))
+            let lastSlot := mload(add(signatureWithType, 0x60))
+            v := byte(0, lastSlot)
+            rawSigType := byte(1, lastSlot)
+        }
+
+        Require.that(
+            rawSigType < uint8(SignatureType.Invalid),
+            FILE,
+            "Invalid signature type"
+        );
+
+        SignatureType sigType = SignatureType(rawSigType);
+
+        bytes32 signedHash;
+        if (sigType == SignatureType.NoPrepend) {
+            signedHash = hash;
+        } else if (sigType == SignatureType.Decimal) {
+            signedHash = keccak256(abi.encodePacked(PREPEND_DEC, hash));
+        } else {
+            assert(sigType == SignatureType.Hexadecimal);
+            signedHash = keccak256(abi.encodePacked(PREPEND_HEX, hash));
+        }
+
+        return ecrecover(
+            signedHash,
+            v,
+            r,
+            s
+        );
+    }
+}

package/contracts/external/lib/UQ112x112.sol

@@ -0,0 +1,22 @@
+pragma solidity ^0.5.16;
+
+// a library for handling binary fixed point numbers (https://en.wikipedia.org/wiki/Q_(number_format))
+
+// range: [0, 2**112 - 1]
+// resolution: 1 / 2**112
+
+
+library UQ112x112 {
+    uint224 constant Q112 = 2 ** 112;
+
+    // encode a uint112 as a UQ112x112
+    function encode(uint112 y) internal pure returns (uint224 z) {
+        // never overflows
+        z = uint224(y) * Q112;
+    }
+
+    // divide a UQ112x112 by a uint112, returning a UQ112x112
+    function uqdiv(uint224 x, uint112 y) internal pure returns (uint224 z) {
+        z = x / uint224(y);
+    }
+}

package/contracts/external/multisig/DelayedMultiSig.sol

@@ -0,0 +1,206 @@
+/*
+
+    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 { MultiSig } from "./MultiSig.sol";
+
+
+/**
+ * @title DelayedMultiSig
+ * @author dYdX
+ *
+ * Multi-Signature Wallet with delay in execution.
+ * Allows multiple parties to execute a transaction after a time lock has passed.
+ * Adapted from Amir Bandeali's MultiSigWalletWithTimeLock contract.
+
+ * Logic Changes:
+ *  - Only owners can execute transactions
+ *  - Require that each transaction succeeds
+ *  - Added function to execute multiple transactions within the same Ethereum transaction
+ */
+contract DelayedMultiSig is
+    MultiSig
+{
+    // ============ Events ============
+
+    event ConfirmationTimeSet(uint256 indexed transactionId, uint256 confirmationTime);
+    event TimeLockChange(uint32 secondsTimeLocked);
+
+    // ============ Storage ============
+
+    uint32 public secondsTimeLocked;
+    mapping (uint256 => uint256) public confirmationTimes;
+
+    // ============ Modifiers ============
+
+    modifier notFullyConfirmed(
+        uint256 transactionId
+    ) {
+        require(
+            !isConfirmed(transactionId),
+            "TX_FULLY_CONFIRMED"
+        );
+        _;
+    }
+
+    modifier fullyConfirmed(
+        uint256 transactionId
+    ) {
+        require(
+            isConfirmed(transactionId),
+            "TX_NOT_FULLY_CONFIRMED"
+        );
+        _;
+    }
+
+    modifier pastTimeLock(
+        uint256 transactionId
+    ) {
+        require(
+            block.timestamp >= confirmationTimes[transactionId] + secondsTimeLocked,
+            "TIME_LOCK_INCOMPLETE"
+        );
+        _;
+    }
+
+    // ============ Constructor ============
+
+    /**
+     * Contract constructor sets initial owners, required number of confirmations, and time lock.
+     *
+     * @param  _owners             List of initial owners.
+     * @param  _required           Number of required confirmations.
+     * @param  _secondsTimeLocked  Duration needed after a transaction is confirmed and before it
+     *                             becomes executable, in seconds.
+     */
+    constructor (
+        address[] memory _owners,
+        uint256 _required,
+        uint32 _secondsTimeLocked
+    )
+        public
+        MultiSig(_owners, _required)
+    {
+        secondsTimeLocked = _secondsTimeLocked;
+    }
+
+    // ============ Wallet-Only Functions ============
+
+    /**
+     * Changes the duration of the time lock for transactions.
+     *
+     * @param  _secondsTimeLocked  Duration needed after a transaction is confirmed and before it
+     *                             becomes executable, in seconds.
+     */
+    function changeTimeLock(
+        uint32 _secondsTimeLocked
+    )
+        public
+        onlyWallet
+    {
+        secondsTimeLocked = _secondsTimeLocked;
+        emit TimeLockChange(_secondsTimeLocked);
+    }
+
+    // ============ Admin Functions ============
+
+    /**
+     * Allows an owner to confirm a transaction.
+     * Overrides the function in MultiSig.
+     *
+     * @param  transactionId  Transaction ID.
+     */
+    function confirmTransaction(
+        uint256 transactionId
+    )
+        public
+        ownerExists(msg.sender)
+        transactionExists(transactionId)
+        notConfirmed(transactionId, msg.sender)
+        notFullyConfirmed(transactionId)
+    {
+        confirmations[transactionId][msg.sender] = true;
+        emit Confirmation(msg.sender, transactionId);
+        if (isConfirmed(transactionId)) {
+            setConfirmationTime(transactionId, block.timestamp);
+        }
+    }
+
+    /**
+     * Allows an owner to execute a confirmed transaction.
+     * Overrides the function in MultiSig.
+     *
+     * @param  transactionId  Transaction ID.
+     */
+    function executeTransaction(
+        uint256 transactionId
+    )
+        public
+        ownerExists(msg.sender)
+        notExecuted(transactionId)
+        fullyConfirmed(transactionId)
+        pastTimeLock(transactionId)
+    {
+        Transaction storage txn = transactions[transactionId];
+        txn.executed = true;
+        bool success = externalCall(
+            txn.destination,
+            txn.value,
+            txn.data.length,
+            txn.data
+        );
+        require(
+            success,
+            "TX_REVERTED"
+        );
+        emit Execution(transactionId);
+    }
+
+    /**
+     * Allows an owner to execute multiple confirmed transactions.
+     *
+     * @param  transactionIds  List of transaction IDs.
+     */
+    function executeMultipleTransactions(
+        uint256[] memory transactionIds
+    )
+        public
+        ownerExists(msg.sender)
+    {
+        for (uint256 i = 0; i < transactionIds.length; i++) {
+            executeTransaction(transactionIds[i]);
+        }
+    }
+
+    // ============ Helper Functions ============
+
+    /**
+     * Sets the time of when a submission first passed.
+     */
+    function setConfirmationTime(
+        uint256 transactionId,
+        uint256 confirmationTime
+    )
+        internal
+    {
+        confirmationTimes[transactionId] = confirmationTime;
+        emit ConfirmationTimeSet(transactionId, confirmationTime);
+    }
+}