Merge pull request #94 from Instadapp/paraswap-avax-connector

[Avalanche] Add Paraswap connector

contracts/avalanche/connectors/paraswap/events.sol

@@ -0,0 +1,11 @@
+pragma solidity ^0.7.0;
+
+contract Events {
+    event LogSwap(
+        address buyToken,
+        address sellToken,
+        uint256 buyAmt,
+        uint256 sellAmt,
+        uint256 setId
+    );
+}

contracts/avalanche/connectors/paraswap/helpers.sol

@@ -0,0 +1,57 @@
+pragma solidity ^0.7.0;
+
+import { DSMath } from "../../common/math.sol";
+import { Basic } from "../../common/basic.sol";
+import { TokenInterface } from "../../common/interfaces.sol";
+import { AugustusSwapperInterface } from "./interface.sol";
+
+abstract contract Helpers is DSMath, Basic {
+
+    struct SwapData {
+        TokenInterface sellToken;
+        TokenInterface buyToken;
+        uint256 _sellAmt;
+        uint256 _buyAmt;
+        uint256 unitAmt;
+        bytes callData;
+    }
+
+    address internal constant paraswap = 0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57;
+
+    function _swapHelper(SwapData memory swapData, uint256 wmaticAmt) internal returns (uint256 buyAmt) {
+        TokenInterface buyToken = swapData.buyToken;
+        (uint256 _buyDec, uint256 _sellDec) = getTokensDec(buyToken, swapData.sellToken);
+        uint256 _sellAmt18 = convertTo18(_sellDec, swapData._sellAmt);
+        uint256 _slippageAmt = convert18ToDec(_buyDec, wmul(swapData.unitAmt, _sellAmt18));
+
+        uint256 initalBal = getTokenBal(buyToken);
+
+        (bool success, ) = paraswap.call{value: wmaticAmt}(swapData.callData);
+        if (!success) revert("paraswap-failed");
+
+        uint256 finalBal = getTokenBal(buyToken);
+
+        buyAmt = sub(finalBal, initalBal);
+
+        require(_slippageAmt <= buyAmt, "Too much slippage");
+    }
+
+    function _swap(SwapData memory swapData, uint256 setId) internal returns (SwapData memory) {
+        TokenInterface _sellAddr = swapData.sellToken;
+
+        uint256 maticAmt;
+
+        if (address(_sellAddr) == avaxAddr) {
+            maticAmt = swapData._sellAmt;
+        } else {
+            address tokenProxy = AugustusSwapperInterface(paraswap).getTokenTransferProxy();
+            approve(TokenInterface(_sellAddr), tokenProxy, swapData._sellAmt);
+        }
+
+        swapData._buyAmt = _swapHelper(swapData, maticAmt);
+
+        setUint(setId, swapData._buyAmt);
+
+        return swapData;
+    }
+}

contracts/avalanche/connectors/paraswap/interface.sol

@@ -0,0 +1,5 @@
+pragma solidity ^0.7.0;
+
+interface AugustusSwapperInterface {
+    function getTokenTransferProxy() external view returns (address);
+}

contracts/avalanche/connectors/paraswap/main.sol

@@ -0,0 +1,55 @@
+pragma solidity ^0.7.0;
+
+/**
+ * @title Paraswap.
+ * @dev DEX Aggregator.
+ */
+
+import { TokenInterface } from "../../common/interfaces.sol";
+import { Stores } from "../../common/stores.sol";
+import { Helpers } from "./helpers.sol";
+
+abstract contract ParaswapResolver is Helpers {
+    /**
+     * @dev Sell AVAX/ERC20_Token using ParaSwap.
+     * @notice Swap tokens from exchanges like kyber, 0x etc, with calculation done off-chain.
+     * @param buyAddr The address of the token to buy.(For AVAX: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)
+     * @param sellAddr The address of the token to sell.(For AVAX: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)
+     * @param sellAmt The amount of the token to sell.
+     * @param unitAmt The amount of buyAmt/sellAmt with slippage.
+     * @param callData Data from paraswap API.
+     * @param setId ID stores the amount of token brought.
+    */
+    function swap(
+        address buyAddr,
+        address sellAddr,
+        uint256 sellAmt,
+        uint256 unitAmt,
+        bytes calldata callData,
+        uint256 setId
+    ) external payable returns (string memory _eventName, bytes memory _eventParam) {
+        Helpers.SwapData memory swapData = Helpers.SwapData({
+            buyToken: TokenInterface(buyAddr),
+            sellToken: TokenInterface(sellAddr),
+            unitAmt: unitAmt,
+            callData: callData,
+            _sellAmt: sellAmt,
+            _buyAmt: 0
+        });
+
+        swapData = _swap(swapData, setId);
+
+        _eventName = "LogSwap(address,address,uint256,uint256,uint256)";
+        _eventParam = abi.encode(
+            address(swapData.buyToken),
+            address(swapData.sellToken),
+            swapData._buyAmt,
+            swapData._sellAmt,
+            setId
+        );
+    }
+}
+
+contract ConnectV2ParaswapAvalanche is ParaswapResolver {
+    string public constant name = "Paraswap-v1";
+}