Compare text

Find the difference between two text files

Real-time editor

Hide unchanged lines

Disable line wrap

Layout

Diff precision

Syntax highlighting

Diffchecker Desktop The most secure way to run Diffchecker. Get the Diffchecker Desktop app: your diffs never leave your computer!Get Desktop

Created last yearDiff never expires

51 removals

Lines
Total
Removed

Characters
Total
Removed

To continue using this feature, upgrade to Diffchecker Pro View Pricing

105 lines

21 additions

Lines
Total
Added

Characters
Total
Added

To continue using this feature, upgrade to Diffchecker Pro View Pricing

79 lines

contract TShare is ERC20Burnable, Operator {

contract GHOG is ERC20Burnable, Operator {

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 endTime;

uint256 public communityFundRewardRate;

uint256 public devFundRewardRate;

address public communityFund;

address public devFund;

uint256 public communityFundLastClaimed;

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;

endTime = startTime + VESTING_DURATION;

communityFundLastClaimed = startTime;

devFundLastClaimed = startTime;

communityFundRewardRate = COMMUNITY_FUND_POOL_ALLOCATION.div(VESTING_DURATION);

devFundRewardRate = DEV_FUND_POOL_ALLOCATION.div(VESTING_DURATION);

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

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 {

require(msg.sender == devFund, "!dev");

require(_devFund != address(0), "zero");

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) {

uint256 _now = block.timestamp;

if (_now > endTime) _now = endTime;

if (devFundLastClaimed >= _now) return 0;

_pending = _now.sub(devFundLastClaimed).mul(devFundRewardRate);

}

/**

* @dev Claim pending rewards to community and dev fund

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)) {

_mint(devFund, _pending);

devFundLastClaimed = block.timestamp;

}

/**

* @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 {

super.burn(amount);

}

function governanceRecoverUnsupported(

IERC20 _token,

uint256 _amount,

address _to

) external onlyOperator {

_token.transfer(_to, _amount);

}

Saved diffs

Original text

Open file

contract TShare is ERC20Burnable, Operator {
    using SafeMath for uint256;

// TOTAL MAX SUPPLY = 70,000 tSHAREs
    uint256 public constant FARMING_POOL_REWARD_ALLOCATION = 59500 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;
    uint256 public startTime;
    uint256 public endTime;

uint256 public communityFundRewardRate;
    uint256 public devFundRewardRate;

address public communityFund;
    address public devFund;

uint256 public communityFundLastClaimed;
    uint256 public devFundLastClaimed;

bool public rewardPoolDistributed = false;

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;
        endTime = startTime + VESTING_DURATION;

communityFundLastClaimed = startTime;
        devFundLastClaimed = startTime;

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

require(_devFund != address(0), "Address cannot be 0");
        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 {
        require(msg.sender == devFund, "!dev");
        require(_devFund != address(0), "zero");
        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) {
        uint256 _now = block.timestamp;
        if (_now > endTime) _now = endTime;
        if (devFundLastClaimed >= _now) return 0;
        _pending = _now.sub(devFundLastClaimed).mul(devFundRewardRate);
    }

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

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

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

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

Changed text

Open file

contract GHOG is ERC20Burnable, Operator {
    using SafeMath for uint256;

uint256 public constant REWARD_POOL_ALLOCATION = 60000 ether;
    uint256 public constant DEV_FUND_POOL_ALLOCATION = 10000 ether;

bool public rewardsDistributed = false;

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

uint256 public devFundRewardRate;
    address public devFund;
    uint256 public devFundLastClaimed;

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

startTime = _startTime;
        endTime = startTime + VESTING_DURATION;

devFundLastClaimed = startTime;

devFundRewardRate = DEV_FUND_POOL_ALLOCATION.div(VESTING_DURATION);

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

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

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

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

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

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