Comparar texto

Encuentra la diferencia entre dos archivos de texto

Editor live

Ocultar sin cambios

Sin ajuste de línea

Vista

Nivel de detalle

Resaltado de sintaxis

Diffchecker Desktop La forma más segura de usar Diffchecker. ¡Obtén la app de Diffchecker Desktop: tus diffs nunca salen de tu computadora!Obtener Desktop

BNBMiner vs BNBMachine

Creado hace 3 añosEl diff nunca expira

15 eliminaciones

Líneas
Total
Eliminado

Caracteres
Total
Eliminado

Para continuar usando esta función, actualice a Diffchecker Pro Ver precios

152 líneas

19 adiciones

Líneas
Total
Añadido

Caracteres
Total
Añadido

Para continuar usando esta función, actualice a Diffchecker Pro Ver precios

156 líneas

/**

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

}

Diferencias guardadas

Texto original

Abrir archivo

/**
 *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;
  }
}

Texto modificado

Abrir archivo

/**
 *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;
  }
}