From 5ff4637b91d605961156b304a04c159e976915f6 Mon Sep 17 00:00:00 2001 From: pradyuman-verma Date: Wed, 23 Mar 2022 13:41:24 +0530 Subject: [PATCH] removed bugs and fixed lint --- .../connectors/compound-import/events.sol | 19 +- .../connectors/compound-import/helpers.sol | 365 +++++++++--------- .../connectors/compound-import/interface.sol | 108 ++++-- .../connectors/compound-import/main.sol | 143 ++++--- 4 files changed, 367 insertions(+), 268 deletions(-) diff --git a/contracts/mainnet/connectors/compound-import/events.sol b/contracts/mainnet/connectors/compound-import/events.sol index 09e3e8f2..79fd7d69 100644 --- a/contracts/mainnet/connectors/compound-import/events.sol +++ b/contracts/mainnet/connectors/compound-import/events.sol @@ -1,13 +1,14 @@ +// SPDX-License-Identifier: MIT pragma solidity ^0.7.6; pragma experimental ABIEncoderV2; contract Events { - event LogCompoundImport( - address indexed user, - address[] ctokens, - string[] supplyIds, - string[] borrowIds, - uint256[] supplyAmts, - uint256[] borrowAmts - ); -} \ No newline at end of file + event LogCompoundImport( + address indexed user, + address[] ctokens, + string[] supplyIds, + string[] borrowIds, + uint256[] supplyAmts, + uint256[] borrowAmts + ); +} diff --git a/contracts/mainnet/connectors/compound-import/helpers.sol b/contracts/mainnet/connectors/compound-import/helpers.sol index b53347fd..93acc1fb 100644 --- a/contracts/mainnet/connectors/compound-import/helpers.sol +++ b/contracts/mainnet/connectors/compound-import/helpers.sol @@ -1,3 +1,4 @@ +// SPDX-License-Identifier: MIT pragma solidity ^0.7.6; import { DSMath } from "../../common/math.sol"; @@ -6,196 +7,216 @@ import { TokenInterface, AccountInterface } from "../../common/interfaces.sol"; import { ComptrollerInterface, CompoundMappingInterface, CETHInterface, CTokenInterface } from "./interface.sol"; abstract contract Helpers is DSMath, Basic { + /** + * @dev Compound CEth + */ + CETHInterface internal constant cEth = + CETHInterface(0x4Ddc2D193948926D02f9B1fE9e1daa0718270ED5); - /** - * @dev Compound CEth - */ - CETHInterface internal constant cEth = CETHInterface(0x4Ddc2D193948926D02f9B1fE9e1daa0718270ED5); + /** + * @dev Compound Comptroller + */ + ComptrollerInterface internal constant troller = + ComptrollerInterface(0x3d9819210A31b4961b30EF54bE2aeD79B9c9Cd3B); - /** - * @dev Compound Comptroller - */ - ComptrollerInterface internal constant troller = ComptrollerInterface(0x3d9819210A31b4961b30EF54bE2aeD79B9c9Cd3B); + /** + * @dev Compound Mapping + */ + CompoundMappingInterface internal constant compMapping = + CompoundMappingInterface(0xe7a85d0adDB972A4f0A4e57B698B37f171519e88); - /** - * @dev Compound Mapping - */ - CompoundMappingInterface internal constant compMapping = CompoundMappingInterface(0xe7a85d0adDB972A4f0A4e57B698B37f171519e88); + struct ImportData { + address[] cTokens; // is the list of all tokens the user has interacted with (supply/borrow) -> used to enter markets + uint256[] borrowAmts; + uint256[] supplyAmts; + address[] borrowTokens; + address[] supplyTokens; + CTokenInterface[] borrowCtokens; + CTokenInterface[] supplyCtokens; + address[] supplyCtokensAddr; + address[] borrowCtokensAddr; + } - struct ImportData { - address[] cTokens; // is the list of all tokens the user has interacted with (supply/borrow) -> used to enter markets - uint[] borrowAmts; - uint[] supplyAmts; - address[] borrowTokens; - address[] supplyTokens; - CTokenInterface[] borrowCtokens; - CTokenInterface[] supplyCtokens; - address[] supplyCtokensAddr; - address[] borrowCtokensAddr; - } + struct ImportInputData { + address userAccount; + string[] supplyIds; + string[] borrowIds; + } - struct ImportInputData { - address userAccount; - string[] supplyIds; - string[] borrowIds; - } - - /** - * @dev enter compound market - * @param _cotkens array of ctoken addresses to enter compound market - */ - function _enterMarkets(address[] memory _cotkens) internal { - troller.enterMarkets(_cotkens); - } + /** + * @dev enter compound market + * @param _cotkens array of ctoken addresses to enter compound market + */ + function _enterMarkets(address[] memory _cotkens) internal { + troller.enterMarkets(_cotkens); + } } contract CompoundHelper is Helpers { + /** + * @notice fetch the borrow details of the user + * @dev approve the cToken to spend (borrowed amount of) tokens to allow for repaying later + * @param _importInputData the struct containing borrowIds of the users borrowed tokens + * @param data struct used to store the final data on which the CompoundHelper contract functions operate + * @return ImportData the final value of param data + */ + function getBorrowAmounts( + ImportInputData memory _importInputData, + ImportData memory data + ) internal returns (ImportData memory) { + if (_importInputData.borrowIds.length > 0) { + // initialize arrays for borrow data + uint256 _length = _importInputData.borrowIds.length; + data.borrowTokens = new address[](_length); + data.borrowCtokens = new CTokenInterface[](_length); + data.borrowCtokensAddr = new address[](_length); + data.borrowAmts = new uint256[](_length); - /** - * @notice fetch the borrow details of the user - * @dev approve the cToken to spend (borrowed amount of) tokens to allow for repaying later - * @param _importInputData the struct containing borrowIds of the users borrowed tokens - * @param data struct used to store the final data on which the CompoundHelper contract functions operate - * @return ImportData the final value of param data - */ - function getBorrowAmounts ( - ImportInputData memory _importInputData, - ImportData memory data - ) internal returns(ImportData memory) { - if (_importInputData.borrowIds.length > 0) { - // initialize arrays for borrow data - data.borrowTokens = new address[](_importInputData.borrowIds.length); - data.borrowCtokens = new CTokenInterface[](_importInputData.borrowIds.length); - data.borrowCtokensAddr = new address[](_importInputData.borrowIds.length); - data.borrowAmts = new uint[](_importInputData.borrowIds.length); + // populate the arrays with borrow tokens, cToken addresses and instances, and borrow amounts + for (uint256 i; i < _length; i++) { + (address _token, address _cToken) = compMapping.getMapping( + _importInputData.borrowIds[i] + ); - // populate the arrays with borrow tokens, cToken addresses and instances, and borrow amounts - for (uint i = 0; i < _importInputData.borrowIds.length; i++) { - (address _token, address _cToken) = compMapping.getMapping(_importInputData.borrowIds[i]); + require( + _token != address(0) && _cToken != address(0), + "ctoken mapping not found" + ); - require(_token != address(0) && _cToken != address(0), "ctoken mapping not found"); + data.cTokens[i] = _cToken; - data.cTokens[i] = _cToken; + data.borrowTokens[i] = _token; + data.borrowCtokens[i] = CTokenInterface(_cToken); + data.borrowCtokensAddr[i] = _cToken; + data.borrowAmts[i] = data.borrowCtokens[i].borrowBalanceCurrent( + _importInputData.userAccount + ); - data.borrowTokens[i] = _token; - data.borrowCtokens[i] = CTokenInterface(_cToken); - data.borrowCtokensAddr[i] = _cToken; - data.borrowAmts[i] = data.borrowCtokens[i].borrowBalanceCurrent(_importInputData.userAccount); + // give the resp. cToken address approval to spend tokens + if (_token != ethAddr && data.borrowAmts[i] > 0) { + // will be required when repaying the borrow amount on behalf of the user + TokenInterface(_token).approve(_cToken, data.borrowAmts[i]); + } + } + } + return data; + } - // give the resp. cToken address approval to spend tokens - if (_token != ethAddr && data.borrowAmts[i] > 0) { - // will be required when repaying the borrow amount on behalf of the user - TokenInterface(_token).approve(_cToken, data.borrowAmts[i]); - } - } - } - return data; - } + /** + * @notice fetch the supply details of the user + * @dev only reads data from blockchain hence view + * @param _importInputData the struct containing supplyIds of the users supplied tokens + * @param data struct used to store the final data on which the CompoundHelper contract functions operate + * @return ImportData the final value of param data + */ + function getSupplyAmounts( + ImportInputData memory _importInputData, + ImportData memory data + ) internal view returns (ImportData memory) { + // initialize arrays for supply data + uint256 _length = _importInputData.supplyIds.length; + data.supplyTokens = new address[](_length); + data.supplyCtokens = new CTokenInterface[](_length); + data.supplyCtokensAddr = new address[](_length); + data.supplyAmts = new uint256[](_length); - /** - * @notice fetch the supply details of the user - * @dev only reads data from blockchain hence view - * @param _importInputData the struct containing supplyIds of the users supplied tokens - * @param data struct used to store the final data on which the CompoundHelper contract functions operate - * @return ImportData the final value of param data - */ - function getSupplyAmounts ( - ImportInputData memory _importInputData, - ImportData memory data - ) internal view returns(ImportData memory) { - // initialize arrays for supply data - data.supplyTokens = new address[](_importInputData.supplyIds.length); - data.supplyCtokens = new CTokenInterface[](_importInputData.supplyIds.length); - data.supplyCtokensAddr = new address[](_importInputData.supplyIds.length); - data.supplyAmts = new uint[](_importInputData.supplyIds.length); + // populate arrays with supply data (supply tokens address, cToken addresses, cToken instances and supply amounts) + for (uint256 i; i < _length; i++) { + (address _token, address _cToken) = compMapping.getMapping( + _importInputData.supplyIds[i] + ); - // populate arrays with supply data (supply tokens address, cToken addresses, cToken instances and supply amounts) - for (uint i = 0; i < _importInputData.supplyIds.length; i++) { - (address _token, address _cToken) = compMapping.getMapping(_importInputData.supplyIds[i]); - - require(_token != address(0) && _cToken != address(0), "ctoken mapping not found"); + require( + _token != address(0) && _cToken != address(0), + "ctoken mapping not found" + ); - uint _supplyIndex = add(i, _importInputData.borrowIds.length); - data.cTokens[_supplyIndex] = _cToken; + uint256 _supplyIndex = add(i, _importInputData.borrowIds.length); + data.cTokens[_supplyIndex] = _cToken; - data.supplyTokens[i] = _token; - data.supplyCtokens[i] = CTokenInterface(_cToken); - data.supplyCtokensAddr[i] = (_cToken); - data.supplyAmts[i] = data.supplyCtokens[i].balanceOf(_importInputData.userAccount); - } - return data; - } + data.supplyTokens[i] = _token; + data.supplyCtokens[i] = CTokenInterface(_cToken); + data.supplyCtokensAddr[i] = (_cToken); + data.supplyAmts[i] = data.supplyCtokens[i].balanceOf( + _importInputData.userAccount + ); + } + return data; + } - /** - * @notice repays the debt taken by user on Compound on its behalf to free its collateral for transfer - * @dev uses the cEth contract for ETH repays, otherwise the general cToken interface - * @param _userAccount the user address for which debt is to be repayed - * @param _cTokenContracts array containing all interfaces to the cToken contracts in which the user has debt positions - * @param _borrowAmts array containing the amount borrowed for each token - */ - function _repayUserDebt( - address _userAccount, - CTokenInterface[] memory _cTokenContracts, - uint[] memory _borrowAmts - ) internal { - for(uint i = 0; i < _cTokenContracts.length; i++){ - if(_borrowAmts[i] > 0){ - if(address(_cTokenContracts[i]) == address(cEth)){ - cEth.repayBorrowBehalf{value: _borrowAmts[i]}(_userAccount); - } - else{ - require(_cTokenContracts[i].repayBorrowBehalf( - _userAccount, - _borrowAmts[i] - ) == 0, "repayOnBehalf-failed"); - } - } - } - } + /** + * @notice repays the debt taken by user on Compound on its behalf to free its collateral for transfer + * @dev uses the cEth contract for ETH repays, otherwise the general cToken interface + * @param _userAccount the user address for which debt is to be repayed + * @param _cTokenContracts array containing all interfaces to the cToken contracts in which the user has debt positions + * @param _borrowAmts array containing the amount borrowed for each token + */ + function _repayUserDebt( + address _userAccount, + CTokenInterface[] memory _cTokenContracts, + uint256[] memory _borrowAmts + ) internal { + for (uint256 i; i < _cTokenContracts.length; i++) { + if (_borrowAmts[i] > 0) { + if (address(_cTokenContracts[i]) == address(cEth)) + cEth.repayBorrowBehalf{ value: _borrowAmts[i] }( + _userAccount + ); + else + require( + _cTokenContracts[i].repayBorrowBehalf( + _userAccount, + _borrowAmts[i] + ) == 0, + "repayOnBehalf-failed" + ); + } + } + } - /** - * @notice used to transfer user's supply position on Compound to DSA - * @dev uses the transferFrom token in cToken contracts to transfer positions, requires approval from user first - * @param _userAccount address of the user account whose position is to be transferred - * @param _cTokenContracts array containing all interfaces to the cToken contracts in which the user has supply positions - * @param _amts array containing the amount supplied for each token - */ - function _transferTokensToDsa( - address _userAccount, - CTokenInterface[] memory _cTokenContracts, - uint[] memory _amts - ) internal { - for(uint i = 0; i < _cTokenContracts.length; i++) { - if(_amts[i] > 0) { - require(_cTokenContracts[i].transferFrom( - _userAccount, - address(this), - _amts[i] - ), "ctoken-transfer-failed-allowance?"); - } - } - } + /** + * @notice used to transfer user's supply position on Compound to DSA + * @dev uses the transferFrom token in cToken contracts to transfer positions, requires approval from user first + * @param _userAccount address of the user account whose position is to be transferred + * @param _cTokenContracts array containing all interfaces to the cToken contracts in which the user has supply positions + * @param _amts array containing the amount supplied for each token + */ + function _transferTokensToDsa( + address _userAccount, + CTokenInterface[] memory _cTokenContracts, + uint256[] memory _amts + ) internal { + for (uint256 i; i < _cTokenContracts.length; i++) + if (_amts[i] > 0) + require( + _cTokenContracts[i].transferFrom( + _userAccount, + address(this), + _amts[i] + ), + "ctoken-transfer-failed-allowance?" + ); + } - /** - * @notice borrows the user's debt positions from Compound via DSA, so that its debt positions get imported to DSA - * @dev actually borrow some extra amount than the original position to cover the flash loan fee - * @param _cTokenContracts array containing all interfaces to the cToken contracts in which the user has debt positions - * @param _amts array containing the amounts the user had borrowed originally from Compound plus the flash loan fee - * @param _flashLoanFees flash loan fee (in percentage and scaled up to 10**2) - */ - function _borrowDebtPosition( - CTokenInterface[] memory _cTokenContracts, - uint256[] memory _amts, - uint256[] memory _flashLoanFees - ) internal { - for (uint i = 0; i < _cTokenContracts.length; i++) { - if (_amts[i] > 0) { - require(_cTokenContracts[i].borrow( - add( - _amts[i], - _flashLoanFees[i] - )) == 0, "borrow-failed-collateral?"); - } - } - } -} \ No newline at end of file + /** + * @notice borrows the user's debt positions from Compound via DSA, so that its debt positions get imported to DSA + * @dev actually borrow some extra amount than the original position to cover the flash loan fee + * @param _cTokenContracts array containing all interfaces to the cToken contracts in which the user has debt positions + * @param _amts array containing the amounts the user had borrowed originally from Compound plus the flash loan fee + * @param _flashLoanFees flash loan fee (in percentage and scaled up to 10**2) + */ + function _borrowDebtPosition( + CTokenInterface[] memory _cTokenContracts, + uint256[] memory _amts, + uint256[] memory _flashLoanFees + ) internal { + for (uint256 i; i < _cTokenContracts.length; i++) + if (_amts[i] > 0) + require( + _cTokenContracts[i].borrow( + add(_amts[i], _flashLoanFees[i]) + ) == 0, + "borrow-failed-collateral?" + ); + } +} diff --git a/contracts/mainnet/connectors/compound-import/interface.sol b/contracts/mainnet/connectors/compound-import/interface.sol index 7a08c094..5f9bf98d 100644 --- a/contracts/mainnet/connectors/compound-import/interface.sol +++ b/contracts/mainnet/connectors/compound-import/interface.sol @@ -1,46 +1,100 @@ +// SPDX-License-Identifier: MIT pragma solidity ^0.7.6; interface TokenInterface { - function balanceOf(address) external view returns (uint); - function allowance(address, address) external view returns (uint); - function approve(address, uint) external; - function transfer(address, uint) external returns (bool); - function transferFrom(address, address, uint) external returns (bool); + function balanceOf(address) external view returns (uint256); + + function allowance(address, address) external view returns (uint256); + + function approve(address, uint256) external; + + function transfer(address, uint256) external returns (bool); + + function transferFrom( + address, + address, + uint256 + ) external returns (bool); } interface CTokenInterface { - function mint(uint mintAmount) external returns (uint); - function redeem(uint redeemTokens) external returns (uint); - function borrow(uint borrowAmount) external returns (uint); - function repayBorrow(uint repayAmount) external returns (uint); - function repayBorrowBehalf(address borrower, uint repayAmount) external returns (uint); // For ERC20 - function liquidateBorrow(address borrower, uint repayAmount, address cTokenCollateral) external returns (uint); + function mint(uint256 mintAmount) external returns (uint256); - function borrowBalanceCurrent(address account) external returns (uint); - function redeemUnderlying(uint redeemAmount) external returns (uint); - function exchangeRateCurrent() external returns (uint); + function redeem(uint256 redeemTokens) external returns (uint256); - function balanceOf(address owner) external view returns (uint256 balance); - function transferFrom(address, address, uint) external returns (bool); - function allowance(address, address) external view returns (uint); + function borrow(uint256 borrowAmount) external returns (uint256); + function repayBorrow(uint256 repayAmount) external returns (uint256); + + function repayBorrowBehalf(address borrower, uint256 repayAmount) + external + returns (uint256); // For ERC20 + + function liquidateBorrow( + address borrower, + uint256 repayAmount, + address cTokenCollateral + ) external returns (uint256); + + function borrowBalanceCurrent(address account) external returns (uint256); + + function redeemUnderlying(uint256 redeemAmount) external returns (uint256); + + function exchangeRateCurrent() external returns (uint256); + + function balanceOf(address owner) external view returns (uint256 balance); + + function transferFrom( + address, + address, + uint256 + ) external returns (bool); + + function allowance(address, address) external view returns (uint256); } interface CETHInterface { - function mint() external payable; - function repayBorrow() external payable; - function repayBorrowBehalf(address borrower) external payable; - function liquidateBorrow(address borrower, address cTokenCollateral) external payable; + function mint() external payable; + + function repayBorrow() external payable; + + function repayBorrowBehalf(address borrower) external payable; + + function liquidateBorrow(address borrower, address cTokenCollateral) + external + payable; } interface ComptrollerInterface { - function enterMarkets(address[] calldata cTokens) external returns (uint[] memory); - function exitMarket(address cTokenAddress) external returns (uint); - function getAssetsIn(address account) external view returns (address[] memory); - function getAccountLiquidity(address account) external view returns (uint, uint, uint); + function enterMarkets(address[] calldata cTokens) + external + returns (uint256[] memory); + + function exitMarket(address cTokenAddress) external returns (uint256); + + function getAssetsIn(address account) + external + view + returns (address[] memory); + + function getAccountLiquidity(address account) + external + view + returns ( + uint256, + uint256, + uint256 + ); } interface CompoundMappingInterface { - function cTokenMapping(string calldata tokenId) external view returns (address); - function getMapping(string calldata tokenId) external view returns (address, address); + function cTokenMapping(string calldata tokenId) + external + view + returns (address); + + function getMapping(string calldata tokenId) + external + view + returns (address, address); } diff --git a/contracts/mainnet/connectors/compound-import/main.sol b/contracts/mainnet/connectors/compound-import/main.sol index e600033d..62923ec5 100644 --- a/contracts/mainnet/connectors/compound-import/main.sol +++ b/contracts/mainnet/connectors/compound-import/main.sol @@ -1,3 +1,4 @@ +// SPDX-License-Identifier: MIT pragma solidity ^0.7.6; pragma experimental ABIEncoderV2; @@ -11,77 +12,99 @@ import { Events } from "./events.sol"; // 4. Then borrow debt of same tokens but include flash loan fee in it. contract CompoundImportResolver is CompoundHelper { + /** + * @notice this function performs the import of user's Compound positions into its DSA + * @dev called internally by the importCompound and migrateCompound functions + * @param _importInputData the struct containing borrowIds of the users borrowed tokens + * @param _flashLoanFees list of flash loan fees + */ + function _importCompound( + ImportInputData memory _importInputData, + uint256[] memory _flashLoanFees + ) internal returns (string memory _eventName, bytes memory _eventParam) { + require( + AccountInterface(address(this)).isAuth( + _importInputData.userAccount + ), + "user-account-not-auth" + ); - /** - * @notice this function performs the import of user's Compound positions into its DSA - * @dev called internally by the importCompound and migrateCompound functions - * @param _importInputData the struct containing borrowIds of the users borrowed tokens - * @param _flashLoanFees list of flash loan fees - */ - function _importCompound( - ImportInputData memory _importInputData, - uint256[] memory _flashLoanFees - ) internal returns (string memory _eventName, bytes memory _eventParam) { - require(AccountInterface(address(this)).isAuth(_importInputData.userAccount), "user-account-not-auth"); + require(_importInputData.supplyIds.length > 0, "0-length-not-allowed"); - require(_importInputData.supplyIds.length > 0, "0-length-not-allowed"); + ImportData memory data; - ImportData memory data; + uint256 _length = add( + _importInputData.supplyIds.length, + _importInputData.borrowIds.length + ); + data.cTokens = new address[](_length); - uint _length = add(_importInputData.supplyIds.length, _importInputData.borrowIds.length); - data.cTokens = new address[](_length); + // get info about all borrowings and lendings by the user on Compound + data = getBorrowAmounts(_importInputData, data); + data = getSupplyAmounts(_importInputData, data); - // get info about all borrowings and lendings by the user on Compound - data = getBorrowAmounts(_importInputData, data); - data = getSupplyAmounts(_importInputData, data); + _enterMarkets(data.cTokens); - _enterMarkets(_importInputData.cTokens); + // pay back user's debt using flash loan funds + _repayUserDebt( + _importInputData.userAccount, + data.borrowCtokens, + data.borrowAmts + ); - // pay back user's debt using flash loan funds - _repayUserDebt(_importInputData.userAccount, data.borrowCtokens, data.borrowAmts); + // transfer user's tokens to DSA + _transferTokensToDsa( + _importInputData.userAccount, + data.supplyCtokens, + data.supplyAmts + ); - // transfer user's tokens to DSA - _transferTokensToDsa(_importInputData.userAccount, data.supplyCtokens, data.supplyAmts); + // borrow the earlier position from Compound with flash loan fee added + _borrowDebtPosition( + data.borrowCtokens, + data.borrowAmts, + _flashLoanFees + ); - // borrow the earlier position from Compound with flash loan fee added - _borrowDebtPosition(data.borrowCtokens, data.borrowAmts, _flashLoanFees); + _eventName = "LogCompoundImport(address,address[],string[],string[],uint256[],uint256[])"; + _eventParam = abi.encode( + _importInputData.userAccount, + data.cTokens, + _importInputData.supplyIds, + _importInputData.borrowIds, + data.supplyAmts, + data.borrowAmts + ); + } - _eventName = "LogCompoundImport(address,address[],string[],string[],uint256[],uint256[])"; - _eventParam = abi.encode( - _importInputData.userAccount, - data.cTokens, - _importInputData.supplyIds, - _importInputData.borrowIds, - data.supplyAmts, - data.borrowAmts - ); - } - - /** - * @notice import Compound position of the address passed in as userAccount - * @dev internally calls _importContract to perform the actual import - * @param _userAccount address of user whose position is to be imported to DSA - * @param _supplyIds Ids of all tokens the user has supplied to Compound - * @param _borrowIds Ids of all token borrowed by the user - * @param _flashLoanFees list of flash loan fees - */ - function importCompound( - address _userAccount, - string[] memory _supplyIds, - string[] memory _borrowIds, - uint256[] memory _flashLoanFees - ) external payable returns (string memory _eventName, bytes memory _eventParam) { - ImportInputData memory inputData = ImportInputData({ - userAccount: _userAccount, - supplyIds: _supplyIds, - borrowIds: _borrowIds - }); - - (_eventName, _eventParam) = _importCompound(inputData, _flashLoanFees); - } + /** + * @notice import Compound position of the address passed in as userAccount + * @dev internally calls _importContract to perform the actual import + * @param _userAccount address of user whose position is to be imported to DSA + * @param _supplyIds Ids of all tokens the user has supplied to Compound + * @param _borrowIds Ids of all token borrowed by the user + * @param _flashLoanFees list of flash loan fees + */ + function importCompound( + address _userAccount, + string[] memory _supplyIds, + string[] memory _borrowIds, + uint256[] memory _flashLoanFees + ) + external + payable + returns (string memory _eventName, bytes memory _eventParam) + { + ImportInputData memory inputData = ImportInputData({ + userAccount: _userAccount, + supplyIds: _supplyIds, + borrowIds: _borrowIds + }); + (_eventName, _eventParam) = _importCompound(inputData, _flashLoanFees); + } } contract ConnectV2CompoundImport is CompoundImportResolver { - string public constant name = "Compound-Import-v2"; -} \ No newline at end of file + string public constant name = "Compound-Import-v2"; +}