feat: add base & paraswap

contracts/base/common/basic.sol

@@ -0,0 +1,91 @@
+//SPDX-License-Identifier: MIT
+pragma solidity ^0.8.2;
+
+import {TokenInterface} from "./interfaces.sol";
+import {Stores} from "./stores.sol";
+import {DSMath} from "./math.sol";
+
+abstract contract Basic is DSMath, Stores {
+    function convert18ToDec(
+        uint _dec,
+        uint256 _amt
+    ) internal pure returns (uint256 amt) {
+        amt = (_amt / 10 ** (18 - _dec));
+    }
+
+    function convertTo18(
+        uint _dec,
+        uint256 _amt
+    ) internal pure returns (uint256 amt) {
+        amt = mul(_amt, 10 ** (18 - _dec));
+    }
+
+    function getTokenBal(
+        TokenInterface token
+    ) internal view returns (uint _amt) {
+        _amt = address(token) == ethAddr
+            ? address(this).balance
+            : token.balanceOf(address(this));
+    }
+
+    function getTokensDec(
+        TokenInterface buyAddr,
+        TokenInterface sellAddr
+    ) internal view returns (uint buyDec, uint sellDec) {
+        buyDec = address(buyAddr) == ethAddr ? 18 : buyAddr.decimals();
+        sellDec = address(sellAddr) == ethAddr ? 18 : sellAddr.decimals();
+    }
+
+    function encodeEvent(
+        string memory eventName,
+        bytes memory eventParam
+    ) internal pure returns (bytes memory) {
+        return abi.encode(eventName, eventParam);
+    }
+
+    function approve(
+        TokenInterface token,
+        address spender,
+        uint256 amount
+    ) internal {
+        try token.approve(spender, amount) {} catch {
+            token.approve(spender, 0);
+            token.approve(spender, amount);
+        }
+    }
+
+    function changeEthAddress(
+        address buy,
+        address sell
+    ) internal pure returns (TokenInterface _buy, TokenInterface _sell) {
+        _buy = buy == ethAddr ? TokenInterface(wethAddr) : TokenInterface(buy);
+        _sell = sell == ethAddr
+            ? TokenInterface(wethAddr)
+            : TokenInterface(sell);
+    }
+
+    function changeEthAddrToWethAddr(
+        address token
+    ) internal pure returns (address tokenAddr) {
+        tokenAddr = token == ethAddr ? wethAddr : token;
+    }
+
+    function convertEthToWeth(
+        bool isEth,
+        TokenInterface token,
+        uint amount
+    ) internal {
+        if (isEth) token.deposit{value: amount}();
+    }
+
+    function convertWethToEth(
+        bool isEth,
+        TokenInterface token,
+        uint amount
+    ) internal {
+        if (isEth) {
+            approve(token, address(token), amount);
+            token.withdraw(amount);
+        }
+    }
+}

contracts/base/common/interfaces.sol

@@ -0,0 +1,48 @@
+//SPDX-License-Identifier: MIT
+pragma solidity ^0.8.2;
+
+interface TokenInterface {
+    function approve(address, uint256) external;
+    function transfer(address, uint) external;
+    function transferFrom(address, address, uint) external;
+    function deposit() external payable;
+    function withdraw(uint) external;
+    function balanceOf(address) external view returns (uint);
+    function decimals() external view returns (uint);
+    function totalSupply() external view returns (uint);
+    function allowance(
+        address owner,
+        address spender
+    ) external view returns (uint256);
+}
+
+interface MemoryInterface {
+    function getUint(uint id) external returns (uint num);
+    function setUint(uint id, uint val) external;
+}
+
+interface InstaMapping {
+    function cTokenMapping(address) external view returns (address);
+    function gemJoinMapping(bytes32) external view returns (address);
+}
+
+interface AccountInterface {
+    function enable(address) external;
+    function disable(address) external;
+    function isAuth(address) external view returns (bool);
+    function cast(
+        string[] calldata _targetNames,
+        bytes[] calldata _datas,
+        address _origin
+    ) external payable returns (bytes32[] memory responses);
+}
+
+interface ListInterface {
+    function accountID(address) external returns (uint64);
+}
+
+interface InstaConnectors {
+    function isConnectors(
+        string[] calldata
+    ) external returns (bool, address[] memory);
+}

contracts/base/common/math.sol

@@ -0,0 +1,55 @@
+//SPDX-License-Identifier: MIT
+pragma solidity ^0.8.2;
+
+import {SafeMath} from "@openzeppelin/contracts/utils/math/SafeMath.sol";
+
+contract DSMath {
+    uint constant WAD = 10 ** 18;
+    uint constant RAY = 10 ** 27;
+
+    function add(uint x, uint y) internal pure returns (uint z) {
+        z = SafeMath.add(x, y);
+    }
+
+    function sub(uint x, uint y) internal pure virtual returns (uint z) {
+        z = SafeMath.sub(x, y);
+    }
+
+    function mul(uint x, uint y) internal pure returns (uint z) {
+        z = SafeMath.mul(x, y);
+    }
+
+    function div(uint x, uint y) internal pure returns (uint z) {
+        z = SafeMath.div(x, y);
+    }
+
+    function wmul(uint x, uint y) internal pure returns (uint z) {
+        z = SafeMath.add(SafeMath.mul(x, y), WAD / 2) / WAD;
+    }
+
+    function wdiv(uint x, uint y) internal pure returns (uint z) {
+        z = SafeMath.add(SafeMath.mul(x, WAD), y / 2) / y;
+    }
+
+    function rdiv(uint x, uint y) internal pure returns (uint z) {
+        z = SafeMath.add(SafeMath.mul(x, RAY), y / 2) / y;
+    }
+
+    function rmul(uint x, uint y) internal pure returns (uint z) {
+        z = SafeMath.add(SafeMath.mul(x, y), RAY / 2) / RAY;
+    }
+
+    function toInt(uint x) internal pure returns (int y) {
+        y = int(x);
+        require(y >= 0, "int-overflow");
+    }
+
+    function toUint(int256 x) internal pure returns (uint256) {
+        require(x >= 0, "int-overflow");
+        return uint256(x);
+    }
+
+    function toRad(uint wad) internal pure returns (uint rad) {
+        rad = mul(wad, 10 ** 27);
+    }
+}

contracts/base/common/stores.sol

@@ -0,0 +1,50 @@
+//SPDX-License-Identifier: MIT
+pragma solidity ^0.8.2;
+
+import {MemoryInterface, InstaMapping, ListInterface, InstaConnectors} from "./interfaces.sol";
+
+abstract contract Stores {
+    /**
+     * @dev Return ethereum address
+     */
+    address internal constant ethAddr =
+        0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
+
+    /**
+     * @dev Return Wrapped ETH address
+     */
+    address internal constant wethAddr =
+        0x4200000000000000000000000000000000000006;
+
+    /**
+     * @dev Return memory variable address
+     */
+    MemoryInterface internal constant instaMemory =
+        MemoryInterface(0x3254Ce8f5b1c82431B8f21Df01918342215825C2);
+
+    /**
+     * @dev Return InstaList Address
+     */
+    ListInterface internal constant instaList =
+        ListInterface(0x9926955e0Dd681Dc303370C52f4Ad0a4dd061687);
+
+    /**
+     * @dev Return connectors registry address
+     */
+    InstaConnectors internal constant instaConnectors =
+        InstaConnectors(0x127d8cD0E2b2E0366D522DeA53A787bfE9002C14);
+
+    /**
+     * @dev Get Uint value from InstaMemory Contract.
+     */
+    function getUint(uint getId, uint val) internal returns (uint returnVal) {
+        returnVal = getId == 0 ? val : instaMemory.getUint(getId);
+    }
+
+    /**
+     * @dev Set Uint value in InstaMemory Contract.
+     */
+    function setUint(uint setId, uint val) internal virtual {
+        if (setId != 0) instaMemory.setUint(setId, val);
+    }
+}

contracts/base/connectors/paraswap/helpers.sol

@@ -0,0 +1,68 @@
+//SPDX-License-Identifier: MIT
+pragma solidity 0.8.19;
+
+import {DSMath} from "../../common/math.sol";
+import {Basic} from "../../common/basic.sol";
+import {TokenInterface} from "../../common/interfaces.sol";
+
+abstract contract Helpers is DSMath, Basic {
+    struct SwapData {
+        TokenInterface sellToken;
+        TokenInterface buyToken;
+        uint256 _sellAmt;
+        uint256 _buyAmt;
+        uint256 unitAmt;
+        bytes callData;
+    }
+
+    address internal constant AUGUSTUS_V6 =
+        0x6A000F20005980200259B80c5102003040001068;
+
+    function _swapHelper(
+        SwapData memory swapData,
+        uint256 wethAmt
+    ) 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, ) = AUGUSTUS_V6.call{value: wethAmt}(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 ethAmt;
+
+        if (address(_sellAddr) == ethAddr) {
+            ethAmt = swapData._sellAmt;
+        } else {
+            approve(TokenInterface(_sellAddr), AUGUSTUS_V6, swapData._sellAmt);
+        }
+
+        swapData._buyAmt = _swapHelper(swapData, ethAmt);
+
+        setUint(setId, swapData._buyAmt);
+
+        return swapData;
+    }
+}

contracts/base/connectors/paraswap/main.sol

@@ -0,0 +1,55 @@
+//SPDX-License-Identifier: MIT
+pragma solidity 0.8.19;
+
+import {TokenInterface} from "../../common/interfaces.sol";
+import {Stores} from "../../common/stores.sol";
+import {Helpers} from "./helpers.sol";
+
+contract ParaswapResolver is Helpers {
+    /**
+     * @dev Sell ETH/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 ETH: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)
+     * @param sellAddr The address of the token to sell.(For ETH: 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 ConnectV2ParaswapV6Arbitrum is ParaswapResolver {
+    string public name = "Paraswap-v6.2";
+}