More Info
Private Name Tags
ContractCreator:
Loading...
Loading
Contract Name:
CommunityIssuance
Compiler Version
v0.6.11+commit.5ef660b1
Optimization Enabled:
Yes with 1000 runs
Other Settings:
default evmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: MIT pragma solidity 0.6.11; import "../Interfaces/ILQTYToken.sol"; import "../Interfaces/ICommunityIssuance.sol"; import "../Dependencies/BaseMath.sol"; import "../Dependencies/LiquityMath.sol"; import "../Dependencies/Ownable.sol"; import "../Dependencies/SafeMath.sol"; contract CommunityIssuance is ICommunityIssuance, Ownable, BaseMath { using SafeMath for uint; // --- Data --- string constant public NAME = "CommunityIssuance"; uint constant public SECONDS_IN_ONE_MINUTE = 60; /* The issuance factor F determines the curvature of the issuance curve. * * Minutes in one year: 60*24*365 = 525600 * * For 50% of remaining tokens issued each year, with minutes as time units, we have: * * F ** 525600 = 0.5 * * Re-arranging: * * 525600 * ln(F) = ln(0.5) * F = 0.5 ** (1/525600) * F = 0.999998681227695000 */ uint constant public ISSUANCE_FACTOR = 999998681227695000; /* * The community LQTY supply cap is the starting balance of the Community Issuance contract. * It should be minted to this contract by LQTYToken, when the token is deployed. * */ uint public LQTYSupplyCap; ILQTYToken public lqtyToken; address public stabilityPoolAddress; uint public totalLQTYIssued; uint public immutable deploymentTime; // --- Events --- event LQTYTokenAddressSet(address _lqtyTokenAddress); event StabilityPoolAddressSet(address _stabilityPoolAddress); event TotalLQTYIssuedUpdated(uint _totalLQTYIssued); // --- Functions --- constructor() public { deploymentTime = block.timestamp; } function setAddresses ( address _lqtyTokenAddress, address _stabilityPoolAddress, uint _LQTYSupplyCap ) external onlyOwner override { LQTYSupplyCap = _LQTYSupplyCap; lqtyToken = ILQTYToken(_lqtyTokenAddress); stabilityPoolAddress = _stabilityPoolAddress; // When LQTYToken deployed, it should have transferred CommunityIssuance's LQTY entitlement // uint LQTYBalance = lqtyToken.balanceOf(address(this)); // assert(LQTYBalance >= LQTYSupplyCap); emit LQTYTokenAddressSet(_lqtyTokenAddress); emit StabilityPoolAddressSet(_stabilityPoolAddress); _renounceOwnership(); } function issueLQTY() external override returns (uint) { _requireCallerIsStabilityPool(); uint latestTotalLQTYIssued = LQTYSupplyCap.mul(_getCumulativeIssuanceFraction()).div(DECIMAL_PRECISION); uint issuance = latestTotalLQTYIssued.sub(totalLQTYIssued); totalLQTYIssued = latestTotalLQTYIssued; emit TotalLQTYIssuedUpdated(latestTotalLQTYIssued); return issuance; } /* Gets 1-f^t where: f < 1 f: issuance factor that determines the shape of the curve t: time passed since last LQTY issuance event */ function _getCumulativeIssuanceFraction() internal view returns (uint) { // Get the time passed since deployment uint timePassedInMinutes = block.timestamp.sub(deploymentTime).div(SECONDS_IN_ONE_MINUTE); // f^t uint power = LiquityMath._decPow(ISSUANCE_FACTOR, timePassedInMinutes); // (1 - f^t) uint cumulativeIssuanceFraction = (uint(DECIMAL_PRECISION).sub(power)); assert(cumulativeIssuanceFraction <= DECIMAL_PRECISION); // must be in range [0,1] return cumulativeIssuanceFraction; } function sendLQTY(address _account, uint _LQTYamount) external override { _requireCallerIsStabilityPool(); lqtyToken.transfer(_account, _LQTYamount); } // --- 'require' functions --- function _requireCallerIsStabilityPool() internal view { require(msg.sender == stabilityPoolAddress, "CommunityIssuance: caller is not SP"); } }
// SPDX-License-Identifier: MIT pragma solidity 0.6.11; import "../Dependencies/IERC20.sol"; import "../Dependencies/IERC2612.sol"; interface ILQTYToken is IERC20, IERC2612 { // --- Events --- event CommunityIssuanceAddressSet(address _communityIssuanceAddress); event LQTYStakingAddressSet(address _lqtyStakingAddress); event LockupContractFactoryAddressSet(address _lockupContractFactoryAddress); // --- Functions --- function sendToLQTYStaking(address _sender, uint256 _amount) external; function getDeploymentStartTime() external view returns (uint256); function getLpRewardsEntitlement() external view returns (uint256); }
// SPDX-License-Identifier: MIT pragma solidity 0.6.11; interface ICommunityIssuance { // --- Events --- event LQTYTokenAddressSet(address _lqtyTokenAddress); event StabilityPoolAddressSet(address _stabilityPoolAddress); event TotalLQTYIssuedUpdated(uint _totalLQTYIssued); // --- Functions --- function setAddresses(address _lqtyTokenAddress, address _stabilityPoolAddress, uint _LQTYSupplyCap) external; function issueLQTY() external returns (uint); function sendLQTY(address _account, uint _LQTYamount) external; }
// SPDX-License-Identifier: MIT pragma solidity 0.6.11; /** * Based on OpenZeppelin's SafeMath: * https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/math/SafeMath.sol * * @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. * * _Available since v2.4.0._ */ 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. * * _Available since v2.4.0._ */ function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { // Solidity only automatically asserts when dividing by 0 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. * * _Available since v2.4.0._ */ 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.11; /** * Based on OpenZeppelin's Ownable contract: * https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/access/Ownable.sol * * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ contract Ownable { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor () internal { _owner = msg.sender; emit OwnershipTransferred(address(0), msg.sender); } /** * @dev Returns the address of the current owner. */ function owner() public view returns (address) { return _owner; } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { require(isOwner(), "Ownable: caller is not the owner"); _; } /** * @dev Returns true if the caller is the current owner. */ function isOwner() public view returns (bool) { return msg.sender == _owner; } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions anymore. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby removing any functionality that is only available to the owner. * * NOTE: This function is not safe, as it doesn’t check owner is calling it. * Make sure you check it before calling it. */ function _renounceOwnership() internal { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } }
// SPDX-License-Identifier: MIT pragma solidity 0.6.11; import "./SafeMath.sol"; library LiquityMath { using SafeMath for uint; uint internal constant DECIMAL_PRECISION = 1e18; /* Precision for Nominal ICR (independent of price). Rationale for the value: * * - Making it “too high” could lead to overflows. * - Making it “too low” could lead to an ICR equal to zero, due to truncation from Solidity floor division. * * This value of 1e20 is chosen for safety: the NICR will only overflow for numerator > ~1e39 ETH, * and will only truncate to 0 if the denominator is at least 1e20 times greater than the numerator. * */ uint internal constant NICR_PRECISION = 1e20; function _min(uint _a, uint _b) internal pure returns (uint) { return (_a < _b) ? _a : _b; } function _max(uint _a, uint _b) internal pure returns (uint) { return (_a >= _b) ? _a : _b; } /* * Multiply two decimal numbers and use normal rounding rules: * -round product up if 19'th mantissa digit >= 5 * -round product down if 19'th mantissa digit < 5 * * Used only inside the exponentiation, _decPow(). */ function decMul(uint x, uint y) internal pure returns (uint decProd) { uint prod_xy = x.mul(y); decProd = prod_xy.add(DECIMAL_PRECISION / 2).div(DECIMAL_PRECISION); } /* * _decPow: Exponentiation function for 18-digit decimal base, and integer exponent n. * * Uses the efficient "exponentiation by squaring" algorithm. O(log(n)) complexity. * * Called by two functions that represent time in units of minutes: * 1) TroveManager._calcDecayedBaseRate * 2) CommunityIssuance._getCumulativeIssuanceFraction * * The exponent is capped to avoid reverting due to overflow. The cap 525600000 equals * "minutes in 1000 years": 60 * 24 * 365 * 1000 * * If a period of > 1000 years is ever used as an exponent in either of the above functions, the result will be * negligibly different from just passing the cap, since: * * In function 1), the decayed base rate will be 0 for 1000 years or > 1000 years * In function 2), the difference in tokens issued at 1000 years and any time > 1000 years, will be negligible */ function _decPow(uint _base, uint _minutes) internal pure returns (uint) { if (_minutes > 525600000) {_minutes = 525600000;} // cap to avoid overflow if (_minutes == 0) {return DECIMAL_PRECISION;} uint y = DECIMAL_PRECISION; uint x = _base; uint n = _minutes; // Exponentiation-by-squaring while (n > 1) { if (n % 2 == 0) { x = decMul(x, x); n = n.div(2); } else { // if (n % 2 != 0) y = decMul(x, y); x = decMul(x, x); n = (n.sub(1)).div(2); } } return decMul(x, y); } function _getAbsoluteDifference(uint _a, uint _b) internal pure returns (uint) { return (_a >= _b) ? _a.sub(_b) : _b.sub(_a); } function _computeNominalCR(uint _coll, uint _debt) internal pure returns (uint) { if (_debt > 0) { return _coll.mul(NICR_PRECISION).div(_debt); } // Return the maximal value for uint256 if the Trove has a debt of 0. Represents "infinite" CR. else { // if (_debt == 0) return 2**256 - 1; } } function _computeCR(uint _coll, uint _debt, uint _price) internal pure returns (uint) { if (_debt > 0) { uint newCollRatio = _coll.mul(_price).div(_debt); return newCollRatio; } // Return the maximal value for uint256 if the Trove has a debt of 0. Represents "infinite" CR. else { // if (_debt == 0) return 2**256 - 1; } } }
// SPDX-License-Identifier: MIT pragma solidity 0.6.11; /** * @dev Interface of the ERC2612 standard as defined in the EIP. * * Adds the {permit} method, which can be used to change one's * {IERC20-allowance} without having to send a transaction, by signing a * message. This allows users to spend tokens without having to hold Ether. * * See https://eips.ethereum.org/EIPS/eip-2612. * * Code adapted from https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2237/ */ interface IERC2612 { /** * @dev Sets `amount` as the allowance of `spender` over `owner`'s tokens, * given `owner`'s signed approval. * * IMPORTANT: The same issues {IERC20-approve} has related to transaction * ordering also apply here. * * Emits an {Approval} event. * * Requirements: * * - `owner` cannot be the zero address. * - `spender` cannot be the zero address. * - `deadline` must be a timestamp in the future. * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner` * over the EIP712-formatted function arguments. * - the signature must use ``owner``'s current nonce (see {nonces}). * * For more information on the signature format, see the * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP * section]. */ function permit(address owner, address spender, uint256 amount, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external; /** * @dev Returns the current ERC2612 nonce for `owner`. This value must be * included whenever a signature is generated for {permit}. * * Every successful call to {permit} increases `owner`'s nonce by one. This * prevents a signature from being used multiple times. * * `owner` can limit the time a Permit is valid for by setting `deadline` to * a value in the near future. The deadline argument can be set to uint(-1) to * create Permits that effectively never expire. */ function nonces(address owner) external view returns (uint256); function version() external view returns (string memory); function permitTypeHash() external view returns (bytes32); function domainSeparator() external view returns (bytes32); }
// SPDX-License-Identifier: MIT pragma solidity 0.6.11; /** * Based on the OpenZeppelin IER20 interface: * https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol * * @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); function increaseAllowance(address spender, uint256 addedValue) external returns (bool); function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool); /** * @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); function name() external view returns (string memory); function symbol() external view returns (string memory); function decimals() external view returns (uint8); /** * @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); }
// SPDX-License-Identifier: MIT pragma solidity 0.6.11; contract BaseMath { uint constant public DECIMAL_PRECISION = 1e18; }
{ "remappings": [], "optimizer": { "enabled": true, "runs": 1000 }, "evmVersion": "istanbul", "libraries": {}, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "abi" ] } } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"_lqtyTokenAddress","type":"address"}],"name":"LQTYTokenAddressSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"_stabilityPoolAddress","type":"address"}],"name":"StabilityPoolAddressSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"_totalLQTYIssued","type":"uint256"}],"name":"TotalLQTYIssuedUpdated","type":"event"},{"inputs":[],"name":"DECIMAL_PRECISION","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ISSUANCE_FACTOR","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"LQTYSupplyCap","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"NAME","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SECONDS_IN_ONE_MINUTE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"deploymentTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isOwner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"issueLQTY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"lqtyToken","outputs":[{"internalType":"contract ILQTYToken","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"},{"internalType":"uint256","name":"_LQTYamount","type":"uint256"}],"name":"sendLQTY","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_lqtyTokenAddress","type":"address"},{"internalType":"address","name":"_stabilityPoolAddress","type":"address"},{"internalType":"uint256","name":"_LQTYSupplyCap","type":"uint256"}],"name":"setAddresses","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stabilityPoolAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalLQTYIssued","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 24 Chains
[ 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.