Orion Protocol

1/**
2 * @title Exchange
3 * @dev Exchange contract for the Orion Protocol
4 * @author @wafflemakr
5 */
6​
7/*
8  Overflow safety:
9  We do not use SafeMath and control overflows by
10  not accepting large ints on input.
11  Balances inside contract are stored as int192.
12  Allowed input amounts are int112 or uint112: it is enough for all
13  practically used tokens: for instance if decimal unit is 1e18, int112
14  allow to encode up to 2.5e15 decimal units.
15  That way adding/subtracting any amount from balances won't overflow, since
16  minimum number of operations to reach max int is practically infinite: ~1e24.
17  Allowed prices are uint64. Note, that price is represented as
18  price per 1e8 tokens. That means that amount*price always fit uint256,
19  while amount*price/1e8 not only fit int192, but also can be added, subtracted
20  without overflow checks: number of malicion operations to overflow ~1e13.
21*/
22contract Exchange is OrionVault, ReentrancyGuard {
23​
24    using LibValidator for LibValidator.Order;
25    using SafeERC20 for IERC20;
26​
27    /  Flags for updateOrders
28    /      All flags are explicit
29    uint8 constant kSell = 0;
30    uint8 constant kBuy = 1;    //  if 0 - then sell
31    uint8 constant kCorrectMatcherFeeByOrderAmount = 2;
32​
33    // EVENTS
34    event NewAssetTransaction(
35        address indexed user,
36        address indexed assetAddress,
37        bool isDeposit,
38        uint112 amount,
39        uint64 timestamp
40    );
41​
42    event NewTrade(
43        address indexed buyer,
44        address indexed seller,
45        address baseAsset,
46        address quoteAsset,
47        uint64 filledPrice,
48        uint192 filledAmount,
49        uint192 amountQuote
50    );
51​
52    // MAIN FUNCTIONS
53​
54    /**
55     * @dev Since Exchange will work behind the Proxy contract it can not have constructor
56     */
57    function initialize() public payable initializer {
58        OwnableUpgradeSafe.__Ownable_init();
59    }
60​
61    /**
62     * @dev set basic Exchange params
63     * @param orionToken - base token address
64     * @param priceOracleAddress - adress of PriceOracle contract
65     * @param allowedMatcher - address which has authorization to match orders
66     */
67    function setBasicParams(address orionToken, address priceOracleAddress, address allowedMatcher) public onlyOwner {
68      require((orionToken != address(0)) && (priceOracleAddress != address(0)), "E15");
69      _orionToken = IERC20(orionToken);
70      _oracleAddress = priceOracleAddress;
71      _allowedMatcher = allowedMatcher;
72    }
73​
74​
75    /**
76     * @dev set marginal settings
77     * @param _collateralAssets - list of addresses of assets which may be used as collateral
78     * @param _stakeRisk - risk coefficient for staken orion as uint8 (0=0, 255=1)
79     * @param _liquidationPremium - premium for liquidator as uint8 (0=0, 255=1)
80     * @param _priceOverdue - time after that price became outdated
81     * @param _positionOverdue - time after that liabilities became overdue and may be liquidated
82     */
83​
84    function updateMarginalSettings(address[] calldata _collateralAssets,
85                                    uint8 _stakeRisk,
86                                    uint8 _liquidationPremium,
87                                    uint64 _priceOverdue,
88                                    uint64 _positionOverdue) public onlyOwner {
89      collateralAssets = _collateralAssets;
90      stakeRisk = _stakeRisk;
91      liquidationPremium = _liquidationPremium;
92      priceOverdue = _priceOverdue;
93      positionOverdue = _positionOverdue;
94    }
95​
96    /**
97     * @dev set risk coefficients for collateral assets
98     * @param assets - list of assets
99     * @param risks - list of risks as uint8 (0=0, 255=1)
100     */
101    function updateAssetRisks(address[] calldata assets, uint8[] calldata risks) public onlyOwner {
102        for(uint256 i; i< assets.length; i++)
103         assetRisks[assets[i]] = risks[i];
104    }
105​
106    /**
107     * @dev Deposit ERC20 tokens to the exchange contract
108     * @dev User needs to approve token contract first
109     * @param amount asset amount to deposit in its base unit
110     */
111    function depositAsset(address assetAddress, uint112 amount) external {
112        //require(asset.transferFrom(msg.sender, address(this), uint256(amount)), "E6");
113        IERC20(assetAddress).safeTransferFrom(msg.sender, address(this), uint256(amount));
114        generalDeposit(assetAddress,amount);
115    }
116​
117    /**
118     * @notice Deposit ETH to the exchange contract
119     * @dev deposit event will be emitted with the amount in decimal format (10^8)
120     * @dev balance will be stored in decimal format too
121     */
122    function deposit() external payable {
123        generalDeposit(address(0), uint112(msg.value));
124    }
125​
126    /**
127     * @dev internal implementation of deposits
128     */
129    function generalDeposit(address assetAddress, uint112 amount) internal {
130        address user = msg.sender;
131        bool wasLiability = assetBalances[user][assetAddress]<0;
132        int112 safeAmountDecimal = LibUnitConverter.baseUnitToDecimal(
133            assetAddress,
134            amount
135        );
136        assetBalances[user][assetAddress] += safeAmountDecimal;
137        if(amount>0)
138          emit NewAssetTransaction(user, assetAddress, true, uint112(safeAmountDecimal), uint64(block.timestamp));
139        if(wasLiability)
140          MarginalFunctionality.updateLiability(user, assetAddress, liabilities, uint112(safeAmountDecimal), assetBalances[user][assetAddress]);
141​
142    }
143    /**
144     * @dev Withdrawal of remaining funds from the contract back to the address
145     * @param assetAddress address of the asset to withdraw
146     * @param amount asset amount to withdraw in its base unit
147     */
148    function withdraw(address assetAddress, uint112 amount)
149        external
150        nonReentrant
151    {
152        int112 safeAmountDecimal = LibUnitConverter.baseUnitToDecimal(
153            assetAddress,
154            amount
155        );
156​
157        address user = msg.sender;
158​
159        assetBalances[user][assetAddress] -= safeAmountDecimal;
160​
161        require(assetBalances[user][assetAddress]>=0, "E1w1"); //TODO
162        require(checkPosition(user), "E1w2"); //TODO
163​
164        uint256 _amount = uint256(amount);
165        if(assetAddress == address(0)) {
166          (bool success, ) = user.call{value:_amount}("");
167          require(success, "E6w");
168        } else {
169          IERC20(assetAddress).safeTransfer(user, _amount);
170        }
171​
172​
173        emit NewAssetTransaction(user, assetAddress, false, uint112(safeAmountDecimal), uint64(block.timestamp));
174    }
175​

Solidity Contracts

JavaScript Tests