From 46d999016db1d2303e732be7ced62d9299a42e54 Mon Sep 17 00:00:00 2001 From: Shriya Tyagi Date: Tue, 18 Jun 2024 17:09:07 +0530 Subject: [PATCH 1/2] feat: update FLA address --- contracts/mainnet/connectors/instapool_v5/main.sol | 2 +- contracts/mainnet/connectors/instapool_v5/variables.sol | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/contracts/mainnet/connectors/instapool_v5/main.sol b/contracts/mainnet/connectors/instapool_v5/main.sol index 8fce0d1..587150c 100644 --- a/contracts/mainnet/connectors/instapool_v5/main.sol +++ b/contracts/mainnet/connectors/instapool_v5/main.sol @@ -132,5 +132,5 @@ contract LiquidityResolver is Stores, Variables, Events { } contract ConnectV2InstaPoolV5 is LiquidityResolver { - string public name = "Instapool-v5"; + string public name = "Instapool-v5.1"; } diff --git a/contracts/mainnet/connectors/instapool_v5/variables.sol b/contracts/mainnet/connectors/instapool_v5/variables.sol index f2182a4..3c098ff 100644 --- a/contracts/mainnet/connectors/instapool_v5/variables.sol +++ b/contracts/mainnet/connectors/instapool_v5/variables.sol @@ -9,6 +9,6 @@ contract Variables { * @dev Instapool contract proxy */ InstaFlashV5Interface public constant instaPool = - InstaFlashV5Interface(0xAB50Dd1C57938218627Df2311ef65b4e2e84aF48); + InstaFlashV5Interface(0x352423e2fA5D5c99343d371C9e3bC56C87723Cc7); } \ No newline at end of file From 34a9248c18ae131e0edb31ba2e632269781f5fb1 Mon Sep 17 00:00:00 2001 From: Shriya Tyagi Date: Tue, 18 Jun 2024 17:16:33 +0530 Subject: [PATCH 2/2] feat: add arbitrum instapool contract --- contracts/arbitrum/common/basic.sol | 55 +++++++ contracts/arbitrum/common/interfaces.sol | 42 ++++++ contracts/arbitrum/common/math.sol | 51 +++++++ contracts/arbitrum/common/stores.sol | 48 ++++++ .../connectors/instapool_v5/events.sol | 10 ++ .../connectors/instapool_v5/interfaces.sol | 11 ++ .../arbitrum/connectors/instapool_v5/main.sol | 138 ++++++++++++++++++ .../connectors/instapool_v5/variables.sol | 14 ++ 8 files changed, 369 insertions(+) create mode 100644 contracts/arbitrum/common/basic.sol create mode 100644 contracts/arbitrum/common/interfaces.sol create mode 100644 contracts/arbitrum/common/math.sol create mode 100644 contracts/arbitrum/common/stores.sol create mode 100644 contracts/arbitrum/connectors/instapool_v5/events.sol create mode 100644 contracts/arbitrum/connectors/instapool_v5/interfaces.sol create mode 100644 contracts/arbitrum/connectors/instapool_v5/main.sol create mode 100644 contracts/arbitrum/connectors/instapool_v5/variables.sol diff --git a/contracts/arbitrum/common/basic.sol b/contracts/arbitrum/common/basic.sol new file mode 100644 index 0000000..ed6ab8c --- /dev/null +++ b/contracts/arbitrum/common/basic.sol @@ -0,0 +1,55 @@ +//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 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); + } + } +} \ No newline at end of file diff --git a/contracts/arbitrum/common/interfaces.sol b/contracts/arbitrum/common/interfaces.sol new file mode 100644 index 0000000..0991a34 --- /dev/null +++ b/contracts/arbitrum/common/interfaces.sol @@ -0,0 +1,42 @@ +//SPDX-License-Identifier: MIT +pragma solidity ^0.8.2; + +interface TokenInterface { + function approve(address, uint256) external; + function allowance(address, address) external view returns (uint); + 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); +} + +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/arbitrum/common/math.sol b/contracts/arbitrum/common/math.sol new file mode 100644 index 0000000..a61586b --- /dev/null +++ b/contracts/arbitrum/common/math.sol @@ -0,0 +1,51 @@ +//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 virtual pure 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 toRad(uint wad) internal pure returns (uint rad) { + rad = mul(wad, 10 ** 27); + } + +} diff --git a/contracts/arbitrum/common/stores.sol b/contracts/arbitrum/common/stores.sol new file mode 100644 index 0000000..adf9bba --- /dev/null +++ b/contracts/arbitrum/common/stores.sol @@ -0,0 +1,48 @@ +//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 constant internal ethAddr = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE; + + /** + * @dev Return Wrapped ETH address + */ + address constant internal wethAddr = 0x82aF49447D8a07e3bd95BD0d56f35241523fBab1; + + /** + * @dev Return memory variable address + */ + MemoryInterface constant internal instaMemory = MemoryInterface(0xc109f7Ef06152c3a63dc7254fD861E612d3Ac571); + + /** + * @dev Return InstaList address + */ + ListInterface internal constant instaList = ListInterface(0x3565F6057b7fFE36984779A507fC87b31EFb0f09); + + /** + * @dev Return connectors registry address + */ + InstaConnectors internal constant instaConnectors = InstaConnectors(0x67fCE99Dd6d8d659eea2a1ac1b8881c57eb6592B); + + /** + * @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) virtual internal { + if (setId != 0) instaMemory.setUint(setId, val); + } + +} diff --git a/contracts/arbitrum/connectors/instapool_v5/events.sol b/contracts/arbitrum/connectors/instapool_v5/events.sol new file mode 100644 index 0000000..a6cb012 --- /dev/null +++ b/contracts/arbitrum/connectors/instapool_v5/events.sol @@ -0,0 +1,10 @@ +//SPDX-License-Identifier: MIT +pragma solidity ^0.8.0; + +contract Events { + event LogFlashBorrow(address token, uint256 tokenAmt); + event LogFlashPayback(address token, uint256 tokenAmt); + + event LogFlashMultiBorrow(address[] token, uint256[] tokenAmts); + event LogFlashMultiPayback(address[] token, uint256[] tokenAmts); +} \ No newline at end of file diff --git a/contracts/arbitrum/connectors/instapool_v5/interfaces.sol b/contracts/arbitrum/connectors/instapool_v5/interfaces.sol new file mode 100644 index 0000000..a7dff8e --- /dev/null +++ b/contracts/arbitrum/connectors/instapool_v5/interfaces.sol @@ -0,0 +1,11 @@ +//SPDX-License-Identifier: MIT +pragma solidity ^0.8.0; + +interface InstaFlashV5Interface { + function flashLoan(address[] memory tokens, uint256[] memory amts, uint route, bytes memory data, bytes memory extraData) external; +} + +interface AccountInterface { + function enable(address) external; + function disable(address) external; +} diff --git a/contracts/arbitrum/connectors/instapool_v5/main.sol b/contracts/arbitrum/connectors/instapool_v5/main.sol new file mode 100644 index 0000000..61a50a6 --- /dev/null +++ b/contracts/arbitrum/connectors/instapool_v5/main.sol @@ -0,0 +1,138 @@ +//SPDX-License-Identifier: MIT +pragma solidity ^0.8.0; + +/** + * @title Instapool. + * @dev Inbuilt Flash Loan in DSA + */ + +import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; +import { Address } from "@openzeppelin/contracts/utils/Address.sol"; +import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol"; +import { TokenInterface } from "../../common/interfaces.sol"; +import { AccountInterface } from "./interfaces.sol"; +import { Stores } from "../../common/stores.sol"; +import { Variables } from "./variables.sol"; +import { Events } from "./events.sol"; + +contract LiquidityResolver is Stores, Variables, Events { + using SafeERC20 for IERC20; + + /** + * @dev Borrow Flashloan and Cast spells. + * @notice Borrow Flashloan and Cast spells. + * @param token Token Address. + * @param amt Token Amount. + * @param route Flashloan source route. + * @param data targets & data for cast. + * @param extraData to be kept bytes(0) in most cases. Can be useful to decide data for some particular routes + */ + function flashBorrowAndCast( + address token, + uint amt, + uint route, + bytes memory data, + bytes memory extraData + ) external payable returns (string memory _eventName, bytes memory _eventParam) { + AccountInterface(address(this)).enable(address(instaPool)); + (string[] memory _targets, bytes[] memory callDatas) = abi.decode(data, (string[], bytes[])); + + bytes memory callData_ = abi.encodeWithSignature("cast(string[],bytes[],address)", _targets, callDatas, address(instaPool)); + + address[] memory tokens_ = new address[](1); + tokens_[0] = token; + uint[] memory amts_ = new uint[](1); + amts_[0] = amt; + instaPool.flashLoan(tokens_, amts_, route, callData_, extraData); + + AccountInterface(address(this)).disable(address(instaPool)); + + _eventName = "LogFlashBorrow(address,uint256)"; + _eventParam = abi.encode(token, amt); + } + + /** + * @dev Return token to InstaPool. + * @notice Return token to InstaPool. + * @param token Token Address. + * @param amt Token Amount. + * @param getId Get token amount at this ID from `InstaMemory` Contract. + * @param setId Set token amount at this ID in `InstaMemory` Contract. + */ + function flashPayback( + address token, + uint amt, + uint getId, + uint setId + ) external payable returns (string memory _eventName, bytes memory _eventParam) { + uint _amt = getUint(getId, amt); + + IERC20 tokenContract = IERC20(token); + + tokenContract.safeTransfer(address(instaPool), _amt); + + setUint(setId, _amt); + + _eventName = "LogFlashPayback(address,uint256)"; + _eventParam = abi.encode(token, amt); + } + + /** + * @dev Borrow multi-tokens Flashloan and Cast spells. + * @notice Borrow multi-tokens Flashloan and Cast spells. + * @param tokens_ Array of Token Addresses. + * @param amts_ Array of Token Amounts. + * @param route Flashloan source route. + * @param data targets & data for cast. + * @param extraData to be kept bytes(0) in most cases. Can be useful to decide data for some particular routes + */ + function flashMultiBorrowAndCast( + address[] memory tokens_, + uint[] memory amts_, + uint route, + bytes memory data, + bytes memory extraData + ) external payable returns (string memory _eventName, bytes memory _eventParam) { + AccountInterface(address(this)).enable(address(instaPool)); + (string[] memory _targets, bytes[] memory callDatas) = abi.decode(data, (string[], bytes[])); + + bytes memory callData_ = abi.encodeWithSignature("cast(string[],bytes[],address)", _targets, callDatas, address(instaPool)); + + instaPool.flashLoan(tokens_, amts_, route, callData_, extraData); + + AccountInterface(address(this)).disable(address(instaPool)); + _eventName = "LogFlashMultiBorrow(address[],uint256[])"; + _eventParam = abi.encode(tokens_, amts_); + } + + /** + * @dev Return multi-tokens to InstaPool. + * @notice Return multi-tokens to InstaPool. + * @param tokens_ Array of Token Addresses. + * @param amts_ Array of Token Amounts. + * @param getIds Array of getId token amounts. + * @param setIds Array of setId token amounts. + */ + function flashMultiPayback( + address[] memory tokens_, + uint[] memory amts_, + uint[] memory getIds, + uint[] memory setIds + ) external payable returns (string memory _eventName, bytes memory _eventParam) { + for (uint i = 0; i < tokens_.length; i++) { + amts_[i] = getUint(getIds[i], amts_[i]); + + IERC20(tokens_[i]).safeTransfer(address(instaPool), amts_[i]); + + setUint(setIds[i], amts_[i]); + } + + _eventName = "LogFlashMultiPayback(address[],uint256[])"; + _eventParam = abi.encode(tokens_, amts_); + } + +} + +contract ConnectV2InstaPoolV5 is LiquidityResolver { + string public name = "Instapool-v5"; +} diff --git a/contracts/arbitrum/connectors/instapool_v5/variables.sol b/contracts/arbitrum/connectors/instapool_v5/variables.sol new file mode 100644 index 0000000..3c098ff --- /dev/null +++ b/contracts/arbitrum/connectors/instapool_v5/variables.sol @@ -0,0 +1,14 @@ +//SPDX-License-Identifier: MIT +pragma solidity ^0.8.0; + +import { InstaFlashV5Interface } from "./interfaces.sol"; + +contract Variables { + + /** + * @dev Instapool contract proxy + */ + InstaFlashV5Interface public constant instaPool = + InstaFlashV5Interface(0x352423e2fA5D5c99343d371C9e3bC56C87723Cc7); + +} \ No newline at end of file