Polygon Sponsored slots available. Book your slot here!
Overview
POL Balance
0 POL
POL Value
$0.00Token Holdings
More Info
Private Name Tags
ContractCreator
Latest 25 from a total of 1,322 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Release MIMO | 55308478 | 255 days ago | IN | 0 POL | 0.0087701 | ||||
Release MIMO | 55075017 | 262 days ago | IN | 0 POL | 0.00218687 | ||||
Release MIMO | 54148223 | 286 days ago | IN | 0 POL | 0.00309106 | ||||
Release MIMO | 53681641 | 298 days ago | IN | 0 POL | 0.00291436 | ||||
Release MIMO | 52671218 | 324 days ago | IN | 0 POL | 0.00622077 | ||||
Release MIMO | 50887750 | 370 days ago | IN | 0 POL | 0.06311209 | ||||
Release MIMO | 49909521 | 395 days ago | IN | 0 POL | 0.00953692 | ||||
Release MIMO | 49484237 | 405 days ago | IN | 0 POL | 0.00790052 | ||||
Release MIMO | 49457931 | 406 days ago | IN | 0 POL | 0.00722354 | ||||
Release MIMO | 49443918 | 406 days ago | IN | 0 POL | 0.00481858 | ||||
Release MIMO | 49403319 | 407 days ago | IN | 0 POL | 0.00612268 | ||||
Release MIMO | 49363853 | 408 days ago | IN | 0 POL | 0.00577514 | ||||
Release MIMO | 49322599 | 409 days ago | IN | 0 POL | 0.00554948 | ||||
Release MIMO | 49286192 | 410 days ago | IN | 0 POL | 0.00457056 | ||||
Release MIMO | 49278617 | 410 days ago | IN | 0 POL | 0.00779688 | ||||
Release MIMO | 49244464 | 411 days ago | IN | 0 POL | 0.00527006 | ||||
Release MIMO | 49204008 | 412 days ago | IN | 0 POL | 0.00668638 | ||||
Release MIMO | 49202946 | 412 days ago | IN | 0 POL | 0.0056524 | ||||
Release MIMO | 49170930 | 413 days ago | IN | 0 POL | 0.00597199 | ||||
Release MIMO | 49123212 | 414 days ago | IN | 0 POL | 0.00643278 | ||||
Release MIMO | 49096616 | 415 days ago | IN | 0 POL | 0.0057568 | ||||
Release MIMO | 49044826 | 416 days ago | IN | 0 POL | 0.00926351 | ||||
Release MIMO | 49009777 | 417 days ago | IN | 0 POL | 0.00532709 | ||||
Release MIMO | 48972548 | 418 days ago | IN | 0 POL | 0.00539138 | ||||
Release MIMO | 48929694 | 419 days ago | IN | 0 POL | 0.00370467 |
Loading...
Loading
Contract Name:
SupplyMiner
Compiler Version
v0.6.12+commit.27d51765
Optimization Enabled:
Yes with 200 runs
Other Settings:
default evmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: MIT pragma experimental ABIEncoderV2; pragma solidity 0.6.12; import "@openzeppelin/contracts/math/SafeMath.sol"; import "./GenericMiner.sol"; import "./interfaces/ISupplyMiner.sol"; import "../governance/interfaces/IGovernanceAddressProvider.sol"; contract SupplyMiner is ISupplyMiner, GenericMiner { using SafeMath for uint256; constructor(IGovernanceAddressProvider _addresses) public GenericMiner(_addresses) {} modifier onlyNotifier() { require(msg.sender == address(a.debtNotifier()), "Caller is not DebtNotifier"); _; } /** Gets called by the `DebtNotifier` and will update the stake of the user to match his current outstanding debt by using his baseDebt. @param user address of the user. @param newBaseDebt the new baseDebt and therefore stake for the user. */ function baseDebtChanged(address user, uint256 newBaseDebt) public override onlyNotifier { _updateStake(user, newBaseDebt); } }
// SPDX-License-Identifier: UNLICENSED pragma solidity 0.6.12; interface AggregatorV3Interface { function decimals() external view returns (uint8); function description() external view returns (string memory); function version() external view returns (uint256); function getRoundData(uint80 _roundId) external view returns ( uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound ); function latestRoundData() external view returns ( uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound ); }
// SPDX-License-Identifier: MIT pragma experimental ABIEncoderV2; pragma solidity 0.6.12; import "./IGovernorAlpha.sol"; import "./ITimelock.sol"; import "./IVotingEscrow.sol"; import "../../interfaces/IAccessController.sol"; import "../../interfaces/IAddressProvider.sol"; import "../../liquidityMining/interfaces/IMIMO.sol"; import "../../liquidityMining/interfaces/IDebtNotifier.sol"; interface IGovernanceAddressProvider { function setParallelAddressProvider(IAddressProvider _parallel) external; function setMIMO(IMIMO _mimo) external; function setDebtNotifier(IDebtNotifier _debtNotifier) external; function setGovernorAlpha(IGovernorAlpha _governorAlpha) external; function setTimelock(ITimelock _timelock) external; function setVotingEscrow(IVotingEscrow _votingEscrow) external; function controller() external view returns (IAccessController); function parallel() external view returns (IAddressProvider); function mimo() external view returns (IMIMO); function debtNotifier() external view returns (IDebtNotifier); function governorAlpha() external view returns (IGovernorAlpha); function timelock() external view returns (ITimelock); function votingEscrow() external view returns (IVotingEscrow); }
// SPDX-License-Identifier: MIT pragma experimental ABIEncoderV2; pragma solidity 0.6.12; interface IGovernorAlpha { /// @notice Possible states that a proposal may be in enum ProposalState { Active, Canceled, Defeated, Succeeded, Queued, Expired, Executed } struct Proposal { // Unique id for looking up a proposal uint256 id; // Creator of the proposal address proposer; // The timestamp that the proposal will be available for execution, set once the vote succeeds uint256 eta; // the ordered list of target addresses for calls to be made address[] targets; // The ordered list of values (i.e. msg.value) to be passed to the calls to be made uint256[] values; // The ordered list of function signatures to be called string[] signatures; // The ordered list of calldata to be passed to each call bytes[] calldatas; // The timestamp at which voting begins: holders must delegate their votes prior to this timestamp uint256 startTime; // The timestamp at which voting ends: votes must be cast prior to this timestamp uint endTime; // Current number of votes in favor of this proposal uint256 forVotes; // Current number of votes in opposition to this proposal uint256 againstVotes; // Flag marking whether the proposal has been canceled bool canceled; // Flag marking whether the proposal has been executed bool executed; // Receipts of ballots for the entire set of voters mapping (address => Receipt) receipts; } /// @notice Ballot receipt record for a voter struct Receipt { // Whether or not a vote has been cast bool hasVoted; // Whether or not the voter supports the proposal bool support; // The number of votes the voter had, which were cast uint votes; } /// @notice An event emitted when a new proposal is created event ProposalCreated(uint256 id, address proposer, address[] targets, uint256[] values, string[] signatures, bytes[] calldatas, uint startTime, uint endTime, string description); /// @notice An event emitted when a vote has been cast on a proposal event VoteCast(address voter, uint256 proposalId, bool support, uint256 votes); /// @notice An event emitted when a proposal has been canceled event ProposalCanceled(uint256 id); /// @notice An event emitted when a proposal has been queued in the Timelock event ProposalQueued(uint256 id, uint256 eta); /// @notice An event emitted when a proposal has been executed in the Timelock event ProposalExecuted(uint256 id); function propose(address[] memory targets, uint256[] memory values, string[] memory signatures, bytes[] memory calldatas, string memory description, uint256 endTime) external returns (uint); function queue(uint256 proposalId) external; function execute(uint256 proposalId) external payable; function cancel(uint256 proposalId) external; function castVote(uint256 proposalId, bool support) external; function getActions(uint256 proposalId) external view returns (address[] memory targets, uint256[] memory values, string[] memory signatures, bytes[] memory calldatas); function getReceipt(uint256 proposalId, address voter) external view returns (Receipt memory); function state(uint proposalId) external view returns (ProposalState); function quorumVotes() external view returns (uint256); function proposalThreshold() external view returns (uint256); }
// SPDX-License-Identifier: BSD-3-Clause pragma solidity 0.6.12; interface ITimelock { event NewAdmin(address indexed newAdmin); event NewPendingAdmin(address indexed newPendingAdmin); event NewDelay(uint256 indexed newDelay); event CancelTransaction( bytes32 indexed txHash, address indexed target, uint256 value, string signature, bytes data, uint256 eta ); event ExecuteTransaction( bytes32 indexed txHash, address indexed target, uint256 value, string signature, bytes data, uint256 eta ); event QueueTransaction( bytes32 indexed txHash, address indexed target, uint256 value, string signature, bytes data, uint256 eta ); function acceptAdmin() external; function queueTransaction( address target, uint256 value, string calldata signature, bytes calldata data, uint256 eta ) external returns (bytes32); function cancelTransaction( address target, uint256 value, string calldata signature, bytes calldata data, uint256 eta ) external; function executeTransaction( address target, uint256 value, string calldata signature, bytes calldata data, uint256 eta ) external payable returns (bytes memory); function delay() external view returns (uint256); function GRACE_PERIOD() external view returns (uint256); function queuedTransactions(bytes32 hash) external view returns (bool); }
// SPDX-License-Identifier: AGPL-3.0 pragma solidity 0.6.12; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; interface IVotingEscrow { enum LockAction { CREATE_LOCK, INCREASE_LOCK_AMOUNT, INCREASE_LOCK_TIME } struct LockedBalance { uint256 amount; uint256 end; } /** Shared Events */ event Deposit(address indexed provider, uint256 value, uint256 locktime, LockAction indexed action, uint256 ts); event Withdraw(address indexed provider, uint256 value, uint256 ts); event Expired(); function createLock(uint256 _value, uint256 _unlockTime) external; function increaseLockAmount(uint256 _value) external; function increaseLockLength(uint256 _unlockTime) external; function withdraw() external; function expireContract() external; function name() external view returns (string memory); function symbol() external view returns (string memory); function decimals() external view returns (uint256); function balanceOf(address _owner) external view returns (uint256); function balanceOfAt(address _owner, uint256 _blockTime) external view returns (uint256); function stakingToken() external view returns (IERC20); }
// SPDX-License-Identifier: MIT pragma solidity 0.6.12; interface IAccessController { event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole); event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender); event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender); function grantRole(bytes32 role, address account) external; function revokeRole(bytes32 role, address account) external; function renounceRole(bytes32 role, address account) external; function MANAGER_ROLE() external view returns (bytes32); function MINTER_ROLE() external view returns (bytes32); function hasRole(bytes32 role, address account) external view returns (bool); function getRoleMemberCount(bytes32 role) external view returns (uint256); function getRoleMember(bytes32 role, uint256 index) external view returns (address); function getRoleAdmin(bytes32 role) external view returns (bytes32); }
// SPDX-License-Identifier: MIT pragma experimental ABIEncoderV2; pragma solidity 0.6.12; import "./IAccessController.sol"; import "./IConfigProvider.sol"; import "./ISTABLEX.sol"; import "./IPriceFeed.sol"; import "./IRatesManager.sol"; import "./ILiquidationManager.sol"; import "./IVaultsCore.sol"; import "./IVaultsDataProvider.sol"; import "./IFeeDistributor.sol"; interface IAddressProvider { function setAccessController(IAccessController _controller) external; function setConfigProvider(IConfigProvider _config) external; function setVaultsCore(IVaultsCore _core) external; function setStableX(ISTABLEX _stablex) external; function setRatesManager(IRatesManager _ratesManager) external; function setPriceFeed(IPriceFeed _priceFeed) external; function setLiquidationManager(ILiquidationManager _liquidationManager) external; function setVaultsDataProvider(IVaultsDataProvider _vaultsData) external; function setFeeDistributor(IFeeDistributor _feeDistributor) external; function controller() external view returns (IAccessController); function config() external view returns (IConfigProvider); function core() external view returns (IVaultsCore); function stablex() external view returns (ISTABLEX); function ratesManager() external view returns (IRatesManager); function priceFeed() external view returns (IPriceFeed); function liquidationManager() external view returns (ILiquidationManager); function vaultsData() external view returns (IVaultsDataProvider); function feeDistributor() external view returns (IFeeDistributor); }
// SPDX-License-Identifier: MIT pragma experimental ABIEncoderV2; pragma solidity 0.6.12; import "../interfaces/IAddressProvider.sol"; interface IConfigProvider { struct CollateralConfig { address collateralType; uint256 debtLimit; uint256 liquidationRatio; uint256 minCollateralRatio; uint256 borrowRate; uint256 originationFee; uint256 liquidationBonus; uint256 liquidationFee; } event CollateralUpdated( address indexed collateralType, uint256 debtLimit, uint256 liquidationRatio, uint256 minCollateralRatio, uint256 borrowRate, uint256 originationFee, uint256 liquidationBonus, uint256 liquidationFee ); event CollateralRemoved(address indexed collateralType); function setCollateralConfig( address _collateralType, uint256 _debtLimit, uint256 _liquidationRatio, uint256 _minCollateralRatio, uint256 _borrowRate, uint256 _originationFee, uint256 _liquidationBonus, uint256 _liquidationFee ) external; function removeCollateral(address _collateralType) external; function setCollateralDebtLimit(address _collateralType, uint256 _debtLimit) external; function setCollateralLiquidationRatio(address _collateralType, uint256 _liquidationRatio) external; function setCollateralMinCollateralRatio(address _collateralType, uint256 _minCollateralRatio) external; function setCollateralBorrowRate(address _collateralType, uint256 _borrowRate) external; function setCollateralOriginationFee(address _collateralType, uint256 _originationFee) external; function setCollateralLiquidationBonus(address _collateralType, uint256 _liquidationBonus) external; function setCollateralLiquidationFee(address _collateralType, uint256 _liquidationFee) external; function setMinVotingPeriod(uint256 _minVotingPeriod) external; function setMaxVotingPeriod(uint256 _maxVotingPeriod) external; function setVotingQuorum(uint256 _votingQuorum) external; function setProposalThreshold(uint256 _proposalThreshold) external; function a() external view returns (IAddressProvider); function collateralConfigs(uint256 _id) external view returns (CollateralConfig memory); function collateralIds(address _collateralType) external view returns (uint256); function numCollateralConfigs() external view returns (uint256); function minVotingPeriod() external view returns (uint256); function maxVotingPeriod() external view returns (uint256); function votingQuorum() external view returns (uint256); function proposalThreshold() external view returns (uint256); function collateralDebtLimit(address _collateralType) external view returns (uint256); function collateralLiquidationRatio(address _collateralType) external view returns (uint256); function collateralMinCollateralRatio(address _collateralType) external view returns (uint256); function collateralBorrowRate(address _collateralType) external view returns (uint256); function collateralOriginationFee(address _collateralType) external view returns (uint256); function collateralLiquidationBonus(address _collateralType) external view returns (uint256); function collateralLiquidationFee(address _collateralType) external view returns (uint256); }
// SPDX-License-Identifier: MIT pragma solidity 0.6.12; import "../interfaces/IAddressProvider.sol"; interface IFeeDistributor { event PayeeAdded(address indexed account, uint256 shares); event FeeReleased(uint256 income, uint256 releasedAt); function release() external; function changePayees(address[] memory _payees, uint256[] memory _shares) external; function a() external view returns (IAddressProvider); function lastReleasedAt() external view returns (uint256); function getPayees() external view returns (address[] memory); function totalShares() external view returns (uint256); function shares(address payee) external view returns (uint256); }
// SPDX-License-Identifier: MIT pragma experimental ABIEncoderV2; pragma solidity 0.6.12; import "../interfaces/IAddressProvider.sol"; interface ILiquidationManager { function a() external view returns (IAddressProvider); function calculateHealthFactor( uint256 _collateralValue, uint256 _vaultDebt, uint256 _minRatio ) external view returns (uint256 healthFactor); function liquidationBonus(address _collateralType, uint256 _amount) external view returns (uint256 bonus); function applyLiquidationDiscount(address _collateralType, uint256 _amount) external view returns (uint256 discountedAmount); function isHealthy( uint256 _collateralValue, uint256 _vaultDebt, uint256 _minRatio ) external view returns (bool); }
// SPDX-License-Identifier: MIT pragma solidity 0.6.12; import "../chainlink/AggregatorV3Interface.sol"; import "../interfaces/IAddressProvider.sol"; interface IPriceFeed { event OracleUpdated(address indexed asset, address oracle, address sender); event EurOracleUpdated(address oracle, address sender); function setAssetOracle(address _asset, address _oracle) external; function setEurOracle(address _oracle) external; function a() external view returns (IAddressProvider); function assetOracles(address _asset) external view returns (AggregatorV3Interface); function eurOracle() external view returns (AggregatorV3Interface); function getAssetPrice(address _asset) external view returns (uint256); function convertFrom(address _asset, uint256 _amount) external view returns (uint256); function convertTo(address _asset, uint256 _amount) external view returns (uint256); }
// SPDX-License-Identifier: MIT pragma experimental ABIEncoderV2; pragma solidity 0.6.12; import "../interfaces/IAddressProvider.sol"; interface IRatesManager { function a() external view returns (IAddressProvider); //current annualized borrow rate function annualizedBorrowRate(uint256 _currentBorrowRate) external pure returns (uint256); //uses current cumulative rate to calculate totalDebt based on baseDebt at time T0 function calculateDebt(uint256 _baseDebt, uint256 _cumulativeRate) external pure returns (uint256); //uses current cumulative rate to calculate baseDebt at time T0 function calculateBaseDebt(uint256 _debt, uint256 _cumulativeRate) external pure returns (uint256); //calculate a new cumulative rate function calculateCumulativeRate( uint256 _borrowRate, uint256 _cumulativeRate, uint256 _timeElapsed ) external view returns (uint256); }
// SPDX-License-Identifier: MIT pragma solidity 0.6.12; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "../interfaces/IAddressProvider.sol"; interface ISTABLEX is IERC20 { function mint(address account, uint256 amount) external; function burn(address account, uint256 amount) external; function a() external view returns (IAddressProvider); }
// SPDX-License-Identifier: MIT pragma experimental ABIEncoderV2; pragma solidity 0.6.12; import "../interfaces/IAddressProvider.sol"; import "../interfaces/IVaultsCoreState.sol"; import "../interfaces/IWETH.sol"; import "../liquidityMining/interfaces/IDebtNotifier.sol"; interface IVaultsCore { event Opened(uint256 indexed vaultId, address indexed collateralType, address indexed owner); event Deposited(uint256 indexed vaultId, uint256 amount, address indexed sender); event Withdrawn(uint256 indexed vaultId, uint256 amount, address indexed sender); event Borrowed(uint256 indexed vaultId, uint256 amount, address indexed sender); event Repaid(uint256 indexed vaultId, uint256 amount, address indexed sender); event Liquidated( uint256 indexed vaultId, uint256 debtRepaid, uint256 collateralLiquidated, address indexed owner, address indexed sender ); event InsurancePaid(uint256 indexed vaultId, uint256 insuranceAmount, address indexed sender); function deposit(address _collateralType, uint256 _amount) external; function depositETH() external payable; function depositByVaultId(uint256 _vaultId, uint256 _amount) external; function depositETHByVaultId(uint256 _vaultId) external payable; function depositAndBorrow( address _collateralType, uint256 _depositAmount, uint256 _borrowAmount ) external; function depositETHAndBorrow(uint256 _borrowAmount) external payable; function withdraw(uint256 _vaultId, uint256 _amount) external; function withdrawETH(uint256 _vaultId, uint256 _amount) external; function borrow(uint256 _vaultId, uint256 _amount) external; function repayAll(uint256 _vaultId) external; function repay(uint256 _vaultId, uint256 _amount) external; function liquidate(uint256 _vaultId) external; function liquidatePartial(uint256 _vaultId, uint256 _amount) external; function upgrade(address payable _newVaultsCore) external; function acceptUpgrade(address payable _oldVaultsCore) external; function setDebtNotifier(IDebtNotifier _debtNotifier) external; //Read only function a() external view returns (IAddressProvider); function WETH() external view returns (IWETH); function debtNotifier() external view returns (IDebtNotifier); function state() external view returns (IVaultsCoreState); function cumulativeRates(address _collateralType) external view returns (uint256); }
// SPDX-License-Identifier: MIT pragma experimental ABIEncoderV2; pragma solidity 0.6.12; import "./IAddressProvider.sol"; import "../v1/interfaces/IVaultsCoreV1.sol"; interface IVaultsCoreState { event CumulativeRateUpdated(address indexed collateralType, uint256 elapsedTime, uint256 newCumulativeRate); //cumulative interest rate from deployment time T0 function initializeRates(address _collateralType) external; function refresh() external; function refreshCollateral(address collateralType) external; function syncState(IVaultsCoreState _stateAddress) external; function syncStateFromV1(IVaultsCoreV1 _core) external; //Read only function a() external view returns (IAddressProvider); function availableIncome() external view returns (uint256); function cumulativeRates(address _collateralType) external view returns (uint256); function lastRefresh(address _collateralType) external view returns (uint256); function synced() external view returns (bool); }
// SPDX-License-Identifier: MIT pragma experimental ABIEncoderV2; pragma solidity 0.6.12; import "../interfaces/IAddressProvider.sol"; interface IVaultsDataProvider { struct Vault { // borrowedType support USDX / PAR address collateralType; address owner; uint256 collateralBalance; uint256 baseDebt; uint256 createdAt; } //Write function createVault(address _collateralType, address _owner) external returns (uint256); function setCollateralBalance(uint256 _id, uint256 _balance) external; function setBaseDebt(uint256 _id, uint256 _newBaseDebt) external; // Read function a() external view returns (IAddressProvider); function baseDebt(address _collateralType) external view returns (uint256); function vaultCount() external view returns (uint256); function vaults(uint256 _id) external view returns (Vault memory); function vaultOwner(uint256 _id) external view returns (address); function vaultCollateralType(uint256 _id) external view returns (address); function vaultCollateralBalance(uint256 _id) external view returns (uint256); function vaultBaseDebt(uint256 _id) external view returns (uint256); function vaultId(address _collateralType, address _owner) external view returns (uint256); function vaultExists(uint256 _id) external view returns (bool); function vaultDebt(uint256 _vaultId) external view returns (uint256); function debt() external view returns (uint256); function collateralDebt(address _collateralType) external view returns (uint256); }
// SPDX-License-Identifier: MIT pragma experimental ABIEncoderV2; pragma solidity 0.6.12; interface IWETH { function deposit() external payable; function transfer(address to, uint256 value) external returns (bool); function withdraw(uint256 wad) external; }
// SPDX-License-Identifier: MIT pragma solidity 0.6.12; import "@openzeppelin/contracts/math/SafeMath.sol"; /****************** @title WadRayMath library @author Aave @dev Provides mul and div function for wads (decimal numbers with 18 digits precision) and rays (decimals with 27 digits) */ library WadRayMath { using SafeMath for uint256; uint256 internal constant _WAD = 1e18; uint256 internal constant _HALF_WAD = _WAD / 2; uint256 internal constant _RAY = 1e27; uint256 internal constant _HALF_RAY = _RAY / 2; uint256 internal constant _WAD_RAY_RATIO = 1e9; function ray() internal pure returns (uint256) { return _RAY; } function wad() internal pure returns (uint256) { return _WAD; } function halfRay() internal pure returns (uint256) { return _HALF_RAY; } function halfWad() internal pure returns (uint256) { return _HALF_WAD; } function wadMul(uint256 a, uint256 b) internal pure returns (uint256) { return _HALF_WAD.add(a.mul(b)).div(_WAD); } function wadDiv(uint256 a, uint256 b) internal pure returns (uint256) { uint256 halfB = b / 2; return halfB.add(a.mul(_WAD)).div(b); } function rayMul(uint256 a, uint256 b) internal pure returns (uint256) { return _HALF_RAY.add(a.mul(b)).div(_RAY); } function rayDiv(uint256 a, uint256 b) internal pure returns (uint256) { uint256 halfB = b / 2; return halfB.add(a.mul(_RAY)).div(b); } function rayToWad(uint256 a) internal pure returns (uint256) { uint256 halfRatio = _WAD_RAY_RATIO / 2; return halfRatio.add(a).div(_WAD_RAY_RATIO); } function wadToRay(uint256 a) internal pure returns (uint256) { return a.mul(_WAD_RAY_RATIO); } /** * @dev calculates x^n, in ray. The code uses the ModExp precompile * @param x base * @param n exponent * @return z = x^n, in ray */ function rayPow(uint256 x, uint256 n) internal pure returns (uint256 z) { z = n % 2 != 0 ? x : _RAY; for (n /= 2; n != 0; n /= 2) { x = rayMul(x, x); if (n % 2 != 0) { z = rayMul(z, x); } } } }
//SPDX-License-Identifier: MIT pragma experimental ABIEncoderV2; pragma solidity 0.6.12; import "@openzeppelin/contracts/math/SafeMath.sol"; import "../libraries/WadRayMath.sol"; import "./interfaces/IGenericMiner.sol"; /* GenericMiner is based on ERC2917. https://github.com/gnufoo/ERC2917-Proposal The Objective of GenericMiner is to implement a decentralized staking mechanism, which calculates _users' share by accumulating stake * time. And calculates _users revenue from anytime t0 to t1 by the formula below: user_accumulated_stake(time1) - user_accumulated_stake(time0) _____________________________________________________________________________ * (gross_stake(t1) - gross_stake(t0)) total_accumulated_stake(time1) - total_accumulated_stake(time0) */ contract GenericMiner is IGenericMiner { using SafeMath for uint256; using WadRayMath for uint256; mapping(address => UserInfo) private _users; uint256 public override totalStake; IGovernanceAddressProvider public override a; uint256 private _balanceTracker; uint256 private _accAmountPerShare; constructor(IGovernanceAddressProvider _addresses) public { require(address(_addresses) != address(0)); a = _addresses; } /** Releases the outstanding MIMO balance to the user. @param _user the address of the user for which the MIMO tokens will be released. */ function releaseMIMO(address _user) public override { UserInfo storage userInfo = _users[_user]; _refresh(); uint256 pending = userInfo.stake.rayMul(_accAmountPerShare.sub(userInfo.accAmountPerShare)); _balanceTracker = _balanceTracker.sub(pending); userInfo.accAmountPerShare = _accAmountPerShare; require(a.mimo().transfer(_user, pending)); } /** Returns the number of tokens a user has staked. @param _user the address of the user. @return number of staked tokens */ function stake(address _user) public view override returns (uint256) { return _users[_user].stake; } /** Returns the number of tokens a user can claim via `releaseMIMO`. @param _user the address of the user. @return number of MIMO tokens that the user can claim */ function pendingMIMO(address _user) public view override returns (uint256) { uint256 currentBalance = a.mimo().balanceOf(address(this)); uint256 reward = currentBalance.sub(_balanceTracker); uint256 accAmountPerShare = _accAmountPerShare.add(reward.rayDiv(totalStake)); return _users[_user].stake.rayMul(accAmountPerShare.sub(_users[_user].accAmountPerShare)); } /** Returns the userInfo stored of a user. @param _user the address of the user. @return `struct UserInfo { uint256 stake; uint256 rewardDebt; }` **/ function userInfo(address _user) public view override returns (UserInfo memory) { return _users[_user]; } /** Refreshes the global state and subsequently decreases the stake a user has. This is an internal call and meant to be called within derivative contracts. @param user the address of the user @param value the amount by which the stake will be reduced */ function _decreaseStake(address user, uint256 value) internal { require(value > 0, "STAKE_MUST_BE_GREATER_THAN_ZERO"); //TODO cleanup error message UserInfo storage userInfo = _users[user]; require(userInfo.stake >= value, "INSUFFICIENT_STAKE_FOR_USER"); //TODO cleanup error message _refresh(); uint256 pending = userInfo.stake.rayMul(_accAmountPerShare.sub(userInfo.accAmountPerShare)); _balanceTracker = _balanceTracker.sub(pending); userInfo.stake = userInfo.stake.sub(value); userInfo.accAmountPerShare = _accAmountPerShare; totalStake = totalStake.sub(value); require(a.mimo().transfer(user, pending)); emit StakeDecreased(user, value); } /** Refreshes the global state and subsequently increases a user's stake. This is an internal call and meant to be called within derivative contracts. @param user the address of the user @param value the amount by which the stake will be increased */ function _increaseStake(address user, uint256 value) internal { require(value > 0, "STAKE_MUST_BE_GREATER_THAN_ZERO"); //TODO cleanup error message UserInfo storage userInfo = _users[user]; _refresh(); uint256 pending; if (userInfo.stake > 0) { pending = userInfo.stake.rayMul(_accAmountPerShare.sub(userInfo.accAmountPerShare)); _balanceTracker = _balanceTracker.sub(pending); } totalStake = totalStake.add(value); userInfo.stake = userInfo.stake.add(value); userInfo.accAmountPerShare = _accAmountPerShare; if (pending > 0) { require(a.mimo().transfer(user, pending)); } emit StakeIncreased(user, value); } /** Refreshes the global state and subsequently updates a user's stake. This is an internal call and meant to be called within derivative contracts. @param user the address of the user @param stake the new amount of stake for the user */ function _updateStake(address user, uint256 stake) internal returns (bool) { uint256 oldStake = _users[user].stake; if (stake > oldStake) { _increaseStake(user, stake.sub(oldStake)); } if (stake < oldStake) { _decreaseStake(user, oldStake.sub(stake)); } } /** Internal read function to calculate the number of MIMO tokens that have accumulated since the last token release. @dev This is an internal call and meant to be called within derivative contracts. @return newly accumulated token balance */ function _newTokensReceived() internal view returns (uint256) { return a.mimo().balanceOf(address(this)).sub(_balanceTracker); } /** Updates the internal state variables after accounting for newly received MIMO tokens. */ function _refresh() internal { if (totalStake == 0) { return; } uint256 currentBalance = a.mimo().balanceOf(address(this)); uint256 reward = currentBalance.sub(_balanceTracker); _balanceTracker = currentBalance; _accAmountPerShare = _accAmountPerShare.add(reward.rayDiv(totalStake)); } }
// SPDX-License-Identifier: MIT pragma experimental ABIEncoderV2; pragma solidity 0.6.12; import "../../governance/interfaces/IGovernanceAddressProvider.sol"; import "./ISupplyMiner.sol"; interface IDebtNotifier { function debtChanged(uint256 _vaultId) external; function setCollateralSupplyMiner(address collateral, ISupplyMiner supplyMiner) external; function a() external view returns (IGovernanceAddressProvider); function collateralSupplyMinerMapping(address collateral) external view returns (ISupplyMiner); }
// SPDX-License-Identifier: MIT pragma experimental ABIEncoderV2; pragma solidity 0.6.12; import "@openzeppelin/contracts/math/SafeMath.sol"; import "../../interfaces/IAddressProvider.sol"; import "../../governance/interfaces/IGovernanceAddressProvider.sol"; interface IGenericMiner { struct UserInfo { uint256 stake; uint256 accAmountPerShare; // User's accAmountPerShare } /// @dev This emit when a users' productivity has changed /// It emits with the user's address and the the value after the change. event StakeIncreased(address indexed user, uint256 stake); /// @dev This emit when a users' productivity has changed /// It emits with the user's address and the the value after the change. event StakeDecreased(address indexed user, uint256 stake); function releaseMIMO(address _user) external; function a() external view returns (IGovernanceAddressProvider); function stake(address _user) external view returns (uint256); function pendingMIMO(address _user) external view returns (uint256); function totalStake() external view returns (uint256); function userInfo(address _user) external view returns (UserInfo memory); }
// SPDX-License-Identifier: MIT pragma solidity 0.6.12; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; interface IMIMO is IERC20 { function burn(address account, uint256 amount) external; function mint(address account, uint256 amount) external; }
// SPDX-License-Identifier: MIT pragma experimental ABIEncoderV2; pragma solidity 0.6.12; interface ISupplyMiner { function baseDebtChanged(address user, uint256 newBaseDebt) external; }
// SPDX-License-Identifier: MIT pragma experimental ABIEncoderV2; pragma solidity 0.6.12; import "./IConfigProviderV1.sol"; import "./ILiquidationManagerV1.sol"; import "./IVaultsCoreV1.sol"; import "../../interfaces/IVaultsCore.sol"; import "../../interfaces/IAccessController.sol"; import "../../interfaces/ISTABLEX.sol"; import "../../interfaces/IPriceFeed.sol"; import "../../interfaces/IRatesManager.sol"; import "../../interfaces/IVaultsDataProvider.sol"; import "../../interfaces/IFeeDistributor.sol"; interface IAddressProviderV1 { function setAccessController(IAccessController _controller) external; function setConfigProvider(IConfigProviderV1 _config) external; function setVaultsCore(IVaultsCoreV1 _core) external; function setStableX(ISTABLEX _stablex) external; function setRatesManager(IRatesManager _ratesManager) external; function setPriceFeed(IPriceFeed _priceFeed) external; function setLiquidationManager(ILiquidationManagerV1 _liquidationManager) external; function setVaultsDataProvider(IVaultsDataProvider _vaultsData) external; function setFeeDistributor(IFeeDistributor _feeDistributor) external; function controller() external view returns (IAccessController); function config() external view returns (IConfigProviderV1); function core() external view returns (IVaultsCoreV1); function stablex() external view returns (ISTABLEX); function ratesManager() external view returns (IRatesManager); function priceFeed() external view returns (IPriceFeed); function liquidationManager() external view returns (ILiquidationManagerV1); function vaultsData() external view returns (IVaultsDataProvider); function feeDistributor() external view returns (IFeeDistributor); }
// SPDX-License-Identifier: MIT pragma experimental ABIEncoderV2; pragma solidity 0.6.12; import "./IAddressProviderV1.sol"; interface IConfigProviderV1 { struct CollateralConfig { address collateralType; uint256 debtLimit; uint256 minCollateralRatio; uint256 borrowRate; uint256 originationFee; } event CollateralUpdated( address indexed collateralType, uint256 debtLimit, uint256 minCollateralRatio, uint256 borrowRate, uint256 originationFee ); event CollateralRemoved(address indexed collateralType); function setCollateralConfig( address _collateralType, uint256 _debtLimit, uint256 _minCollateralRatio, uint256 _borrowRate, uint256 _originationFee ) external; function removeCollateral(address _collateralType) external; function setCollateralDebtLimit(address _collateralType, uint256 _debtLimit) external; function setCollateralMinCollateralRatio(address _collateralType, uint256 _minCollateralRatio) external; function setCollateralBorrowRate(address _collateralType, uint256 _borrowRate) external; function setCollateralOriginationFee(address _collateralType, uint256 _originationFee) external; function setLiquidationBonus(uint256 _bonus) external; function a() external view returns (IAddressProviderV1); function collateralConfigs(uint256 _id) external view returns (CollateralConfig memory); function collateralIds(address _collateralType) external view returns (uint256); function numCollateralConfigs() external view returns (uint256); function liquidationBonus() external view returns (uint256); function collateralDebtLimit(address _collateralType) external view returns (uint256); function collateralMinCollateralRatio(address _collateralType) external view returns (uint256); function collateralBorrowRate(address _collateralType) external view returns (uint256); function collateralOriginationFee(address _collateralType) external view returns (uint256); }
// SPDX-License-Identifier: MIT pragma experimental ABIEncoderV2; pragma solidity 0.6.12; import "./IAddressProviderV1.sol"; interface ILiquidationManagerV1 { function a() external view returns (IAddressProviderV1); function calculateHealthFactor( address _collateralType, uint256 _collateralValue, uint256 _vaultDebt ) external view returns (uint256 healthFactor); function liquidationBonus(uint256 _amount) external view returns (uint256 bonus); function applyLiquidationDiscount(uint256 _amount) external view returns (uint256 discountedAmount); function isHealthy( address _collateralType, uint256 _collateralValue, uint256 _vaultDebt ) external view returns (bool); }
// SPDX-License-Identifier: MIT pragma experimental ABIEncoderV2; pragma solidity 0.6.12; import "./IAddressProviderV1.sol"; interface IVaultsCoreV1 { event Opened(uint256 indexed vaultId, address indexed collateralType, address indexed owner); event Deposited(uint256 indexed vaultId, uint256 amount, address indexed sender); event Withdrawn(uint256 indexed vaultId, uint256 amount, address indexed sender); event Borrowed(uint256 indexed vaultId, uint256 amount, address indexed sender); event Repaid(uint256 indexed vaultId, uint256 amount, address indexed sender); event Liquidated( uint256 indexed vaultId, uint256 debtRepaid, uint256 collateralLiquidated, address indexed owner, address indexed sender ); event CumulativeRateUpdated(address indexed collateralType, uint256 elapsedTime, uint256 newCumulativeRate); //cumulative interest rate from deployment time T0 event InsurancePaid(uint256 indexed vaultId, uint256 insuranceAmount, address indexed sender); function deposit(address _collateralType, uint256 _amount) external; function withdraw(uint256 _vaultId, uint256 _amount) external; function withdrawAll(uint256 _vaultId) external; function borrow(uint256 _vaultId, uint256 _amount) external; function repayAll(uint256 _vaultId) external; function repay(uint256 _vaultId, uint256 _amount) external; function liquidate(uint256 _vaultId) external; //Refresh function initializeRates(address _collateralType) external; function refresh() external; function refreshCollateral(address collateralType) external; //upgrade function upgrade(address _newVaultsCore) external; //Read only function a() external view returns (IAddressProviderV1); function availableIncome() external view returns (uint256); function cumulativeRates(address _collateralType) external view returns (uint256); function lastRefresh(address _collateralType) external view returns (uint256); }
// SPDX-License-Identifier: MIT pragma solidity ^0.6.0; /** * @dev Wrappers over Solidity's arithmetic operations with added overflow * checks. * * Arithmetic operations in Solidity wrap on overflow. This can easily result * in bugs, because programmers usually assume that an overflow raises an * error, which is the standard behavior in high level programming languages. * `SafeMath` restores this intuition by reverting the transaction when an * operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. */ library SafeMath { /** * @dev Returns the addition of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `+` operator. * * Requirements: * * - Addition cannot overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } /** * @dev Returns the subtraction of two unsigned integers, reverting on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } /** * @dev Returns the multiplication of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `*` operator. * * Requirements: * * - Multiplication cannot overflow. */ function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } /** * @dev Returns the integer division of two unsigned integers. Reverts on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } /** * @dev Returns the integer division of two unsigned integers. Reverts with custom message on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * Reverts when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * Reverts with custom message when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } }
// SPDX-License-Identifier: MIT pragma solidity ^0.6.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `recipient`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address recipient, uint256 amount) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns (uint256); /** * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 amount) external returns (bool); /** * @dev Moves `amount` tokens from `sender` to `recipient` using the * allowance mechanism. `amount` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); }
{ "remappings": [], "optimizer": { "enabled": true, "runs": 200 }, "evmVersion": "istanbul", "libraries": {}, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "abi" ] } } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"contract IGovernanceAddressProvider","name":"_addresses","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"stake","type":"uint256"}],"name":"StakeDecreased","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"stake","type":"uint256"}],"name":"StakeIncreased","type":"event"},{"inputs":[],"name":"a","outputs":[{"internalType":"contract IGovernanceAddressProvider","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"newBaseDebt","type":"uint256"}],"name":"baseDebtChanged","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"}],"name":"pendingMIMO","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"}],"name":"releaseMIMO","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"}],"name":"stake","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalStake","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"}],"name":"userInfo","outputs":[{"components":[{"internalType":"uint256","name":"stake","type":"uint256"},{"internalType":"uint256","name":"accAmountPerShare","type":"uint256"}],"internalType":"struct IGenericMiner.UserInfo","name":"","type":"tuple"}],"stateMutability":"view","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
0000000000000000000000002489df1f40bca6dba1554aafecc237bbc6d0453c
-----Decoded View---------------
Arg [0] : _addresses (address): 0x2489DF1F40BcA6DBa1554AafeCc237BBc6d0453c
-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 0000000000000000000000002489df1f40bca6dba1554aafecc237bbc6d0453c
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 30 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|---|---|---|---|---|
POL | 100.00% | $0.005639 | 490.2971 | $2.76 |
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.