ABI encoded trades. (gnosis/gp-v2-contracts#390)

This is a refinement and replacement for #381

This PR adds a new trade structure and relies on ABI 

This PR is very large, mostly because the decoding and signer recovering code was quite coupled, specifically regarding the unit tests. The `GPv2Encoding.test.ts` was split into two separate test modules and the reason for most of the code change (the original test file was around 500 LoC). If this PR is too hard to review, I can try and make the PR smaller by first just fixing the tests directly in `GPv2Encoding.test.ts` and then moving them out afterwards.

### Test Plan

Adjusted tests to new structure.

Author: LunaTechLab56

src/contracts/GPv2Settlement.sol

@@ -9,16 +9,16 @@ import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
 
 import "./GPv2AllowanceManager.sol";
 import "./interfaces/GPv2Authentication.sol";
-import "./libraries/GPv2Encoding.sol";
 import "./libraries/GPv2Interaction.sol";
 import "./libraries/GPv2Order.sol";
+import "./libraries/GPv2Trade.sol";
 import "./libraries/GPv2TradeExecution.sol";
 
 /// @title Gnosis Protocol v2 Settlement Contract
 /// @author Gnosis Developers
 contract GPv2Settlement is ReentrancyGuard, StorageAccessible {
-    using GPv2Encoding for bytes;
     using GPv2Order for bytes;
+    using GPv2Signing for GPv2Signing.RecoveredOrder;
     using GPv2TradeExecution for GPv2TradeExecution.Data;
     using SafeMath for uint256;
 
@@ -142,7 +142,7 @@ contract GPv2Settlement is ReentrancyGuard, StorageAccessible {
     /// Orders and interactions encode tokens as indices into this array.
     /// @param clearingPrices An array of clearing prices where the `i`-th price
     /// is for the `i`-th token in the [`tokens`] array.
-    /// @param encodedTrades Encoded trades for signed orders.
+    /// @param trades Trades for signed orders.
     /// @param interactions Smart contract interactions split into three
     /// separate lists to be run before the settlement, during the settlement
     /// and after the settlement respectively.
@@ -151,14 +151,14 @@ contract GPv2Settlement is ReentrancyGuard, StorageAccessible {
     function settle(
         IERC20[] calldata tokens,
         uint256[] calldata clearingPrices,
-        bytes calldata encodedTrades,
+        GPv2Trade.Data[] calldata trades,
         GPv2Interaction.Data[][3] calldata interactions,
         bytes[] calldata orderRefunds
     ) external nonReentrant onlySolver {
         executeInteractions(interactions[0]);
 
         GPv2TradeExecution.Data[] memory executedTrades =
-            computeTradeExecutions(tokens, clearingPrices, encodedTrades);
+            computeTradeExecutions(tokens, clearingPrices, trades);
         allowanceManager.transferIn(executedTrades);
 
         executeInteractions(interactions[1]);
@@ -191,58 +191,63 @@ contract GPv2Settlement is ReentrancyGuard, StorageAccessible {
     /// [`computeTradeExecution`] for more details.
     /// @param tokens An array of ERC20 tokens to be traded in the settlement.
     /// @param clearingPrices An array of token clearing prices.
-    /// @param encodedTrades Encoded trades for signed orders.
+    /// @param trades Trades for signed orders.
     /// @return executedTrades Array of executed trades.
     function computeTradeExecutions(
         IERC20[] calldata tokens,
         uint256[] calldata clearingPrices,
-        bytes calldata encodedTrades
+        GPv2Trade.Data[] calldata trades
     ) internal returns (GPv2TradeExecution.Data[] memory executedTrades) {
-        (uint256 tradeCount, bytes calldata remainingEncodedTrades) =
-            encodedTrades.decodeTradeCount();
-        executedTrades = new GPv2TradeExecution.Data[](tradeCount);
-
-        GPv2Encoding.Trade memory trade;
-        uint256 i = 0;
-        while (remainingEncodedTrades.length != 0) {
-            remainingEncodedTrades = remainingEncodedTrades.decodeTrade(
+        GPv2Signing.RecoveredOrder memory recoveredOrder =
+            GPv2Signing.allocateRecoveredOrder();
+
+        executedTrades = new GPv2TradeExecution.Data[](trades.length);
+        for (uint256 i = 0; i < trades.length; i++) {
+            GPv2Trade.Data calldata trade = trades[i];
+
+            recoveredOrder.recoverOrderFromTrade(
                 domainSeparator,
                 tokens,
                 trade
             );
             computeTradeExecution(
-                trade,
+                recoveredOrder,
                 clearingPrices[trade.sellTokenIndex],
                 clearingPrices[trade.buyTokenIndex],
+                trade.executedAmount,
+                trade.feeDiscount,
                 executedTrades[i]
             );
-            i++;
         }
-
-        require(i == tradeCount, "GPv2: invalid trade encoding");
     }
 
     /// @dev Compute the in and out transfer amounts for a single trade.
     /// This function reverts if:
     /// - The order has expired
     /// - The order's limit price is not respected.
     ///
-    /// @param trade The trade to process.
+    /// @param recoveredOrder The recovered order to process.
     /// @param sellPrice The price of the order's sell token.
     /// @param buyPrice The price of the order's buy token.
+    /// @param executedAmount The portion of the order to execute. This will be
+    /// ignored for fill-or-kill orders.
+    /// @param feeDiscount The discount to apply to the final executed fees.
     /// @param executedTrade Memory location for computed executed trade data.
     function computeTradeExecution(
-        GPv2Encoding.Trade memory trade,
+        GPv2Signing.RecoveredOrder memory recoveredOrder,
         uint256 sellPrice,
         uint256 buyPrice,
+        uint256 executedAmount,
+        uint256 feeDiscount,
         GPv2TradeExecution.Data memory executedTrade
     ) internal {
-        GPv2Order.Data memory order = trade.order;
+        GPv2Order.Data memory order = recoveredOrder.data;
+        bytes memory orderUid = recoveredOrder.uid;
 
         // solhint-disable-next-line not-rely-on-time
         require(order.validTo >= block.timestamp, "GPv2: order expired");
 
-        executedTrade.owner = trade.owner;
+        executedTrade.owner = recoveredOrder.owner;
         executedTrade.receiver = order.receiver;
         executedTrade.sellToken = order.sellToken;
         executedTrade.buyToken = order.buyToken;
@@ -282,7 +287,7 @@ contract GPv2Settlement is ReentrancyGuard, StorageAccessible {
 
         if (order.kind == GPv2Order.SELL) {
             if (order.partiallyFillable) {
-                executedSellAmount = trade.executedAmount;
+                executedSellAmount = executedAmount;
                 executedFeeAmount =
                     order.feeAmount.mul(executedSellAmount) /
                     order.sellAmount;
@@ -293,7 +298,7 @@ contract GPv2Settlement is ReentrancyGuard, StorageAccessible {
 
             executedBuyAmount = executedSellAmount.mul(sellPrice) / buyPrice;
 
-            currentFilledAmount = filledAmount[trade.orderUid].add(
+            currentFilledAmount = filledAmount[orderUid].add(
                 executedSellAmount
             );
             require(
@@ -302,7 +307,7 @@ contract GPv2Settlement is ReentrancyGuard, StorageAccessible {
             );
         } else {
             if (order.partiallyFillable) {
-                executedBuyAmount = trade.executedAmount;
+                executedBuyAmount = executedAmount;
                 executedFeeAmount =
                     order.feeAmount.mul(executedBuyAmount) /
                     order.buyAmount;
@@ -313,33 +318,31 @@ contract GPv2Settlement is ReentrancyGuard, StorageAccessible {
 
             executedSellAmount = executedBuyAmount.mul(buyPrice) / sellPrice;
 
-            currentFilledAmount = filledAmount[trade.orderUid].add(
-                executedBuyAmount
-            );
+            currentFilledAmount = filledAmount[orderUid].add(executedBuyAmount);
             require(
                 currentFilledAmount <= order.buyAmount,
                 "GPv2: order filled"
             );
         }
 
         require(
-            trade.feeDiscount <= executedFeeAmount,
+            feeDiscount <= executedFeeAmount,
             "GPv2: fee discount too large"
         );
-        executedFeeAmount = executedFeeAmount - trade.feeDiscount;
+        executedFeeAmount = executedFeeAmount - feeDiscount;
 
         executedTrade.sellAmount = executedSellAmount.add(executedFeeAmount);
         executedTrade.buyAmount = executedBuyAmount;
 
-        filledAmount[trade.orderUid] = currentFilledAmount;
+        filledAmount[orderUid] = currentFilledAmount;
         emit Trade(
             executedTrade.owner,
             executedTrade.sellToken,
             executedTrade.buyToken,
             executedTrade.sellAmount,
             executedTrade.buyAmount,
             executedFeeAmount,
-            trade.orderUid
+            orderUid
         );
     }