Loopring V3

1/ SPDX-License-Identifier: Apache-2.0
2/ Copyright 2017 Loopring Technology Limited.
3pragma solidity ^0.7.0;
4pragma experimental ABIEncoderV2;
5​
6import "../aux/access/ITransactionReceiver.sol";
7import "../core/iface/IAgentRegistry.sol";
8import "../lib/ReentrancyGuard.sol";
9import "../lib/TransferUtil.sol";
10import "./libamm/AmmAssetManagement.sol";
11import "./libamm/AmmData.sol";
12import "./libamm/AmmExitRequest.sol";
13import "./libamm/AmmJoinRequest.sol";
14import "./libamm/AmmPoolToken.sol";
15import "./libamm/AmmStatus.sol";
16import "./libamm/AmmTransactionReceiver.sol";
17import "./libamm/AmmWithdrawal.sol";
18import "./PoolToken.sol";
19​
20​
21/// @title LoopringAmmPool
22contract LoopringAmmPool is
23    PoolToken,
24    IAgent,
25    ITransactionReceiver,
26    ReentrancyGuard
27{
28    using AmmAssetManagement     for AmmData.State;
29    using AmmJoinRequest         for AmmData.State;
30    using AmmExitRequest         for AmmData.State;
31    using AmmPoolToken           for AmmData.State;
32    using AmmStatus              for AmmData.State;
33    using AmmTransactionReceiver for AmmData.State;
34    using AmmWithdrawal          for AmmData.State;
35    using TransferUtil           for address;
36​
37    event PoolJoinRequested(AmmData.PoolJoin join);
38    event PoolExitRequested(AmmData.PoolExit exit, bool force);
39    event ForcedExitProcessed(address owner, uint96 burnAmount, uint96[] amounts);
40    event Shutdown(uint timestamp);
41​
42    IAmmController public immutable controller;
43    IAssetManager  public immutable assetManager;
44    bool           public immutable joinsDisabled;
45​
46    modifier onlyFromExchangeOwner()
47    {
48        require(msg.sender == state.exchangeOwner, "UNAUTHORIZED");
49        _;
50    }
51​
52    modifier onlyFromAssetManager()
53    {
54        require(msg.sender == address(assetManager), "UNAUTHORIZED");
55        _;
56    }
57​
58    modifier onlyFromController()
59    {
60        require(msg.sender == address(controller), "UNAUTHORIZED");
61        _;
62    }
63​
64    modifier onlyWhenOnline()
65    {
66        require(state.isOnline(), "NOT_ONLINE");
67        _;
68    }
69​
70    modifier onlyWhenOffline()
71    {
72        require(!state.isOnline(), "NOT_OFFLINE");
73        _;
74    }
75​
76    constructor(
77        IAmmController _controller,
78        IAssetManager  _assetManager,
79        bool           _joinsDisabled
80    )
81    {
82        require(_controller != IAmmController(0), "ZERO_ADDRESS");
83        controller = _controller;
84        assetManager = _assetManager;
85        joinsDisabled = _joinsDisabled;
86    }
87​
88    function isOnline()
89        public
90        view
91        returns (bool)
92    {
93        return state.isOnline();
94    }
95​
96    receive() payable external {}
97​
98    function setupPool(AmmData.PoolConfig calldata config)
99        external
100        nonReentrant
101    {
102        require(state.accountID == 0 || msg.sender == address(controller), "UNAUTHORIZED");
103        state.setupPool(config);
104    }
105​
106    function enterExitMode(bool enabled)
107        external
108        onlyFromController
109    {
110        require(state.exitMode != enabled, "INVALID_STATE");
111        state.exitMode = enabled;
112    }
113​
114    // Anyone is able to shut down the pool when requests aren't being processed any more.
115    function shutdown(address exitOwner)
116        external
117        payable
118        onlyWhenOnline
119        nonReentrant
120    {
121        state.shutdownByLP(exitOwner);
122    }
123​
124    function shutdownByController()
125        external
126        onlyWhenOnline
127        nonReentrant
128        onlyFromController
129    {
130        state.shutdownByController();
131    }
132​
133    function joinPool(
134        uint96[]     calldata joinAmounts,
135        uint96                mintMinAmount,
136        uint96                fee
137        )
138        external
139        payable
140        onlyWhenOnline
141        nonReentrant
142    {
143        state.joinPool(joinAmounts, mintMinAmount, fee);
144    }
145​
146    function exitPool(
147        uint96            burnAmount,
148        uint96[] calldata exitMinAmounts
149        )
150        external
151        payable
152        onlyWhenOnline
153        nonReentrant
154    {
155        state.exitPool(burnAmount, exitMinAmounts, false);
156    }
157​
158    function forceExitPool(
159        uint96            burnAmount,
160        uint96[] calldata exitMinAmounts
161        )
162        external
163        payable
164        onlyWhenOnline
165        nonReentrant
166    {
167        state.exitPool(burnAmount, exitMinAmounts, true);
168    }
169​
170    function onReceiveTransactions(
171        bytes              calldata txsData,
172        bytes              calldata callbackData
173        )
174        external
175        override
176        onlyWhenOnline
177        onlyFromExchangeOwner
178        // nonReentrant     // Not needed, does not do any external calls
179                            // and can only be called by the exchange owner.
180    {
181        AmmData.Settings memory settings = AmmData.Settings({
182            controller: controller,
183            assetManager: assetManager,
184            joinsDisabled: joinsDisabled
185        });
186        state.onReceiveTransactions(txsData, callbackData, settings);
187    }
188​
189    function withdrawWhenOffline()
190        external
191        onlyWhenOffline
192        nonReentrant
193    {
194        state.withdrawWhenOffline();
195    }
196​
197    function transferOut(
198        address to,
199        address token,
200        uint    amount
201        )
202        external
203        nonReentrant
204        onlyFromAssetManager
205    {
206        state.transferOut(to, token, amount);
207    }
208​
209    function setBalanceL1(
210        address token,
211        uint96  balance
212        )
213        external
214        nonReentrant
215        onlyFromAssetManager
216    {
217        state.balancesL1[token] = balance;
218    }
219​
220    function getBalanceL1(
221        address token
222        )
223        public
224        view
225        returns (uint96)
226    {
227        return state.balancesL1[token];
228    }
229}

Solidity Contracts

JavaScript Tests