Comparar texto

Encontre a diferença entre dois arquivos de texto

Real-time diff

Unified diff

Collapse lines

Highlight change

Syntax highlighting

Ferramentas

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

Untitled diff

Created about a year agoDiff never expires

235 lines

// SPDX-License-Identifier: Unlicensed

pragma solidity ^0.8.20;

import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

import {MerkleProof} from "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";

import {IRouter} from "./interfaces/IRouter.sol";

contract MEOWMiner {

contract CoqInuMiner {

using SafeERC20 for IERC20;

uint256 public EGGS_TO_HATCH_1MINERS = 864000;

uint256 PSN = 10000;

uint256 PSNH = 5000;

bool public initialized = false;

IERC20 public MEOW;

IERC20 public COQ;

IRouter public ROUTER;

bytes32 public merkleRoot;

address public treasuryAddress;

address public owner;

mapping(address => uint256) public hatcheryMiners;

mapping(address => uint256) public claimedEggs;

mapping(address => uint256) public lastHatch;

mapping(address => uint256) public lastWithdraw;

mapping(address => address) public referrals;

uint256 constant HATCH_STEP = 1 days;

uint256 constant HATCH_STEP_MODIFIER = 0.1e18;

uint256 constant BASE_PERCENTAGE = 0.5e18;

uint256 public marketMEOW;

uint256 public marketCoq;

modifier onlyOwner() {

require(msg.sender == owner, "not owner");

}

constructor(address _treasuryAddress, bytes32 _merkleRoot) {

owner = msg.sender;

MEOW = IERC20(0x8aD25B0083C9879942A64f00F20a70D3278f6187);

COQ = IERC20(0x420FcA0121DC28039145009570975747295f2329);

ROUTER = IRouter(0x60aE616a2155Ee3d9A68541Ba4544862310933d4);

treasuryAddress = _treasuryAddress;

merkleRoot = _merkleRoot;

}

function compound(address ref) public {

require(initialized);

if (ref == msg.sender) {

ref = address(0);

}

if (

referrals[msg.sender] == address(0) &&

referrals[msg.sender] != msg.sender

) {

referrals[msg.sender] = ref;

}

uint256 eggsUsed = getMyEggs();

uint256 newMiners = eggsUsed / EGGS_TO_HATCH_1MINERS;

hatcheryMiners[msg.sender] += newMiners;

claimedEggs[msg.sender] = 0;

lastHatch[msg.sender] = block.timestamp;

//send referral eggs

claimedEggs[referrals[msg.sender]] += eggsUsed / 10;

//boost market to nerf miners hoarding

marketMEOW += eggsUsed / 2;

marketCoq += eggsUsed / 2;

}

function withdraw() external {

require(initialized);

uint256 hasEggs = getMyEggs();

require(hasEggs > 0, "no eggs");

uint256 eggValue = calculateEggSell(hasEggs);

uint256 fee = devFee(eggValue);

claimedEggs[msg.sender] = 0;

lastHatch[msg.sender] = block.timestamp;

lastWithdraw[msg.sender] = block.timestamp;

// boost market to nerf miners hoarding

marketMEOW += hasEggs;

marketCoq += hasEggs;

MEOW.safeTransfer(treasuryAddress, fee);

COQ.safeTransfer(treasuryAddress, fee);

MEOW.safeTransfer(msg.sender, eggValue - fee);

COQ.safeTransfer(msg.sender, eggValue - fee);

}

function depositAvax(uint minAmount, address ref) external payable {

require(initialized, "not initialized");

require(msg.value > 0, "invalid amount");

uint amount = _swap(minAmount);

_deposit(amount, ref, false);

}

function depositMEOW(uint amount, address ref) external {

function depositCoq(uint amount, address ref) external {

require(initialized, "not initialized");

require(amount > 0, "invalid amount");

MEOW.safeTransferFrom(msg.sender, address(this), amount);

COQ.safeTransferFrom(msg.sender, address(this), amount);

_deposit(amount, ref, false);

}

function depositMEOWWithProof(

function depositCoqWithProof(

uint amount,

address ref,

bytes32[] memory proof

) external {

require(initialized, "not initialized");

require(amount > 0, "invalid amount");

bytes32 leaf = keccak256(abi.encodePacked(msg.sender));

require(MerkleProof.verify(proof, merkleRoot, leaf), "invalid proof");

MEOW.safeTransferFrom(msg.sender, address(this), amount);

COQ.safeTransferFrom(msg.sender, address(this), amount);

_deposit(amount, ref, true); // is an holder

}

function _deposit(uint amount, address ref, bool holder) internal {

uint256 eggsBought = calculateEggBuy(amount, getBalance() - amount);

if (holder) {

eggsBought += (eggsBought * 2) / 100; // 2% boost reward

}

eggsBought -= devFee(eggsBought);

uint256 fee = devFee(amount);

MEOW.safeTransfer(treasuryAddress, fee);

COQ.safeTransfer(treasuryAddress, fee);

claimedEggs[msg.sender] += eggsBought;

compound(ref);

}

function _swap(uint minTokenOut) internal returns (uint) {

uint initialBalance = getBalance();

address[] memory path = new address[](2);

path[0] = ROUTER.WAVAX();

path[1] = address(MEOW);

path[1] = address(COQ);

ROUTER.swapExactAVAXForTokens{value: msg.value}(

minTokenOut,

path,

address(this),

block.timestamp

);

return getBalance() - initialBalance;

}

//magic trade balancing algorithm

function calculateTrade(

uint256 rt,

uint256 rs,

uint256 bs

) public view returns (uint256) {

return (PSN * bs) / (PSNH + ((PSN * rs + PSNH * rt) / rt));

}

function calculateEggSell(uint256 eggs) public view returns (uint256) {

if (eggs == 0) return 0;

return calculateTrade(eggs, marketMEOW, getBalance());

return calculateTrade(eggs, marketCoq, getBalance());

}

function calculateEggBuy(

uint256 eth,

uint256 contractBalance

) public view returns (uint256) {

return calculateTrade(eth, contractBalance, marketMEOW);

return calculateTrade(eth, contractBalance, marketCoq);

}

function calculateEggBuySimple(uint256 eth) public view returns (uint256) {

return calculateEggBuy(eth, getBalance());

}

function devFee(uint256 amount) public pure returns (uint256) {

return (amount * 5) / 100;

}

function seedMarket() public payable onlyOwner {

require(marketMEOW == 0);

require(marketCoq == 0);

initialized = true;

marketMEOW = 86400000000;

marketCoq = 86400000000;

}

function getBalance() public view returns (uint256) {

return MEOW.balanceOf(address(this));

return COQ.balanceOf(address(this));

}

function getMyMiners() public view returns (uint256) {

return hatcheryMiners[msg.sender];

}

function getMyEggs() public view returns (uint256) {

return claimedEggs[msg.sender] + getEggsSinceLastHatch(msg.sender);

}

function getEggsSinceLastHatch(address adr) public view returns (uint256) {

uint256 steps = (block.timestamp - lastWithdraw[msg.sender]) /

HATCH_STEP;

// the percentage is capped at 100%

// it takes 1 day to reach 100% after a withdrawal

uint256 percentage = min(

1e18,

BASE_PERCENTAGE + steps * HATCH_STEP_MODIFIER

);

uint256 secondsPassed = min(

EGGS_TO_HATCH_1MINERS,

block.timestamp - lastHatch[adr]

);

return ((secondsPassed * hatcheryMiners[adr]) * percentage) / 1e18;

}

function getHalvingPercentage() public view returns (uint256) {

uint256 steps = (block.timestamp - lastWithdraw[msg.sender]) /

HATCH_STEP;

return min(1e18, BASE_PERCENTAGE + steps * HATCH_STEP_MODIFIER);

}

function min(uint256 a, uint256 b) private pure returns (uint256) {

return a < b ? a : b;

}

Diffs salvos

Texto original

Abrir arquivo

// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.20;

import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {MerkleProof} from "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import {IRouter} from "./interfaces/IRouter.sol";

contract MEOWMiner {
    using SafeERC20 for IERC20;

uint256 public EGGS_TO_HATCH_1MINERS = 864000;
    uint256 PSN = 10000;
    uint256 PSNH = 5000;
    bool public initialized = false;

IERC20 public MEOW;
    IRouter public ROUTER;
    bytes32 public merkleRoot;

address public treasuryAddress;
    address public owner;

mapping(address => uint256) public hatcheryMiners;
    mapping(address => uint256) public claimedEggs;
    mapping(address => uint256) public lastHatch;
    mapping(address => uint256) public lastWithdraw;
    mapping(address => address) public referrals;

uint256 constant HATCH_STEP = 1 days;
    uint256 constant HATCH_STEP_MODIFIER = 0.1e18;
    uint256 constant BASE_PERCENTAGE = 0.5e18;

uint256 public marketMEOW;

modifier onlyOwner() {
        require(msg.sender == owner, "not owner");
        _;
    }

constructor(address _treasuryAddress, bytes32 _merkleRoot) {
        owner = msg.sender;

MEOW = IERC20(0x8aD25B0083C9879942A64f00F20a70D3278f6187);
        ROUTER = IRouter(0x60aE616a2155Ee3d9A68541Ba4544862310933d4);

treasuryAddress = _treasuryAddress;
        merkleRoot = _merkleRoot;
    }

function compound(address ref) public {
        require(initialized);
        if (ref == msg.sender) {
            ref = address(0);
        }
        if (
            referrals[msg.sender] == address(0) &&
            referrals[msg.sender] != msg.sender
        ) {
            referrals[msg.sender] = ref;
        }
        uint256 eggsUsed = getMyEggs();

uint256 newMiners = eggsUsed / EGGS_TO_HATCH_1MINERS;
        hatcheryMiners[msg.sender] += newMiners;
        claimedEggs[msg.sender] = 0;
        lastHatch[msg.sender] = block.timestamp;

//send referral eggs
        claimedEggs[referrals[msg.sender]] += eggsUsed / 10;

//boost market to nerf miners hoarding
        marketMEOW += eggsUsed / 2;
    }

function withdraw() external {
        require(initialized);
        uint256 hasEggs = getMyEggs();

require(hasEggs > 0, "no eggs");
        uint256 eggValue = calculateEggSell(hasEggs);
        uint256 fee = devFee(eggValue);

claimedEggs[msg.sender] = 0;
        lastHatch[msg.sender] = block.timestamp;
        lastWithdraw[msg.sender] = block.timestamp;

// boost market to nerf miners hoarding
        marketMEOW += hasEggs;

MEOW.safeTransfer(treasuryAddress, fee);
        MEOW.safeTransfer(msg.sender, eggValue - fee);
    }

function depositAvax(uint minAmount, address ref) external payable {
        require(initialized, "not initialized");
        require(msg.value > 0, "invalid amount");

uint amount = _swap(minAmount);
        _deposit(amount, ref, false);
    }

function depositMEOW(uint amount, address ref) external {
        require(initialized, "not initialized");
        require(amount > 0, "invalid amount");

MEOW.safeTransferFrom(msg.sender, address(this), amount);
        _deposit(amount, ref, false);
    }

function depositMEOWWithProof(
        uint amount,
        address ref,
        bytes32[] memory proof
    ) external {
        require(initialized, "not initialized");
        require(amount > 0, "invalid amount");

bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
        require(MerkleProof.verify(proof, merkleRoot, leaf), "invalid proof");

MEOW.safeTransferFrom(msg.sender, address(this), amount);
        _deposit(amount, ref, true); // is an holder
    }

function _deposit(uint amount, address ref, bool holder) internal {
        uint256 eggsBought = calculateEggBuy(amount, getBalance() - amount);

if (holder) {
            eggsBought += (eggsBought * 2) / 100; // 2% boost reward
        }

eggsBought -= devFee(eggsBought);
        uint256 fee = devFee(amount);

MEOW.safeTransfer(treasuryAddress, fee);

claimedEggs[msg.sender] += eggsBought;
        compound(ref);
    }

function _swap(uint minTokenOut) internal returns (uint) {
        uint initialBalance = getBalance();

address[] memory path = new address[](2);
        path[0] = ROUTER.WAVAX();
        path[1] = address(MEOW);

ROUTER.swapExactAVAXForTokens{value: msg.value}(
            minTokenOut,
            path,
            address(this),
            block.timestamp
        );

return getBalance() - initialBalance;
    }

//magic trade balancing algorithm
    function calculateTrade(
        uint256 rt,
        uint256 rs,
        uint256 bs
    ) public view returns (uint256) {
        return (PSN * bs) / (PSNH + ((PSN * rs + PSNH * rt) / rt));
    }

function calculateEggSell(uint256 eggs) public view returns (uint256) {
        if (eggs == 0) return 0;
        return calculateTrade(eggs, marketMEOW, getBalance());
    }

function calculateEggBuy(
        uint256 eth,
        uint256 contractBalance
    ) public view returns (uint256) {
        return calculateTrade(eth, contractBalance, marketMEOW);
    }

function calculateEggBuySimple(uint256 eth) public view returns (uint256) {
        return calculateEggBuy(eth, getBalance());
    }

function devFee(uint256 amount) public pure returns (uint256) {
        return (amount * 5) / 100;
    }

function seedMarket() public payable onlyOwner {
        require(marketMEOW == 0);
        initialized = true;
        marketMEOW = 86400000000;
    }

function getBalance() public view returns (uint256) {
        return MEOW.balanceOf(address(this));
    }

function getMyMiners() public view returns (uint256) {
        return hatcheryMiners[msg.sender];
    }

function getMyEggs() public view returns (uint256) {
        return claimedEggs[msg.sender] + getEggsSinceLastHatch(msg.sender);
    }

function getEggsSinceLastHatch(address adr) public view returns (uint256) {
        uint256 steps = (block.timestamp - lastWithdraw[msg.sender]) /
            HATCH_STEP;

// the percentage is capped at 100%
        // it takes 1 day to reach 100% after a withdrawal
        uint256 percentage = min(
            1e18,
            BASE_PERCENTAGE + steps * HATCH_STEP_MODIFIER
        );

uint256 secondsPassed = min(
            EGGS_TO_HATCH_1MINERS,
            block.timestamp - lastHatch[adr]
        );
        return ((secondsPassed * hatcheryMiners[adr]) * percentage) / 1e18;
    }

function getHalvingPercentage() public view returns (uint256) {
        uint256 steps = (block.timestamp - lastWithdraw[msg.sender]) /
            HATCH_STEP;

return min(1e18, BASE_PERCENTAGE + steps * HATCH_STEP_MODIFIER);
    }

function min(uint256 a, uint256 b) private pure returns (uint256) {
        return a < b ? a : b;
    }
}

Texto alterado

Abrir arquivo

// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.20;

contract CoqInuMiner {
    using SafeERC20 for IERC20;

uint256 public EGGS_TO_HATCH_1MINERS = 864000;
    uint256 PSN = 10000;
    uint256 PSNH = 5000;
    bool public initialized = false;

IERC20 public COQ;
    IRouter public ROUTER;
    bytes32 public merkleRoot;

address public treasuryAddress;
    address public owner;

uint256 constant HATCH_STEP = 1 days;
    uint256 constant HATCH_STEP_MODIFIER = 0.1e18;
    uint256 constant BASE_PERCENTAGE = 0.5e18;

uint256 public marketCoq;

modifier onlyOwner() {
        require(msg.sender == owner, "not owner");
        _;
    }

constructor(address _treasuryAddress, bytes32 _merkleRoot) {
        owner = msg.sender;

COQ = IERC20(0x420FcA0121DC28039145009570975747295f2329);
        ROUTER = IRouter(0x60aE616a2155Ee3d9A68541Ba4544862310933d4);

treasuryAddress = _treasuryAddress;
        merkleRoot = _merkleRoot;
    }

uint256 newMiners = eggsUsed / EGGS_TO_HATCH_1MINERS;
        hatcheryMiners[msg.sender] += newMiners;
        claimedEggs[msg.sender] = 0;
        lastHatch[msg.sender] = block.timestamp;

//send referral eggs
        claimedEggs[referrals[msg.sender]] += eggsUsed / 10;

//boost market to nerf miners hoarding
        marketCoq += eggsUsed / 2;
    }

function withdraw() external {
        require(initialized);
        uint256 hasEggs = getMyEggs();

require(hasEggs > 0, "no eggs");
        uint256 eggValue = calculateEggSell(hasEggs);
        uint256 fee = devFee(eggValue);

claimedEggs[msg.sender] = 0;
        lastHatch[msg.sender] = block.timestamp;
        lastWithdraw[msg.sender] = block.timestamp;

// boost market to nerf miners hoarding
        marketCoq += hasEggs;

COQ.safeTransfer(treasuryAddress, fee);
        COQ.safeTransfer(msg.sender, eggValue - fee);
    }

function depositAvax(uint minAmount, address ref) external payable {
        require(initialized, "not initialized");
        require(msg.value > 0, "invalid amount");

uint amount = _swap(minAmount);
        _deposit(amount, ref, false);
    }

function depositCoq(uint amount, address ref) external {
        require(initialized, "not initialized");
        require(amount > 0, "invalid amount");

COQ.safeTransferFrom(msg.sender, address(this), amount);
        _deposit(amount, ref, false);
    }

function depositCoqWithProof(
        uint amount,
        address ref,
        bytes32[] memory proof
    ) external {
        require(initialized, "not initialized");
        require(amount > 0, "invalid amount");

bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
        require(MerkleProof.verify(proof, merkleRoot, leaf), "invalid proof");

COQ.safeTransferFrom(msg.sender, address(this), amount);
        _deposit(amount, ref, true); // is an holder
    }

function _deposit(uint amount, address ref, bool holder) internal {
        uint256 eggsBought = calculateEggBuy(amount, getBalance() - amount);

if (holder) {
            eggsBought += (eggsBought * 2) / 100; // 2% boost reward
        }

eggsBought -= devFee(eggsBought);
        uint256 fee = devFee(amount);

COQ.safeTransfer(treasuryAddress, fee);

claimedEggs[msg.sender] += eggsBought;
        compound(ref);
    }

function _swap(uint minTokenOut) internal returns (uint) {
        uint initialBalance = getBalance();

address[] memory path = new address[](2);
        path[0] = ROUTER.WAVAX();
        path[1] = address(COQ);

ROUTER.swapExactAVAXForTokens{value: msg.value}(
            minTokenOut,
            path,
            address(this),
            block.timestamp
        );

return getBalance() - initialBalance;
    }

function calculateEggSell(uint256 eggs) public view returns (uint256) {
        if (eggs == 0) return 0;
        return calculateTrade(eggs, marketCoq, getBalance());
    }

function calculateEggBuy(
        uint256 eth,
        uint256 contractBalance
    ) public view returns (uint256) {
        return calculateTrade(eth, contractBalance, marketCoq);
    }

function calculateEggBuySimple(uint256 eth) public view returns (uint256) {
        return calculateEggBuy(eth, getBalance());
    }

function devFee(uint256 amount) public pure returns (uint256) {
        return (amount * 5) / 100;
    }

function seedMarket() public payable onlyOwner {
        require(marketCoq == 0);
        initialized = true;
        marketCoq = 86400000000;
    }

function getBalance() public view returns (uint256) {
        return COQ.balanceOf(address(this));
    }

function getMyMiners() public view returns (uint256) {
        return hatcheryMiners[msg.sender];
    }

function getMyEggs() public view returns (uint256) {
        return claimedEggs[msg.sender] + getEggsSinceLastHatch(msg.sender);
    }

function getEggsSinceLastHatch(address adr) public view returns (uint256) {
        uint256 steps = (block.timestamp - lastWithdraw[msg.sender]) /
            HATCH_STEP;

function getHalvingPercentage() public view returns (uint256) {
        uint256 steps = (block.timestamp - lastWithdraw[msg.sender]) /
            HATCH_STEP;

return min(1e18, BASE_PERCENTAGE + steps * HATCH_STEP_MODIFIER);
    }

function min(uint256 a, uint256 b) private pure returns (uint256) {
        return a < b ? a : b;
    }
}

Words removed	20
Total words	672
Words removed (%)	2.98

Words added	20
Total words	672
Words added (%)	2.98