テキスト比較

2 つのテキストファイルの違いを見つける

Real-time diff

Unified diff

Collapse lines

Highlight change

Syntax highlighting

ツール

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

Comparing sensitive data, confidential files or internal emails?

Most legal and privacy policies prohibit uploading sensitive data online. Diffchecker Desktop ensures your confidential information never leaves your computer. Work offline and compare documents securely.

Download Diffchecker Desktop Learn more

BNBMiner vs BNBMachine

Created 2 years agoDiff never expires

14 removals

152 lines

18 additions

156 lines

/**

*Submitted for verification at BscScan.com on 2021-03-22

*Submitted for verification at BscScan.com on 2022-12-31

/**

/* BNB Machine

*Website: https://bnbMiner.finance

Website: bnbmachine.xyz

Telegram: https://t.me/TheBNBMachine

pragma solidity ^0.4.26; // solhint-disable-line

contract BNBMiner{

contract BNB_Machine{

//uint256 EGGS_PER_MINERS_PER_SECOND=1;

//uint256 BNB_PER_MINERS_PER_SECOND=1;

uint256 public EGGS_TO_HATCH_1MINERS=2592000;//for final version should be seconds in a day

uint256 public BNB_TO_HATCH_1MINERS=540000;//for final version should be seconds in a day.

uint256 PSN=10000;

uint256 PSNH=5000;

bool public initialized=false;

address public ceoAddress;

address public ceoAddress2;

mapping (address => uint256) public hatcheryMiners;

mapping (address => uint256) public claimedEggs;

mapping (address => uint256) public lastHatch;

mapping (address => address) public referrals;

uint256 public marketEggs;

constructor() public{

ceoAddress=msg.sender;

ceoAddress2=address(0x5Ce4c97C4Ab2dE8698A5Ca2C277f8e2cb468e71A);

ceoAddress2=address(0x90f44470bd0322C9E8c58d8234CF005018cf91D8);

}

function hatchEggs(address ref) public{

require(initialized);

if(ref == msg.sender) {

ref = 0;

}

if(referrals[msg.sender]==0 && referrals[msg.sender]!=msg.sender){

referrals[msg.sender]=ref;

}

uint256 eggsUsed=getMyEggs();

uint256 newMiners=SafeMath.div(eggsUsed,EGGS_TO_HATCH_1MINERS);

uint256 newMiners=SafeMath.div(eggsUsed,BNB_TO_HATCH_1MINERS);

hatcheryMiners[msg.sender]=SafeMath.add(hatcheryMiners[msg.sender],newMiners);

claimedEggs[msg.sender]=0;

lastHatch[msg.sender]=now;

//send referral eggs

claimedEggs[referrals[msg.sender]]=SafeMath.add(claimedEggs[referrals[msg.sender]],SafeMath.div(eggsUsed,10));

claimedEggs[referrals[msg.sender]]=SafeMath.add(claimedEggs[referrals[msg.sender]],SafeMath.div(eggsUsed,8));

//boost market to nerf miners hoarding

marketEggs=SafeMath.add(marketEggs,SafeMath.div(eggsUsed,5));

}

function sellEggs() public{

require(initialized);

uint256 hasEggs=getMyEggs();

uint256 eggValue=calculateEggSell(hasEggs);

uint256 fee=devFee(eggValue);

uint256 fee2=fee/2;

claimedEggs[msg.sender]=0;

lastHatch[msg.sender]=now;

marketEggs=SafeMath.add(marketEggs,hasEggs);

ceoAddress.transfer(fee2);

ceoAddress2.transfer(fee-fee2);

msg.sender.transfer(SafeMath.sub(eggValue,fee));

}

function buyEggs(address ref) public payable{

require(initialized);

uint256 eggsBought=calculateEggBuy(msg.value,SafeMath.sub(address(this).balance,msg.value));

eggsBought=SafeMath.sub(eggsBought,devFee(eggsBought));

uint256 fee=devFee(msg.value);

uint256 fee2=fee/2;

ceoAddress.transfer(fee2);

ceoAddress2.transfer(fee-fee2);

claimedEggs[msg.sender]=SafeMath.add(claimedEggs[msg.sender],eggsBought);

hatchEggs(ref);

}

//magic trade balancing algorithm

function calculateTrade(uint256 rt,uint256 rs, uint256 bs) public view returns(uint256){

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

return SafeMath.div(SafeMath.mul(PSN,bs),SafeMath.add(PSNH,SafeMath.div(SafeMath.add(SafeMath.mul(PSN,rs),SafeMath.mul(PSNH,rt)),rt)));

}

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

return calculateTrade(eggs,marketEggs,address(this).balance);

}

function calculateEggBuy(uint256 eth,uint256 contractBalance) public view returns(uint256){

return calculateTrade(eth,contractBalance,marketEggs);

}

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

return calculateEggBuy(eth,address(this).balance);

}

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

return SafeMath.div(SafeMath.mul(amount,5),100);

return SafeMath.div(SafeMath.mul(amount,4),100);

}

function seedMarket() public payable{

require(marketEggs==0);

initialized=true;

marketEggs=259200000000;

marketEggs=54000000000;

}

function getBalance() public view returns(uint256){

return address(this).balance;

}

function getMyMiners() public view returns(uint256){

return hatcheryMiners[msg.sender];

}

function getMyEggs() public view returns(uint256){

return SafeMath.add(claimedEggs[msg.sender],getEggsSinceLastHatch(msg.sender));

}

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

uint256 secondsPassed=min(EGGS_TO_HATCH_1MINERS,SafeMath.sub(now,lastHatch[adr]));

uint256 secondsPassed=min(BNB_TO_HATCH_1MINERS,SafeMath.sub(now,lastHatch[adr]));

return SafeMath.mul(secondsPassed,hatcheryMiners[adr]);

}

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

return a < b ? a : b;

}

library SafeMath {

/**

* @dev Multiplies two numbers, throws on overflow.

function mul(uint256 a, uint256 b) internal pure returns (uint256) {

if (a == 0) {

return 0;

}

uint256 c = a * b;

assert(c / a == b);

return c;

}

/**

* @dev Integer division of two numbers, truncating the quotient.

function div(uint256 a, uint256 b) internal pure returns (uint256) {

// assert(b > 0); // Solidity automatically throws when dividing by 0

uint256 c = a / b;

// assert(a == b * c + a % b); // There is no case in which this doesn't hold

return c;

}

/**

* @dev Substracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).

function sub(uint256 a, uint256 b) internal pure returns (uint256) {

assert(b <= a);

return a - b;

}

/**

* @dev Adds two numbers, throws on overflow.

function add(uint256 a, uint256 b) internal pure returns (uint256) {

uint256 c = a + b;

assert(c >= a);

return c;

}

保存された差分

原文

Open file

/**
 *Submitted for verification at BscScan.com on 2021-03-22
*/

/**
 *Website: https://bnbMiner.finance
*/

pragma solidity ^0.4.26; // solhint-disable-line

contract BNBMiner{
    //uint256 EGGS_PER_MINERS_PER_SECOND=1;
    uint256 public EGGS_TO_HATCH_1MINERS=2592000;//for final version should be seconds in a day
    uint256 PSN=10000;
    uint256 PSNH=5000;
    bool public initialized=false;
    address public ceoAddress;
    address public ceoAddress2;
    mapping (address => uint256) public hatcheryMiners;
    mapping (address => uint256) public claimedEggs;
    mapping (address => uint256) public lastHatch;
    mapping (address => address) public referrals;
    uint256 public marketEggs;
    constructor() public{
        ceoAddress=msg.sender;
        ceoAddress2=address(0x5Ce4c97C4Ab2dE8698A5Ca2C277f8e2cb468e71A);
    }
    function hatchEggs(address ref) public{
        require(initialized);
        if(ref == msg.sender) {
            ref = 0;
        }
        if(referrals[msg.sender]==0 && referrals[msg.sender]!=msg.sender){
            referrals[msg.sender]=ref;
        }
        uint256 eggsUsed=getMyEggs();
        uint256 newMiners=SafeMath.div(eggsUsed,EGGS_TO_HATCH_1MINERS);
        hatcheryMiners[msg.sender]=SafeMath.add(hatcheryMiners[msg.sender],newMiners);
        claimedEggs[msg.sender]=0;
        lastHatch[msg.sender]=now;
        
        //send referral eggs
        claimedEggs[referrals[msg.sender]]=SafeMath.add(claimedEggs[referrals[msg.sender]],SafeMath.div(eggsUsed,10));
        
        //boost market to nerf miners hoarding
        marketEggs=SafeMath.add(marketEggs,SafeMath.div(eggsUsed,5));
    }
    function sellEggs() public{
        require(initialized);
        uint256 hasEggs=getMyEggs();
        uint256 eggValue=calculateEggSell(hasEggs);
        uint256 fee=devFee(eggValue);
        uint256 fee2=fee/2;
        claimedEggs[msg.sender]=0;
        lastHatch[msg.sender]=now;
        marketEggs=SafeMath.add(marketEggs,hasEggs);
        ceoAddress.transfer(fee2);
        ceoAddress2.transfer(fee-fee2);
        msg.sender.transfer(SafeMath.sub(eggValue,fee));
    }
    function buyEggs(address ref) public payable{
        require(initialized);
        uint256 eggsBought=calculateEggBuy(msg.value,SafeMath.sub(address(this).balance,msg.value));
        eggsBought=SafeMath.sub(eggsBought,devFee(eggsBought));
        uint256 fee=devFee(msg.value);
        uint256 fee2=fee/2;
        ceoAddress.transfer(fee2);
        ceoAddress2.transfer(fee-fee2);
        claimedEggs[msg.sender]=SafeMath.add(claimedEggs[msg.sender],eggsBought);
        hatchEggs(ref);
    }
    //magic trade balancing algorithm
    function calculateTrade(uint256 rt,uint256 rs, uint256 bs) public view returns(uint256){
        //(PSN*bs)/(PSNH+((PSN*rs+PSNH*rt)/rt));
        return SafeMath.div(SafeMath.mul(PSN,bs),SafeMath.add(PSNH,SafeMath.div(SafeMath.add(SafeMath.mul(PSN,rs),SafeMath.mul(PSNH,rt)),rt)));
    }
    function calculateEggSell(uint256 eggs) public view returns(uint256){
        return calculateTrade(eggs,marketEggs,address(this).balance);
    }
    function calculateEggBuy(uint256 eth,uint256 contractBalance) public view returns(uint256){
        return calculateTrade(eth,contractBalance,marketEggs);
    }
    function calculateEggBuySimple(uint256 eth) public view returns(uint256){
        return calculateEggBuy(eth,address(this).balance);
    }
    function devFee(uint256 amount) public pure returns(uint256){
        return SafeMath.div(SafeMath.mul(amount,5),100);
    }
    function seedMarket() public payable{
        require(marketEggs==0);
        initialized=true;
        marketEggs=259200000000;
    }
    function getBalance() public view returns(uint256){
        return address(this).balance;
    }
    function getMyMiners() public view returns(uint256){
        return hatcheryMiners[msg.sender];
    }
    function getMyEggs() public view returns(uint256){
        return SafeMath.add(claimedEggs[msg.sender],getEggsSinceLastHatch(msg.sender));
    }
    function getEggsSinceLastHatch(address adr) public view returns(uint256){
        uint256 secondsPassed=min(EGGS_TO_HATCH_1MINERS,SafeMath.sub(now,lastHatch[adr]));
        return SafeMath.mul(secondsPassed,hatcheryMiners[adr]);
    }
    function min(uint256 a, uint256 b) private pure returns (uint256) {
        return a < b ? a : b;
    }
}

library SafeMath {

/**
  * @dev Multiplies two numbers, throws on overflow.
  */
  function mul(uint256 a, uint256 b) internal pure returns (uint256) {
    if (a == 0) {
      return 0;
    }
    uint256 c = a * b;
    assert(c / a == b);
    return c;
  }

/**
  * @dev Integer division of two numbers, truncating the quotient.
  */
  function div(uint256 a, uint256 b) internal pure returns (uint256) {
    // assert(b > 0); // Solidity automatically throws when dividing by 0
    uint256 c = a / b;
    // assert(a == b * c + a % b); // There is no case in which this doesn't hold
    return c;
  }

/**
  * @dev Substracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
  */
  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
    assert(b <= a);
    return a - b;
  }

/**
  * @dev Adds two numbers, throws on overflow.
  */
  function add(uint256 a, uint256 b) internal pure returns (uint256) {
    uint256 c = a + b;
    assert(c >= a);
    return c;
  }
}

変更されたテキスト

Open file

/**
 *Submitted for verification at BscScan.com on 2022-12-31
*/

/* BNB Machine

Website: bnbmachine.xyz

Telegram:  https://t.me/TheBNBMachine

*/
pragma solidity ^0.4.26; // solhint-disable-line

contract BNB_Machine{
    //uint256 BNB_PER_MINERS_PER_SECOND=1;
    uint256 public BNB_TO_HATCH_1MINERS=540000;//for final version should be seconds in a day.
    uint256 PSN=10000;
    uint256 PSNH=5000;
    bool public initialized=false;
    address public ceoAddress;
    address public ceoAddress2;
    mapping (address => uint256) public hatcheryMiners;
    mapping (address => uint256) public claimedEggs;
    mapping (address => uint256) public lastHatch;
    mapping (address => address) public referrals;
    uint256 public marketEggs;
    constructor() public{
        ceoAddress=msg.sender;
        ceoAddress2=address(0x90f44470bd0322C9E8c58d8234CF005018cf91D8);
    }
    function hatchEggs(address ref) public{
        require(initialized);
        if(ref == msg.sender) {
            ref = 0;
        }
        if(referrals[msg.sender]==0 && referrals[msg.sender]!=msg.sender){
            referrals[msg.sender]=ref;
        }
        uint256 eggsUsed=getMyEggs();
        uint256 newMiners=SafeMath.div(eggsUsed,BNB_TO_HATCH_1MINERS);
        hatcheryMiners[msg.sender]=SafeMath.add(hatcheryMiners[msg.sender],newMiners);
        claimedEggs[msg.sender]=0;
        lastHatch[msg.sender]=now;
        
        //send referral eggs
        claimedEggs[referrals[msg.sender]]=SafeMath.add(claimedEggs[referrals[msg.sender]],SafeMath.div(eggsUsed,8));
        
        //boost market to nerf miners hoarding
        marketEggs=SafeMath.add(marketEggs,SafeMath.div(eggsUsed,5));
    }
    function sellEggs() public{
        require(initialized);
        uint256 hasEggs=getMyEggs();
        uint256 eggValue=calculateEggSell(hasEggs);
        uint256 fee=devFee(eggValue);
        uint256 fee2=fee/2;
        claimedEggs[msg.sender]=0;
        lastHatch[msg.sender]=now;
        marketEggs=SafeMath.add(marketEggs,hasEggs);
        ceoAddress.transfer(fee2);
        ceoAddress2.transfer(fee-fee2);
        msg.sender.transfer(SafeMath.sub(eggValue,fee));
    }
    function buyEggs(address ref) public payable{
        require(initialized);
        uint256 eggsBought=calculateEggBuy(msg.value,SafeMath.sub(address(this).balance,msg.value));
        eggsBought=SafeMath.sub(eggsBought,devFee(eggsBought));
        uint256 fee=devFee(msg.value);
        uint256 fee2=fee/2;
        ceoAddress.transfer(fee2);
        ceoAddress2.transfer(fee-fee2);
        claimedEggs[msg.sender]=SafeMath.add(claimedEggs[msg.sender],eggsBought);
        hatchEggs(ref);
    }
    //magic trade balancing algorithm
    function calculateTrade(uint256 rt,uint256 rs, uint256 bs) public view returns(uint256){
        //(PSN*bs)/(PSNH+((PSN*rs+PSNH*rt)/rt));
        return SafeMath.div(SafeMath.mul(PSN,bs),SafeMath.add(PSNH,SafeMath.div(SafeMath.add(SafeMath.mul(PSN,rs),SafeMath.mul(PSNH,rt)),rt)));
    }
    function calculateEggSell(uint256 eggs) public view returns(uint256){
        return calculateTrade(eggs,marketEggs,address(this).balance);
    }
    function calculateEggBuy(uint256 eth,uint256 contractBalance) public view returns(uint256){
        return calculateTrade(eth,contractBalance,marketEggs);
    }
    function calculateEggBuySimple(uint256 eth) public view returns(uint256){
        return calculateEggBuy(eth,address(this).balance);
    }
    function devFee(uint256 amount) public pure returns(uint256){
        return SafeMath.div(SafeMath.mul(amount,4),100);
    }
    function seedMarket() public payable{
        require(marketEggs==0);
        initialized=true;
        marketEggs=54000000000;
    }
    function getBalance() public view returns(uint256){
        return address(this).balance;
    }
    function getMyMiners() public view returns(uint256){
        return hatcheryMiners[msg.sender];
    }
    function getMyEggs() public view returns(uint256){
        return SafeMath.add(claimedEggs[msg.sender],getEggsSinceLastHatch(msg.sender));
    }
    function getEggsSinceLastHatch(address adr) public view returns(uint256){
        uint256 secondsPassed=min(BNB_TO_HATCH_1MINERS,SafeMath.sub(now,lastHatch[adr]));
        return SafeMath.mul(secondsPassed,hatcheryMiners[adr]);
    }
    function min(uint256 a, uint256 b) private pure returns (uint256) {
        return a < b ? a : b;
    }
}

library SafeMath {

/**
  * @dev Adds two numbers, throws on overflow.
  */
  function add(uint256 a, uint256 b) internal pure returns (uint256) {
    uint256 c = a + b;
    assert(c >= a);
    return c;
  }
}