Comparar texto

Encuentra la diferencia entre dos archivos de texto

Real-time diff

Unified diff

Collapse lines

Highlight change

Syntax highlighting

Herramientas

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

Created 20 days agoDiff never expires

105 lines

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

}

Diffs guardadas

Texto original

Abrir archivo

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);
    }
}

Texto modificado

Abrir archivo

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);
    }
}

Words removed	129
Total words	334
Words removed (%)	38.62

Words added	28
Total words	233
Words added (%)	12.02