Instadapp/dsa-connectors
1
0
Fork 0
mirror of https://github.com/Instadapp/dsa-connectors.git synced 2024-07-29 22:37:00 +00:00
Code Issues Packages Projects Releases Wiki Activity

updated quickswap

Browse Source
This commit is contained in:
pradyuman-verma 2021-12-15 16:35:10 +05:30
parent 95ed18984f
commit da09b6b1cb
No known key found for this signature in database
GPG Key ID: E36FD6BC8923221F
4 changed files with 492 additions and 492 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
contracts/polygon/connectors/quickswap/events.sol
View File

@ -1,41 +1,41 @@
pragma solidity ^0.7.0; pragma solidity ^0.7.0;
contract Events { contract Events {
event LogDepositLiquidity( event LogDepositLiquidity(
address indexed tokenA, address indexed tokenA,
address indexed tokenB, address indexed tokenB,
uint256 amtA, uint256 amtA,
uint256 amtB, uint256 amtB,
uint256 uniAmount, uint256 uniAmount,
uint256 getId, uint256 getId,
uint256 setId uint256 setId
); );
event LogWithdrawLiquidity( event LogWithdrawLiquidity(
address indexed tokenA, address indexed tokenA,
address indexed tokenB, address indexed tokenB,
uint256 amountA, uint256 amountA,
uint256 amountB, uint256 amountB,
uint256 uniAmount, uint256 uniAmount,
uint256 getId, uint256 getId,
uint256[] setId uint256[] setId
); );
event LogBuy( event LogBuy(
address indexed buyToken, address indexed buyToken,
address indexed sellToken, address indexed sellToken,
uint256 buyAmt, uint256 buyAmt,
uint256 sellAmt, uint256 sellAmt,
uint256 getId, uint256 getId,
uint256 setId uint256 setId
); );
event LogSell( event LogSell(
address indexed buyToken, address indexed buyToken,
address indexed sellToken, address indexed sellToken,
uint256 buyAmt, uint256 buyAmt,
uint256 sellAmt, uint256 sellAmt,
uint256 getId, uint256 getId,
uint256 setId uint256 setId
); );
} }

326
contracts/polygon/connectors/quickswap/helpers.sol
View File

@ -1,184 +1,184 @@
pragma solidity ^0.7.0; pragma solidity ^0.7.0;
import {TokenInterface} from "../../common/interfaces.sol"; import { TokenInterface } from "../../common/interfaces.sol";
import {DSMath} from "../../common/math.sol"; import { DSMath } from "../../common/math.sol";
import {Basic} from "../../common/basic.sol"; import { Basic } from "../../common/basic.sol";
import {IQuickSwapRouter, IQuickSwapFactory} from "./interface.sol"; import { IQuickSwapRouter, IQuickSwapFactory } from "./interface.sol";
abstract contract Helpers is DSMath, Basic { abstract contract Helpers is DSMath, Basic {
/** /**
* @dev IQuickSwapRouter * @dev IQuickSwapRouter
*/ */
IQuickSwapRouter internal constant router = IQuickSwapRouter internal constant router =
IQuickSwapRouter(0xa5E0829CaCEd8fFDD4De3c43696c57F7D7A678ff); IQuickSwapRouter(0xa5E0829CaCEd8fFDD4De3c43696c57F7D7A678ff);
function getExpectedBuyAmt(address[] memory paths, uint256 sellAmt) function getExpectedBuyAmt(address[] memory paths, uint256 sellAmt)
internal internal
view view
returns (uint256 buyAmt) returns (uint256 buyAmt)
{ {
uint256[] memory amts = router.getAmountsOut(sellAmt, paths); uint256[] memory amts = router.getAmountsOut(sellAmt, paths);
buyAmt = amts[1]; buyAmt = amts[1];
} }
function getExpectedSellAmt(address[] memory paths, uint256 buyAmt) function getExpectedSellAmt(address[] memory paths, uint256 buyAmt)
internal internal
view view
returns (uint256 sellAmt) returns (uint256 sellAmt)
{ {
uint256[] memory amts = router.getAmountsIn(buyAmt, paths); uint256[] memory amts = router.getAmountsIn(buyAmt, paths);
sellAmt = amts[0]; sellAmt = amts[0];
} }
function checkPair(address[] memory paths) internal view { function checkPair(address[] memory paths) internal view {
address pair = IQuickSwapFactory(router.factory()).getPair( address pair = IQuickSwapFactory(router.factory()).getPair(
paths[0], paths[0],
paths[1] paths[1]
); );
require(pair != address(0), "No-exchange-address"); require(pair != address(0), "No-exchange-address");
} }
function getPaths(address buyAddr, address sellAddr) function getPaths(address buyAddr, address sellAddr)
internal internal
pure pure
returns (address[] memory paths) returns (address[] memory paths)
{ {
paths = new address[](2); paths = new address[](2);
paths[0] = address(sellAddr); paths[0] = address(sellAddr);
paths[1] = address(buyAddr); paths[1] = address(buyAddr);
} }
function getMinAmount( function getMinAmount(
TokenInterface token, TokenInterface token,
uint256 amt, uint256 amt,
uint256 slippage uint256 slippage
) internal view returns (uint256 minAmt) { ) internal view returns (uint256 minAmt) {
uint256 _amt18 = convertTo18(token.decimals(), amt); uint256 _amt18 = convertTo18(token.decimals(), amt);
minAmt = wmul(_amt18, sub(WAD, slippage)); minAmt = wmul(_amt18, sub(WAD, slippage));
minAmt = convert18ToDec(token.decimals(), minAmt); minAmt = convert18ToDec(token.decimals(), minAmt);
} }
function _addLiquidity( function _addLiquidity(
address tokenA, address tokenA,
address tokenB, address tokenB,
uint256 _amt, uint256 _amt,
uint256 unitAmt, uint256 unitAmt,
uint256 slippage uint256 slippage
) )
internal internal
returns ( returns (
uint256 _amtA, uint256 _amtA,
uint256 _amtB, uint256 _amtB,
uint256 _liquidity uint256 _liquidity
) )
{ {
(TokenInterface _tokenA, TokenInterface _tokenB) = changeMaticAddress( (TokenInterface _tokenA, TokenInterface _tokenB) = changeMaticAddress(
tokenA, tokenA,
tokenB tokenB
); );
_amtA = _amt == uint256(-1) _amtA = _amt == uint256(-1)
? getTokenBal(TokenInterface(tokenA)) ? getTokenBal(TokenInterface(tokenA))
: _amt; : _amt;
_amtB = convert18ToDec( _amtB = convert18ToDec(
_tokenB.decimals(), _tokenB.decimals(),
wmul(unitAmt, convertTo18(_tokenA.decimals(), _amtA)) wmul(unitAmt, convertTo18(_tokenA.decimals(), _amtA))
); );
bool isMatic = address(_tokenA) == wmaticAddr; bool isMatic = address(_tokenA) == wmaticAddr;
convertMaticToWmatic(isMatic, _tokenA, _amtA); convertMaticToWmatic(isMatic, _tokenA, _amtA);
isMatic = address(_tokenB) == wmaticAddr; isMatic = address(_tokenB) == wmaticAddr;
convertMaticToWmatic(isMatic, _tokenB, _amtB); convertMaticToWmatic(isMatic, _tokenB, _amtB);
approve(_tokenA, address(router), _amtA); approve(_tokenA, address(router), _amtA);
approve(_tokenB, address(router), _amtB); approve(_tokenB, address(router), _amtB);
uint256 minAmtA = getMinAmount(_tokenA, _amtA, slippage); uint256 minAmtA = getMinAmount(_tokenA, _amtA, slippage);
uint256 minAmtB = getMinAmount(_tokenB, _amtB, slippage); uint256 minAmtB = getMinAmount(_tokenB, _amtB, slippage);
(_amtA, _amtB, _liquidity) = router.addLiquidity( (_amtA, _amtB, _liquidity) = router.addLiquidity(
address(_tokenA), address(_tokenA),
address(_tokenB), address(_tokenB),
_amtA, _amtA,
_amtB, _amtB,
minAmtA, minAmtA,
minAmtA, minAmtB,
address(this), address(this),
block.timestamp + 1 block.timestamp + 1
); );
} }
function _removeLiquidity( function _removeLiquidity(
address tokenA, address tokenA,
address tokenB, address tokenB,
uint256 _amt, uint256 _amt,
uint256 unitAmtA, uint256 unitAmtA,
uint256 unitAmtB uint256 unitAmtB
) )
internal internal
returns ( returns (
uint256 _amtA, uint256 _amtA,
uint256 _amtB, uint256 _amtB,
uint256 _uniAmt uint256 _uniAmt
) )
{ {
TokenInterface _tokenA; TokenInterface _tokenA;
TokenInterface _tokenB; TokenInterface _tokenB;
(_tokenA, _tokenB, _uniAmt) = _getRemoveLiquidityData( (_tokenA, _tokenB, _uniAmt) = _getRemoveLiquidityData(
tokenA, tokenA,
tokenB, tokenB,
_amt _amt
); );
{ {
uint256 minAmtA = convert18ToDec( uint256 minAmtA = convert18ToDec(
_tokenA.decimals(), _tokenA.decimals(),
wmul(unitAmtA, _uniAmt) wmul(unitAmtA, _uniAmt)
); );
uint256 minAmtB = convert18ToDec( uint256 minAmtB = convert18ToDec(
_tokenB.decimals(), _tokenB.decimals(),
wmul(unitAmtB, _uniAmt) wmul(unitAmtB, _uniAmt)
); );
(_amtA, _amtB) = router.removeLiquidity( (_amtA, _amtB) = router.removeLiquidity(
address(_tokenA), address(_tokenA),
address(_tokenB), address(_tokenB),
_uniAmt, _uniAmt,
minAmtA, minAmtA,
minAmtB, minAmtB,
address(this), address(this),
block.timestamp + 1 block.timestamp + 1
); );
} }
bool isMatic = address(_tokenA) == wmaticAddr; bool isMatic = address(_tokenA) == wmaticAddr;
convertWmaticToMatic(isMatic, _tokenA, _amtA); convertWmaticToMatic(isMatic, _tokenA, _amtA);
isMatic = address(_tokenB) == wmaticAddr; isMatic = address(_tokenB) == wmaticAddr;
convertWmaticToMatic(isMatic, _tokenB, _amtB); convertWmaticToMatic(isMatic, _tokenB, _amtB);
} }
function _getRemoveLiquidityData( function _getRemoveLiquidityData(
address tokenA, address tokenA,
address tokenB, address tokenB,
uint256 _amt uint256 _amt
) )
internal internal
returns ( returns (
TokenInterface _tokenA, TokenInterface _tokenA,
TokenInterface _tokenB, TokenInterface _tokenB,
uint256 _uniAmt uint256 _uniAmt
) )
{ {
(_tokenA, _tokenB) = changeMaticAddress(tokenA, tokenB); (_tokenA, _tokenB) = changeMaticAddress(tokenA, tokenB);
address exchangeAddr = IQuickSwapFactory(router.factory()).getPair( address exchangeAddr = IQuickSwapFactory(router.factory()).getPair(
address(_tokenA), address(_tokenA),
address(_tokenB) address(_tokenB)
); );
require(exchangeAddr != address(0), "pair-not-found."); require(exchangeAddr != address(0), "pair-not-found.");
TokenInterface uniToken = TokenInterface(exchangeAddr); TokenInterface uniToken = TokenInterface(exchangeAddr);
_uniAmt = _amt == uint256(-1) _uniAmt = _amt == uint256(-1)
? uniToken.balanceOf(address(this)) ? uniToken.balanceOf(address(this))
: _amt; : _amt;
approve(uniToken, address(router), _uniAmt); approve(uniToken, address(router), _uniAmt);
} }
} }

150
contracts/polygon/connectors/quickswap/interface.sol
View File

@ -1,97 +1,97 @@
pragma solidity ^0.7.0; pragma solidity ^0.7.0;
interface IQuickSwapRouter { interface IQuickSwapRouter {
function factory() external pure returns (address); function factory() external pure returns (address);
function WETH() external pure returns (address); function WETH() external pure returns (address);
function addLiquidity( function addLiquidity(
address tokenA, address tokenA,
address tokenB, address tokenB,
uint256 amountADesired, uint256 amountADesired,
uint256 amountBDesired, uint256 amountBDesired,
uint256 amountAMin, uint256 amountAMin,
uint256 amountBMin, uint256 amountBMin,
address to, address to,
uint256 deadline uint256 deadline
) )
external external
returns ( returns (
uint256 amountA, uint256 amountA,
uint256 amountB, uint256 amountB,
uint256 liquidity uint256 liquidity
); );
function removeLiquidity( function removeLiquidity(
address tokenA, address tokenA,
address tokenB, address tokenB,
uint256 liquidity, uint256 liquidity,
uint256 amountAMin, uint256 amountAMin,
uint256 amountBMin, uint256 amountBMin,
address to, address to,
uint256 deadline uint256 deadline
) external returns (uint256 amountA, uint256 amountB); ) external returns (uint256 amountA, uint256 amountB);
function swapExactTokensForTokens( function swapExactTokensForTokens(
uint256 amountIn, uint256 amountIn,
uint256 amountOutMin, uint256 amountOutMin,
address[] calldata path, address[] calldata path,
address to, address to,
uint256 deadline uint256 deadline
) external returns (uint256[] memory amounts); ) external returns (uint256[] memory amounts);
function swapTokensForExactTokens( function swapTokensForExactTokens(
uint256 amountOut, uint256 amountOut,
uint256 amountInMax, uint256 amountInMax,
address[] calldata path, address[] calldata path,
address to, address to,
uint256 deadline uint256 deadline
) external returns (uint256[] memory amounts); ) external returns (uint256[] memory amounts);
function quote( function quote(
uint256 amountA, uint256 amountA,
uint256 reserveA, uint256 reserveA,
uint256 reserveB uint256 reserveB
) external pure returns (uint256 amountB); ) external pure returns (uint256 amountB);
function getAmountOut( function getAmountOut(
uint256 amountIn, uint256 amountIn,
uint256 reserveIn, uint256 reserveIn,
uint256 reserveOut uint256 reserveOut
) external pure returns (uint256 amountOut); ) external pure returns (uint256 amountOut);
function getAmountIn( function getAmountIn(
uint256 amountOut, uint256 amountOut,
uint256 reserveIn, uint256 reserveIn,
uint256 reserveOut uint256 reserveOut
) external pure returns (uint256 amountIn); ) external pure returns (uint256 amountIn);
function getAmountsOut(uint256 amountIn, address[] calldata path) function getAmountsOut(uint256 amountIn, address[] calldata path)
external external
view view
returns (uint256[] memory amounts); returns (uint256[] memory amounts);
function getAmountsIn(uint256 amountOut, address[] calldata path) function getAmountsIn(uint256 amountOut, address[] calldata path)
external external
view view
returns (uint256[] memory amounts); returns (uint256[] memory amounts);
} }
interface IQuickSwapFactory { interface IQuickSwapFactory {
function getPair(address tokenA, address tokenB) function getPair(address tokenA, address tokenB)
external external
view view
returns (address pair); returns (address pair);
function allPairs(uint256) external view returns (address pair); function allPairs(uint256) external view returns (address pair);
function allPairsLength() external view returns (uint256); function allPairsLength() external view returns (uint256);
function feeTo() external view returns (address); function feeTo() external view returns (address);
function feeToSetter() external view returns (address); function feeToSetter() external view returns (address);
function createPair(address tokenA, address tokenB) function createPair(address tokenA, address tokenB)
external external
returns (address pair); returns (address pair);
} }

440
contracts/polygon/connectors/quickswap/main.sol
View File

@ -5,252 +5,252 @@ pragma solidity ^0.7.0;
* @dev Decentralized Exchange. * @dev Decentralized Exchange.
*/ */
import {TokenInterface} from "../../common/interfaces.sol"; import { TokenInterface } from "../../common/interfaces.sol";
import {Helpers} from "./helpers.sol"; import { Helpers } from "./helpers.sol";
import {Events} from "./events.sol"; import { Events } from "./events.sol";
abstract contract QuickpswapResolver is Helpers, Events { abstract contract QuickpswapResolver is Helpers, Events {
/** /**
* @dev Deposit Liquidity. * @dev Deposit Liquidity.
* @notice Deposit Liquidity to a QuickSwap pool. * @notice Deposit Liquidity to a QuickSwap pool.
* @param tokenA The address of token A.(For ETH: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE) * @param tokenA The address of token A.(For ETH: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)
* @param tokenB The address of token B.(For ETH: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE) * @param tokenB The address of token B.(For ETH: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)
* @param amtA The amount of A tokens to deposit. * @param amtA The amount of A tokens to deposit.
* @param unitAmt The unit amount of of amtB/amtA with slippage. * @param unitAmt The unit amount of of amtB/amtA with slippage.
* @param slippage Slippage amount. * @param slippage Slippage amount.
* @param getId ID to retrieve amtA. * @param getId ID to retrieve amtA.
* @param setId ID stores the amount of pools tokens received. * @param setId ID stores the amount of pools tokens received.
*/ */
function deposit( function deposit(
address tokenA, address tokenA,
address tokenB, address tokenB,
uint256 amtA, uint256 amtA,
uint256 unitAmt, uint256 unitAmt,
uint256 slippage, uint256 slippage,
uint256 getId, uint256 getId,
uint256 setId uint256 setId
) )
external external
payable payable
returns (string memory _eventName, bytes memory _eventParam) returns (string memory _eventName, bytes memory _eventParam)
{ {
uint256 _amt = getUint(getId, amtA); uint256 _amt = getUint(getId, amtA);
(uint256 _amtA, uint256 _amtB, uint256 _uniAmt) = _addLiquidity( (uint256 _amtA, uint256 _amtB, uint256 _uniAmt) = _addLiquidity(
tokenA, tokenA,
tokenB, tokenB,
_amt, _amt,
unitAmt, unitAmt,
slippage slippage
); );
setUint(setId, _uniAmt); setUint(setId, _uniAmt);
_eventName = "LogDepositLiquidity(address,address,uint256,uint256,uint256,uint256,uint256)"; _eventName = "LogDepositLiquidity(address,address,uint256,uint256,uint256,uint256,uint256)";
_eventParam = abi.encode( _eventParam = abi.encode(
tokenA, tokenA,
tokenB, tokenB,
_amtA, _amtA,
_amtB, _amtB,
_uniAmt, _uniAmt,
getId, getId,
setId setId
); );
} }
/** /**
* @dev Withdraw Liquidity. * @dev Withdraw Liquidity.
* @notice Withdraw Liquidity from a QuickSwap pool. * @notice Withdraw Liquidity from a QuickSwap pool.
* @param tokenA The address of token A.(For ETH: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE) * @param tokenA The address of token A.(For ETH: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)
* @param tokenB The address of token B.(For ETH: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE) * @param tokenB The address of token B.(For ETH: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)
* @param uniAmt The amount of pool tokens to withdraw. * @param uniAmt The amount of pool tokens to withdraw.
* @param unitAmtA The unit amount of amtA/uniAmt with slippage. * @param unitAmtA The unit amount of amtA/uniAmt with slippage.
* @param unitAmtB The unit amount of amtB/uniAmt with slippage. * @param unitAmtB The unit amount of amtB/uniAmt with slippage.
* @param getId ID to retrieve uniAmt. * @param getId ID to retrieve uniAmt.
* @param setIds Array of IDs to store the amount tokens received. * @param setIds Array of IDs to store the amount tokens received.
*/ */
function withdraw( function withdraw(
address tokenA, address tokenA,
address tokenB, address tokenB,
uint256 uniAmt, uint256 uniAmt,
uint256 unitAmtA, uint256 unitAmtA,
uint256 unitAmtB, uint256 unitAmtB,
uint256 getId, uint256 getId,
uint256[] calldata setIds uint256[] calldata setIds
) )
external external
payable payable
returns (string memory _eventName, bytes memory _eventParam) returns (string memory _eventName, bytes memory _eventParam)
{ {
uint256 _amt = getUint(getId, uniAmt); uint256 _amt = getUint(getId, uniAmt);
(uint256 _amtA, uint256 _amtB, uint256 _uniAmt) = _removeLiquidity( (uint256 _amtA, uint256 _amtB, uint256 _uniAmt) = _removeLiquidity(
tokenA, tokenA,
tokenB, tokenB,
_amt, _amt,
unitAmtA, unitAmtA,
unitAmtB unitAmtB
); );
setUint(setIds[0], _amtA); setUint(setIds[0], _amtA);
setUint(setIds[1], _amtB); setUint(setIds[1], _amtB);
_eventName = "LogWithdrawLiquidity(address,address,uint256,uint256,uint256,uint256,uint256[])"; _eventName = "LogWithdrawLiquidity(address,address,uint256,uint256,uint256,uint256,uint256[])";
_eventParam = abi.encode( _eventParam = abi.encode(
tokenA, tokenA,
tokenB, tokenB,
_amtA, _amtA,
_amtB, _amtB,
_uniAmt, _uniAmt,
getId, getId,
setIds setIds
); );
} }
/** /**
* @dev Buy ETH/ERC20_Token. * @dev Buy ETH/ERC20_Token.
* @notice Buy a token using a QuickSwap * @notice Buy a token using a QuickSwap
* @param buyAddr The address of the token to buy.(For ETH: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE) * @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 sellAddr The address of the token to sell.(For ETH: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)
* @param buyAmt The amount of tokens to buy. * @param buyAmt The amount of tokens to buy.
* @param unitAmt The unit amount of sellAmt/buyAmt with slippage. * @param unitAmt The unit amount of sellAmt/buyAmt with slippage.
* @param getId ID to retrieve buyAmt. * @param getId ID to retrieve buyAmt.
* @param setId ID to store the amount of tokens sold. * @param setId ID to store the amount of tokens sold.
*/ */
function buy( function buy(
address buyAddr, address buyAddr,
address sellAddr, address sellAddr,
uint256 buyAmt, uint256 buyAmt,
uint256 unitAmt, uint256 unitAmt,
uint256 getId, uint256 getId,
uint256 setId uint256 setId
) )
external external
payable payable
returns (string memory _eventName, bytes memory _eventParam) returns (string memory _eventName, bytes memory _eventParam)
{ {
uint256 _buyAmt = getUint(getId, buyAmt); uint256 _buyAmt = getUint(getId, buyAmt);
( (
TokenInterface _buyAddr, TokenInterface _buyAddr,
TokenInterface _sellAddr TokenInterface _sellAddr
) = changeMaticAddress(buyAddr, sellAddr); ) = changeMaticAddress(buyAddr, sellAddr);
address[] memory paths = getPaths( address[] memory paths = getPaths(
address(_buyAddr), address(_buyAddr),
address(_sellAddr) address(_sellAddr)
); );
uint256 _slippageAmt = convert18ToDec( uint256 _slippageAmt = convert18ToDec(
_sellAddr.decimals(), _sellAddr.decimals(),
wmul(unitAmt, convertTo18(_buyAddr.decimals(), _buyAmt)) wmul(unitAmt, convertTo18(_buyAddr.decimals(), _buyAmt))
); );
checkPair(paths); checkPair(paths);
uint256 _expectedAmt = getExpectedSellAmt(paths, _buyAmt); uint256 _expectedAmt = getExpectedSellAmt(paths, _buyAmt);
require(_slippageAmt >= _expectedAmt, "Too much slippage"); require(_slippageAmt >= _expectedAmt, "Too much slippage");
bool isEth = address(_sellAddr) == wmaticAddr; bool isEth = address(_sellAddr) == wmaticAddr;
convertMaticToWmatic(isEth, _sellAddr, _expectedAmt); convertMaticToWmatic(isEth, _sellAddr, _expectedAmt);
approve(_sellAddr, address(router), _expectedAmt); approve(_sellAddr, address(router), _expectedAmt);
uint256 _sellAmt = router.swapTokensForExactTokens( uint256 _sellAmt = router.swapTokensForExactTokens(
_buyAmt, _buyAmt,
_expectedAmt, _expectedAmt,
paths, paths,
address(this), address(this),
block.timestamp + 1 block.timestamp + 1
)[0]; )[0];
isEth = address(_buyAddr) == wmaticAddr; isEth = address(_buyAddr) == wmaticAddr;
convertWmaticToMatic(isEth, _buyAddr, _buyAmt); convertWmaticToMatic(isEth, _buyAddr, _buyAmt);
setUint(setId, _sellAmt); setUint(setId, _sellAmt);
_eventName = "LogBuy(address,address,uint256,uint256,uint256,uint256)"; _eventName = "LogBuy(address,address,uint256,uint256,uint256,uint256)";
_eventParam = abi.encode( _eventParam = abi.encode(
buyAddr, buyAddr,
sellAddr, sellAddr,
_buyAmt, _buyAmt,
_sellAmt, _sellAmt,
getId, getId,
setId setId
); );
} }
/** /**
* @dev Sell ETH/ERC20_Token. * @dev Sell ETH/ERC20_Token.
* @notice Sell a token using a QuickSwap * @notice Sell a token using a QuickSwap
* @param buyAddr The address of the token to buy.(For ETH: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE) * @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 sellAddr The address of the token to sell.(For ETH: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)
* @param sellAmt The amount of the token to sell. * @param sellAmt The amount of the token to sell.
* @param unitAmt The unit amount of buyAmt/sellAmt with slippage. * @param unitAmt The unit amount of buyAmt/sellAmt with slippage.
* @param getId ID to retrieve sellAmt. * @param getId ID to retrieve sellAmt.
* @param setId ID stores the amount of token brought. * @param setId ID stores the amount of token brought.
*/ */
function sell( function sell(
address buyAddr, address buyAddr,
address sellAddr, address sellAddr,
uint256 sellAmt, uint256 sellAmt,
uint256 unitAmt, uint256 unitAmt,
uint256 getId, uint256 getId,
uint256 setId uint256 setId
) )
external external
payable payable
returns (string memory _eventName, bytes memory _eventParam) returns (string memory _eventName, bytes memory _eventParam)
{ {
uint256 _sellAmt = getUint(getId, sellAmt); uint256 _sellAmt = getUint(getId, sellAmt);
( (
TokenInterface _buyAddr, TokenInterface _buyAddr,
TokenInterface _sellAddr TokenInterface _sellAddr
) = changeMaticAddress(buyAddr, sellAddr); ) = changeMaticAddress(buyAddr, sellAddr);
address[] memory paths = getPaths( address[] memory paths = getPaths(
address(_buyAddr), address(_buyAddr),
address(_sellAddr) address(_sellAddr)
); );
if (_sellAmt == uint256(-1)) { if (_sellAmt == uint256(-1)) {
_sellAmt = sellAddr == maticAddr _sellAmt = sellAddr == maticAddr
? address(this).balance ? address(this).balance
: _sellAddr.balanceOf(address(this)); : _sellAddr.balanceOf(address(this));
} }
uint256 _slippageAmt = convert18ToDec( uint256 _slippageAmt = convert18ToDec(
_buyAddr.decimals(), _buyAddr.decimals(),
wmul(unitAmt, convertTo18(_sellAddr.decimals(), _sellAmt)) wmul(unitAmt, convertTo18(_sellAddr.decimals(), _sellAmt))
); );
checkPair(paths); checkPair(paths);
uint256 _expectedAmt = getExpectedBuyAmt(paths, _sellAmt); uint256 _expectedAmt = getExpectedBuyAmt(paths, _sellAmt);
require(_slippageAmt <= _expectedAmt, "Too much slippage"); require(_slippageAmt <= _expectedAmt, "Too much slippage");
bool isEth = address(_sellAddr) == wmaticAddr; bool isEth = address(_sellAddr) == wmaticAddr;
convertMaticToWmatic(isEth, _sellAddr, _sellAmt); convertMaticToWmatic(isEth, _sellAddr, _sellAmt);
approve(_sellAddr, address(router), _sellAmt); approve(_sellAddr, address(router), _sellAmt);
uint256 _buyAmt = router.swapExactTokensForTokens( uint256 _buyAmt = router.swapExactTokensForTokens(
_sellAmt, _sellAmt,
_expectedAmt, _expectedAmt,
paths, paths,
address(this), address(this),
block.timestamp + 1 block.timestamp + 1
)[1]; )[1];
isEth = address(_buyAddr) == wmaticAddr; isEth = address(_buyAddr) == wmaticAddr;
convertWmaticToMatic(isEth, _buyAddr, _buyAmt); convertWmaticToMatic(isEth, _buyAddr, _buyAmt);
setUint(setId, _buyAmt); setUint(setId, _buyAmt);
_eventName = "LogSell(address,address,uint256,uint256,uint256,uint256)"; _eventName = "LogSell(address,address,uint256,uint256,uint256,uint256)";
_eventParam = abi.encode( _eventParam = abi.encode(
buyAddr, buyAddr,
sellAddr, sellAddr,
_buyAmt, _buyAmt,
_sellAmt, _sellAmt,
getId, getId,
setId setId
); );
} }
} }
contract ConnectV2Quickswap is QuickpswapResolver { contract ConnectV2Quickswap is QuickpswapResolver {
string public constant name = "Quickpswap-v1.1"; string public constant name = "Quickpswap-v1.1";
} }