Source Code
Overview
DEV Balance
0 DEV
More Info
ContractCreator
Multichain Info
N/A
Latest 1 from a total of 1 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
0x60806040 | 3409482 | 682 days ago | IN | 0 DEV | 0.0007154 |
Latest 25 internal transactions (View All)
Parent Transaction Hash | Block | From | To | |||
---|---|---|---|---|---|---|
3831588 | 617 days ago | 0 DEV | ||||
3831588 | 617 days ago | 0 DEV | ||||
3831588 | 617 days ago | 0 DEV | ||||
3831588 | 617 days ago | 0 DEV | ||||
3831588 | 617 days ago | 0 DEV | ||||
3645026 | 644 days ago | 0 DEV | ||||
3645026 | 644 days ago | 0 DEV | ||||
3645026 | 644 days ago | 0 DEV | ||||
3645026 | 644 days ago | 0 DEV | ||||
3645026 | 644 days ago | 0 DEV | ||||
3645026 | 644 days ago | 0 DEV | ||||
3645026 | 644 days ago | 0 DEV | ||||
3645026 | 644 days ago | 0 DEV | ||||
3645026 | 644 days ago | 0 DEV | ||||
3645026 | 644 days ago | 0 DEV | ||||
3645017 | 644 days ago | 0 DEV | ||||
3645017 | 644 days ago | 0 DEV | ||||
3645017 | 644 days ago | 0 DEV | ||||
3645017 | 644 days ago | 0 DEV | ||||
3645017 | 644 days ago | 0 DEV | ||||
3630079 | 647 days ago | 0 DEV | ||||
3630079 | 647 days ago | 0 DEV | ||||
3630079 | 647 days ago | 0 DEV | ||||
3630079 | 647 days ago | 0 DEV | ||||
3630079 | 647 days ago | 0 DEV |
Loading...
Loading
Contract Name:
TradingEmissionsQontroller
Compiler Version
v0.8.10+commit.fc410830
Optimization Enabled:
Yes with 200 runs
Other Settings:
default evmVersion
Contract Source Code (Solidity Standard Json-Input format)
//SPDX-License-Identifier: NONE pragma solidity ^0.8.9; import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; import "./interfaces/IQAdmin.sol"; import "./interfaces/ITradingEmissionsQontroller.sol"; import "./interfaces/IQodaERC20.sol"; contract TradingEmissionsQontroller is Initializable, ITradingEmissionsQontroller { struct EmissionsPhase { /// @notice Token reward per $1 USD in txn fees uint rewardRate; /// @notice Current amount of tokens accrued in the current phase uint tokensAccrued; /// @notice Total amount of tokens reserved for the current phase uint tokensTotal; } /// @notice Contract storing all global Qoda parameters IQAdmin private _qAdmin; /// @notice Address of underlying QODA token IQodaERC20 private _qodaERC20; /// @notice Number of emissions phases uint private _numPhases; /// @notice Current phase for emissions uint private _currentPhase; /// @notice Total tokens allocated to reward for `TradingEmissionsQontroller` uint private _totalAllocation; /// @notice Track unclaimed rewards mapping(address => uint) private _claimableEmissions; /// @notice Map defining the emissions phase and associated configurations mapping(uint => EmissionsPhase) private _emissionsPhase; /// @notice Emitted when user claims emissions event ClaimEmissions(address account, uint amount); /// @notice Constructor for upgradeable contracts function initialize( address qodaERC20Address, address qAdminAddress, uint[] memory rewardRate_, uint[] memory tokensTotal_, uint numPhases_, uint totalAllocation_ ) public initializer { require( rewardRate_.length == numPhases_ && tokensTotal_.length == numPhases_, "TEQ2 length mismatch" ); // Initialize values _qodaERC20 = IQodaERC20(qodaERC20Address); _qAdmin = IQAdmin(qAdminAddress); _numPhases = numPhases_; _currentPhase = 0; _totalAllocation = totalAllocation_; // Initialize emissions phases and rewards config for (uint i = 0; i < numPhases_; i++){ _emissionsPhase[i] = EmissionsPhase({ rewardRate: rewardRate_[i], tokensTotal: tokensTotal_[i], tokensAccrued: 0 }); } // Sanity check on rewards uint totalRewards = 0; for(uint i=0; i<_numPhases; i++){ totalRewards += _emissionsPhase[i].tokensTotal; } require(_totalAllocation == totalRewards, "TEQ0 incorrect rewards"); } modifier onlyMarket() { require(_qAdmin.hasRole(_qAdmin.MARKET_ROLE(), msg.sender), "TEQ1 only market"); _; } /** ACCESS CONTROLLED FUNCTIONS **/ /// @notice Use the fees generated (in USD) as basis to calculate how much /// token reward to disburse for trading volumes. Only `FixedRateMarket` /// contracts may call this function. /// @param borrower Address of the borrower /// @param lender Address of the lender /// @param feeUSD Fees generated (in USD, scaled to 1e18) function updateRewards( address borrower, address lender, uint feeUSD ) external onlyMarket { _updateRewards(borrower, feeUSD); _updateRewards(lender, feeUSD); } /** USER INTERFACE **/ /// @notice Mint the unclaimed rewards to user and reset their claimable emissions function claimEmissions() external { // Get the emissions accrued for the user uint reward = _claimableEmissions[msg.sender]; require(reward > 0, "TEQ3 reward must be positive"); // Reset user's claimable emissions _claimableEmissions[msg.sender] = 0; // Transfer the rewards directly from `TradingEmissionsQontroller` contract // to user. The assumption is that total supply of reward tokens have been // pre-minted to this contract address. This limits the maximum damage of // a potential hack to just tokens within the contract (compared to an // infinite mint of tokens if this contract were allowed to mint on a // callable function _qodaERC20.transfer(msg.sender, reward); // Emit the event emit ClaimEmissions(msg.sender, reward); } /** VIEW FUNCTIONS **/ /// @notice Checks the amount of unclaimed trading rewards that the user can claim /// @param account Address of the user /// @return uint Amount of QODA token rewards the user may claim function claimableEmissions(address account) external view returns(uint){ return _claimableEmissions[account]; } /// @notice Get the address of the `QAdmin` contract /// @return address Address of `QAdmin` contract function qAdmin() external view returns(address) { return address(_qAdmin); } /// @notice Get the address of the `QodaERC20` contract /// @return address Address of `QodaERC20` contract function qodaERC20() external view returns(address) { return address(_qodaERC20); } function numPhases() external view returns(uint) { return _numPhases; } function currentPhase() external view returns(uint) { return _currentPhase; } function totalAllocation() external view returns(uint) { return _totalAllocation; } function emissionsPhase(uint phase) external view returns(uint, uint, uint) { uint rewardRate = _emissionsPhase[phase].rewardRate; uint tokensAccrued = _emissionsPhase[phase].tokensAccrued; uint tokensTotal = _emissionsPhase[phase].tokensTotal; return (rewardRate, tokensAccrued, tokensTotal); } /** INTERNAL FUNCTIONS **/ /// @notice Use the fees generated (in USD) as basis to calculate how much /// token reward to disburse for trading volumes. /// @param account Address of the user /// @param feeUSD Fees generated (in USD, scaled to 1e18) function _updateRewards(address account, uint feeUSD) internal { if(_currentPhase == _numPhases){ // All trading rewards have already been distributed return; } uint tokensTotal = _emissionsPhase[_currentPhase].tokensTotal; uint tokensAccrued = _emissionsPhase[_currentPhase].tokensAccrued; // One USD has 18 decimal places to avoid rounding problem (see QPriceOracle) uint proposedReward = _emissionsPhase[_currentPhase].rewardRate * feeUSD / _qAdmin.MANTISSA_USD(); // Check if the `proposedReward` will push the emission schedule into the next phase if(proposedReward + tokensAccrued > tokensTotal) { // Total reward under old phase can't be more than the remaining reserved tokens in the phase uint rewardOldPhase = tokensTotal - tokensAccrued; // The reward is enough to move us to the next emissions phase // First, set `tokensAccrued` = `tokensTotal` in the current phase _emissionsPhase[_currentPhase].tokensAccrued = tokensTotal; // Move to next phase _currentPhase++; // Accrue the remaining amount of reward in `tokensAccrued` of next phase uint rewardNewPhase = proposedReward - rewardOldPhase; // Scale the remaining reward by the reward rate of the new phase rewardNewPhase = rewardNewPhase * _emissionsPhase[_currentPhase].rewardRate / _emissionsPhase[_currentPhase-1].rewardRate; _emissionsPhase[_currentPhase].tokensAccrued = rewardNewPhase; // Store the amount of claimable emissions for the user _claimableEmissions[account] += rewardOldPhase + rewardNewPhase; }else { // Accrue the full amount of reward in `tokensAccrued` of the current phase _emissionsPhase[_currentPhase].tokensAccrued += proposedReward; // Store the amount of claimable emissions for the user _claimableEmissions[account] += proposedReward; } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.0) (proxy/utils/Initializable.sol) pragma solidity ^0.8.2; import "../../utils/AddressUpgradeable.sol"; /** * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect. * * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in * case an upgrade adds a module that needs to be initialized. * * For example: * * [.hljs-theme-light.nopadding] * ``` * contract MyToken is ERC20Upgradeable { * function initialize() initializer public { * __ERC20_init("MyToken", "MTK"); * } * } * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable { * function initializeV2() reinitializer(2) public { * __ERC20Permit_init("MyToken"); * } * } * ``` * * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}. * * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity. * * [CAUTION] * ==== * Avoid leaving a contract uninitialized. * * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed: * * [.hljs-theme-light.nopadding] * ``` * /// @custom:oz-upgrades-unsafe-allow constructor * constructor() { * _disableInitializers(); * } * ``` * ==== */ abstract contract Initializable { /** * @dev Indicates that the contract has been initialized. * @custom:oz-retyped-from bool */ uint8 private _initialized; /** * @dev Indicates that the contract is in the process of being initialized. */ bool private _initializing; /** * @dev Triggered when the contract has been initialized or reinitialized. */ event Initialized(uint8 version); /** * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope, * `onlyInitializing` functions can be used to initialize parent contracts. Equivalent to `reinitializer(1)`. */ modifier initializer() { bool isTopLevelCall = !_initializing; require( (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1), "Initializable: contract is already initialized" ); _initialized = 1; if (isTopLevelCall) { _initializing = true; } _; if (isTopLevelCall) { _initializing = false; emit Initialized(1); } } /** * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be * used to initialize parent contracts. * * `initializer` is equivalent to `reinitializer(1)`, so a reinitializer may be used after the original * initialization step. This is essential to configure modules that are added through upgrades and that require * initialization. * * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in * a contract, executing them in the right order is up to the developer or operator. */ modifier reinitializer(uint8 version) { require(!_initializing && _initialized < version, "Initializable: contract is already initialized"); _initialized = version; _initializing = true; _; _initializing = false; emit Initialized(version); } /** * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the * {initializer} and {reinitializer} modifiers, directly or indirectly. */ modifier onlyInitializing() { require(_initializing, "Initializable: contract is not initializing"); _; } /** * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call. * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized * to any version. It is recommended to use this to lock implementation contracts that are designed to be called * through proxies. */ function _disableInitializers() internal virtual { require(!_initializing, "Initializable: contract is initializing"); if (_initialized < type(uint8).max) { _initialized = type(uint8).max; emit Initialized(type(uint8).max); } } }
//SPDX-License-Identifier: UNLICENSED pragma solidity ^0.8.9; import "@openzeppelin/contracts-upgradeable/access/IAccessControlUpgradeable.sol"; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "../libraries/QTypes.sol"; interface IQAdmin is IAccessControlUpgradeable { /// @notice Emitted when a new FixedRateMarket is deployed event CreateFixedRateMarket(address indexed marketAddress, address indexed tokenAddress, uint maturity); /// @notice Emitted when a new `Asset` is added event AddAsset( address indexed tokenAddress, bool isYieldBearing, address oracleFeed, uint collateralFactor, uint marketFactor); /// @notice Emitted when setting `_qollateralManager` event SetQollateralManager(address qollateralManagerAddress); /// @notice Emitted when setting `_stakingEmissionsQontroller` event SetStakingEmissionsQontroller(address stakingEmissionsQontrollerAddress); /// @notice Emitted when setting `_tradingEmissionsQontroller` event SetTradingEmissionsQontroller(address tradingEmissionsQontrollerAddress); /// @notice Emitted when setting `_feeEmissionsQontroller` event SetFeeEmissionsQontroller(address feeEmissionsQontrollerAddress); /// @notice Emitted when setting `_veQoda` event SetVeQoda(address veQodaAddress); /// @notice Emitted when setting `collateralFactor` event SetCollateralFactor(address indexed tokenAddress, uint oldValue, uint newValue); /// @notice Emitted when setting `marketFactor` event SetMarketFactor(address indexed tokenAddress, uint oldValue, uint newValue); /// @notice Emitted when setting `minQuoteSize` event SetMinQuoteSize(address indexed tokenAddress, uint oldValue, uint newValue); /// @notice Emitted when `_minCollateralRatioDefault` and `_initCollateralRatioDefault` get updated event SetCollateralRatio(uint oldMinValue, uint oldInitValue, uint newMinValue, uint newInitValue); /// @notice Emitted when `CreditFacility` gets updated event SetCreditFacility(address account, bool oldEnabled, uint oldMinValue, uint oldInitValue, uint oldCreditValue, bool newEnabled, uint newMinValue, uint newInitValue, uint newCreditValue); /// @notice Emitted when `_closeFactor` gets updated event SetCloseFactor(uint oldValue, uint newValue); /// @notice Emitted when `_repaymentGracePeriod` gets updated event SetRepaymentGracePeriod(uint oldValue, uint newValue); /// @notice Emitted when `_maturityGracePeriod` gets updated event SetMaturityGracePeriod(uint oldValue, uint newValue); /// @notice Emitted when `_liquidationIncentive` gets updated event SetLiquidationIncentive(uint oldValue, uint newValue); /// @notice Emitted when `_protocolFee` gets updated event SetProtocolFee(uint oldValue, uint newValue); /** ADMIN FUNCTIONS **/ /// @notice Call upon initialization after deploying `QollateralManager` contract /// @param qollateralManagerAddress Address of `QollateralManager` deployment function _setQollateralManager(address qollateralManagerAddress) external; /// @notice Call upon initialization after deploying `StakingEmissionsQontroller` contract /// @param stakingEmissionsQontrollerAddress Address of `StakingEmissionsQontroller` deployment function _setStakingEmissionsQontroller(address stakingEmissionsQontrollerAddress) external; /// @notice Call upon initialization after deploying `TradingEmissionsQontroller` contract /// @param tradingEmissionsQontrollerAddress Address of `TradingEmissionsQontroller` deployment function _setTradingEmissionsQontroller(address tradingEmissionsQontrollerAddress) external; /// @notice Call upon initialization after deploying `FeeEmissionsQontroller` contract /// @param feeEmissionsQontrollerAddress Address of `FeeEmissionsQontroller` deployment function _setFeeEmissionsQontroller(address feeEmissionsQontrollerAddress) external; /// @notice Call upon initialization after deploying `veQoda` contract /// @param veQodaAddress Address of `veQoda` deployment function _setVeQoda(address veQodaAddress) external; /// @notice Set credit facility for specified account /// @param account_ account for credit facility adjustment /// @param enabled_ If credit facility should be enabled /// @param minCollateralRatio_ New minimum collateral ratio value /// @param initCollateralRatio_ New initial collateral ratio value /// @param creditLimit_ new credit limit in USD, scaled by 1e18 function _setCreditFacility(address account_, bool enabled_, uint minCollateralRatio_, uint initCollateralRatio_, uint creditLimit_) external; /// @notice Admin function for adding new Assets. An Asset must be added before it /// can be used as collateral or borrowed. Note: We can create functionality for /// allowing borrows of a token but not using it as collateral by setting /// `collateralFactor` to zero. /// @param token ERC20 token corresponding to the Asset /// @param isYieldBearing True if token bears interest (eg aToken, cToken, mToken, etc) /// @param underlying Address of the underlying token /// @param oracleFeed Chainlink price feed address /// @param collateralFactor 0.0 to 1.0 (scaled to 1e8) for discounting risky assets /// @param marketFactor 0.0 to 1.0 (scaled to 1e8) for premium on risky borrows function _addAsset( IERC20 token, bool isYieldBearing, address underlying, address oracleFeed, uint collateralFactor, uint marketFactor ) external; /// @notice Adds a new `FixedRateMarket` contract into the internal mapping of /// whitelisted market addresses /// @param marketAddress New `FixedRateMarket` contract address /// @param protocolFee_ Corresponding protocol fee in basis points /// @param minQuoteSize_ Size in PV terms, local currency function _addFixedRateMarket( address marketAddress, uint protocolFee_, uint minQuoteSize_ ) external; /// @notice Update the `collateralFactor` for a given `Asset` /// @param token ERC20 token corresponding to the Asset /// @param collateralFactor 0.0 to 1.0 (scaled to 1e8) for discounting risky assets function _setCollateralFactor(IERC20 token, uint collateralFactor) external; /// @notice Update the `marketFactor` for a given `Asset` /// @param token Address of the token corresponding to the Asset /// @param marketFactor 0.0 to 1.0 (scaled to 1e8) for discounting risky assets function _setMarketFactor(IERC20 token, uint marketFactor) external; /// @notice Set the minimum quote size for a particular `FixedRateMarket` /// @param marketAddress Address of the `FixedRateMarket` contract /// @param minQuoteSize_ Size in PV terms, local currency function _setMinQuoteSize(address marketAddress, uint minQuoteSize_) external; /// @notice Set the global minimum and initial collateral ratio /// @param minCollateralRatio_ New global minimum collateral ratio value /// @param initCollateralRatio_ New global initial collateral ratio value function _setCollateralRatio(uint minCollateralRatio_, uint initCollateralRatio_) external; /// @notice Set the global close factor /// @param closeFactor_ New close factor value function _setCloseFactor(uint closeFactor_) external; /// @notice Set the global repayment grace period /// @param repaymentGracePeriod_ New repayment grace period function _setRepaymentGracePeriod(uint repaymentGracePeriod_) external; /// @notice Set the global maturity grace period /// @param maturityGracePeriod_ New maturity grace period function _setMaturityGracePeriod(uint maturityGracePeriod_) external; /// @notice Set the global liquidation incetive /// @param liquidationIncentive_ New liquidation incentive value function _setLiquidationIncentive(uint liquidationIncentive_) external; /// @notice Set the global annualized protocol fees for each market in basis points /// @param marketAddress Address of the `FixedRateMarket` contract /// @param protocolFee_ New protocol fee value (scaled to 1e4) function _setProtocolFee(address marketAddress, uint protocolFee_) external; /// @notice Set the global threshold in USD for protocol fee transfer /// @param thresholdUSD_ New threshold USD value (scaled by 1e6) function _setThresholdUSD(uint thresholdUSD_) external; /** VIEW FUNCTIONS **/ function ADMIN_ROLE() external view returns(bytes32); function MARKET_ROLE() external view returns(bytes32); function MINTER_ROLE() external view returns(bytes32); function VETOKEN_ROLE() external view returns(bytes32); /// @notice Get the address of the `QollateralManager` contract function qollateralManager() external view returns(address); /// @notice Get the address of the `QPriceOracle` contract function qPriceOracle() external view returns(address); /// @notice Get the address of the `StakingEmissionsQontroller` contract function stakingEmissionsQontroller() external view returns(address); /// @notice Get the address of the `TradingEmissionsQontroller` contract function tradingEmissionsQontroller() external view returns(address); /// @notice Get the address of the `FeeEmissionsQontroller` contract function feeEmissionsQontroller() external view returns(address); /// @notice Get the address of the `veQoda` contract function veQoda() external view returns(address); /// @notice Get the credit limit with associated address, scaled by 1e18 function creditLimit(address account_) external view returns(uint); /// @notice Gets the `Asset` mapped to the address of a ERC20 token /// @param token ERC20 token /// @return QTypes.Asset Associated `Asset` function assets(IERC20 token) external view returns(QTypes.Asset memory); /// @notice Get all enabled `Asset`s /// @return address[] iterable list of enabled `Asset`s function allAssets() external view returns(address[] memory); /// @notice Gets the `oracleFeed` associated with a ERC20 token /// @param token ERC20 token /// @return address Address of the oracle feed function oracleFeed(IERC20 token) external view returns(address); /// @notice Gets the `CollateralFactor` associated with a ERC20 token /// @param token ERC20 token /// @return uint Collateral Factor, scaled by 1e8 function collateralFactor(IERC20 token) external view returns(uint); /// @notice Gets the `MarketFactor` associated with a ERC20 token /// @param token ERC20 token /// @return uint Market Factor, scaled by 1e8 function marketFactor(IERC20 token) external view returns(uint); /// @notice Gets the `maturities` associated with a ERC20 token /// @param token ERC20 token /// @return uint[] array of UNIX timestamps (in seconds) of the maturity dates function maturities(IERC20 token) external view returns(uint[] memory); /// @notice Get the MToken market corresponding to any underlying ERC20 /// tokenAddress => mTokenAddress function underlyingToMToken(IERC20 token) external view returns(address); /// @notice Gets the address of the `FixedRateMarket` contract /// @param token ERC20 token /// @param maturity UNIX timestamp of the maturity date /// @return address Address of `FixedRateMarket` contract function fixedRateMarkets(IERC20 token, uint maturity) external view returns(address); /// @notice Check whether an address is a valid FixedRateMarket address. /// Can be used for checks for inter-contract admin/restricted function call. /// @param marketAddress Address of the `FixedRateMarket` contract /// @return bool True if valid false otherwise function isMarketEnabled(address marketAddress) external view returns(bool); function minQuoteSize(address marketAddress) external view returns(uint); function minCollateralRatio() external view returns(uint); function minCollateralRatio(address account) external view returns(uint); function initCollateralRatio() external view returns(uint); function initCollateralRatio(address account) external view returns(uint); function closeFactor() external view returns(uint); function repaymentGracePeriod() external view returns(uint); function maturityGracePeriod() external view returns(uint); function liquidationIncentive() external view returns(uint); /// @notice Annualized protocol fee in basis points, scaled by 1e4 function protocolFee(address marketAddress) external view returns(uint); /// @notice threshold in USD where protocol fee from each market will be transferred into `FeeEmissionsQontroller` /// once this amount is reached, scaled by 1e6 function thresholdUSD() external view returns(uint); /// @notice 2**256 - 1 function UINT_MAX() external pure returns(uint); /// @notice Generic mantissa corresponding to ETH decimals function MANTISSA_DEFAULT() external pure returns(uint); /// @notice Mantissa for USD function MANTISSA_USD() external pure returns(uint); /// @notice Mantissa for collateral ratio function MANTISSA_COLLATERAL_RATIO() external pure returns(uint); /// @notice `assetFactor` and `marketFactor` have up to 8 decimal places precision function MANTISSA_FACTORS() external pure returns(uint); /// @notice Basis points have 4 decimal place precision function MANTISSA_BPS() external pure returns(uint); /// @notice Staked Qoda has 6 decimal place precision function MANTISSA_STAKING() external pure returns(uint); /// @notice `collateralFactor` cannot be above 1.0 function MAX_COLLATERAL_FACTOR() external pure returns(uint); /// @notice `marketFactor` cannot be above 1.0 function MAX_MARKET_FACTOR() external pure returns(uint); /// @notice version number of this contract, will be bumped upon contractual change function VERSION_NUMBER() external pure returns(string memory); }
//SPDX-License-Identifier: UNLICENSED pragma solidity ^0.8.9; interface ITradingEmissionsQontroller { /** ACCESS CONTROLLED FUNCTIONS **/ /// @notice Use the fees generated (in USD) as basis to calculate how much /// token reward to disburse for trading volumes. Only `FixedRateMarket` /// contracts may call this function. /// @param borrower Address of the borrower /// @param lender Address of the lender /// @param feeUSD Fees generated (in USD, scaled to 1e18) function updateRewards(address borrower, address lender, uint feeUSD) external; /** USER INTERFACE **/ /// @notice Mint the unclaimed rewards to user and reset their claimable emissions function claimEmissions() external; /** VIEW FUNCTIONS **/ /// @notice Checks the amount of unclaimed trading rewards that the user can claim /// @param account Address of the user /// @return uint Amount of QODA token rewards the user may claim function claimableEmissions(address account) external view returns(uint); /// @notice Get the address of the `QAdmin` contract /// @return address Address of `QAdmin` contract function qAdmin() external view returns(address); /// @notice Get the address of the `QodaERC20` contract /// @return address Address of `QodaERC20` contract function qodaERC20() external view returns(address); function numPhases() external view returns(uint); function currentPhase() external view returns(uint); function totalAllocation() external view returns(uint); function emissionsPhase(uint phase) external view returns(uint, uint, uint); }
// SPDX-License-Identifier: UNLICENSED pragma solidity ^0.8.9; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol"; interface IQodaERC20 is IERC20, IERC20Metadata { /// @notice Mints tokens to a recipient, as long as it is under the /// supply cap. Reverts if the caller does not have the minter role. /// @param recipient Account to mint tokens to /// @param amount Amount of tokens to mint function mint(address recipient, uint amount) external returns(bool); function supplyCap() external view returns(uint); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol) pragma solidity ^0.8.1; /** * @dev Collection of functions related to the address type */ library AddressUpgradeable { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== * * [IMPORTANT] * ==== * You shouldn't rely on `isContract` to protect against flash loan attacks! * * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract * constructor. * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize/address.code.length, which returns 0 // for contracts in construction, since the code is only stored at the end // of the constructor execution. return account.code.length > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); (bool success, ) = recipient.call{value: amount}(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value ) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value, string memory errorMessage ) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall( address target, bytes memory data, string memory errorMessage ) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResult(success, returndata, errorMessage); } /** * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal pure returns (bytes memory) { if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly /// @solidity memory-safe-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol) pragma solidity ^0.8.0; /** * @dev External interface of AccessControl declared to support ERC165 detection. */ interface IAccessControlUpgradeable { /** * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole` * * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite * {RoleAdminChanged} not being emitted signaling this. * * _Available since v3.1._ */ event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole); /** * @dev Emitted when `account` is granted `role`. * * `sender` is the account that originated the contract call, an admin role * bearer except when using {AccessControl-_setupRole}. */ event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender); /** * @dev Emitted when `account` is revoked `role`. * * `sender` is the account that originated the contract call: * - if using `revokeRole`, it is the admin role bearer * - if using `renounceRole`, it is the role bearer (i.e. `account`) */ event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender); /** * @dev Returns `true` if `account` has been granted `role`. */ function hasRole(bytes32 role, address account) external view returns (bool); /** * @dev Returns the admin role that controls `role`. See {grantRole} and * {revokeRole}. * * To change a role's admin, use {AccessControl-_setRoleAdmin}. */ function getRoleAdmin(bytes32 role) external view returns (bytes32); /** * @dev Grants `role` to `account`. * * If `account` had not been already granted `role`, emits a {RoleGranted} * event. * * Requirements: * * - the caller must have ``role``'s admin role. */ function grantRole(bytes32 role, address account) external; /** * @dev Revokes `role` from `account`. * * If `account` had been granted `role`, emits a {RoleRevoked} event. * * Requirements: * * - the caller must have ``role``'s admin role. */ function revokeRole(bytes32 role, address account) external; /** * @dev Revokes `role` from the calling account. * * Roles are often managed via {grantRole} and {revokeRole}: this function's * purpose is to provide a mechanism for accounts to lose their privileges * if they are compromised (such as when a trusted device is misplaced). * * If the calling account had been granted `role`, emits a {RoleRevoked} * event. * * Requirements: * * - the caller must be `account`. */ function renounceRole(bytes32 role, address account) external; }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @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); /** * @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 `to`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address to, 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 `from` to `to` 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 from, address to, uint256 amount ) external returns (bool); }
//SPDX-License-Identifier: UNLICENSED pragma solidity ^0.8.9; library QTypes { /// @notice Contains all the details of an Asset. Assets must be defined /// before they can be used as collateral. /// @member isEnabled True if an asset is defined, false otherwise /// @member isYieldBearing True if token bears interest (eg aToken, cToken, mToken, etc) /// @member underlying Address of the underlying token /// @member oracleFeed Address of the corresponding chainlink oracle feed /// @member collateralFactor 0.0 to 1.0 (scaled to 1e8) for discounting risky assets /// @member marketFactor 0.0 1.0 for premium on risky borrows /// @member maturities Iterable storage for all enabled maturities struct Asset { bool isEnabled; bool isYieldBearing; address underlying; address oracleFeed; uint collateralFactor; uint marketFactor; uint[] maturities; } /// @notice Contains all the fields of a created Quote /// @param id ID of the quote /// @param next Next quote in the list /// @param prev Previous quote in the list /// @param quoter Account of the Quoter /// @param quoteType 0 for PV+APR, 1 for FV+APR /// @param APR In decimal form scaled by 1e4 (ex. 10.52% = 1052) /// @param cashflow Can be PV or FV depending on `quoteType` /// @param filled Amount quote has got filled partially struct Quote { uint64 id; uint64 next; uint64 prev; address quoter; uint8 quoteType; uint64 APR; uint cashflow; uint filled; } /// @notice Contains all the configurations customizable to an address /// @member enabled If config for an address is enabled. When enabled is false, credit limit is infinite even if value is 0 /// @member minCollateralRatio If collateral ratio falls below `_minCollateralRatio`, it is subject to liquidation. Scaled by 1e8 /// @member initCollateralRatio When initially taking a loan, collateral ratio must be higher than this. `initCollateralRatio` should always be higher than `minCollateralRatio`. Scaled by 1e8 /// @member creditLimit Allowed limit in virtual USD for each address to do uncollateralized borrow, scaled by 1e18 struct CreditFacility { bool enabled; uint minCollateralRatio; uint initCollateralRatio; uint creditLimit; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol) pragma solidity ^0.8.0; import "../IERC20.sol"; /** * @dev Interface for the optional metadata functions from the ERC20 standard. * * _Available since v4.1._ */ interface IERC20Metadata is IERC20 { /** * @dev Returns the name of the token. */ function name() external view returns (string memory); /** * @dev Returns the symbol of the token. */ function symbol() external view returns (string memory); /** * @dev Returns the decimals places of the token. */ function decimals() external view returns (uint8); }
{ "optimizer": { "enabled": true, "runs": 200 }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "metadata": { "useLiteralContent": true }, "libraries": {} }
[{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"ClaimEmissions","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"version","type":"uint8"}],"name":"Initialized","type":"event"},{"inputs":[],"name":"claimEmissions","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"claimableEmissions","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"currentPhase","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"phase","type":"uint256"}],"name":"emissionsPhase","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"qodaERC20Address","type":"address"},{"internalType":"address","name":"qAdminAddress","type":"address"},{"internalType":"uint256[]","name":"rewardRate_","type":"uint256[]"},{"internalType":"uint256[]","name":"tokensTotal_","type":"uint256[]"},{"internalType":"uint256","name":"numPhases_","type":"uint256"},{"internalType":"uint256","name":"totalAllocation_","type":"uint256"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"numPhases","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"qAdmin","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"qodaERC20","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAllocation","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"borrower","type":"address"},{"internalType":"address","name":"lender","type":"address"},{"internalType":"uint256","name":"feeUSD","type":"uint256"}],"name":"updateRewards","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Loading...
Loading
Loading...
Loading
[ Download: CSV Export ]
[ 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.