Texte vergleichen

Finde den Unterschied zwischen zwei Textdateien

Live-Editor
Gleiches ausblenden
Zeilenumbruch aus
Ansicht
Vergleichsgenauigkeit
Syntaxhervorhebung

SHARE

Erstellt Diff läuft nie ab
51 Entfernungen
105 Zeilen
21 Hinzufügungen
79 Zeilen
contract TShare is ERC20Burnable, Operator {
contract GHOG is ERC20Burnable, Operator {
using SafeMath for uint256;
using SafeMath for uint256;


// TOTAL MAX SUPPLY = 70,000 tSHAREs
uint256 public constant REWARD_POOL_ALLOCATION = 60000 ether;
uint256 public constant FARMING_POOL_REWARD_ALLOCATION = 59500 ether;
uint256 public constant DEV_FUND_POOL_ALLOCATION = 10000 ether;
uint256 public constant COMMUNITY_FUND_POOL_ALLOCATION = 5500 ether;
uint256 public constant DEV_FUND_POOL_ALLOCATION = 5000 ether;


uint256 public constant VESTING_DURATION = 365 days;
bool public rewardsDistributed = false;

uint256 public constant VESTING_DURATION = 370 days;
uint256 public startTime;
uint256 public startTime;
uint256 public endTime;
uint256 public endTime;


uint256 public communityFundRewardRate;
uint256 public devFundRewardRate;
uint256 public devFundRewardRate;

address public communityFund;
address public devFund;
address public devFund;

uint256 public communityFundLastClaimed;
uint256 public devFundLastClaimed;
uint256 public devFundLastClaimed;


bool public rewardPoolDistributed = false;
constructor(uint256 _startTime, address _devFund) ERC20("GHOG", "GHOG") {

_mint(msg.sender, 10 ether); // mint 10 GHOG for initial pools deployment
constructor(uint256 _startTime, address _communityFund, address _devFund) public ERC20("TSHARE", "TSHARE") {
_mint(msg.sender, 1 ether); // mint 1 TOMB Share for initial pools deployment


startTime = _startTime;
startTime = _startTime;
endTime = startTime + VESTING_DURATION;
endTime = startTime + VESTING_DURATION;


communityFundLastClaimed = startTime;
devFundLastClaimed = startTime;
devFundLastClaimed = startTime;


communityFundRewardRate = COMMUNITY_FUND_POOL_ALLOCATION.div(VESTING_DURATION);
devFundRewardRate = DEV_FUND_POOL_ALLOCATION.div(VESTING_DURATION);
devFundRewardRate = DEV_FUND_POOL_ALLOCATION.div(VESTING_DURATION);


require(_devFund != address(0), "Address cannot be 0");
require(_devFund != address(0), "Address cannot be 0");
devFund = _devFund;
devFund = _devFund;

require(_communityFund != address(0), "Address cannot be 0");
communityFund = _communityFund;
}

function setTreasuryFund(address _communityFund) external {
require(msg.sender == devFund, "!dev");
communityFund = _communityFund;
}
}


function setDevFund(address _devFund) external {
function setDevFund(address _devFund) external {
require(msg.sender == devFund, "!dev");
require(msg.sender == devFund, "!dev");
require(_devFund != address(0), "zero");
require(_devFund != address(0), "zero");
devFund = _devFund;
devFund = _devFund;
}
}


function unclaimedTreasuryFund() public view returns (uint256 _pending) {
uint256 _now = block.timestamp;
if (_now > endTime) _now = endTime;
if (communityFundLastClaimed >= _now) return 0;
_pending = _now.sub(communityFundLastClaimed).mul(communityFundRewardRate);
}

function unclaimedDevFund() public view returns (uint256 _pending) {
function unclaimedDevFund() public view returns (uint256 _pending) {
uint256 _now = block.timestamp;
uint256 _now = block.timestamp;
if (_now > endTime) _now = endTime;
if (_now > endTime) _now = endTime;
if (devFundLastClaimed >= _now) return 0;
if (devFundLastClaimed >= _now) return 0;
_pending = _now.sub(devFundLastClaimed).mul(devFundRewardRate);
_pending = _now.sub(devFundLastClaimed).mul(devFundRewardRate);
}
}


/**
/**
* @dev Claim pending rewards to community and dev fund
* @dev Claim pending rewards to community and dev fund
*/
*/
function claimRewards() external {
function claimRewards() external {
uint256 _pending = unclaimedTreasuryFund();
uint256 _pending = unclaimedDevFund();
if (_pending > 0 && communityFund != address(0)) {
_mint(communityFund, _pending);
communityFundLastClaimed = block.timestamp;
}
_pending = unclaimedDevFund();
if (_pending > 0 && devFund != address(0)) {
if (_pending > 0 && devFund != address(0)) {
_mint(devFund, _pending);
_mint(devFund, _pending);
devFundLastClaimed = block.timestamp;
devFundLastClaimed = block.timestamp;
}
}
}
}


/**
/**
* @notice distribute to reward pool (only once)
* @notice distribute to reward pool (only once)
*/
*/
function distributeReward(address _farmingIncentiveFund) external onlyOperator {
function distributeReward(
require(!rewardPoolDistributed, "only can distribute once");
address _rewardPool
require(_farmingIncentiveFund != address(0), "!_farmingIncentiveFund");
) external onlyOperator {
rewardPoolDistributed = true;
require(_rewardPool != address(0), "!_rewardPool");
_mint(_farmingIncentiveFund, FARMING_POOL_REWARD_ALLOCATION);
require(!rewardsDistributed, "only can distribute once");
rewardsDistributed = true;
_mint(_rewardPool, REWARD_POOL_ALLOCATION);
}
}


function burn(uint256 amount) public override {
function burn(uint256 amount) public override {
super.burn(amount);
super.burn(amount);
}
}


function governanceRecoverUnsupported(
function governanceRecoverUnsupported(
IERC20 _token,
IERC20 _token,
uint256 _amount,
uint256 _amount,
address _to
address _to
) external onlyOperator {
) external onlyOperator {
_token.transfer(_to, _amount);
_token.transfer(_to, _amount);
}
}
}
}

Gespeicherte Diffs