Initial deploy script

Author: akshatmittal

contracts/GPv2AllowListAuthentication.sol

@@ -8,11 +8,7 @@ import "./mixins/StorageAccessible.sol";
 
 /// @title Gnosis Protocol v2 Access Control Contract
 /// @author Gnosis Developers
-contract GPv2AllowListAuthentication is
-    GPv2Authentication,
-    Initializable,
-    StorageAccessible
-{
+contract GPv2AllowListAuthentication is GPv2Authentication, Initializable, StorageAccessible {
     /// @dev The address of the manager that has permissions to add and remove
     /// solvers.
     address public manager;
@@ -57,10 +53,7 @@ contract GPv2AllowListAuthentication is
     /// This modifier assumes that the proxy uses an EIP-1967 compliant storage
     /// slot for the admin.
     modifier onlyManagerOrOwner() {
-        require(
-            manager == msg.sender || GPv2EIP1967.getAdmin() == msg.sender,
-            "GPv2: not authorized"
-        );
+        require(manager == msg.sender || GPv2EIP1967.getAdmin() == msg.sender, "GPv2: not authorized");
         _;
     }
 
@@ -100,9 +93,7 @@ contract GPv2AllowListAuthentication is
     }
 
     /// @inheritdoc GPv2Authentication
-    function isSolver(
-        address prospectiveSolver
-    ) external view override returns (bool) {
+    function isSolver(address prospectiveSolver) external view override returns (bool) {
         return solvers[prospectiveSolver];
     }
 }

contracts/GPv2Settlement.sol

@@ -126,10 +126,8 @@ contract GPv2Settlement is GPv2Signing, ReentrancyGuard, StorageAccessible {
     ) external nonReentrant onlySolver {
         executeInteractions(interactions[0]);
 
-        (
-            GPv2Transfer.Data[] memory inTransfers,
-            GPv2Transfer.Data[] memory outTransfers
-        ) = computeTradeExecutions(tokens, clearingPrices, trades);
+        (GPv2Transfer.Data[] memory inTransfers, GPv2Transfer.Data[] memory outTransfers) =
+            computeTradeExecutions(tokens, clearingPrices, trades);
 
         vaultRelayer.transferFromAccounts(inTransfers);
 
@@ -150,26 +148,22 @@ contract GPv2Settlement is GPv2Signing, ReentrancyGuard, StorageAccessible {
     /// @param trade The trade to match directly against Balancer liquidity. The
     /// order will always be fully executed, so the trade's `executedAmount`
     /// field is used to represent a swap limit amount.
-    function swap(
-        IVault.BatchSwapStep[] calldata swaps,
-        IERC20[] calldata tokens,
-        GPv2Trade.Data calldata trade
-    ) external nonReentrant onlySolver {
+    function swap(IVault.BatchSwapStep[] calldata swaps, IERC20[] calldata tokens, GPv2Trade.Data calldata trade)
+        external
+        nonReentrant
+        onlySolver
+    {
         RecoveredOrder memory recoveredOrder = allocateRecoveredOrder();
         GPv2Order.Data memory order = recoveredOrder.data;
         recoverOrderFromTrade(recoveredOrder, tokens, trade);
 
-        IVault.SwapKind kind = order.kind == GPv2Order.KIND_SELL
-            ? IVault.SwapKind.GIVEN_IN
-            : IVault.SwapKind.GIVEN_OUT;
+        IVault.SwapKind kind = order.kind == GPv2Order.KIND_SELL ? IVault.SwapKind.GIVEN_IN : IVault.SwapKind.GIVEN_OUT;
 
         IVault.FundManagement memory funds;
         funds.sender = recoveredOrder.owner;
-        funds.fromInternalBalance =
-            order.sellTokenBalance == GPv2Order.BALANCE_INTERNAL;
+        funds.fromInternalBalance = order.sellTokenBalance == GPv2Order.BALANCE_INTERNAL;
         funds.recipient = payable(recoveredOrder.receiver);
-        funds.toInternalBalance =
-            order.buyTokenBalance == GPv2Order.BALANCE_INTERNAL;
+        funds.toInternalBalance = order.buyTokenBalance == GPv2Order.BALANCE_INTERNAL;
 
         int256[] memory limits = new int256[](tokens.length);
         uint256 limitAmount = trade.executedAmount;
@@ -205,27 +199,19 @@ contract GPv2Settlement is GPv2Signing, ReentrancyGuard, StorageAccessible {
         );
 
         bytes memory orderUid = recoveredOrder.uid;
-        uint256 executedSellAmount = tokenDeltas[trade.sellTokenIndex]
-            .toUint256();
-        uint256 executedBuyAmount = (-tokenDeltas[trade.buyTokenIndex])
-            .toUint256();
+        uint256 executedSellAmount = tokenDeltas[trade.sellTokenIndex].toUint256();
+        uint256 executedBuyAmount = (-tokenDeltas[trade.buyTokenIndex]).toUint256();
 
         // NOTE: Check that the orders were completely filled and update their
         // filled amounts to avoid replaying them. The limit price and order
         // validity has already been verified when executing the swap through
         // the `limit` and `deadline` parameters.
         require(filledAmount[orderUid] == 0, "GPv2: order filled");
         if (order.kind == GPv2Order.KIND_SELL) {
-            require(
-                executedSellAmount == order.sellAmount,
-                "GPv2: sell amount not respected"
-            );
+            require(executedSellAmount == order.sellAmount, "GPv2: sell amount not respected");
             filledAmount[orderUid] = order.sellAmount;
         } else {
-            require(
-                executedBuyAmount == order.buyAmount,
-                "GPv2: buy amount not respected"
-            );
+            require(executedBuyAmount == order.buyAmount, "GPv2: buy amount not respected");
             filledAmount[orderUid] = order.buyAmount;
         }
 
@@ -248,7 +234,7 @@ contract GPv2Settlement is GPv2Signing, ReentrancyGuard, StorageAccessible {
     /// must be the sender of this message. See [`extractOrderUidParams`]
     /// for details on orderUid.
     function invalidateOrder(bytes calldata orderUid) external {
-        (, address owner, ) = orderUid.extractOrderUidParams();
+        (, address owner,) = orderUid.extractOrderUidParams();
         require(owner == msg.sender, "GPv2: caller does not own order");
         filledAmount[orderUid] = type(uint256).max;
         emit OrderInvalidated(owner, orderUid);
@@ -259,9 +245,7 @@ contract GPv2Settlement is GPv2Signing, ReentrancyGuard, StorageAccessible {
     ///
     /// @param orderUids The unique identifiers of the expired order to free
     /// storage for.
-    function freeFilledAmountStorage(
-        bytes[] calldata orderUids
-    ) external onlyInteraction {
+    function freeFilledAmountStorage(bytes[] calldata orderUids) external onlyInteraction {
         freeOrderStorage(filledAmount, orderUids);
     }
 
@@ -270,9 +254,7 @@ contract GPv2Settlement is GPv2Signing, ReentrancyGuard, StorageAccessible {
     ///
     /// @param orderUids The unique identifiers of the expired order to free
     /// storage for.
-    function freePreSignatureStorage(
-        bytes[] calldata orderUids
-    ) external onlyInteraction {
+    function freePreSignatureStorage(bytes[] calldata orderUids) external onlyInteraction {
         freeOrderStorage(preSignature, orderUids);
     }
 
@@ -291,13 +273,7 @@ contract GPv2Settlement is GPv2Signing, ReentrancyGuard, StorageAccessible {
         IERC20[] calldata tokens,
         uint256[] calldata clearingPrices,
         GPv2Trade.Data[] calldata trades
-    )
-        internal
-        returns (
-            GPv2Transfer.Data[] memory inTransfers,
-            GPv2Transfer.Data[] memory outTransfers
-        )
-    {
+    ) internal returns (GPv2Transfer.Data[] memory inTransfers, GPv2Transfer.Data[] memory outTransfers) {
         RecoveredOrder memory recoveredOrder = allocateRecoveredOrder();
 
         inTransfers = new GPv2Transfer.Data[](trades.length);
@@ -365,10 +341,7 @@ contract GPv2Settlement is GPv2Signing, ReentrancyGuard, StorageAccessible {
         // amount_y = amount_x * price_x / price_y
         // ```
 
-        require(
-            order.sellAmount.mul(sellPrice) >= order.buyAmount.mul(buyPrice),
-            "GPv2: limit price not respected"
-        );
+        require(order.sellAmount.mul(sellPrice) >= order.buyAmount.mul(buyPrice), "GPv2: limit price not respected");
 
         uint256 executedSellAmount;
         uint256 executedBuyAmount;
@@ -378,31 +351,20 @@ contract GPv2Settlement is GPv2Signing, ReentrancyGuard, StorageAccessible {
         if (order.kind == GPv2Order.KIND_SELL) {
             if (order.partiallyFillable) {
                 executedSellAmount = executedAmount;
-                executedFeeAmount = order.feeAmount.mul(executedSellAmount).div(
-                    order.sellAmount
-                );
+                executedFeeAmount = order.feeAmount.mul(executedSellAmount).div(order.sellAmount);
             } else {
                 executedSellAmount = order.sellAmount;
                 executedFeeAmount = order.feeAmount;
             }
 
-            executedBuyAmount = executedSellAmount.mul(sellPrice).ceilDiv(
-                buyPrice
-            );
+            executedBuyAmount = executedSellAmount.mul(sellPrice).ceilDiv(buyPrice);
 
-            currentFilledAmount = filledAmount[orderUid].add(
-                executedSellAmount
-            );
-            require(
-                currentFilledAmount <= order.sellAmount,
-                "GPv2: order filled"
-            );
+            currentFilledAmount = filledAmount[orderUid].add(executedSellAmount);
+            require(currentFilledAmount <= order.sellAmount, "GPv2: order filled");
         } else {
             if (order.partiallyFillable) {
                 executedBuyAmount = executedAmount;
-                executedFeeAmount = order.feeAmount.mul(executedBuyAmount).div(
-                    order.buyAmount
-                );
+                executedFeeAmount = order.feeAmount.mul(executedBuyAmount).div(order.buyAmount);
             } else {
                 executedBuyAmount = order.buyAmount;
                 executedFeeAmount = order.feeAmount;
@@ -411,10 +373,7 @@ contract GPv2Settlement is GPv2Signing, ReentrancyGuard, StorageAccessible {
             executedSellAmount = executedBuyAmount.mul(buyPrice).div(sellPrice);
 
             currentFilledAmount = filledAmount[orderUid].add(executedBuyAmount);
-            require(
-                currentFilledAmount <= order.buyAmount,
-                "GPv2: order filled"
-            );
+            require(currentFilledAmount <= order.buyAmount, "GPv2: order filled");
         }
 
         executedSellAmount = executedSellAmount.add(executedFeeAmount);
@@ -443,25 +402,16 @@ contract GPv2Settlement is GPv2Signing, ReentrancyGuard, StorageAccessible {
 
     /// @dev Execute a list of arbitrary contract calls from this contract.
     /// @param interactions The list of interactions to execute.
-    function executeInteractions(
-        GPv2Interaction.Data[] calldata interactions
-    ) internal {
+    function executeInteractions(GPv2Interaction.Data[] calldata interactions) internal {
         for (uint256 i; i < interactions.length; ++i) {
             GPv2Interaction.Data calldata interaction = interactions[i];
 
             // To prevent possible attack on user funds, we explicitly disable
             // any interactions with the vault relayer contract.
-            require(
-                interaction.target != address(vaultRelayer),
-                "GPv2: forbidden interaction"
-            );
+            require(interaction.target != address(vaultRelayer), "GPv2: forbidden interaction");
             GPv2Interaction.execute(interaction);
 
-            emit Interaction(
-                interaction.target,
-                interaction.value,
-                GPv2Interaction.selector(interaction)
-            );
+            emit Interaction(interaction.target, interaction.value, GPv2Interaction.selector(interaction));
         }
     }
 
@@ -471,14 +421,11 @@ contract GPv2Settlement is GPv2Signing, ReentrancyGuard, StorageAccessible {
     ///
     /// @param orderUids Order refund data for freeing storage.
     /// @param orderStorage Order storage mapped on a UID.
-    function freeOrderStorage(
-        mapping(bytes => uint256) storage orderStorage,
-        bytes[] calldata orderUids
-    ) internal {
+    function freeOrderStorage(mapping(bytes => uint256) storage orderStorage, bytes[] calldata orderUids) internal {
         for (uint256 i; i < orderUids.length; ++i) {
             bytes calldata orderUid = orderUids[i];
 
-            (, , uint32 validTo) = orderUid.extractOrderUidParams();
+            (,, uint32 validTo) = orderUid.extractOrderUidParams();
             // solhint-disable-next-line not-rely-on-time
             require(validTo < block.timestamp, "GPv2: order still valid");
 

contracts/GPv2VaultRelayer.sol

@@ -38,9 +38,7 @@ contract GPv2VaultRelayer {
     /// - Any ERC20 transfer fails
     ///
     /// @param transfers The transfers to execute.
-    function transferFromAccounts(
-        GPv2Transfer.Data[] calldata transfers
-    ) external onlyCreator {
+    function transferFromAccounts(GPv2Transfer.Data[] calldata transfers) external onlyCreator {
         vault.transferFromAccounts(transfers, msg.sender);
     }
 
@@ -72,14 +70,7 @@ contract GPv2VaultRelayer {
         uint256 deadline,
         GPv2Transfer.Data calldata feeTransfer
     ) external onlyCreator returns (int256[] memory tokenDeltas) {
-        tokenDeltas = vault.batchSwap(
-            kind,
-            swaps,
-            tokens,
-            funds,
-            limits,
-            deadline
-        );
+        tokenDeltas = vault.batchSwap(kind, swaps, tokens, funds, limits, deadline);
         vault.fastTransferFromAccount(feeTransfer, msg.sender);
     }
 }

contracts/interfaces/GPv2EIP1271.sol

@@ -24,8 +24,5 @@ interface EIP1271Verifier {
     /// solc > 0.5)
     /// MUST allow external calls
     ///
-    function isValidSignature(
-        bytes32 _hash,
-        bytes memory _signature
-    ) external view returns (bytes4 magicValue);
+    function isValidSignature(bytes32 _hash, bytes memory _signature) external view returns (bytes4 magicValue);
 }

contracts/interfaces/IERC20.sol

@@ -44,10 +44,7 @@ interface IERC20 {
      *
      * Emits a {Transfer} event.
      */
-    function transfer(
-        address recipient,
-        uint256 amount
-    ) external returns (bool);
+    function transfer(address recipient, uint256 amount) external returns (bool);
 
     /**
      * @dev Returns the remaining number of tokens that `spender` will be
@@ -56,10 +53,7 @@ interface IERC20 {
      *
      * This value changes when {approve} or {transferFrom} are called.
      */
-    function allowance(
-        address owner,
-        address spender
-    ) external view returns (uint256);
+    function allowance(address owner, address spender) external view returns (uint256);
 
     /**
      * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
@@ -86,11 +80,7 @@ interface IERC20 {
      *
      * Emits a {Transfer} event.
      */
-    function transferFrom(
-        address sender,
-        address recipient,
-        uint256 amount
-    ) external returns (bool);
+    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
 
     /**
      * @dev Emitted when `value` tokens are moved from one account (`from`) to
@@ -104,9 +94,5 @@ interface IERC20 {
      * @dev Emitted when the allowance of a `spender` for an `owner` is set by
      * a call to {approve}. `value` is the new allowance.
      */
-    event Approval(
-        address indexed owner,
-        address indexed spender,
-        uint256 value
-    );
+    event Approval(address indexed owner, address indexed spender, uint256 value);
 }

contracts/interfaces/IVault.sol

@@ -44,7 +44,7 @@ interface IVault {
 
     /**
      * @dev Data for `manageUserBalance` operations, which include the possibility for ETH to be sent and received
-     without manual WETH wrapping or unwrapping.
+     *  without manual WETH wrapping or unwrapping.
      */
     struct UserBalanceOp {
         UserBalanceOpKind kind;
@@ -164,12 +164,10 @@ interface IVault {
      *
      * Emits a `Swap` event.
      */
-    function swap(
-        SingleSwap memory singleSwap,
-        FundManagement memory funds,
-        uint256 limit,
-        uint256 deadline
-    ) external payable returns (uint256);
+    function swap(SingleSwap memory singleSwap, FundManagement memory funds, uint256 limit, uint256 deadline)
+        external
+        payable
+        returns (uint256);
 
     /**
      * @dev Data for a single swap executed by `swap`. `amount` is either `amountIn` or `amountOut` depending on

contracts/libraries/GPv2EIP1967.sol

@@ -4,8 +4,7 @@ pragma solidity >=0.7.6 <0.9.0;
 library GPv2EIP1967 {
     /// @dev The storage slot where the proxy administrator is stored, defined
     /// as `keccak256('eip1967.proxy.admin') - 1`.
-    bytes32 internal constant ADMIN_SLOT =
-        hex"b53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103";
+    bytes32 internal constant ADMIN_SLOT = hex"b53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103";
 
     /// @dev Returns the address stored in the EIP-1967 administrator storage
     /// slot for the current contract. If this method is not called from an