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

HOG

Created last yearDiff never expires

224 removals

Lines
Total
Removed

Characters
Total
Removed

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

262 lines

37 additions

Lines
Total
Added

Characters
Total
Added

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

89 lines

contract Tomb is ERC20Burnable, Operator {

contract HOG is ERC20Burnable, Operator {

using SafeMath8 for uint8;

using SafeMath for uint256;

// Initial distribution for the first 24h genesis pools

uint256 public constant INITIAL_DAOFUND_DISTRIBUTION = 1000 ether; // 1000 HOG

uint256 public constant INITIAL_GENESIS_POOL_DISTRIBUTION = 11000 ether;

uint256 public constant GENESIS_DISTRIBUTION = 714000 ether; // 714k HOG for genesis pool

// Initial distribution for the day 2-5 TOMB-WFTM LP -> TOMB pool

uint256 public constant INITIAL_TOMB_POOL_DISTRIBUTION = 140000 ether;

// Distribution for airdrops wallet

uint256 public constant INITIAL_AIRDROP_WALLET_DISTRIBUTION = 9000 ether;

// Have the rewards been distributed to the pools

bool public rewardsDistributed = false;

bool public rewardPoolDistributed = false;

/* ================= Taxation =============== */

// Address of the Oracle

address public tombOracle;

address public hogOracle;

// Address of the Tax Office

address public taxOffice;

// Current tax rate

uint256 public taxRate;

// Price threshold below which taxes will get burned

uint256 public burnThreshold = 1.10e18;

// Address of the tax collector wallet

address public taxCollectorAddress;

// Should the taxes be calculated using the tax tiers

bool public autoCalculateTax;

// Tax Tiers

uint256[] public taxTiersTwaps = [0, 5e17, 6e17, 7e17, 8e17, 9e17, 9.5e17, 1e18, 1.05e18, 1.10e18, 1.20e18, 1.30e18, 1.40e18, 1.50e18];

uint256[] public taxTiersRates = [2000, 1900, 1800, 1700, 1600, 1500, 1500, 1500, 1500, 1400, 900, 400, 200, 100];

// Sender addresses excluded from Tax

mapping(address => bool) public excludedAddresses;

event TaxOfficeTransferred(address oldAddress, address newAddress);

modifier onlyTaxOffice() {

require(taxOffice == msg.sender, "Caller is not the tax office");

}

modifier onlyOperatorOrTaxOffice() {

require(isOperator() || taxOffice == msg.sender, "Caller is not the operator or the tax office");

}

/**

* @notice Constructs the TOMB ERC-20 contract.

* @notice Constructs the HOG ERC-20 contract.

constructor(uint256 _taxRate, address _taxCollectorAddress) public ERC20("TOMB", "TOMB") {

constructor() ERC20("HOG", "HOG") {

// Mints 1 TOMB to contract creator for initial pool setup

// Mints 200 HOG to contract creator for initial pool setup

require(_taxRate < 10000, "tax equal or bigger to 100%");

require(_taxCollectorAddress != address(0), "tax collector address must be non-zero address");

excludeAddress(address(this));

_mint(msg.sender, 1 ether);

taxRate = _taxRate;

taxCollectorAddress = _taxCollectorAddress;

}

/* ============= Taxation ============= */

function getTaxTiersTwapsCount() public view returns (uint256 count) {

return taxTiersTwaps.length;

}

function getTaxTiersRatesCount() public view returns (uint256 count) {

return taxTiersRates.length;

}

function isAddressExcluded(address _address) public view returns (bool) {

return excludedAddresses[_address];

}

function setTaxTiersTwap(uint8 _index, uint256 _value) public onlyTaxOffice returns (bool) {

require(_index >= 0, "Index has to be higher than 0");

require(_index < getTaxTiersTwapsCount(), "Index has to lower than count of tax tiers");

if (_index > 0) {

require(_value > taxTiersTwaps[_index - 1]);

}

if (_index < getTaxTiersTwapsCount().sub(1)) {

require(_value < taxTiersTwaps[_index + 1]);

}

taxTiersTwaps[_index] = _value;

return true;

}

function setTaxTiersRate(uint8 _index, uint256 _value) public onlyTaxOffice returns (bool) {

require(_index >= 0, "Index has to be higher than 0");

require(_index < getTaxTiersRatesCount(), "Index has to lower than count of tax tiers");

taxTiersRates[_index] = _value;

return true;

}

function setBurnThreshold(uint256 _burnThreshold) public onlyTaxOffice returns (bool) {

_mint(msg.sender, 200 ether);

burnThreshold = _burnThreshold;

}

function _getTombPrice() internal view returns (uint256 _tombPrice) {

function _getHogPrice() internal view returns (uint256 _hogPrice) {

try IOracle(tombOracle).consult(address(this), 1e18) returns (uint144 _price) {

try IOracle(hogOracle).consult(address(this), 1e18) returns (uint256 _price) {

return uint256(_price);

} catch {

revert("Tomb: failed to fetch TOMB price from Oracle");

revert("Hog: failed to fetch HOG price from Oracle");

}

function _updateTaxRate(uint256 _tombPrice) internal returns (uint256){

if (autoCalculateTax) {

for (uint8 tierId = uint8(getTaxTiersTwapsCount()).sub(1); tierId >= 0; --tierId) {

if (_tombPrice >= taxTiersTwaps[tierId]) {

require(taxTiersRates[tierId] < 10000, "tax equal or bigger to 100%");

taxRate = taxTiersRates[tierId];

return taxTiersRates[tierId];

}

function enableAutoCalculateTax() public onlyTaxOffice {

function setHogOracle(address _hogOracle) public onlyOperator {

autoCalculateTax = true;

require(_hogOracle != address(0), "oracle address cannot be 0 address");

}

hogOracle = _hogOracle;

function disableAutoCalculateTax() public onlyTaxOffice {

autoCalculateTax = false;

}

function setTombOracle(address _tombOracle) public onlyOperatorOrTaxOffice {

require(_tombOracle != address(0), "oracle address cannot be 0 address");

tombOracle = _tombOracle;

}

function setTaxOffice(address _taxOffice) public onlyOperatorOrTaxOffice {

require(_taxOffice != address(0), "tax office address cannot be 0 address");

emit TaxOfficeTransferred(taxOffice, _taxOffice);

taxOffice = _taxOffice;

}

function setTaxCollectorAddress(address _taxCollectorAddress) public onlyTaxOffice {

require(_taxCollectorAddress != address(0), "tax collector address must be non-zero address");

taxCollectorAddress = _taxCollectorAddress;

}

function setTaxRate(uint256 _taxRate) public onlyTaxOffice {

require(!autoCalculateTax, "auto calculate tax cannot be enabled");

require(_taxRate < 10000, "tax equal or bigger to 100%");

taxRate = _taxRate;

}

function excludeAddress(address _address) public onlyOperatorOrTaxOffice returns (bool) {

require(!excludedAddresses[_address], "address can't be excluded");

excludedAddresses[_address] = true;

return true;

}

function includeAddress(address _address) public onlyOperatorOrTaxOffice returns (bool) {

require(excludedAddresses[_address], "address can't be included");

excludedAddresses[_address] = false;

return true;

}

/**

* @notice Operator mints TOMB to a recipient

* @notice Operator mints HOG to a recipient

* @param recipient_ The address of recipient

* @param amount_ The amount of TOMB to mint to

* @param amount_ The amount of HOG to mint to

* @return whether the process has been done

function mint(address recipient_, uint256 amount_) public onlyOperator returns (bool) {

uint256 balanceBefore = balanceOf(recipient_);

_mint(recipient_, amount_);

uint256 balanceAfter = balanceOf(recipient_);

return balanceAfter > balanceBefore;

}

function burn(uint256 amount) public override {

super.burn(amount);

}

function burnFrom(address account, uint256 amount) public override onlyOperator {

super.burnFrom(account, amount);

}

function transferFrom(

address sender,

address recipient,

uint256 amount

) public override returns (bool) {

uint256 currentTaxRate = 0;

_transfer(sender, recipient, amount);

bool burnTax = false;

if (autoCalculateTax) {

uint256 currentTombPrice = _getTombPrice();

currentTaxRate = _updateTaxRate(currentTombPrice);

if (currentTombPrice < burnThreshold) {

burnTax = true;

}

if (currentTaxRate == 0 || excludedAddresses[sender]) {

_transfer(sender, recipient, amount);

} else {

_transferWithTax(sender, recipient, amount, burnTax);

}

_approve(sender, _msgSender(), allowance(sender, _msgSender()).sub(amount, "ERC20: transfer amount exceeds allowance"));

return true;

}

function _transferWithTax(

address sender,

address recipient,

uint256 amount,

bool burnTax

) internal returns (bool) {

uint256 taxAmount = amount.mul(taxRate).div(10000);

uint256 amountAfterTax = amount.sub(taxAmount);

if(burnTax) {

// Burn tax

super.burnFrom(sender, taxAmount);

} else {

// Transfer tax to tax collector

_transfer(sender, taxCollectorAddress, taxAmount);

}

// Transfer amount after tax to recipient

_transfer(sender, recipient, amountAfterTax);

return true;

}

/**

* @notice distribute to reward pool (only once)

function distributeReward(

address _genesisPool,

address _daoFund,

address _tombPool,

address _genesis

address _airdropWallet

) external onlyOperator {

require(!rewardPoolDistributed, "only can distribute once");

require(_daoFund != address(0), "!_treasury");

require(_genesisPool != address(0), "!_genesisPool");

require(_genesis != address(0), "!_genesis");

require(_tombPool != address(0), "!_tombPool");

require(!rewardsDistributed, "only can distribute once");

require(_airdropWallet != address(0), "!_airdropWallet");

rewardsDistributed = true;

rewardPoolDistributed = true;

_mint(_daoFund, INITIAL_DAOFUND_DISTRIBUTION);

_mint(_genesisPool, INITIAL_GENESIS_POOL_DISTRIBUTION);

_mint(_genesis, GENESIS_DISTRIBUTION);

_mint(_tombPool, INITIAL_TOMB_POOL_DISTRIBUTION);

_mint(_airdropWallet, INITIAL_AIRDROP_WALLET_DISTRIBUTION);

}

function governanceRecoverUnsupported(

IERC20 _token,

uint256 _amount,

address _to

) external onlyOperator {

_token.transfer(_to, _amount);

}

Saved diffs

Original text

Open file

contract Tomb is ERC20Burnable, Operator {
    using SafeMath8 for uint8;
    using SafeMath for uint256;

// Initial distribution for the first 24h genesis pools
    uint256 public constant INITIAL_GENESIS_POOL_DISTRIBUTION = 11000 ether;
    // Initial distribution for the day 2-5 TOMB-WFTM LP -> TOMB pool
    uint256 public constant INITIAL_TOMB_POOL_DISTRIBUTION = 140000 ether;
    // Distribution for airdrops wallet
    uint256 public constant INITIAL_AIRDROP_WALLET_DISTRIBUTION = 9000 ether;

// Have the rewards been distributed to the pools
    bool public rewardPoolDistributed = false;

/* ================= Taxation =============== */
    // Address of the Oracle
    address public tombOracle;
    // Address of the Tax Office
    address public taxOffice;

// Current tax rate
    uint256 public taxRate;
    // Price threshold below which taxes will get burned
    uint256 public burnThreshold = 1.10e18;
    // Address of the tax collector wallet
    address public taxCollectorAddress;

// Should the taxes be calculated using the tax tiers
    bool public autoCalculateTax;

// Tax Tiers
    uint256[] public taxTiersTwaps = [0, 5e17, 6e17, 7e17, 8e17, 9e17, 9.5e17, 1e18, 1.05e18, 1.10e18, 1.20e18, 1.30e18, 1.40e18, 1.50e18];
    uint256[] public taxTiersRates = [2000, 1900, 1800, 1700, 1600, 1500, 1500, 1500, 1500, 1400, 900, 400, 200, 100];

// Sender addresses excluded from Tax
    mapping(address => bool) public excludedAddresses;

event TaxOfficeTransferred(address oldAddress, address newAddress);

modifier onlyTaxOffice() {
        require(taxOffice == msg.sender, "Caller is not the tax office");
        _;
    }

modifier onlyOperatorOrTaxOffice() {
        require(isOperator() || taxOffice == msg.sender, "Caller is not the operator or the tax office");
        _;
    }

/**
     * @notice Constructs the TOMB ERC-20 contract.
     */
    constructor(uint256 _taxRate, address _taxCollectorAddress) public ERC20("TOMB", "TOMB") {
        // Mints 1 TOMB to contract creator for initial pool setup
        require(_taxRate < 10000, "tax equal or bigger to 100%");
        require(_taxCollectorAddress != address(0), "tax collector address must be non-zero address");

excludeAddress(address(this));

_mint(msg.sender, 1 ether);
        taxRate = _taxRate;
        taxCollectorAddress = _taxCollectorAddress;
    }

/* ============= Taxation ============= */

function getTaxTiersTwapsCount() public view returns (uint256 count) {
        return taxTiersTwaps.length;
    }

function getTaxTiersRatesCount() public view returns (uint256 count) {
        return taxTiersRates.length;
    }

function isAddressExcluded(address _address) public view returns (bool) {
        return excludedAddresses[_address];
    }

function setTaxTiersRate(uint8 _index, uint256 _value) public onlyTaxOffice returns (bool) {
        require(_index >= 0, "Index has to be higher than 0");
        require(_index < getTaxTiersRatesCount(), "Index has to lower than count of tax tiers");
        taxTiersRates[_index] = _value;
        return true;
    }

function setBurnThreshold(uint256 _burnThreshold) public onlyTaxOffice returns (bool) {
        burnThreshold = _burnThreshold;
    }

function _getTombPrice() internal view returns (uint256 _tombPrice) {
        try IOracle(tombOracle).consult(address(this), 1e18) returns (uint144 _price) {
            return uint256(_price);
        } catch {
            revert("Tomb: failed to fetch TOMB price from Oracle");
        }
    }

function enableAutoCalculateTax() public onlyTaxOffice {
        autoCalculateTax = true;
    }

function disableAutoCalculateTax() public onlyTaxOffice {
        autoCalculateTax = false;
    }

function setTombOracle(address _tombOracle) public onlyOperatorOrTaxOffice {
        require(_tombOracle != address(0), "oracle address cannot be 0 address");
        tombOracle = _tombOracle;
    }

function setTaxOffice(address _taxOffice) public onlyOperatorOrTaxOffice {
        require(_taxOffice != address(0), "tax office address cannot be 0 address");
        emit TaxOfficeTransferred(taxOffice, _taxOffice);
        taxOffice = _taxOffice;
    }

function setTaxCollectorAddress(address _taxCollectorAddress) public onlyTaxOffice {
        require(_taxCollectorAddress != address(0), "tax collector address must be non-zero address");
        taxCollectorAddress = _taxCollectorAddress;
    }

function setTaxRate(uint256 _taxRate) public onlyTaxOffice {
        require(!autoCalculateTax, "auto calculate tax cannot be enabled");
        require(_taxRate < 10000, "tax equal or bigger to 100%");
        taxRate = _taxRate;
    }

function excludeAddress(address _address) public onlyOperatorOrTaxOffice returns (bool) {
        require(!excludedAddresses[_address], "address can't be excluded");
        excludedAddresses[_address] = true;
        return true;
    }

function includeAddress(address _address) public onlyOperatorOrTaxOffice returns (bool) {
        require(excludedAddresses[_address], "address can't be included");
        excludedAddresses[_address] = false;
        return true;
    }

/**
     * @notice Operator mints TOMB to a recipient
     * @param recipient_ The address of recipient
     * @param amount_ The amount of TOMB to mint to
     * @return whether the process has been done
     */
    function mint(address recipient_, uint256 amount_) public onlyOperator returns (bool) {
        uint256 balanceBefore = balanceOf(recipient_);
        _mint(recipient_, amount_);
        uint256 balanceAfter = balanceOf(recipient_);

return balanceAfter > balanceBefore;
    }

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

function burnFrom(address account, uint256 amount) public override onlyOperator {
        super.burnFrom(account, amount);
    }

function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public override returns (bool) {
        uint256 currentTaxRate = 0;
        bool burnTax = false;

if (autoCalculateTax) {
            uint256 currentTombPrice = _getTombPrice();
            currentTaxRate = _updateTaxRate(currentTombPrice);
            if (currentTombPrice < burnThreshold) {
                burnTax = true;
            }
        }

if (currentTaxRate == 0 || excludedAddresses[sender]) {
            _transfer(sender, recipient, amount);
        } else {
            _transferWithTax(sender, recipient, amount, burnTax);
        }

_approve(sender, _msgSender(), allowance(sender, _msgSender()).sub(amount, "ERC20: transfer amount exceeds allowance"));
        return true;
    }

function _transferWithTax(
        address sender,
        address recipient,
        uint256 amount,
        bool burnTax
    ) internal returns (bool) {
        uint256 taxAmount = amount.mul(taxRate).div(10000);
        uint256 amountAfterTax = amount.sub(taxAmount);

if(burnTax) {
            // Burn tax
            super.burnFrom(sender, taxAmount);
        } else {
            // Transfer tax to tax collector
            _transfer(sender, taxCollectorAddress, taxAmount);
        }

// Transfer amount after tax to recipient
        _transfer(sender, recipient, amountAfterTax);

return true;
    }

/**
     * @notice distribute to reward pool (only once)
     */
    function distributeReward(
        address _genesisPool,
        address _tombPool,
        address _airdropWallet
    ) external onlyOperator {
        require(!rewardPoolDistributed, "only can distribute once");
        require(_genesisPool != address(0), "!_genesisPool");
        require(_tombPool != address(0), "!_tombPool");
        require(_airdropWallet != address(0), "!_airdropWallet");
        rewardPoolDistributed = true;
        _mint(_genesisPool, INITIAL_GENESIS_POOL_DISTRIBUTION);
        _mint(_tombPool, INITIAL_TOMB_POOL_DISTRIBUTION);
        _mint(_airdropWallet, INITIAL_AIRDROP_WALLET_DISTRIBUTION);
    }

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

Changed text

Open file

contract HOG is ERC20Burnable, Operator {
    using SafeMath8 for uint8;
    using SafeMath for uint256;

uint256 public constant INITIAL_DAOFUND_DISTRIBUTION = 1000 ether; // 1000 HOG
    uint256 public constant GENESIS_DISTRIBUTION = 714000 ether; // 714k HOG for genesis pool

bool public rewardsDistributed = false;

// Address of the Oracle
    address public hogOracle;

/**
     * @notice Constructs the HOG ERC-20 contract.
     */
    constructor() ERC20("HOG", "HOG") {
        // Mints 200 HOG to contract creator for initial pool setup

_mint(msg.sender, 200 ether);
    }

function _getHogPrice() internal view returns (uint256 _hogPrice) {
        try IOracle(hogOracle).consult(address(this), 1e18) returns (uint256 _price) {
            return uint256(_price);
        } catch {
            revert("Hog: failed to fetch HOG price from Oracle");
        }
    }

function setHogOracle(address _hogOracle) public onlyOperator {
        require(_hogOracle != address(0), "oracle address cannot be 0 address");
        hogOracle = _hogOracle;
    }

/**
     * @notice Operator mints HOG to a recipient
     * @param recipient_ The address of recipient
     * @param amount_ The amount of HOG to mint to
     * @return whether the process has been done
     */
    function mint(address recipient_, uint256 amount_) public onlyOperator returns (bool) {
        uint256 balanceBefore = balanceOf(recipient_);
        _mint(recipient_, amount_);
        uint256 balanceAfter = balanceOf(recipient_);

return balanceAfter > balanceBefore;
    }

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

function burnFrom(address account, uint256 amount) public override onlyOperator {
        super.burnFrom(account, amount);
    }

function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public override returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(sender, _msgSender(), allowance(sender, _msgSender()).sub(amount, "ERC20: transfer amount exceeds allowance"));
        return true;
    }

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

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