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

wip: mStable save deposit

Browse Source
This commit is contained in:
Dimitri 2021-12-29 17:37:38 +07:00
parent b14b9dc78c
commit 76ebe50729
4 changed files with 435 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
contracts/polygon/connectors/mstable/events.sol Normal file
View File

@ -0,0 +1,13 @@
pragma solidity ^0.7.6;
contract Events {
// TODO: Events go here
event LogDeposit(address token, uint256 amount, address path);
event LogWithdraw(address token, uint256 amount, address origin);
event LogClaimReward(
address token,
uint256 amount,
address platformToken,
uint256 platformAmount
);
}

27
contracts/polygon/connectors/mstable/helpers.sol Normal file
View File

@ -0,0 +1,27 @@
pragma solidity ^0.7.6;
import { DSMath } from "../../common/math.sol";
import { Basic } from "../../common/basic.sol";
// import { SaveWrapper } from "./interface.sol";
// interfaces here
// import { AaveLendingPoolProviderInterface, AaveDataProviderInterface } from "./interface.sol";
abstract contract Helpers is DSMath, Basic {
// Helpers go here
/*
* @dev SaveWrapper address
*/
// SaveWrapper internal constant saveWrapper =
// SaveWrapper(0x299081f52738A4204C3D58264ff44f6F333C6c88);
// Addresses that will be important for the contract
address internal constant mUsdToken =
0xE840B73E5287865EEc17d250bFb1536704B43B21;
address internal constant imUsdToken =
0x5290Ad3d83476CA6A2b178Cd9727eE1EF72432af;
address internal constant imUsdVault =
0x32aBa856Dc5fFd5A56Bcd182b13380e5C855aa29;
}

234
contracts/polygon/connectors/mstable/interface.sol Normal file
View File

@ -0,0 +1,234 @@
pragma solidity ^0.7.6;
// TODO: Interfaces go here
// https://polygonscan.com/address/0xca9cf48ad534f1efa2b0f6923457f2953df86e0b#code
interface IMasset {
// Mint
function mint(
address _input,
uint256 _inputQuantity,
uint256 _minOutputQuantity,
address _recipient
) external returns (uint256 mintOutput);
function mintMulti(
address[] calldata _inputs,
uint256[] calldata _inputQuantities,
uint256 _minOutputQuantity,
address _recipient
) external returns (uint256 mintOutput);
function getMintOutput(address _input, uint256 _inputQuantity)
external
view
returns (uint256 mintOutput);
function getMintMultiOutput(
address[] calldata _inputs,
uint256[] calldata _inputQuantities
) external view returns (uint256 mintOutput);
// Swaps
function swap(
address _input,
address _output,
uint256 _inputQuantity,
uint256 _minOutputQuantity,
address _recipient
) external returns (uint256 swapOutput);
function getSwapOutput(
address _input,
address _output,
uint256 _inputQuantity
) external view returns (uint256 swapOutput);
// Redemption
function redeem(
address _output,
uint256 _mAssetQuantity,
uint256 _minOutputQuantity,
address _recipient
) external returns (uint256 outputQuantity);
function redeemMasset(
uint256 _mAssetQuantity,
uint256[] calldata _minOutputQuantities,
address _recipient
) external returns (uint256[] memory outputQuantities);
function redeemExactBassets(
address[] calldata _outputs,
uint256[] calldata _outputQuantities,
uint256 _maxMassetQuantity,
address _recipient
) external returns (uint256 mAssetRedeemed);
function getRedeemOutput(address _output, uint256 _mAssetQuantity)
external
view
returns (uint256 bAssetOutput);
function getRedeemExactBassetsOutput(
address[] calldata _outputs,
uint256[] calldata _outputQuantities
) external view returns (uint256 mAssetAmount);
// Views
// This return an index, could be used to check if it's part of the basket
function bAssetIndexes(address) external view returns (uint8);
function getPrice() external view returns (uint256 price, uint256 k);
}
interface ISavingsContractV2 {
function depositInterest(uint256 _amount) external; // V1 & V2
function depositSavings(uint256 _amount)
external
returns (uint256 creditsIssued); // V1 & V2
function depositSavings(uint256 _amount, address _beneficiary)
external
returns (uint256 creditsIssued); // V2
function redeemCredits(uint256 _amount)
external
returns (uint256 underlyingReturned); // V2
function redeemUnderlying(uint256 _amount)
external
returns (uint256 creditsBurned); // V2
function exchangeRate() external view returns (uint256); // V1 & V2
function balanceOfUnderlying(address _user)
external
view
returns (uint256 balance); // V2
function underlyingToCredits(uint256 _credits)
external
view
returns (uint256 underlying); // V2
function creditsToUnderlying(uint256 _underlying)
external
view
returns (uint256 credits); // V2
}
interface IStakingRewardsWithPlatformToken {
/**
* @dev Stakes a given amount of the StakingToken for the sender
* @param _amount Units of StakingToken
*/
function stake(uint256 _amount) external;
/**
* @dev Stakes a given amount of the StakingToken for a given beneficiary
* @param _beneficiary Staked tokens are credited to this address
* @param _amount Units of StakingToken
*/
function stake(address _beneficiary, uint256 _amount) external;
function exit() external;
/**
* @dev Withdraws given stake amount from the pool
* @param _amount Units of the staked token to withdraw
*/
function withdraw(uint256 _amount) external;
/**
* @dev Claims outstanding rewards (both platform and native) for the sender.
* First updates outstanding reward allocation and then transfers.
*/
function claimReward() external;
/**
* @dev Claims outstanding rewards for the sender. Only the native
* rewards token, and not the platform rewards
*/
function claimRewardOnly() external;
}
abstract contract IFeederPool {
// Mint
function mint(
address _input,
uint256 _inputQuantity,
uint256 _minOutputQuantity,
address _recipient
) external virtual returns (uint256 mintOutput);
function mintMulti(
address[] calldata _inputs,
uint256[] calldata _inputQuantities,
uint256 _minOutputQuantity,
address _recipient
) external virtual returns (uint256 mintOutput);
function getMintOutput(address _input, uint256 _inputQuantity)
external
view
virtual
returns (uint256 mintOutput);
function getMintMultiOutput(
address[] calldata _inputs,
uint256[] calldata _inputQuantities
) external view virtual returns (uint256 mintOutput);
// Swaps
function swap(
address _input,
address _output,
uint256 _inputQuantity,
uint256 _minOutputQuantity,
address _recipient
) external virtual returns (uint256 swapOutput);
function getSwapOutput(
address _input,
address _output,
uint256 _inputQuantity
) external view virtual returns (uint256 swapOutput);
// Redemption
function redeem(
address _output,
uint256 _fpTokenQuantity,
uint256 _minOutputQuantity,
address _recipient
) external virtual returns (uint256 outputQuantity);
function redeemProportionately(
uint256 _fpTokenQuantity,
uint256[] calldata _minOutputQuantities,
address _recipient
) external virtual returns (uint256[] memory outputQuantities);
function redeemExactBassets(
address[] calldata _outputs,
uint256[] calldata _outputQuantities,
uint256 _maxMassetQuantity,
address _recipient
) external virtual returns (uint256 mAssetRedeemed);
function getRedeemOutput(address _output, uint256 _fpTokenQuantity)
external
view
virtual
returns (uint256 bAssetOutput);
function getRedeemExactBassetsOutput(
address[] calldata _outputs,
uint256[] calldata _outputQuantities
) external view virtual returns (uint256 mAssetAmount);
// Views
function mAsset() external view virtual returns (address);
function getPrice() public view virtual returns (uint256 price, uint256 k);
}

161
contracts/polygon/connectors/mstable/main.sol Normal file
View File

@ -0,0 +1,161 @@
pragma solidity ^0.7.6;
/**
* @title mStable SAVE.
* @dev Depositing and withdrawing directly to Save
*/
import { Helpers } from "./helpers.sol";
import { Events } from "./events.sol";
import { IMasset, ISavingsContractV2, IStakingRewardsWithPlatformToken, IFeederPool } from "./interface.sol";
import { TokenInterface } from "../../common/interfaces.sol";
import "hardhat/console.sol";
abstract contract mStableResolver is Events, Helpers {
/***************************************
CORE
****************************************/
/**
* @dev Deposit to Save via mUSD
* @notice Deposits token supported by mStable to Save
* @param _token Address of token to deposit
* @param _amount Amount of token to deposit
*/
function deposit(address _token, uint256 _amount)
external
returns (string memory _eventName, bytes memory _eventParam)
{
return _deposit(_token, _amount, imUsdToken);
}
/**
* @dev Deposit to Save via bAsset
* @notice Deposits token, requires _minOut for minting
* @param _token Address of token to deposit
* @param _amount Amount of token to deposit
* @param _minOut Minimum amount of token to mint
*/
function deposit(
address _token,
uint256 _amount,
uint256 _minOut
) external returns (string memory _eventName, bytes memory _eventParam) {
require(
IMasset(mUsdToken).bAssetIndexes(_token) != 0,
"Token not a bAsset"
);
approve(TokenInterface(_token), mUsdToken, _amount);
uint256 mintedAmount = IMasset(mUsdToken).mint(
_token,
_amount,
_minOut,
address(this)
);
return _deposit(_token, mintedAmount, mUsdToken);
}
// /**
// * @dev Deposit to Save via feeder pool
// * @notice Deposits token, requires _minOut for minting and _path
// * @param _token Address of token to deposit
// * @param _amount Amount of token to deposit
// * @param _minOut Minimum amount of token to mint
// * @param _path Feeder Pool address for _token
// */
// function deposit(
// address _token,
// uint256 _amount,
// uint256 _minOut,
// address _path
// ) external returns (string memory _eventName, bytes memory _eventParam) {
// require(_path != address(0), "Path must be set");
// require(
// IMasset(mUsdToken).bAssetIndexes(_token) == 0,
// "Token is bAsset"
// );
// approve(TokenInterface(_token), _path, _amount);
// uint256 mintedAmount = IFeederPool(_path).swap(
// _token,
// mUsdToken,
// _amount,
// _minOut,
// address(this)
// );
// return _deposit(_token, mintedAmount, _path);
// }
/***************************************
Internal
****************************************/
/**
* @dev Deposit to Save from any asset
* @notice Called internally from deposit functions
* @param _token Address of token to deposit
* @param _amount Amount of token to deposit
* @param _path Path to mint mUSD (only needed for Feeder Pool)
*/
function _deposit(
address _token,
uint256 _amount,
address _path
) internal returns (string memory _eventName, bytes memory _eventParam) {
// 1. Deposit mUSD to Save
approve(TokenInterface(mUsdToken), imUsdToken, _amount);
uint256 credits = ISavingsContractV2(imUsdToken).depositSavings(
_amount
);
// 2. Stake imUSD to Vault
approve(TokenInterface(imUsdToken), imUsdVault, credits);
IStakingRewardsWithPlatformToken(imUsdVault).stake(credits);
// 3. Log Events
_eventName = "LogDeposit()";
_eventParam = abi.encode(_token, _amount, _path);
}
/**
* @dev Withdraw from Save
* @notice Withdraws token supported by mStable from Save
* @param _token Address of token to withdraw
* @param _amount Amount of token to withdraw
*/
// function withdraw(address _token, uint256 _amount)
// external
// returns (string memory _eventName, bytes memory _eventParam);
// TODO
// function to support via Feeders or separate function?
// blocked by new SaveUnwrapper upgrade
/**
* @dev Swaps token supported by mStable for another token
* @notice Swaps token supported by mStable for another token
* @param _token Address of token to swap
* @param _amount Amount of token to swap
* @param _minOutput Minimum amount of token to swap
*/
// function swap(
// address _token,
// uint256 _amount,
// uint256 _minOutput
// ) external returns (string memory _eventName, bytes memory _eventParam);
// TODO
// function to support via Feeders or separate function?
}
contract ConnectV2mStable is mStableResolver {
string public constant name = "mStable-Polygon-Connector-v1";
}