hack

.github/workflows/node.js.yml

@@ -0,0 +1,41 @@
+name: Build
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    branches: [master]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [14.x]
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v2
+        with:
+          node-version: ${{ matrix.node-version }}
+      - name: Install dependencies
+        run: npm ci
+      - name: Test
+        run: npm run ci:test
+      - name: Dev deployment
+        run: npm run aave:evm:dev:migration
+      - name: Mainnet deployment at Mainnet fork
+        run: npm run aave:fork:main
+        env:
+          ALCHEMY_KEY: ${{ secrets.ALCHEMY_KEY }}
+      - name: Amm deployment at Mainnet fork
+        run: npm run amm:fork:main
+        env:
+          ALCHEMY_KEY: ${{ secrets.ALCHEMY_KEY }}
+      # - name: Coverage
+      #   run: npm run coverage
+      # - uses: codecov/codecov-action@v1
+      #   with:
+      #     fail_ci_if_error: true

README.md

@@ -1,3 +1,5 @@
+[![License: AGPL v3](https://img.shields.io/badge/License-AGPL%20v3-blue.svg)](https://www.gnu.org/licenses/agpl-3.0)
+[![Build pass](https://github.com/AAVE/protocol-v2/actions/workflows/node.js.yml/badge.svg)](https://github.com/aave/protocol-v2/actions/workflows/node.js.yml)
 ```
         .///.                .///.     //.            .//  `/////////////-
        `++:++`              .++:++`    :++`          `++:  `++:......---.`
@@ -53,8 +55,8 @@ import {ILendingPool} from "@aave/protocol-v2/contracts/interfaces/ILendingPool.
 
 contract Misc {
 
-  function deposit(address pool, address token, address user, uint256 amount) {
-    ILendingPool(pool).deposit(token, amount, user, '0');
+  function deposit(address pool, address token, address user, uint256 amount) public {
+    ILendingPool(pool).deposit(token, amount, user, 0);
     {...}
   }
 }

contracts/adapters/BaseParaSwapAdapter.sol

@@ -0,0 +1,122 @@
+// SPDX-License-Identifier: agpl-3.0
+pragma solidity 0.6.12;
+pragma experimental ABIEncoderV2;
+
+import {SafeMath} from '../dependencies/openzeppelin/contracts/SafeMath.sol';
+import {IERC20} from '../dependencies/openzeppelin/contracts/IERC20.sol';
+import {IERC20Detailed} from '../dependencies/openzeppelin/contracts/IERC20Detailed.sol';
+import {SafeERC20} from '../dependencies/openzeppelin/contracts/SafeERC20.sol';
+import {Ownable} from '../dependencies/openzeppelin/contracts/Ownable.sol';
+import {ILendingPoolAddressesProvider} from '../interfaces/ILendingPoolAddressesProvider.sol';
+import {DataTypes} from '../protocol/libraries/types/DataTypes.sol';
+import {IPriceOracleGetter} from '../interfaces/IPriceOracleGetter.sol';
+import {IERC20WithPermit} from '../interfaces/IERC20WithPermit.sol';
+import {FlashLoanReceiverBase} from '../flashloan/base/FlashLoanReceiverBase.sol';
+
+/**
+ * @title BaseParaSwapAdapter
+ * @notice Utility functions for adapters using ParaSwap
+ * @author Jason Raymond Bell
+ */
+abstract contract BaseParaSwapAdapter is FlashLoanReceiverBase, Ownable {
+  using SafeMath for uint256;
+  using SafeERC20 for IERC20;
+  using SafeERC20 for IERC20Detailed;
+  using SafeERC20 for IERC20WithPermit;
+
+  struct PermitSignature {
+    uint256 amount;
+    uint256 deadline;
+    uint8 v;
+    bytes32 r;
+    bytes32 s;
+  }
+
+  // Max slippage percent allowed
+  uint256 public constant MAX_SLIPPAGE_PERCENT = 3000; // 30%
+
+  IPriceOracleGetter public immutable ORACLE;
+
+  event Swapped(address indexed fromAsset, address indexed toAsset, uint256 fromAmount, uint256 receivedAmount);
+
+  constructor(
+    ILendingPoolAddressesProvider addressesProvider
+  ) public FlashLoanReceiverBase(addressesProvider) {
+    ORACLE = IPriceOracleGetter(addressesProvider.getPriceOracle());
+  }
+
+  /**
+   * @dev Get the price of the asset from the oracle denominated in eth
+   * @param asset address
+   * @return eth price for the asset
+   */
+  function _getPrice(address asset) internal view returns (uint256) {
+    return ORACLE.getAssetPrice(asset);
+  }
+
+  /**
+   * @dev Get the decimals of an asset
+   * @return number of decimals of the asset
+   */
+  function _getDecimals(IERC20Detailed asset) internal view returns (uint8) {
+    uint8 decimals = asset.decimals();
+    // Ensure 10**decimals won't overflow a uint256
+    require(decimals <= 77, 'TOO_MANY_DECIMALS_ON_TOKEN');
+    return decimals;
+  }
+
+  /**
+   * @dev Get the aToken associated to the asset
+   * @return address of the aToken
+   */
+  function _getReserveData(address asset) internal view returns (DataTypes.ReserveData memory) {
+    return LENDING_POOL.getReserveData(asset);
+  }
+
+  /**
+   * @dev Pull the ATokens from the user
+   * @param reserve address of the asset
+   * @param reserveAToken address of the aToken of the reserve
+   * @param user address
+   * @param amount of tokens to be transferred to the contract
+   * @param permitSignature struct containing the permit signature
+   */
+  function _pullATokenAndWithdraw(
+    address reserve,
+    IERC20WithPermit reserveAToken,
+    address user,
+    uint256 amount,
+    PermitSignature memory permitSignature
+  ) internal {
+    // If deadline is set to zero, assume there is no signature for permit
+    if (permitSignature.deadline != 0) {
+      reserveAToken.permit(
+        user,
+        address(this),
+        permitSignature.amount,
+        permitSignature.deadline,
+        permitSignature.v,
+        permitSignature.r,
+        permitSignature.s
+      );
+    }
+
+    // transfer from user to adapter
+    reserveAToken.safeTransferFrom(user, address(this), amount);
+
+    // withdraw reserve
+    require(
+      LENDING_POOL.withdraw(reserve, amount, address(this)) == amount,
+      'UNEXPECTED_AMOUNT_WITHDRAWN'
+    );
+  }
+
+  /**
+   * @dev Emergency rescue for token stucked on this contract, as failsafe mechanism
+   * - Funds should never remain in this contract more time than during transactions
+   * - Only callable by the owner
+   */
+  function rescueTokens(IERC20 token) external onlyOwner {
+    token.safeTransfer(owner(), token.balanceOf(address(this)));
+  }
+}

contracts/adapters/BaseParaSwapSellAdapter.sol

@@ -0,0 +1,109 @@
+// SPDX-License-Identifier: agpl-3.0
+pragma solidity 0.6.12;
+pragma experimental ABIEncoderV2;
+
+import {BaseParaSwapAdapter} from './BaseParaSwapAdapter.sol';
+import {PercentageMath} from '../protocol/libraries/math/PercentageMath.sol';
+import {IParaSwapAugustus} from '../interfaces/IParaSwapAugustus.sol';
+import {IParaSwapAugustusRegistry} from '../interfaces/IParaSwapAugustusRegistry.sol';
+import {ILendingPoolAddressesProvider} from '../interfaces/ILendingPoolAddressesProvider.sol';
+import {IERC20Detailed} from '../dependencies/openzeppelin/contracts/IERC20Detailed.sol';
+
+/**
+ * @title BaseParaSwapSellAdapter
+ * @notice Implements the logic for selling tokens on ParaSwap
+ * @author Jason Raymond Bell
+ */
+abstract contract BaseParaSwapSellAdapter is BaseParaSwapAdapter {
+  using PercentageMath for uint256;
+
+  IParaSwapAugustusRegistry public immutable AUGUSTUS_REGISTRY;
+
+  constructor(
+    ILendingPoolAddressesProvider addressesProvider,
+    IParaSwapAugustusRegistry augustusRegistry
+  ) public BaseParaSwapAdapter(addressesProvider) {
+    // Do something on Augustus registry to check the right contract was passed
+    require(!augustusRegistry.isValidAugustus(address(0)));
+    AUGUSTUS_REGISTRY = augustusRegistry;
+  }
+
+  /**
+   * @dev Swaps a token for another using ParaSwap
+   * @param fromAmountOffset Offset of fromAmount in Augustus calldata if it should be overwritten, otherwise 0
+   * @param swapCalldata Calldata for ParaSwap's AugustusSwapper contract
+   * @param augustus Address of ParaSwap's AugustusSwapper contract
+   * @param assetToSwapFrom Address of the asset to be swapped from
+   * @param assetToSwapTo Address of the asset to be swapped to
+   * @param amountToSwap Amount to be swapped
+   * @param minAmountToReceive Minimum amount to be received from the swap
+   * @return amountReceived The amount received from the swap
+   */
+  function _sellOnParaSwap(
+    uint256 fromAmountOffset,
+    bytes memory swapCalldata,
+    IParaSwapAugustus augustus,
+    IERC20Detailed assetToSwapFrom,
+    IERC20Detailed assetToSwapTo,
+    uint256 amountToSwap,
+    uint256 minAmountToReceive
+  ) internal returns (uint256 amountReceived) {
+    require(AUGUSTUS_REGISTRY.isValidAugustus(address(augustus)), 'INVALID_AUGUSTUS');
+
+    {
+      uint256 fromAssetDecimals = _getDecimals(assetToSwapFrom);
+      uint256 toAssetDecimals = _getDecimals(assetToSwapTo);
+
+      uint256 fromAssetPrice = _getPrice(address(assetToSwapFrom));
+      uint256 toAssetPrice = _getPrice(address(assetToSwapTo));
+
+      uint256 expectedMinAmountOut =
+        amountToSwap
+          .mul(fromAssetPrice.mul(10**toAssetDecimals))
+          .div(toAssetPrice.mul(10**fromAssetDecimals))
+          .percentMul(PercentageMath.PERCENTAGE_FACTOR - MAX_SLIPPAGE_PERCENT);
+
+      require(expectedMinAmountOut <= minAmountToReceive, 'MIN_AMOUNT_EXCEEDS_MAX_SLIPPAGE');
+    }
+
+    uint256 balanceBeforeAssetFrom = assetToSwapFrom.balanceOf(address(this));
+    require(balanceBeforeAssetFrom >= amountToSwap, 'INSUFFICIENT_BALANCE_BEFORE_SWAP');
+    uint256 balanceBeforeAssetTo = assetToSwapTo.balanceOf(address(this));
+
+    address tokenTransferProxy = augustus.getTokenTransferProxy();
+    assetToSwapFrom.safeApprove(tokenTransferProxy, 0);
+    assetToSwapFrom.safeApprove(tokenTransferProxy, amountToSwap);
+
+    if (fromAmountOffset != 0) {
+      // Ensure 256 bit (32 bytes) fromAmount value is within bounds of the
+      // calldata, not overlapping with the first 4 bytes (function selector).
+      require(fromAmountOffset >= 4 &&
+        fromAmountOffset <= swapCalldata.length.sub(32),
+        'FROM_AMOUNT_OFFSET_OUT_OF_RANGE');
+      // Overwrite the fromAmount with the correct amount for the swap.
+      // In memory, swapCalldata consists of a 256 bit length field, followed by
+      // the actual bytes data, that is why 32 is added to the byte offset.
+      assembly {
+        mstore(add(swapCalldata, add(fromAmountOffset, 32)), amountToSwap)
+      }
+    }
+    (bool success,) = address(augustus).call(swapCalldata);
+    if (!success) {
+      // Copy revert reason from call
+      assembly {
+        returndatacopy(0, 0, returndatasize())
+        revert(0, returndatasize())
+      }
+    }
+    require(assetToSwapFrom.balanceOf(address(this)) == balanceBeforeAssetFrom - amountToSwap, 'WRONG_BALANCE_AFTER_SWAP');
+    amountReceived = assetToSwapTo.balanceOf(address(this)).sub(balanceBeforeAssetTo);
+    require(amountReceived >= minAmountToReceive, 'INSUFFICIENT_AMOUNT_RECEIVED');
+
+    emit Swapped(
+      address(assetToSwapFrom),
+      address(assetToSwapTo),
+      amountToSwap,
+      amountReceived
+    );
+  }
+}