From 8b9875db3fd7a6b899ad521467c124dfb631b8aa Mon Sep 17 00:00:00 2001 From: Samarendra Gouda Date: Sun, 23 Jun 2024 00:07:23 +0530 Subject: [PATCH] feat: add avalanche & paraswap --- contracts/avalanche/common/basic.sol | 91 +++++++++++++++++++ contracts/avalanche/common/interfaces.sol | 48 ++++++++++ contracts/avalanche/common/math.sol | 55 +++++++++++ contracts/avalanche/common/stores.sol | 50 ++++++++++ .../avalanche/connectors/paraswap/helpers.sol | 68 ++++++++++++++ .../avalanche/connectors/paraswap/main.sol | 55 +++++++++++ 6 files changed, 367 insertions(+) create mode 100644 contracts/avalanche/common/basic.sol create mode 100644 contracts/avalanche/common/interfaces.sol create mode 100644 contracts/avalanche/common/math.sol create mode 100644 contracts/avalanche/common/stores.sol create mode 100644 contracts/avalanche/connectors/paraswap/helpers.sol create mode 100644 contracts/avalanche/connectors/paraswap/main.sol diff --git a/contracts/avalanche/common/basic.sol b/contracts/avalanche/common/basic.sol new file mode 100644 index 0000000..3141407 --- /dev/null +++ b/contracts/avalanche/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) == avaxAddr + ? address(this).balance + : token.balanceOf(address(this)); + } + + function getTokensDec( + TokenInterface buyAddr, + TokenInterface sellAddr + ) internal view returns (uint buyDec, uint sellDec) { + buyDec = address(buyAddr) == avaxAddr ? 18 : buyAddr.decimals(); + sellDec = address(sellAddr) == avaxAddr ? 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 == avaxAddr ? TokenInterface(wavaxAddr) : TokenInterface(buy); + _sell = sell == avaxAddr + ? TokenInterface(wavaxAddr) + : TokenInterface(sell); + } + + function changeEthAddrToWethAddr( + address token + ) internal pure returns (address tokenAddr) { + tokenAddr = token == avaxAddr ? wavaxAddr : 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); + } + } +} diff --git a/contracts/avalanche/common/interfaces.sol b/contracts/avalanche/common/interfaces.sol new file mode 100644 index 0000000..9862c12 --- /dev/null +++ b/contracts/avalanche/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); +} diff --git a/contracts/avalanche/common/math.sol b/contracts/avalanche/common/math.sol new file mode 100644 index 0000000..fa7f0ac --- /dev/null +++ b/contracts/avalanche/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); + } +} diff --git a/contracts/avalanche/common/stores.sol b/contracts/avalanche/common/stores.sol new file mode 100644 index 0000000..37082be --- /dev/null +++ b/contracts/avalanche/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 avax address + */ + address internal constant avaxAddr = + 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE; + + /** + * @dev Return Wrapped AVAX address + */ + address internal constant wavaxAddr = + 0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7; + + /** + * @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); + } +} diff --git a/contracts/avalanche/connectors/paraswap/helpers.sol b/contracts/avalanche/connectors/paraswap/helpers.sol new file mode 100644 index 0000000..84e29cb --- /dev/null +++ b/contracts/avalanche/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 wavaxAmt + ) 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: wavaxAmt}(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 avaxAmt; + + if (address(_sellAddr) == avaxAddr) { + avaxAmt = swapData._sellAmt; + } else { + approve(TokenInterface(_sellAddr), AUGUSTUS_V6, swapData._sellAmt); + } + + swapData._buyAmt = _swapHelper(swapData, avaxAmt); + + setUint(setId, swapData._buyAmt); + + return swapData; + } +} diff --git a/contracts/avalanche/connectors/paraswap/main.sol b/contracts/avalanche/connectors/paraswap/main.sol new file mode 100644 index 0000000..aa44dce --- /dev/null +++ b/contracts/avalanche/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 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 ConnectV2ParaswapV6Arbitrum is ParaswapResolver { + string public name = "Paraswap-v6.2"; +}