Transaction Hash:
Block:
10736852 at Aug-26-2020 03:19:51 PM +UTC
Transaction Fee:
0.00281436004368246 ETH
$6.92
Gas Used:
29,940 Gas / 94.000001459 Gwei
Account State Difference:
| Address | Before | After | State Difference | ||
|---|---|---|---|---|---|
|
0x5A0b54D5...D3E029c4c
Miner
| (Spark Pool) | 63.80716856354822046 Eth | 63.80998292359190292 Eth | 0.00281436004368246 | |
| 0xa28157E4...24444Ec46 |
0.036901626995686648 Eth
Nonce: 24
|
0.034087266952004188 Eth
Nonce: 25
| 0.00281436004368246 |
Execution Trace
Minereum.CALL( )
Minereum.CALL( )
GenesisAddresses.RemoveGenesisAddressFromSale( _from=0xa28157E40309c3837dD0582F54d0dBA24444Ec46 )-
publicCalls.isGenesisAddress( 0xa28157E40309c3837dD0582F54d0dBA24444Ec46 ) => ( 3 )
-
File 1 of 3: Minereum
File 2 of 3: GenesisAddresses
File 3 of 3: publicCalls
pragma solidity ^0.6.0;
interface publicCalls {
function GenesisDestroyAmountCount ( ) external view returns ( uint256 );
function GenesisDestroyAmountCountSet ( uint256 _GenesisDestroyAmountCount ) external;
function GenesisDestroyCountStake ( ) external view returns ( uint256 );
function GenesisDestroyCountStakeSet ( uint256 _GenesisDestroyCountStake ) external;
function GenesisDestroyed ( ) external view returns ( uint256 );
function GenesisDestroyedSet ( uint256 _GenesisDestroyed ) external;
function NormalAddressBuyPricePerMNE ( address ) external view returns ( uint256 );
function NormalAddressBuyPricePerMNESet ( address _address, uint256 _NormalAddressBuyPricePerMNE ) external;
function NormalAddressFeeCount ( ) external view returns ( uint256 );
function NormalAddressFeeCountSet ( uint256 _NormalAddressFeeCount ) external;
function NormalAddressSalesCount ( ) external view returns ( uint256 );
function NormalAddressSalesCountSet ( uint256 _NormalAddressSalesCount ) external;
function NormalAddressSalesPriceCount ( ) external view returns ( uint256 );
function NormalAddressSalesPriceCountSet ( uint256 _NormalAddressSalesPriceCount ) external;
function NormalBalanceImported ( ) external view returns ( uint256 );
function NormalBalanceImportedSet ( uint256 _NormalBalanceImported ) external;
function NormalImportedAmountCount ( ) external view returns ( uint256 );
function NormalImportedAmountCountSet ( uint256 _NormalImportedAmountCount ) external;
function allowAddressToDestroyGenesis ( address ) external view returns ( address );
function allowAddressToDestroyGenesisSet ( address _address, address _allowAddressToDestroyGenesis ) external;
function allowReceiveGenesisTransfers ( address ) external view returns ( bool );
function allowReceiveGenesisTransfersSet ( address _address, bool _allowReceiveGenesisTransfers ) external;
function allowed ( address, address ) external view returns ( uint256 );
function allowedSet ( address _address, address _spender, uint256 _amount ) external;
function amountOfGenesisToBuyStakes ( ) external view returns ( uint256 );
function amountOfGenesisToBuyStakesSet ( address _from, uint256 _amountOfGenesisToBuyStakes ) external;
function amountOfGenesisToTransferStakes ( ) external view returns ( uint256 );
function amountOfGenesisToTransferStakesSet ( address _from, uint256 _amountOfGenesisToTransferStakes ) external;
function amountOfMNEForToken ( ) external view returns ( uint256 );
function amountOfMNEForTokenICO ( ) external view returns ( uint256 );
function amountOfMNEForTokenICOSet ( address _from, uint256 _amountOfMNEForTokenICO ) external;
function amountOfMNEForTokenSet ( address _from, uint256 _amountOfMNEForToken ) external;
function amountOfMNEToBuyStakes ( ) external view returns ( uint256 );
function amountOfMNEToBuyStakesSet ( address _from, uint256 _amountOfMNEToBuyStakes ) external;
function amountOfMNEToTransferStakes ( ) external view returns ( uint256 );
function amountOfMNEToTransferStakesSet ( address _from, uint256 _amountOfMNEToTransferStakes ) external;
function availableBalance ( ) external view returns ( uint256 );
function availableBalanceSet ( uint256 _availableBalance ) external;
function balances ( address ) external view returns ( uint256 );
function balancesSet ( address _address, uint256 _balances ) external;
function buyStakeGenesisCount ( ) external view returns ( uint256 );
function buyStakeGenesisCountSet ( uint256 _buyStakeGenesisCount ) external;
function buyStakeMNECount ( ) external view returns ( uint256 );
function buyStakeMNECountSet ( uint256 _buyStakeMNECount ) external;
function ethFeeForSellerLevel1 ( ) external view returns ( uint256 );
function ethFeeForSellerLevel1Set ( address _from, uint256 _ethFeeForSellerLevel1 ) external;
function ethFeeForToken ( ) external view returns ( uint256 );
function ethFeeForTokenICO ( ) external view returns ( uint256 );
function ethFeeForTokenICOSet ( address _from, uint256 _ethFeeForTokenICO ) external;
function ethFeeForTokenSet ( address _from, uint256 _ethFeeForToken ) external;
function ethFeeToBuyLevel1 ( ) external view returns ( uint256 );
function ethFeeToBuyLevel1Set ( address _from, uint256 _ethFeeToBuyLevel1 ) external;
function ethFeeToUpgradeToLevel2 ( ) external view returns ( uint256 );
function ethFeeToUpgradeToLevel2Set ( address _from, uint256 _ethFeeToUpgradeToLevel2 ) external;
function ethFeeToUpgradeToLevel3 ( ) external view returns ( uint256 );
function ethFeeToUpgradeToLevel3Set ( address _from, uint256 _ethFeeToUpgradeToLevel3 ) external;
function ethPercentFeeGenesisExchange ( ) external view returns ( uint256 );
function ethPercentFeeGenesisExchangeSet ( address _from, uint256 _ethPercentFeeGenesisExchange ) external;
function ethPercentFeeNormalExchange ( ) external view returns ( uint256 );
function ethPercentFeeNormalExchangeSet ( address _from, uint256 _ethPercentFeeNormalExchange ) external;
function ethPercentStakeExchange ( ) external view returns ( uint256 );
function ethPercentStakeExchangeSet ( address _from, uint256 _ethPercentStakeExchange ) external;
function genesisAddressCount ( ) external view returns ( uint256 );
function genesisAddressCountSet ( uint256 _genesisAddressCount ) external;
function genesisAddressesForSaleLevel1Index ( address ) external view returns ( uint256 );
function genesisAddressesForSaleLevel1IndexSet ( address _address, uint256 _genesisAddressesForSaleLevel1Index ) external;
function genesisAddressesForSaleLevel2Index ( address ) external view returns ( uint256 );
function genesisAddressesForSaleLevel2IndexSet ( address _address, uint256 _genesisAddressesForSaleLevel2Index ) external;
function genesisAddressesForSaleLevel3Index ( address ) external view returns ( uint256 );
function genesisAddressesForSaleLevel3IndexSet ( address _address, uint256 _genesisAddressesForSaleLevel3Index ) external;
function genesisBuyPrice ( address ) external view returns ( uint256 );
function genesisBuyPriceSet ( address _address, uint256 _genesisBuyPrice ) external;
function genesisCallerAddress ( ) external view returns ( address );
function genesisCallerAddressSet ( address _genesisCallerAddress ) external;
function genesisInitialSupply ( address ) external view returns ( uint256 );
function genesisInitialSupplySet ( address _address, uint256 _genesisInitialSupply ) external;
function genesisRewardPerBlock ( ) external view returns ( uint256 );
function genesisSalesCount ( ) external view returns ( uint256 );
function genesisSalesCountSet ( uint256 _genesisSalesCount ) external;
function genesisSalesPriceCount ( ) external view returns ( uint256 );
function genesisSalesPriceCountSet ( uint256 _genesisSalesPriceCount ) external;
function genesisSupplyPerAddress ( ) external view returns ( uint256 );
function genesisTransfersCount ( ) external view returns ( uint256 );
function genesisTransfersCountSet ( uint256 _genesisTransfersCount ) external;
function initialBlockCount ( ) external view returns ( uint256 );
function initialBlockCountPerAddress ( address ) external view returns ( uint256 );
function initialBlockCountPerAddressSet ( address _address, uint256 _initialBlockCountPerAddress ) external;
function initialBlockCountSet ( uint256 _initialBlockCount ) external;
function isGenesisAddress ( address ) external view returns ( uint8 );
function isGenesisAddressForSale ( address ) external view returns ( bool );
function isGenesisAddressForSaleSet ( address _address, bool _isGenesisAddressForSale ) external;
function isGenesisAddressSet ( address _address, uint8 _isGenesisAddress ) external;
function isNormalAddressForSale ( address ) external view returns ( bool );
function isNormalAddressForSaleSet ( address _address, bool _isNormalAddressForSale ) external;
function level2ActivationsFromLevel1Count ( ) external view returns ( uint256 );
function level2ActivationsFromLevel1CountSet ( uint256 _level2ActivationsFromLevel1Count ) external;
function level3ActivationsFromDevCount ( ) external view returns ( uint256 );
function level3ActivationsFromDevCountSet ( uint256 _level3ActivationsFromDevCount ) external;
function level3ActivationsFromLevel1Count ( ) external view returns ( uint256 );
function level3ActivationsFromLevel1CountSet ( uint256 _level3ActivationsFromLevel1Count ) external;
function level3ActivationsFromLevel2Count ( ) external view returns ( uint256 );
function level3ActivationsFromLevel2CountSet ( uint256 _level3ActivationsFromLevel2Count ) external;
function maxBlocks ( ) external view returns ( uint256 );
function mneBurned ( ) external view returns ( uint256 );
function mneBurnedSet ( uint256 _mneBurned ) external;
function normalAddressesForSaleIndex ( address ) external view returns ( uint256 );
function normalAddressesForSaleIndexSet ( address _address, uint256 _normalAddressesForSaleIndex ) external;
function overallSupply ( ) external view returns ( uint256 );
function overallSupplySet ( uint256 _overallSupply ) external;
function ownerGenesis ( ) external view returns ( address );
function ownerGenesisBuys ( ) external view returns ( address );
function ownerMain ( ) external view returns ( address );
function ownerNormalAddress ( ) external view returns ( address );
function ownerStakeBuys ( ) external view returns ( address );
function ownerStakes ( ) external view returns ( address );
function ownerTokenService ( ) external view returns ( address );
function setOwnerGenesis ( ) external;
function setOwnerGenesisBuys ( ) external;
function setOwnerMain ( ) external;
function setOwnerNormalAddress ( ) external;
function setOwnerStakeBuys ( ) external;
function setOwnerStakes ( ) external;
function setOwnerTokenService ( ) external;
function setupRunning ( ) external view returns ( bool );
function setupRunningSet ( bool _setupRunning ) external;
function stakeBalances ( address ) external view returns ( uint256 );
function stakeBalancesSet ( address _address, uint256 _stakeBalances ) external;
function stakeBuyPrice ( address ) external view returns ( uint256 );
function stakeBuyPriceSet ( address _address, uint256 _stakeBuyPrice ) external;
function stakeDecimals ( ) external view returns ( uint256 );
function stakeDecimalsSet ( address _from, uint256 _stakeDecimals ) external;
function stakeHoldersImported ( ) external view returns ( uint256 );
function stakeHoldersImportedSet ( uint256 _stakeHoldersImported ) external;
function stakeHoldersListIndex ( address ) external view returns ( uint256 );
function stakeHoldersListIndexSet ( address _address, uint256 _stakeHoldersListIndex ) external;
function stakeMneBurnCount ( ) external view returns ( uint256 );
function stakeMneBurnCountSet ( uint256 _stakeMneBurnCount ) external;
function stakeMneTransferBurnCount ( ) external view returns ( uint256 );
function stakeMneTransferBurnCountSet ( uint256 _stakeMneTransferBurnCount ) external;
function stakesForSaleIndex ( address ) external view returns ( uint256 );
function stakesForSaleIndexSet ( address _address, uint256 _stakesForSaleIndex ) external;
function tokenCreated ( address, uint256 ) external view returns ( address );
function tokenCreatedSet ( address _address, address _tokenCreated ) external;
function tokenICOCreated ( address, uint256 ) external view returns ( address );
function tokenICOCreatedSet ( address _address, address _tokenICOCreated ) external;
function totalMaxAvailableAmount ( ) external view returns ( uint256 );
function totalMaxAvailableAmountSet ( uint256 _totalMaxAvailableAmount ) external;
function totalPaidStakeHolders ( ) external view returns ( uint256 );
function totalPaidStakeHoldersSet ( uint256 _totalPaidStakeHolders ) external;
function transferStakeGenesisCount ( ) external view returns ( uint256 );
function transferStakeGenesisCountSet ( uint256 _transferStakeGenesisCount ) external;
function transferStakeMNECount ( ) external view returns ( uint256 );
function transferStakeMNECountSet ( uint256 _transferStakeMNECount ) external;
}
interface publicArrays {
function Level1TradeHistoryAmountETH ( uint256 ) external view returns ( uint256 );
function Level1TradeHistoryAmountETHFee ( uint256 ) external view returns ( uint256 );
function Level1TradeHistoryAmountETHFeeLength ( ) external view returns ( uint256 len );
function Level1TradeHistoryAmountETHFeeSet ( uint256 _Level1TradeHistoryAmountETHFee ) external;
function Level1TradeHistoryAmountETHLength ( ) external view returns ( uint256 len );
function Level1TradeHistoryAmountETHSet ( uint256 _Level1TradeHistoryAmountETH ) external;
function Level1TradeHistoryAmountMNE ( uint256 ) external view returns ( uint256 );
function Level1TradeHistoryAmountMNELength ( ) external view returns ( uint256 len );
function Level1TradeHistoryAmountMNESet ( uint256 _Level1TradeHistoryAmountMNE ) external;
function Level1TradeHistoryBuyer ( uint256 ) external view returns ( address );
function Level1TradeHistoryBuyerLength ( ) external view returns ( uint256 len );
function Level1TradeHistoryBuyerSet ( address _Level1TradeHistoryBuyer ) external;
function Level1TradeHistoryDate ( uint256 ) external view returns ( uint256 );
function Level1TradeHistoryDateLength ( ) external view returns ( uint256 len );
function Level1TradeHistoryDateSet ( uint256 _Level1TradeHistoryDate ) external;
function Level1TradeHistorySeller ( uint256 ) external view returns ( address );
function Level1TradeHistorySellerLength ( ) external view returns ( uint256 len );
function Level1TradeHistorySellerSet ( address _Level1TradeHistorySeller ) external;
function Level2TradeHistoryAmountETH ( uint256 ) external view returns ( uint256 );
function Level2TradeHistoryAmountETHFee ( uint256 ) external view returns ( uint256 );
function Level2TradeHistoryAmountETHFeeLength ( ) external view returns ( uint256 len );
function Level2TradeHistoryAmountETHFeeSet ( uint256 _Level2TradeHistoryAmountETHFee ) external;
function Level2TradeHistoryAmountETHLength ( ) external view returns ( uint256 len );
function Level2TradeHistoryAmountETHSet ( uint256 _Level2TradeHistoryAmountETH ) external;
function Level2TradeHistoryAmountMNE ( uint256 ) external view returns ( uint256 );
function Level2TradeHistoryAmountMNELength ( ) external view returns ( uint256 len );
function Level2TradeHistoryAmountMNESet ( uint256 _Level2TradeHistoryAmountMNE ) external;
function Level2TradeHistoryAvailableAmountMNE ( uint256 ) external view returns ( uint256 );
function Level2TradeHistoryAvailableAmountMNELength ( ) external view returns ( uint256 len );
function Level2TradeHistoryAvailableAmountMNESet ( uint256 _Level2TradeHistoryAvailableAmountMNE ) external;
function Level2TradeHistoryBuyer ( uint256 ) external view returns ( address );
function Level2TradeHistoryBuyerLength ( ) external view returns ( uint256 len );
function Level2TradeHistoryBuyerSet ( address _Level2TradeHistoryBuyer ) external;
function Level2TradeHistoryDate ( uint256 ) external view returns ( uint256 );
function Level2TradeHistoryDateLength ( ) external view returns ( uint256 len );
function Level2TradeHistoryDateSet ( uint256 _Level2TradeHistoryDate ) external;
function Level2TradeHistorySeller ( uint256 ) external view returns ( address );
function Level2TradeHistorySellerLength ( ) external view returns ( uint256 len );
function Level2TradeHistorySellerSet ( address _Level2TradeHistorySeller ) external;
function Level3TradeHistoryAmountETH ( uint256 ) external view returns ( uint256 );
function Level3TradeHistoryAmountETHFee ( uint256 ) external view returns ( uint256 );
function Level3TradeHistoryAmountETHFeeLength ( ) external view returns ( uint256 len );
function Level3TradeHistoryAmountETHFeeSet ( uint256 _Level3TradeHistoryAmountETHFee ) external;
function Level3TradeHistoryAmountETHLength ( ) external view returns ( uint256 len );
function Level3TradeHistoryAmountETHSet ( uint256 _Level3TradeHistoryAmountETH ) external;
function Level3TradeHistoryAmountMNE ( uint256 ) external view returns ( uint256 );
function Level3TradeHistoryAmountMNELength ( ) external view returns ( uint256 len );
function Level3TradeHistoryAmountMNESet ( uint256 _Level3TradeHistoryAmountMNE ) external;
function Level3TradeHistoryAvailableAmountMNE ( uint256 ) external view returns ( uint256 );
function Level3TradeHistoryAvailableAmountMNELength ( ) external view returns ( uint256 len );
function Level3TradeHistoryAvailableAmountMNESet ( uint256 _Level3TradeHistoryAvailableAmountMNE ) external;
function Level3TradeHistoryBuyer ( uint256 ) external view returns ( address );
function Level3TradeHistoryBuyerLength ( ) external view returns ( uint256 len );
function Level3TradeHistoryBuyerSet ( address _Level3TradeHistoryBuyer ) external;
function Level3TradeHistoryDate ( uint256 ) external view returns ( uint256 );
function Level3TradeHistoryDateLength ( ) external view returns ( uint256 len );
function Level3TradeHistoryDateSet ( uint256 _Level3TradeHistoryDate ) external;
function Level3TradeHistorySeller ( uint256 ) external view returns ( address );
function Level3TradeHistorySellerLength ( ) external view returns ( uint256 len );
function Level3TradeHistorySellerSet ( address _Level3TradeHistorySeller ) external;
function MNETradeHistoryAmountETH ( uint256 ) external view returns ( uint256 );
function MNETradeHistoryAmountETHFee ( uint256 ) external view returns ( uint256 );
function MNETradeHistoryAmountETHFeeLength ( ) external view returns ( uint256 len );
function MNETradeHistoryAmountETHFeeSet ( uint256 _MNETradeHistoryAmountETHFee ) external;
function MNETradeHistoryAmountETHLength ( ) external view returns ( uint256 len );
function MNETradeHistoryAmountETHSet ( uint256 _MNETradeHistoryAmountETH ) external;
function MNETradeHistoryAmountMNE ( uint256 ) external view returns ( uint256 );
function MNETradeHistoryAmountMNELength ( ) external view returns ( uint256 len );
function MNETradeHistoryAmountMNESet ( uint256 _MNETradeHistoryAmountMNE ) external;
function MNETradeHistoryBuyer ( uint256 ) external view returns ( address );
function MNETradeHistoryBuyerLength ( ) external view returns ( uint256 len );
function MNETradeHistoryBuyerSet ( address _MNETradeHistoryBuyer ) external;
function MNETradeHistoryDate ( uint256 ) external view returns ( uint256 );
function MNETradeHistoryDateLength ( ) external view returns ( uint256 len );
function MNETradeHistoryDateSet ( uint256 _MNETradeHistoryDate ) external;
function MNETradeHistorySeller ( uint256 ) external view returns ( address );
function MNETradeHistorySellerLength ( ) external view returns ( uint256 len );
function MNETradeHistorySellerSet ( address _MNETradeHistorySeller ) external;
function StakeTradeHistoryBuyer ( uint256 ) external view returns ( address );
function StakeTradeHistoryBuyerLength ( ) external view returns ( uint256 len );
function StakeTradeHistoryBuyerSet ( address _StakeTradeHistoryBuyer ) external;
function StakeTradeHistoryDate ( uint256 ) external view returns ( uint256 );
function StakeTradeHistoryDateLength ( ) external view returns ( uint256 len );
function StakeTradeHistoryDateSet ( uint256 _StakeTradeHistoryDate ) external;
function StakeTradeHistoryETHFee ( uint256 ) external view returns ( uint256 );
function StakeTradeHistoryETHFeeLength ( ) external view returns ( uint256 len );
function StakeTradeHistoryETHFeeSet ( uint256 _StakeTradeHistoryETHFee ) external;
function StakeTradeHistoryETHPrice ( uint256 ) external view returns ( uint256 );
function StakeTradeHistoryETHPriceLength ( ) external view returns ( uint256 len );
function StakeTradeHistoryETHPriceSet ( uint256 _StakeTradeHistoryETHPrice ) external;
function StakeTradeHistoryMNEGenesisBurned ( uint256 ) external view returns ( uint256 );
function StakeTradeHistoryMNEGenesisBurnedLength ( ) external view returns ( uint256 len );
function StakeTradeHistoryMNEGenesisBurnedSet ( uint256 _StakeTradeHistoryMNEGenesisBurned ) external;
function StakeTradeHistorySeller ( uint256 ) external view returns ( address );
function StakeTradeHistorySellerLength ( ) external view returns ( uint256 len );
function StakeTradeHistorySellerSet ( address _StakeTradeHistorySeller ) external;
function StakeTradeHistoryStakeAmount ( uint256 ) external view returns ( uint256 );
function StakeTradeHistoryStakeAmountLength ( ) external view returns ( uint256 len );
function StakeTradeHistoryStakeAmountSet ( uint256 _StakeTradeHistoryStakeAmount ) external;
function deleteGenesisAddressesForSaleLevel1 ( ) external;
function deleteGenesisAddressesForSaleLevel2 ( ) external;
function deleteGenesisAddressesForSaleLevel3 ( ) external;
function deleteNormalAddressesForSale ( ) external;
function deleteStakeHoldersList ( ) external;
function deleteStakesForSale ( ) external;
function genesisAddressesForSaleLevel1 ( uint256 ) external view returns ( address );
function genesisAddressesForSaleLevel1Length ( ) external view returns ( uint256 len );
function genesisAddressesForSaleLevel1Set ( address _genesisAddressesForSaleLevel1 ) external;
function genesisAddressesForSaleLevel1SetAt ( uint256 i, address _address ) external;
function genesisAddressesForSaleLevel2 ( uint256 ) external view returns ( address );
function genesisAddressesForSaleLevel2Length ( ) external view returns ( uint256 len );
function genesisAddressesForSaleLevel2Set ( address _genesisAddressesForSaleLevel2 ) external;
function genesisAddressesForSaleLevel2SetAt ( uint256 i, address _address ) external;
function genesisAddressesForSaleLevel3 ( uint256 ) external view returns ( address );
function genesisAddressesForSaleLevel3Length ( ) external view returns ( uint256 len );
function genesisAddressesForSaleLevel3Set ( address _genesisAddressesForSaleLevel3 ) external;
function genesisAddressesForSaleLevel3SetAt ( uint256 i, address _address ) external;
function normalAddressesForSale ( uint256 ) external view returns ( address );
function normalAddressesForSaleLength ( ) external view returns ( uint256 len );
function normalAddressesForSaleSet ( address _normalAddressesForSale ) external;
function normalAddressesForSaleSetAt ( uint256 i, address _address ) external;
function ownerGenesis ( ) external view returns ( address );
function ownerGenesisBuys ( ) external view returns ( address );
function ownerMain ( ) external view returns ( address );
function ownerNormalAddress ( ) external view returns ( address );
function ownerStakeBuys ( ) external view returns ( address );
function ownerStakes ( ) external view returns ( address );
function setOwnerGenesis ( ) external;
function setOwnerGenesisBuys ( ) external;
function setOwnerMain ( ) external;
function setOwnerNormalAddress ( ) external;
function setOwnerStakeBuys ( ) external;
function setOwnerStakes ( ) external;
function stakeHoldersList ( uint256 ) external view returns ( address );
function stakeHoldersListAt ( uint256 i, address _address ) external;
function stakeHoldersListLength ( ) external view returns ( uint256 len );
function stakeHoldersListSet ( address _stakeHoldersList ) external;
function stakesForSale ( uint256 ) external view returns ( address );
function stakesForSaleLength ( ) external view returns ( uint256 len );
function stakesForSaleSet ( address _stakesForSale ) external;
function stakesForSaleSetAt ( uint256 i, address _address ) external;
}
interface genesisCalls {
function AllowAddressToDestroyGenesis ( address _from, address _address ) external;
function AllowReceiveGenesisTransfers ( address _from ) external;
function BurnTokens ( address _from, uint256 mneToBurn ) external returns ( bool success );
function RemoveAllowAddressToDestroyGenesis ( address _from ) external;
function RemoveAllowReceiveGenesisTransfers ( address _from ) external;
function RemoveGenesisAddressFromSale ( address _from ) external;
function SetGenesisForSale ( address _from, uint256 weiPrice ) external;
function TransferGenesis ( address _from, address _to ) external;
function UpgradeToLevel2FromLevel1 ( address _address, uint256 weiValue ) external;
function UpgradeToLevel3FromDev ( address _address ) external;
function UpgradeToLevel3FromLevel1 ( address _address, uint256 weiValue ) external;
function UpgradeToLevel3FromLevel2 ( address _address, uint256 weiValue ) external;
function availableBalanceOf ( address _address ) external view returns ( uint256 Balance );
function balanceOf ( address _address ) external view returns ( uint256 balance );
function deleteAddressFromGenesisSaleList ( address _address ) external;
function isAnyGenesisAddress ( address _address ) external view returns ( bool success );
function isGenesisAddressLevel1 ( address _address ) external view returns ( bool success );
function isGenesisAddressLevel2 ( address _address ) external view returns ( bool success );
function isGenesisAddressLevel2Or3 ( address _address ) external view returns ( bool success );
function isGenesisAddressLevel3 ( address _address ) external view returns ( bool success );
function ownerGenesis ( ) external view returns ( address );
function ownerGenesisBuys ( ) external view returns ( address );
function ownerMain ( ) external view returns ( address );
function ownerNormalAddress ( ) external view returns ( address );
function ownerStakeBuys ( ) external view returns ( address );
function ownerStakes ( ) external view returns ( address );
function setGenesisCallerAddress ( address _caller ) external returns ( bool success );
function setOwnerGenesisBuys ( ) external;
function setOwnerMain ( ) external;
function setOwnerNormalAddress ( ) external;
function setOwnerStakeBuys ( ) external;
function setOwnerStakes ( ) external;
function BurnGenesisAddresses ( address _from, address[] calldata _genesisAddressesToBurn ) external;
}
interface normalAddress {
function BuyNormalAddress ( address _from, address _address, uint256 _msgvalue ) external returns ( uint256 _totalToSend );
function RemoveNormalAddressFromSale ( address _address ) external;
function setBalanceNormalAddress ( address _from, address _address, uint256 balance ) external;
function SetNormalAddressForSale ( address _from, uint256 weiPricePerMNE ) external;
function setOwnerMain ( ) external;
function ownerMain ( ) external view returns ( address );
}
interface stakes {
function RemoveStakeFromSale ( address _from ) external;
function SetStakeForSale ( address _from, uint256 priceInWei ) external;
function StakeTransferGenesis ( address _from, address _to, uint256 _value, address[] calldata _genesisAddressesToBurn ) external;
function StakeTransferMNE ( address _from, address _to, uint256 _value ) external returns ( uint256 _mneToBurn );
function ownerMain ( ) external view returns ( address );
function setBalanceStakes ( address _from, address _address, uint256 balance ) external;
function setOwnerMain ( ) external;
}
interface stakeBuys {
function BuyStakeGenesis ( address _from, address _address, address[] calldata _genesisAddressesToBurn, uint256 _msgvalue ) external returns ( uint256 _feesToPayToSeller );
function BuyStakeMNE ( address _from, address _address, uint256 _msgvalue ) external returns ( uint256 _mneToBurn, uint256 _feesToPayToSeller );
function ownerMain ( ) external view returns ( address );
function setOwnerMain ( ) external;
}
interface genesisBuys {
function BuyGenesisLevel1FromNormal ( address _from, address _address, uint256 _msgvalue ) external returns ( uint256 _totalToSend );
function BuyGenesisLevel2FromNormal ( address _from, address _address, uint256 _msgvalue ) external returns ( uint256 _totalToSend );
function BuyGenesisLevel3FromNormal ( address _from, address _address, uint256 _msgvalue ) external returns ( uint256 _totalToSend );
function ownerMain ( ) external view returns ( address );
function setOwnerMain ( ) external;
}
interface tokenService {
function CreateToken ( address _from, uint256 _msgvalue ) external returns ( uint256 _mneToBurn, address _contract );
function CreateTokenICO ( address _from, uint256 _msgvalue ) external returns ( uint256 _mneToBurn, address _contract );
function ownerMain ( ) external view returns ( address );
function setOwnerMain ( ) external;
}
interface baseTransfers {
function setOwnerMain ( ) external;
function transfer ( address _from, address _to, uint256 _value ) external;
function transferFrom ( address _sender, address _from, address _to, uint256 _amount ) external returns ( bool success );
function stopSetup ( address _from ) external returns ( bool success );
function totalSupply ( ) external view returns ( uint256 TotalSupply );
}
interface mneStaking {
function startStaking(address _sender, uint256 _amountToStake, address[] calldata _addressList, uint256[] calldata uintList) external;
}
interface luckyDraw {
function BuyTickets(address _sender, uint256[] calldata _max) payable external returns ( uint256 );
}
interface externalService {
function externalFunction(address _sender, address[] calldata _addressList, uint256[] calldata _uintList) payable external returns ( uint256 );
}
interface externalReceiver {
function externalFunction(address _sender, uint256 _mneAmount, address[] calldata _addressList, uint256[] calldata _uintList) payable external;
}
contract Minereum {
string public name;
string public symbol;
uint8 public decimals;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event LogStakeHolderSends(address indexed to, uint balance, uint amountToSend);
event LogFailedStakeHolderSends(address indexed to, uint balance, uint amountToSend);
event TokenCreation(address indexed from, address contractAdd);
event TokenCreationICO(address indexed from, address contractAdd);
event StakeTransfer(address indexed from, address indexed to, uint256 value);
publicCalls public pc;
publicArrays public pa;
genesisCalls public gn;
normalAddress public na;
stakes public st;
stakeBuys public stb;
genesisBuys public gnb;
tokenService public tks;
baseTransfers public bst;
mneStaking public mneStk;
luckyDraw public lkd;
externalService public extS1;
externalReceiver public extR1;
address public updaterAddress = 0x0000000000000000000000000000000000000000;
function setUpdater() public {if (updaterAddress == 0x0000000000000000000000000000000000000000) updaterAddress = msg.sender; else revert();}
address public payoutOwner = 0x0000000000000000000000000000000000000000;
bool public payoutBlocked = false;
address payable public secondaryPayoutAddress = 0x0000000000000000000000000000000000000000;
constructor(address _publicCallsAddress, address _publicArraysAddress, address _genesisCallsAddress, address _normalAddressAddress,
address _stakesAddress, address _stakesBuysAddress,address _genesisBuysAddress, address _tokenServiceAddress, address _baseTransfersAddress) public {
name = "Minereum";
symbol = "MNE";
decimals = 8;
setUpdater();
pc = publicCalls(_publicCallsAddress);
pc.setOwnerMain();
pa = publicArrays(_publicArraysAddress);
pa.setOwnerMain();
gn = genesisCalls(_genesisCallsAddress);
gn.setOwnerMain();
na = normalAddress(_normalAddressAddress);
na.setOwnerMain();
st = stakes(_stakesAddress);
st.setOwnerMain();
stb = stakeBuys(_stakesBuysAddress);
stb.setOwnerMain();
gnb = genesisBuys(_genesisBuysAddress);
gnb.setOwnerMain();
tks = tokenService(_tokenServiceAddress);
tks.setOwnerMain();
bst = baseTransfers(_baseTransfersAddress);
bst.setOwnerMain();
}
function reloadGenesis(address _address) public { if (msg.sender == updaterAddress) {gn = genesisCalls(_address); gn.setOwnerMain(); } else revert();}
function reloadNormalAddress(address _address) public { if (msg.sender == updaterAddress) {na = normalAddress(_address); na.setOwnerMain(); } else revert();}
function reloadStakes(address _address) public { if (msg.sender == updaterAddress) {st = stakes(_address); st.setOwnerMain(); } else revert();}
function reloadStakeBuys(address _address) public { if (msg.sender == updaterAddress) {stb = stakeBuys(_address); stb.setOwnerMain(); } else revert();}
function reloadGenesisBuys(address _address) public { if (msg.sender == updaterAddress) {gnb = genesisBuys(_address); gnb.setOwnerMain(); } else revert();}
function reloadTokenService(address _address) public { if (msg.sender == updaterAddress) {tks = tokenService(_address); tks.setOwnerMain(); } else revert();}
function reloadBaseTransfers(address _address) public { if (msg.sender == updaterAddress) {bst = baseTransfers(_address); bst.setOwnerMain(); } else revert();}
function reloadPublicCalls(address _address, uint code) public { if (!(code == 1234)) revert(); if (msg.sender == updaterAddress) {pc = publicCalls(_address); pc.setOwnerMain();} else revert();}
function reloadPublicArrays(address _address, uint code) public { if (!(code == 1234)) revert(); if (msg.sender == updaterAddress) {pa = publicArrays(_address); pa.setOwnerMain();} else revert();}
function loadMNEStaking(address _address) public { if (msg.sender == updaterAddress) {mneStk = mneStaking(_address); } else revert();}
function loadLuckyDraw(address _address) public { if (msg.sender == updaterAddress) {lkd = luckyDraw(_address); } else revert();}
function externalService1(address _address) public { if (msg.sender == updaterAddress) {extS1 = externalService(_address); } else revert();}
function externalReceiver1(address _address) public { if (msg.sender == updaterAddress) {extR1 = externalReceiver(_address); } else revert();}
function setPayoutOwner() public
{
if(payoutOwner == 0x0000000000000000000000000000000000000000)
payoutOwner = msg.sender;
else
revert();
}
function setSecondaryPayoutAddress(address payable _address) public
{
if(msg.sender == payoutOwner)
secondaryPayoutAddress = _address;
else
revert();
}
function SetBlockPayouts(bool toBlock) public
{
if(msg.sender == payoutOwner)
{
payoutBlocked = toBlock;
}
}
function currentEthBlock() public view returns (uint256 blockNumber)
{
return block.number;
}
function currentBlock() public view returns (uint256 blockNumber)
{
return block.number - pc.initialBlockCount();
}
function availableBalanceOf(address _address) public view returns (uint256 Balance)
{
return gn.availableBalanceOf(_address);
}
function totalSupply() public view returns (uint256 TotalSupply)
{
return bst.totalSupply();
}
function transfer(address _to, uint256 _value) public {
if (_to == address(this)) revert('if (_to == address(this))');
bst.transfer(msg.sender, _to, _value);
emit Transfer(msg.sender, _to, _value);
}
function transferFrom(
address _from,
address _to,
uint256 _amount
) public returns (bool success) {
bool result = bst.transferFrom(msg.sender, _from, _to, _amount);
if (result) emit Transfer(_from, _to, _amount);
return result;
}
function approve(address _spender, uint256 _amount) public returns (bool success) {
pc.allowedSet(msg.sender,_spender, _amount);
emit Approval(msg.sender, _spender, _amount);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return pc.allowed(_owner,_spender);
}
function balanceOf(address _address) public view returns (uint256 balance) {
return gn.balanceOf(_address);
}
function stakeBalanceOf(address _address) public view returns (uint256 balance) {
return pc.stakeBalances(_address);
}
function TransferGenesis(address _to) public {
emit Transfer(msg.sender, _to, balanceOf(msg.sender));
if (_to == address(this)) revert('if (_to == address(this))');
gn.TransferGenesis(msg.sender, _to);
}
function SetGenesisForSale(uint256 weiPrice) public {
gn.SetGenesisForSale(msg.sender, weiPrice);
}
function AllowReceiveGenesisTransfers() public {
gn.AllowReceiveGenesisTransfers(msg.sender);
}
function RemoveAllowReceiveGenesisTransfers() public {
gn.RemoveAllowReceiveGenesisTransfers(msg.sender);
}
function RemoveGenesisAddressFromSale() public {
gn.RemoveGenesisAddressFromSale(msg.sender);
}
function AllowAddressToDestroyGenesis(address _address) public {
gn.AllowAddressToDestroyGenesis(msg.sender, _address);
}
function RemoveAllowAddressToDestroyGenesis() public {
gn.RemoveAllowAddressToDestroyGenesis(msg.sender);
}
function UpgradeToLevel2FromLevel1() public payable {
gn.UpgradeToLevel2FromLevel1(msg.sender, msg.value);
}
function UpgradeToLevel3FromLevel1() public payable {
gn.UpgradeToLevel3FromLevel1(msg.sender, msg.value);
}
function UpgradeToLevel3FromLevel2() public payable {
gn.UpgradeToLevel3FromLevel2(msg.sender, msg.value);
}
function UpgradeToLevel3FromDev() public {
gn.UpgradeToLevel3FromDev(msg.sender);
}
function UpgradeOthersToLevel2FromLevel1(address[] memory _addresses) public payable {
uint count = _addresses.length;
if (msg.value != (pc.ethFeeToUpgradeToLevel2()*count)) revert('(msg.value != pc.ethFeeToUpgradeToLevel2()*count)');
uint i = 0;
while (i < count)
{
gn.UpgradeToLevel2FromLevel1(_addresses[i], pc.ethFeeToUpgradeToLevel2());
i++;
}
}
function UpgradeOthersToLevel3FromLevel1(address[] memory _addresses) public payable {
uint count = _addresses.length;
if (msg.value != ((pc.ethFeeToUpgradeToLevel2() + pc.ethFeeToUpgradeToLevel3())*count)) revert('(weiValue != ((msg.value + pc.ethFeeToUpgradeToLevel3())*count))');
uint i = 0;
while (i < count)
{
gn.UpgradeToLevel3FromLevel1(_addresses[i], (pc.ethFeeToUpgradeToLevel2() + pc.ethFeeToUpgradeToLevel3()));
i++;
}
}
function UpgradeOthersToLevel3FromLevel2(address[] memory _addresses) public payable {
uint count = _addresses.length;
if (msg.value != (pc.ethFeeToUpgradeToLevel3()*count)) revert('(msg.value != (pc.ethFeeToUpgradeToLevel3()*count))');
uint i = 0;
while (i < count)
{
gn.UpgradeToLevel3FromLevel2(_addresses[i], pc.ethFeeToUpgradeToLevel3());
i++;
}
}
function UpgradeOthersToLevel3FromDev(address[] memory _addresses) public {
uint count = _addresses.length;
uint i = 0;
while (i < count)
{
gn.UpgradeToLevel3FromDev(_addresses[i]);
i++;
}
}
function BuyGenesisAddress(address payable _address) public payable
{
if (gn.isGenesisAddressLevel1(_address))
BuyGenesisLevel1FromNormal(_address);
else if (gn.isGenesisAddressLevel2(_address))
BuyGenesisLevel2FromNormal(_address);
else if (gn.isGenesisAddressLevel3(_address))
BuyGenesisLevel3FromNormal(_address);
else
revert('Address not for sale');
}
function SetNormalAddressForSale(uint256 weiPricePerMNE) public {
na.SetNormalAddressForSale(msg.sender, weiPricePerMNE);
}
function RemoveNormalAddressFromSale() public
{
na.RemoveNormalAddressFromSale(msg.sender);
}
function BuyNormalAddress(address payable _address) public payable{
emit Transfer(_address, msg.sender, balanceOf(_address));
uint256 feesToPayToSeller = na.BuyNormalAddress(msg.sender, address(_address), msg.value);
if(!_address.send(feesToPayToSeller)) revert('(!_address.send(feesToPayToSeller))');
}
function setBalanceNormalAddress(address _address, uint256 _balance) public
{
na.setBalanceNormalAddress(msg.sender, _address, _balance);
emit Transfer(address(this), _address, _balance);
}
function ContractTransferAllFundsOut() public
{
//in case of hack, funds can be transfered out to another addresses and transferred to the stake holders from there
if (payoutBlocked)
if(!secondaryPayoutAddress.send(address(this).balance)) revert();
}
function PayoutStakeHolders() public {
require(msg.sender == tx.origin); //For security reasons this line is to prevent smart contract calls
if (payoutBlocked) revert('Payouts Blocked'); //In case of hack, payouts can be blocked
uint contractBalance = address(this).balance;
if (!(contractBalance > 0)) revert('(!(contractBalance > 0))');
uint i;
uint max;
i = 0;
max = pa.stakeHoldersListLength();
while (i < max)
{
address payable add = payable(pa.stakeHoldersList(i));
uint balance = pc.stakeBalances(add);
uint amountToSend = contractBalance * balance / pc.stakeDecimals();
if (amountToSend > 0)
{
if (!add.send(amountToSend))
emit LogFailedStakeHolderSends(add, balance, amountToSend);
else
{
pc.totalPaidStakeHoldersSet(pc.totalPaidStakeHolders() + amountToSend);
}
}
i++;
}
}
function stopSetup() public returns (bool success)
{
return bst.stopSetup(msg.sender);
}
function BurnTokens(uint256 mneToBurn) public returns (bool success) {
gn.BurnTokens(msg.sender, mneToBurn);
emit Transfer(msg.sender, 0x0000000000000000000000000000000000000000, mneToBurn);
return true;
}
function SetStakeForSale(uint256 priceInWei) public
{
st.SetStakeForSale(msg.sender, priceInWei);
}
function RemoveStakeFromSale() public {
st.RemoveStakeFromSale(msg.sender);
}
function StakeTransferMNE(address _to, uint256 _value) public {
if (_to == address(this)) revert('if (_to == address(this))');
BurnTokens(st.StakeTransferMNE(msg.sender, _to, _value));
emit StakeTransfer(msg.sender, _to, _value);
}
function BurnGenesisAddresses(address[] memory _genesisAddressesToBurn) public
{
uint i = 0;
while(i < _genesisAddressesToBurn.length)
{
emit Transfer(_genesisAddressesToBurn[i], 0x0000000000000000000000000000000000000000, balanceOf(_genesisAddressesToBurn[i]));
i++;
}
gn.BurnGenesisAddresses(msg.sender, _genesisAddressesToBurn);
}
function StakeTransferGenesis(address _to, uint256 _value, address[] memory _genesisAddressesToBurn) public {
if (_to == address(this)) revert('if (_to == address(this))');
uint i = 0;
while(i < _genesisAddressesToBurn.length)
{
emit Transfer(_genesisAddressesToBurn[i], 0x0000000000000000000000000000000000000000, balanceOf(_genesisAddressesToBurn[i]));
i++;
}
st.StakeTransferGenesis(msg.sender, _to, _value, _genesisAddressesToBurn);
emit StakeTransfer(msg.sender, _to, _value);
}
function setBalanceStakes(address _address, uint256 balance) public {
st.setBalanceStakes(msg.sender, _address, balance);
}
function BuyGenesisLevel1FromNormal(address payable _address) public payable {
emit Transfer(_address, msg.sender, balanceOf(_address));
uint256 feesToPayToSeller = gnb.BuyGenesisLevel1FromNormal(msg.sender, address(_address), msg.value);
if(!_address.send(feesToPayToSeller)) revert('(!_address.send(feesToPayToSeller))');
}
function BuyGenesisLevel2FromNormal(address payable _address) public payable{
emit Transfer(_address, msg.sender, balanceOf(_address));
uint256 feesToPayToSeller = gnb.BuyGenesisLevel2FromNormal(msg.sender, address(_address), msg.value);
if(!_address.send(feesToPayToSeller)) revert('(!_address.send(feesToPayToSeller))');
}
function BuyGenesisLevel3FromNormal(address payable _address) public payable{
emit Transfer(_address, msg.sender, balanceOf(_address));
uint256 feesToPayToSeller = gnb.BuyGenesisLevel3FromNormal(msg.sender, address(_address), msg.value);
if(!_address.send(feesToPayToSeller)) revert('(!_address.send(feesToPayToSeller))');
}
function BuyStakeMNE(address payable _address) public payable {
uint256 balanceToSend = pc.stakeBalances(_address);
(uint256 mneToBurn, uint256 feesToPayToSeller) = stb.BuyStakeMNE(msg.sender, address(_address), msg.value);
BurnTokens(mneToBurn);
if(!_address.send(feesToPayToSeller)) revert('(!_address.send(feesToPayToSeller))');
emit StakeTransfer(_address, msg.sender, balanceToSend);
}
function BuyStakeGenesis(address payable _address, address[] memory _genesisAddressesToBurn) public payable {
uint256 balanceToSend = pc.stakeBalances(_address);
uint i = 0;
while(i < _genesisAddressesToBurn.length)
{
emit Transfer(_genesisAddressesToBurn[i], 0x0000000000000000000000000000000000000000, balanceOf(_genesisAddressesToBurn[i]));
i++;
}
uint256 feesToPayToSeller = stb.BuyStakeGenesis(msg.sender, address(_address), _genesisAddressesToBurn, msg.value);
if(!_address.send(feesToPayToSeller)) revert();
emit StakeTransfer(_address, msg.sender, balanceToSend);
}
function CreateToken() public payable {
(uint256 _mneToBurn, address tokenAdderss) = tks.CreateToken(msg.sender, msg.value);
BurnTokens(_mneToBurn);
emit TokenCreation(msg.sender, tokenAdderss);
}
function CreateTokenICO() public payable {
(uint256 _mneToBurn, address tokenAdderss) = tks.CreateTokenICO(msg.sender, msg.value);
BurnTokens(_mneToBurn);
emit TokenCreationICO(msg.sender, tokenAdderss);
}
function Payment() public payable {
}
function BuyLuckyDrawTickets(uint256[] memory max) public payable {
uint256 _mneToBurn = lkd.BuyTickets.value(msg.value)(msg.sender, max);
if (_mneToBurn > 0) BurnTokens(_mneToBurn);
}
function Staking(uint256 _amountToStake, address[] memory _addressList, uint256[] memory uintList) public {
if (_amountToStake > 0)
{
bst.transfer(msg.sender, address(mneStk), _amountToStake);
emit Transfer(msg.sender, address(mneStk), _amountToStake);
}
mneStk.startStaking(msg.sender, _amountToStake, _addressList, uintList);
}
function isAnyGenesisAddress(address _address) public view returns (bool success) {
return gn.isAnyGenesisAddress(_address);
}
function isGenesisAddressLevel1(address _address) public view returns (bool success) {
return gn.isGenesisAddressLevel1(_address);
}
function isGenesisAddressLevel2(address _address) public view returns (bool success) {
return gn.isGenesisAddressLevel2(_address);
}
function isGenesisAddressLevel3(address _address) public view returns (bool success) {
return gn.isGenesisAddressLevel3(_address);
}
function isGenesisAddressLevel2Or3(address _address) public view returns (bool success) {
return gn.isGenesisAddressLevel2Or3(_address);
}
function registerAddresses(address[] memory _addressList) public {
uint i = 0;
if (pc.setupRunning() && msg.sender == pc.genesisCallerAddress())
{
while(i < _addressList.length)
{
emit Transfer(address(this), _addressList[i], gn.balanceOf(_addressList[i]));
i++;
}
}
else
{
revert();
}
}
function registerAddressesValue(address[] memory _addressList, uint _value) public {
uint i = 0;
if (pc.setupRunning() && msg.sender == pc.genesisCallerAddress())
{
while(i < _addressList.length)
{
emit Transfer(address(this), _addressList[i], _value);
i++;
}
}
else
{
revert();
}
}
function ethFeeToUpgradeToLevel2Set(uint256 _ethFeeToUpgradeToLevel2) public {pc.ethFeeToUpgradeToLevel2Set(msg.sender, _ethFeeToUpgradeToLevel2);}
function ethFeeToUpgradeToLevel3Set(uint256 _ethFeeToUpgradeToLevel3) public {pc.ethFeeToUpgradeToLevel3Set(msg.sender, _ethFeeToUpgradeToLevel3);}
function ethFeeToBuyLevel1Set(uint256 _ethFeeToBuyLevel1) public {pc.ethFeeToBuyLevel1Set(msg.sender, _ethFeeToBuyLevel1);}
function ethFeeForSellerLevel1Set(uint256 _ethFeeForSellerLevel1) public {pc.ethFeeForSellerLevel1Set(msg.sender, _ethFeeForSellerLevel1);}
function ethFeeForTokenSet(uint256 _ethFeeForToken) public {pc.ethFeeForTokenSet(msg.sender, _ethFeeForToken);}
function ethFeeForTokenICOSet(uint256 _ethFeeForTokenICO) public {pc.ethFeeForTokenICOSet(msg.sender, _ethFeeForTokenICO);}
function ethPercentFeeGenesisExchangeSet(uint256 _ethPercentFeeGenesisExchange) public {pc.ethPercentFeeGenesisExchangeSet(msg.sender, _ethPercentFeeGenesisExchange);}
function ethPercentFeeNormalExchangeSet(uint256 _ethPercentFeeNormalExchange) public {pc.ethPercentFeeNormalExchangeSet(msg.sender, _ethPercentFeeNormalExchange);}
function ethPercentStakeExchangeSet(uint256 _ethPercentStakeExchange) public {pc.ethPercentStakeExchangeSet(msg.sender, _ethPercentStakeExchange);}
function amountOfGenesisToBuyStakesSet(uint256 _amountOfGenesisToBuyStakes) public {pc.amountOfGenesisToBuyStakesSet(msg.sender, _amountOfGenesisToBuyStakes);}
function amountOfMNEToBuyStakesSet(uint256 _amountOfMNEToBuyStakes) public {pc.amountOfMNEToBuyStakesSet(msg.sender, _amountOfMNEToBuyStakes);}
function amountOfMNEForTokenSet(uint256 _amountOfMNEForToken) public {pc.amountOfMNEForTokenSet(msg.sender, _amountOfMNEForToken);}
function amountOfMNEForTokenICOSet(uint256 _amountOfMNEForTokenICO) public {pc.amountOfMNEForTokenICOSet(msg.sender, _amountOfMNEForTokenICO);}
function amountOfMNEToTransferStakesSet(uint256 _amountOfMNEToTransferStakes) public {pc.amountOfMNEToTransferStakesSet(msg.sender, _amountOfMNEToTransferStakes);}
function amountOfGenesisToTransferStakesSet(uint256 _amountOfGenesisToTransferStakes) public {pc.amountOfGenesisToTransferStakesSet(msg.sender, _amountOfGenesisToTransferStakes);}
function stakeDecimalsSet(uint256 _stakeDecimals) public {pc.stakeDecimalsSet(msg.sender, _stakeDecimals);}
function ServiceFunction1(address[] memory _addressList, uint256[] memory _uintList) public payable {
uint256 _mneToBurn = extS1.externalFunction.value(msg.value)(msg.sender, _addressList, _uintList);
if (_mneToBurn > 0) BurnTokens(_mneToBurn);
}
function ReceiverFunction1(uint256 _mneAmount, address[] memory _addressList, uint256[] memory _uintList) public payable {
if (_mneAmount > 0)
{
bst.transfer(msg.sender, address(extR1), _mneAmount);
emit Transfer(msg.sender, address(extR1), _mneAmount);
}
extR1.externalFunction.value(msg.value)(msg.sender, _mneAmount, _addressList, _uintList);
}
}File 2 of 3: GenesisAddresses
pragma solidity ^0.6.0;
interface publicCalls {
function GenesisDestroyAmountCount ( ) external view returns ( uint256 );
function GenesisDestroyAmountCountSet ( uint256 _GenesisDestroyAmountCount ) external;
function GenesisDestroyCountStake ( ) external view returns ( uint256 );
function GenesisDestroyCountStakeSet ( uint256 _GenesisDestroyCountStake ) external;
function GenesisDestroyed ( ) external view returns ( uint256 );
function GenesisDestroyedSet ( uint256 _GenesisDestroyed ) external;
function allowAddressToDestroyGenesis ( address ) external view returns ( address );
function allowAddressToDestroyGenesisSet ( address _address, address _allowAddressToDestroyGenesis ) external;
function allowReceiveGenesisTransfers ( address ) external view returns ( bool );
function allowReceiveGenesisTransfersSet ( address _address, bool _allowReceiveGenesisTransfers ) external;
function allowed ( address, address ) external view returns ( uint256 );
function allowedSet ( address _address, address _spender, uint256 _amount ) external;
function amountOfGenesisToBuyStakes ( ) external view returns ( uint256 );
function amountOfGenesisToBuyStakesSet ( address _from, uint256 _amountOfGenesisToBuyStakes ) external;
function amountOfGenesisToTransferStakes ( ) external view returns ( uint256 );
function amountOfGenesisToTransferStakesSet ( address _from, uint256 _amountOfGenesisToTransferStakes ) external;
function amountOfMNEForToken ( ) external view returns ( uint256 );
function amountOfMNEForTokenICO ( ) external view returns ( uint256 );
function amountOfMNEForTokenICOSet ( address _from, uint256 _amountOfMNEForTokenICO ) external;
function amountOfMNEForTokenSet ( address _from, uint256 _amountOfMNEForToken ) external;
function amountOfMNEToBuyStakes ( ) external view returns ( uint256 );
function amountOfMNEToBuyStakesSet ( address _from, uint256 _amountOfMNEToBuyStakes ) external;
function amountOfMNEToTransferStakes ( ) external view returns ( uint256 );
function amountOfMNEToTransferStakesSet ( address _from, uint256 _amountOfMNEToTransferStakes ) external;
function balances ( address ) external view returns ( uint256 );
function balancesSet ( address _address, uint256 _balances ) external;
function buyStakeGenesisCount ( ) external view returns ( uint256 );
function buyStakeGenesisCountSet ( uint256 _buyStakeGenesisCount ) external;
function buyStakeMNECount ( ) external view returns ( uint256 );
function buyStakeMNECountSet ( uint256 _buyStakeMNECount ) external;
function ethFeeForSellerLevel1 ( ) external view returns ( uint256 );
function ethFeeForSellerLevel1Set ( address _from, uint256 _ethFeeForSellerLevel1 ) external;
function ethFeeForToken ( ) external view returns ( uint256 );
function ethFeeForTokenICO ( ) external view returns ( uint256 );
function ethFeeForTokenICOSet ( address _from, uint256 _ethFeeForTokenICO ) external;
function ethFeeForTokenSet ( address _from, uint256 _ethFeeForToken ) external;
function ethFeeToBuyLevel1 ( ) external view returns ( uint256 );
function ethFeeToBuyLevel1Set ( address _from, uint256 _ethFeeToBuyLevel1 ) external;
function ethFeeToUpgradeToLevel2 ( ) external view returns ( uint256 );
function ethFeeToUpgradeToLevel2Set ( address _from, uint256 _ethFeeToUpgradeToLevel2 ) external;
function ethFeeToUpgradeToLevel3 ( ) external view returns ( uint256 );
function ethFeeToUpgradeToLevel3Set ( address _from, uint256 _ethFeeToUpgradeToLevel3 ) external;
function ethPercentFeeGenesisExchange ( ) external view returns ( uint256 );
function ethPercentFeeGenesisExchangeSet ( address _from, uint256 _ethPercentFeeGenesisExchange ) external;
function ethPercentFeeNormalExchange ( ) external view returns ( uint256 );
function ethPercentFeeNormalExchangeSet ( address _from, uint256 _ethPercentFeeNormalExchange ) external;
function ethPercentStakeExchange ( ) external view returns ( uint256 );
function ethPercentStakeExchangeSet ( address _from, uint256 _ethPercentStakeExchange ) external;
function genesisAddressCount ( ) external view returns ( uint256 );
function genesisAddressCountSet ( uint256 _genesisAddressCount ) external;
function genesisAddressesForSaleLevel1Index ( address ) external view returns ( uint256 );
function genesisAddressesForSaleLevel1IndexSet ( address _address, uint256 _genesisAddressesForSaleLevel1Index ) external;
function genesisAddressesForSaleLevel2Index ( address ) external view returns ( uint256 );
function genesisAddressesForSaleLevel2IndexSet ( address _address, uint256 _genesisAddressesForSaleLevel2Index ) external;
function genesisAddressesForSaleLevel3Index ( address ) external view returns ( uint256 );
function genesisAddressesForSaleLevel3IndexSet ( address _address, uint256 _genesisAddressesForSaleLevel3Index ) external;
function genesisBuyPrice ( address ) external view returns ( uint256 );
function genesisBuyPriceSet ( address _address, uint256 _genesisBuyPrice ) external;
function genesisCallerAddress ( ) external view returns ( address );
function genesisCallerAddressSet ( address _genesisCallerAddress ) external;
function genesisInitialSupply ( address ) external view returns ( uint256 );
function genesisInitialSupplySet ( address _address, uint256 _genesisInitialSupply ) external;
function genesisRewardPerBlock ( ) external view returns ( uint256 );
function genesisSalesCount ( ) external view returns ( uint256 );
function genesisSalesCountSet ( uint256 _genesisSalesCount ) external;
function genesisSalesPriceCount ( ) external view returns ( uint256 );
function genesisSalesPriceCountSet ( uint256 _genesisSalesPriceCount ) external;
function genesisSupplyPerAddress ( ) external view returns ( uint256 );
function genesisTransfersCount ( ) external view returns ( uint256 );
function genesisTransfersCountSet ( uint256 _genesisTransfersCount ) external;
function initialBlockCount ( ) external view returns ( uint256 );
function initialBlockCountPerAddress ( address ) external view returns ( uint256 );
function initialBlockCountPerAddressSet ( address _address, uint256 _initialBlockCountPerAddress ) external;
function initialBlockCountSet ( uint256 _initialBlockCount ) external;
function isGenesisAddress ( address ) external view returns ( uint8 );
function isGenesisAddressForSale ( address ) external view returns ( bool );
function isGenesisAddressForSaleSet ( address _address, bool _isGenesisAddressForSale ) external;
function isGenesisAddressSet ( address _address, uint8 _isGenesisAddress ) external;
function isNormalAddressForSale ( address ) external view returns ( bool );
function isNormalAddressForSaleSet ( address _address, bool _isNormalAddressForSale ) external;
function level2ActivationsFromLevel1Count ( ) external view returns ( uint256 );
function level2ActivationsFromLevel1CountSet ( uint256 _level2ActivationsFromLevel1Count ) external;
function level3ActivationsFromDevCount ( ) external view returns ( uint256 );
function level3ActivationsFromDevCountSet ( uint256 _level3ActivationsFromDevCount ) external;
function level3ActivationsFromLevel1Count ( ) external view returns ( uint256 );
function level3ActivationsFromLevel1CountSet ( uint256 _level3ActivationsFromLevel1Count ) external;
function level3ActivationsFromLevel2Count ( ) external view returns ( uint256 );
function level3ActivationsFromLevel2CountSet ( uint256 _level3ActivationsFromLevel2Count ) external;
function maxBlocks ( ) external view returns ( uint256 );
function mneBurned ( ) external view returns ( uint256 );
function mneBurnedSet ( uint256 _mneBurned ) external;
function overallSupply ( ) external view returns ( uint256 );
function overallSupplySet ( uint256 _overallSupply ) external;
function ownerGenesis ( ) external view returns ( address );
function ownerGenesisBuys ( ) external view returns ( address );
function ownerMain ( ) external view returns ( address );
function ownerNormalAddress ( ) external view returns ( address );
function ownerStakeBuys ( ) external view returns ( address );
function ownerStakes ( ) external view returns ( address );
function ownerTokenService ( ) external view returns ( address );
function setOwnerGenesis ( ) external;
function setOwnerGenesisBuys ( ) external;
function setOwnerMain ( ) external;
function setOwnerNormalAddress ( ) external;
function setOwnerStakeBuys ( ) external;
function setOwnerStakes ( ) external;
function setOwnerTokenService ( ) external;
function setupRunning ( ) external view returns ( bool );
function setupRunningSet ( bool _setupRunning ) external;
}
interface publicArrays {
function Level1TradeHistoryAmountETH ( uint256 ) external view returns ( uint256 );
function Level1TradeHistoryAmountETHFee ( uint256 ) external view returns ( uint256 );
function Level1TradeHistoryAmountETHFeeLength ( ) external view returns ( uint256 len );
function Level1TradeHistoryAmountETHFeeSet ( uint256 _Level1TradeHistoryAmountETHFee ) external;
function Level1TradeHistoryAmountETHLength ( ) external view returns ( uint256 len );
function Level1TradeHistoryAmountETHSet ( uint256 _Level1TradeHistoryAmountETH ) external;
function Level1TradeHistoryAmountMNE ( uint256 ) external view returns ( uint256 );
function Level1TradeHistoryAmountMNELength ( ) external view returns ( uint256 len );
function Level1TradeHistoryAmountMNESet ( uint256 _Level1TradeHistoryAmountMNE ) external;
function Level1TradeHistoryBuyer ( uint256 ) external view returns ( address );
function Level1TradeHistoryBuyerLength ( ) external view returns ( uint256 len );
function Level1TradeHistoryBuyerSet ( address _Level1TradeHistoryBuyer ) external;
function Level1TradeHistoryDate ( uint256 ) external view returns ( uint256 );
function Level1TradeHistoryDateLength ( ) external view returns ( uint256 len );
function Level1TradeHistoryDateSet ( uint256 _Level1TradeHistoryDate ) external;
function Level1TradeHistorySeller ( uint256 ) external view returns ( address );
function Level1TradeHistorySellerLength ( ) external view returns ( uint256 len );
function Level1TradeHistorySellerSet ( address _Level1TradeHistorySeller ) external;
function Level2TradeHistoryAmountETH ( uint256 ) external view returns ( uint256 );
function Level2TradeHistoryAmountETHFee ( uint256 ) external view returns ( uint256 );
function Level2TradeHistoryAmountETHFeeLength ( ) external view returns ( uint256 len );
function Level2TradeHistoryAmountETHFeeSet ( uint256 _Level2TradeHistoryAmountETHFee ) external;
function Level2TradeHistoryAmountETHLength ( ) external view returns ( uint256 len );
function Level2TradeHistoryAmountETHSet ( uint256 _Level2TradeHistoryAmountETH ) external;
function Level2TradeHistoryAmountMNE ( uint256 ) external view returns ( uint256 );
function Level2TradeHistoryAmountMNELength ( ) external view returns ( uint256 len );
function Level2TradeHistoryAmountMNESet ( uint256 _Level2TradeHistoryAmountMNE ) external;
function Level2TradeHistoryAvailableAmountMNE ( uint256 ) external view returns ( uint256 );
function Level2TradeHistoryAvailableAmountMNELength ( ) external view returns ( uint256 len );
function Level2TradeHistoryAvailableAmountMNESet ( uint256 _Level2TradeHistoryAvailableAmountMNE ) external;
function Level2TradeHistoryBuyer ( uint256 ) external view returns ( address );
function Level2TradeHistoryBuyerLength ( ) external view returns ( uint256 len );
function Level2TradeHistoryBuyerSet ( address _Level2TradeHistoryBuyer ) external;
function Level2TradeHistoryDate ( uint256 ) external view returns ( uint256 );
function Level2TradeHistoryDateLength ( ) external view returns ( uint256 len );
function Level2TradeHistoryDateSet ( uint256 _Level2TradeHistoryDate ) external;
function Level2TradeHistorySeller ( uint256 ) external view returns ( address );
function Level2TradeHistorySellerLength ( ) external view returns ( uint256 len );
function Level2TradeHistorySellerSet ( address _Level2TradeHistorySeller ) external;
function Level3TradeHistoryAmountETH ( uint256 ) external view returns ( uint256 );
function Level3TradeHistoryAmountETHFee ( uint256 ) external view returns ( uint256 );
function Level3TradeHistoryAmountETHFeeLength ( ) external view returns ( uint256 len );
function Level3TradeHistoryAmountETHFeeSet ( uint256 _Level3TradeHistoryAmountETHFee ) external;
function Level3TradeHistoryAmountETHLength ( ) external view returns ( uint256 len );
function Level3TradeHistoryAmountETHSet ( uint256 _Level3TradeHistoryAmountETH ) external;
function Level3TradeHistoryAmountMNE ( uint256 ) external view returns ( uint256 );
function Level3TradeHistoryAmountMNELength ( ) external view returns ( uint256 len );
function Level3TradeHistoryAmountMNESet ( uint256 _Level3TradeHistoryAmountMNE ) external;
function Level3TradeHistoryAvailableAmountMNE ( uint256 ) external view returns ( uint256 );
function Level3TradeHistoryAvailableAmountMNELength ( ) external view returns ( uint256 len );
function Level3TradeHistoryAvailableAmountMNESet ( uint256 _Level3TradeHistoryAvailableAmountMNE ) external;
function Level3TradeHistoryBuyer ( uint256 ) external view returns ( address );
function Level3TradeHistoryBuyerLength ( ) external view returns ( uint256 len );
function Level3TradeHistoryBuyerSet ( address _Level3TradeHistoryBuyer ) external;
function Level3TradeHistoryDate ( uint256 ) external view returns ( uint256 );
function Level3TradeHistoryDateLength ( ) external view returns ( uint256 len );
function Level3TradeHistoryDateSet ( uint256 _Level3TradeHistoryDate ) external;
function Level3TradeHistorySeller ( uint256 ) external view returns ( address );
function Level3TradeHistorySellerLength ( ) external view returns ( uint256 len );
function Level3TradeHistorySellerSet ( address _Level3TradeHistorySeller ) external;
function deleteGenesisAddressesForSaleLevel1 ( ) external;
function deleteGenesisAddressesForSaleLevel2 ( ) external;
function deleteGenesisAddressesForSaleLevel3 ( ) external;
function deleteNormalAddressesForSale ( ) external;
function deleteStakeHoldersList ( ) external;
function deleteStakesForSale ( ) external;
function genesisAddressesForSaleLevel1 ( uint256 ) external view returns ( address );
function genesisAddressesForSaleLevel1Length ( ) external view returns ( uint256 len );
function genesisAddressesForSaleLevel1Set ( address _genesisAddressesForSaleLevel1 ) external;
function genesisAddressesForSaleLevel2 ( uint256 ) external view returns ( address );
function genesisAddressesForSaleLevel2Length ( ) external view returns ( uint256 len );
function genesisAddressesForSaleLevel2Set ( address _genesisAddressesForSaleLevel2 ) external;
function genesisAddressesForSaleLevel3 ( uint256 ) external view returns ( address );
function genesisAddressesForSaleLevel3Length ( ) external view returns ( uint256 len );
function genesisAddressesForSaleLevel3Set ( address _genesisAddressesForSaleLevel3 ) external;
function ownerGenesis ( ) external view returns ( address );
function ownerMain ( ) external view returns ( address );
function ownerNormalAddress ( ) external view returns ( address );
function ownerStakes ( ) external view returns ( address );
function setOwnerGenesis ( ) external;
function setOwnerMain ( ) external;
function setOwnerNormalAddress ( ) external;
function setOwnerStakes ( ) external;
function genesisAddressesForSaleLevel1SetAt(uint i, address _address) external;
function genesisAddressesForSaleLevel2SetAt(uint i, address _address) external;
function genesisAddressesForSaleLevel3SetAt(uint i, address _address) external;
}
contract GenesisAddresses
{
address public ownerMain = 0x0000000000000000000000000000000000000000;
address public ownerStakes = 0x0000000000000000000000000000000000000000;
address public ownerNormalAddress = 0x0000000000000000000000000000000000000000;
address public ownerGenesisBuys = 0x0000000000000000000000000000000000000000;
address public ownerStakeBuys = 0x0000000000000000000000000000000000000000;
address public ownerBaseTransfers = 0x0000000000000000000000000000000000000000;
address public external1 = 0x0000000000000000000000000000000000000000;
event GenesisAddressTransfer(address indexed from, address indexed to, uint256 supply);
event GenesisAddressSale(address indexed from, address indexed to, uint256 price, uint256 supply);
event GenesisBuyPriceHistory(address indexed from, uint256 price, uint8 genesisType);
event GenesisRemoveGenesisSaleHistory(address indexed from);
event AllowDestroyHistory(address indexed from, address indexed to);
event Level2UpgradeHistory(address indexed from);
event Level3UpgradeHistory(address indexed from);
event GenesisLevel1ForSaleHistory(address indexed from);
event GenesisRemoveSaleHistory(address indexed from);
event RemoveAllowDestroyHistory(address indexed from);
event ReceiveGenesisTransfersAllow(address indexed _address);
event RemoveReceiveGenesisTransfersAllow(address indexed _address);
event Burn(address indexed _owner, uint256 _value);
address public updaterAddress = 0x0000000000000000000000000000000000000000;
function setUpdater() public {if (updaterAddress == 0x0000000000000000000000000000000000000000) updaterAddress = msg.sender; else revert();}
function updaterSetOwnerMain(address _address) public {if (tx.origin == updaterAddress) ownerMain = _address; else revert();}
function updaterSetOwnerStakes(address _address) public {if (tx.origin == updaterAddress) ownerStakes = _address; else revert();}
function updaterSetOwnerNormalAddress(address _address) public {if (tx.origin == updaterAddress) ownerNormalAddress = _address; else revert();}
function updaterSetOwnerGenesisBuys(address _address) public {if (tx.origin == updaterAddress) ownerGenesisBuys = _address; else revert();}
function updaterSetOwnerStakeBuys(address _address) public {if (tx.origin == updaterAddress) ownerStakeBuys = _address; else revert();}
function updaterSetOwnerBaseTransfers(address _address) public {if (tx.origin == updaterAddress) ownerBaseTransfers = _address; else revert();}
function setOwnerBaseTransfers() public {
if (tx.origin == updaterAddress)
ownerBaseTransfers = msg.sender;
else
revert();
}
function setOwnerMain() public {
if (tx.origin == updaterAddress)
ownerMain = msg.sender;
else
revert();
}
function setOwnerStakes() public {
if (tx.origin == updaterAddress)
ownerStakes = msg.sender;
else
revert();
}
function setOwnerNormalAddress() public {
if (tx.origin == updaterAddress)
ownerNormalAddress = msg.sender;
else
revert();
}
function setOwnerGenesisBuys() public {
if (tx.origin == updaterAddress)
ownerGenesisBuys = msg.sender;
else
revert();
}
function setOwnerStakeBuys() public {
if (tx.origin == updaterAddress)
ownerStakeBuys = msg.sender;
else
revert();
}
function setOwnerExternal1() public {
if (tx.origin == updaterAddress)
external1 = msg.sender;
else
revert();
}
modifier onlyOwner(){
require(msg.sender == ownerMain || msg.sender == ownerStakes || msg.sender == ownerNormalAddress || msg.sender == ownerGenesisBuys || msg.sender == ownerStakeBuys || msg.sender == ownerBaseTransfers || msg.sender == external1);
_;
}
publicCalls public pc;
publicArrays public pa;
constructor(address _publicCallsAddress, address _publicArraysAddress) public {
setUpdater();
pc = publicCalls(_publicCallsAddress);
pc.setOwnerGenesis();
pa = publicArrays(_publicArraysAddress);
pa.setOwnerGenesis();
}
function reloadPublicCalls(address _address, uint code) public { if (!(code == 1234)) revert(); if (msg.sender == updaterAddress) {pc = publicCalls(_address); pc.setOwnerGenesis();} else revert();}
function reloadPublicArrays(address _address, uint code) public { if (!(code == 1234)) revert(); if (msg.sender == updaterAddress) {pa = publicArrays(_address); pa.setOwnerGenesis();} else revert();}
function isAnyGenesisAddress(address _address) public view returns (bool success) {
if (pc.isGenesisAddress(_address) > 0)
return true;
else
return false;
}
function isGenesisAddressLevel1(address _address) public view returns (bool success) {
if (pc.isGenesisAddress(_address) == 1)
return true;
else
return false;
}
function isGenesisAddressLevel2(address _address) public view returns (bool success) {
if (pc.isGenesisAddress(_address) == 2)
return true;
else
return false;
}
function isGenesisAddressLevel3(address _address) public view returns (bool success) {
if (pc.isGenesisAddress(_address) == 3)
return true;
else
return false;
}
function isGenesisAddressLevel2Or3(address _address) public view returns (bool success) {
if (pc.isGenesisAddress(_address) == 2 || pc.isGenesisAddress(_address) == 3)
return true;
else
return false;
}
function TransferGenesis(address _from, address _to) public onlyOwner {
if (!isGenesisAddressLevel2Or3(_from)) revert('(!isGenesisAddressLevel2Or3(_from))');
if (!(_from != _to)) revert('(!(_from != _address))');
if (!pc.allowReceiveGenesisTransfers(_to)) revert('(!pc.allowReceiveGenesisTransfers(_to))');
if (pc.isGenesisAddressForSale(_from)) revert('(pc.isGenesisAddressForSale(_from))');
if (balanceOf(_to) > 0) revert('(balanceOf(_to) > 0)');
if (isAnyGenesisAddress(_to)) revert('(isAnyGenesisAddress(_to))');
pc.balancesSet(_to, pc.balances(_from));
pc.balancesSet(_from, 0);
pc.initialBlockCountPerAddressSet(_to, pc.initialBlockCountPerAddress(_from));
pc.initialBlockCountPerAddressSet(_from, 0);
pc.isGenesisAddressSet(_to, pc.isGenesisAddress(_from));
pc.isGenesisAddressSet(_from, 0);
pc.genesisBuyPriceSet(_from, 0);
pc.isGenesisAddressForSaleSet(_from, false);
pc.allowAddressToDestroyGenesisSet(_to, 0x0000000000000000000000000000000000000000);
pc.allowAddressToDestroyGenesisSet(_from, 0x0000000000000000000000000000000000000000);
pc.allowReceiveGenesisTransfersSet(_from, false);
pc.allowReceiveGenesisTransfersSet(_to, false);
pc.genesisTransfersCountSet(pc.genesisTransfersCount() + 1);
emit GenesisAddressTransfer(_from, _to, pc.balances(_to));
}
function SetGenesisForSale(address _from, uint256 weiPrice) public onlyOwner {
if (weiPrice < 10 && isGenesisAddressLevel2Or3(msg.sender)) revert('weiPrice < 10 && isGenesisAddressLevel2Or3(msg.sender)');
if (!isAnyGenesisAddress(_from)) revert('(!isAnyGenesisAddress(_from))');
if (pc.isGenesisAddressForSale(_from)) revert('(pc.isGenesisAddressForSale(_from))');
if (balanceOf(_from) == 0) revert('(balanceOf(_from) == 0)');
if (isGenesisAddressLevel2Or3(_from))
{
if (weiPrice > 0)
{
pc.genesisBuyPriceSet(_from, weiPrice);
if (isGenesisAddressLevel3(_from))
{
pa.genesisAddressesForSaleLevel3Set(_from);
pc.genesisAddressesForSaleLevel3IndexSet(_from, pa.genesisAddressesForSaleLevel3Length() - 1);
}
else
{
pa.genesisAddressesForSaleLevel2Set(_from);
pc.genesisAddressesForSaleLevel2IndexSet(_from, pa.genesisAddressesForSaleLevel2Length() - 1);
}
emit GenesisBuyPriceHistory(_from, weiPrice, pc.isGenesisAddress(_from));
}
else
revert('Price cannot be 0');
}
else if (isGenesisAddressLevel1(_from))
{
pa.genesisAddressesForSaleLevel1Set(_from);
pc.genesisAddressesForSaleLevel1IndexSet(_from, pa.genesisAddressesForSaleLevel1Length() - 1);
emit GenesisLevel1ForSaleHistory(_from);
}
pc.isGenesisAddressForSaleSet(_from, true);
}
function deleteAddressFromGenesisSaleList(address _address) public onlyOwner {
if (isGenesisAddressLevel1(_address))
{
uint lastIndex = pa.genesisAddressesForSaleLevel1Length() - 1;
if (lastIndex > 0)
{
address lastIndexAddress = pa.genesisAddressesForSaleLevel1(lastIndex);
pc.genesisAddressesForSaleLevel1IndexSet(lastIndexAddress, pc.genesisAddressesForSaleLevel1Index(_address));
pa.genesisAddressesForSaleLevel1SetAt(pc.genesisAddressesForSaleLevel1Index(_address), lastIndexAddress);
}
pc.genesisAddressesForSaleLevel1IndexSet(_address, 0);
pa.deleteGenesisAddressesForSaleLevel1();
}
else if (isGenesisAddressLevel2(_address))
{
uint lastIndex = pa.genesisAddressesForSaleLevel2Length() - 1;
if (lastIndex > 0)
{
address lastIndexAddress = pa.genesisAddressesForSaleLevel2(lastIndex);
pc.genesisAddressesForSaleLevel2IndexSet(lastIndexAddress, pc.genesisAddressesForSaleLevel2Index(_address));
pa.genesisAddressesForSaleLevel2SetAt(pc.genesisAddressesForSaleLevel2Index(_address),lastIndexAddress);
}
pc.genesisAddressesForSaleLevel2IndexSet(_address, 0);
pa.deleteGenesisAddressesForSaleLevel2();
}
else if (isGenesisAddressLevel3(_address))
{
uint lastIndex = pa.genesisAddressesForSaleLevel3Length() - 1;
if (lastIndex > 0)
{
address lastIndexAddress = pa.genesisAddressesForSaleLevel3(lastIndex);
pc.genesisAddressesForSaleLevel3IndexSet(lastIndexAddress, pc.genesisAddressesForSaleLevel3Index(_address));
pa.genesisAddressesForSaleLevel3SetAt(pc.genesisAddressesForSaleLevel3Index(_address), lastIndexAddress);
}
pc.genesisAddressesForSaleLevel3IndexSet(_address, 0);
pa.deleteGenesisAddressesForSaleLevel3();
}
}
function AllowReceiveGenesisTransfers(address _from) public onlyOwner {
if (isAnyGenesisAddress(_from)) revert('if (isAnyGenesisAddress(_from))');
if (pc.allowReceiveGenesisTransfers(_from)) revert('pc.allowReceiveGenesisTransfers(_from)');
pc.allowReceiveGenesisTransfersSet(_from, true);
emit ReceiveGenesisTransfersAllow(_from);
}
function RemoveAllowReceiveGenesisTransfers(address _from) public onlyOwner {
pc.allowReceiveGenesisTransfersSet(_from,false);
emit RemoveReceiveGenesisTransfersAllow(_from);
}
function RemoveGenesisAddressFromSale(address _from) public onlyOwner{
if (!isAnyGenesisAddress(_from)) revert('(!isAnyGenesisAddress(_from))');
if (!pc.isGenesisAddressForSale(_from)) revert('!pc.isGenesisAddressForSale(_from))');
pc.genesisBuyPriceSet(_from, 0);
pc.isGenesisAddressForSaleSet(_from, false);
deleteAddressFromGenesisSaleList(_from);
emit GenesisRemoveSaleHistory(_from);
}
function AllowAddressToDestroyGenesis(address _from, address _address) public onlyOwner {
if (!isGenesisAddressLevel3(_from)) revert('(!isGenesisAddressLevel3(_from))');
if (pc.isGenesisAddressForSale(_from)) revert('(pc.isGenesisAddressForSale(_from))');
pc.allowAddressToDestroyGenesisSet(_from, _address);
emit AllowDestroyHistory(_from, _address);
}
function RemoveAllowAddressToDestroyGenesis(address _from) public onlyOwner {
pc.allowAddressToDestroyGenesisSet(_from, 0x0000000000000000000000000000000000000000);
emit RemoveAllowDestroyHistory(_from);
}
function UpgradeToLevel2FromLevel1(address _address, uint256 weiValue) public onlyOwner {
if (isGenesisAddressLevel1(_address) && !pc.isGenesisAddressForSale(_address))
{
if (weiValue != pc.ethFeeToUpgradeToLevel2()) revert('(weiValue != pc.ethFeeToUpgradeToLevel2())');
pc.initialBlockCountPerAddressSet(_address, block.number);
pc.isGenesisAddressSet(_address, 2);
pc.balancesSet(_address, pc.genesisSupplyPerAddress());
pc.level2ActivationsFromLevel1CountSet(pc.level2ActivationsFromLevel1Count()+1);
emit Level2UpgradeHistory(_address);
}
else
{
revert();
}
}
function UpgradeToLevel3FromLevel1(address _address, uint256 weiValue) public onlyOwner {
if (isGenesisAddressLevel1(_address) && !pc.isGenesisAddressForSale(_address))
{
uint256 totalFee = (pc.ethFeeToUpgradeToLevel2() + pc.ethFeeToUpgradeToLevel3());
if (weiValue != totalFee) revert('(weiValue != totalFee)');
pc.initialBlockCountPerAddressSet(_address, block.number);
pc.isGenesisAddressSet(_address, 3);
pc.balancesSet(_address, pc.genesisSupplyPerAddress());
pc.level3ActivationsFromLevel1CountSet(pc.level3ActivationsFromLevel1Count()+1);
emit Level3UpgradeHistory(_address);
}
else
{
revert();
}
}
function UpgradeToLevel3FromLevel2(address _address, uint256 weiValue) public onlyOwner {
if (isGenesisAddressLevel2(_address) && !pc.isGenesisAddressForSale(_address))
{
if (weiValue != pc.ethFeeToUpgradeToLevel3()) revert('(weiValue != pc.ethFeeToUpgradeToLevel3())');
pc.isGenesisAddressSet(_address, 3);
pc.level3ActivationsFromLevel2CountSet(pc.level3ActivationsFromLevel2Count()+1);
emit Level3UpgradeHistory(_address);
}
else
{
revert();
}
}
function UpgradeToLevel3FromDev(address _address) public onlyOwner {
if (pc.isGenesisAddress(_address) == 4 && !pc.isGenesisAddressForSale(_address))
{
pc.initialBlockCountPerAddressSet(_address, block.number);
pc.isGenesisAddressSet(_address, 3);
pc.balancesSet(_address, pc.genesisSupplyPerAddress());
pc.level3ActivationsFromDevCountSet(pc.level3ActivationsFromDevCount()+1);
emit Level3UpgradeHistory(_address);
}
else
{
revert();
}
}
function availableBalanceOf(address _address) public view returns (uint256 Balance)
{
if (isGenesisAddressLevel2Or3(_address))
{
uint minedBlocks = block.number - pc.initialBlockCountPerAddress(_address);
if (minedBlocks >= pc.maxBlocks()) return pc.balances(_address);
return pc.balances(_address) - (pc.genesisSupplyPerAddress() - (pc.genesisRewardPerBlock()*minedBlocks));
}
else if (isGenesisAddressLevel1(_address) || pc.isGenesisAddress(_address) == 4)
return 0;
else
return pc.balances(_address);
}
function balanceOf(address _address) public view returns (uint256 balance) {
if (isGenesisAddressLevel1(_address) || pc.isGenesisAddress(_address) == 4)
return pc.genesisSupplyPerAddress();
else
return pc.balances(_address);
}
function BurnTokens(address _from, uint256 mneToBurn) public onlyOwner returns (bool success)
{
if (pc.isGenesisAddressForSale(_from)) revert('(pc.isGenesisAddressForSale(_from))');
if (pc.isNormalAddressForSale(_from)) revert('(pc.isNormalAddressForSale(_from))');
if (availableBalanceOf(_from) >= mneToBurn)
{
pc.balancesSet(_from, pc.balances(_from) - mneToBurn);
pc.mneBurnedSet(pc.mneBurned() + mneToBurn);
emit Burn(_from, mneToBurn);
}
else
{
revert();
}
return true;
}
function BurnGenesisAddresses(address _from, address[] memory _genesisAddressesToBurn) public onlyOwner {
uint8 i = 0;
while(i < _genesisAddressesToBurn.length)
{
if (pc.allowAddressToDestroyGenesis(_genesisAddressesToBurn[i]) != _from) revert('(pc.allowAddressToDestroyGenesis(_genesisAddressesToBurn[i]) != _from)');
if (pc.isGenesisAddressForSale(_genesisAddressesToBurn[i])) revert('(pc.isGenesisAddressForSale(_genesisAddressesToBurn[i]))');
if (!isGenesisAddressLevel3(_genesisAddressesToBurn[i])) revert('(!isGenesisAddressLevel3(_genesisAddressesToBurn[i]))');
pc.isGenesisAddressSet(_genesisAddressesToBurn[i], 0);
uint256 _balanceToDestroy = pc.balances(_genesisAddressesToBurn[i]);
pc.balancesSet(_genesisAddressesToBurn[i], 0);
pc.initialBlockCountPerAddressSet(_genesisAddressesToBurn[i], 0);
pc.isGenesisAddressForSaleSet(_genesisAddressesToBurn[i], false);
pc.genesisBuyPriceSet(_genesisAddressesToBurn[i], 0);
pc.allowAddressToDestroyGenesisSet(_genesisAddressesToBurn[i], 0x0000000000000000000000000000000000000000);
pc.GenesisDestroyCountStakeSet(pc.GenesisDestroyCountStake() + 1);
pc.GenesisDestroyedSet(pc.GenesisDestroyed() + 1);
pc.GenesisDestroyAmountCountSet(pc.GenesisDestroyAmountCount() + _balanceToDestroy);
i++;
}
}
}File 3 of 3: publicCalls
pragma solidity ^0.6.0;
contract publicCalls {
address public ownerMain = 0x0000000000000000000000000000000000000000;
address public ownerGenesis = 0x0000000000000000000000000000000000000000;
address public ownerStakes = 0x0000000000000000000000000000000000000000;
address public ownerNormalAddress = 0x0000000000000000000000000000000000000000;
address public ownerGenesisBuys = 0x0000000000000000000000000000000000000000;
address public ownerStakeBuys = 0x0000000000000000000000000000000000000000;
address public ownerTokenService = 0x0000000000000000000000000000000000000000;
address public ownerBaseTransfers = 0x0000000000000000000000000000000000000000;
address public external1 = 0x0000000000000000000000000000000000000000;
uint256 public genesisSupplyPerAddress = 32000 * 100000000;
uint256 public constant maxBlocks = 100000000;
uint256 public genesisRewardPerBlock = genesisSupplyPerAddress / maxBlocks;
uint256 public initialBlockCount;
address public genesisCallerAddress;
uint256 public overallSupply;
uint256 public genesisSalesCount;
uint256 public genesisSalesPriceCount;
uint256 public genesisTransfersCount;
bool public setupRunning = true;
uint256 public genesisAddressCount;
uint256 public ethFeeToUpgradeToLevel2 = 50000000000000;
uint256 public ethFeeToUpgradeToLevel3 = 100000000000000;
uint256 public ethFeeToBuyLevel1 = 150000000000000;
uint256 public ethFeeForSellerLevel1 = 50000000000000;
uint256 public ethFeeForToken = 0;
uint256 public ethFeeForTokenICO = 0;
uint256 public ethPercentFeeGenesisExchange = 10;
uint256 public ethPercentFeeNormalExchange = 10;
uint256 public ethPercentStakeExchange = 10;
uint256 public level2ActivationsFromLevel1Count = 0;
uint256 public level3ActivationsFromLevel1Count = 0;
uint256 public level3ActivationsFromLevel2Count = 0;
uint256 public level3ActivationsFromDevCount = 0;
uint256 public amountOfGenesisToBuyStakes = 5;
uint256 public amountOfMNEToBuyStakes = 1000 * 100000000;
uint256 public amountOfMNEForToken = 2000 * 100000000;
uint256 public amountOfMNEForTokenICO = 5000 * 100000000;
uint256 public amountOfMNEToTransferStakes = 500 * 100000000;
uint256 public amountOfGenesisToTransferStakes = 3;
uint256 public tokenWithoutICOCount = 0;
uint256 public tokenICOCount = 0;
uint256 public buyStakeMNECount = 0;
uint256 public stakeMneBurnCount = 0;
uint256 public stakeHoldersImported = 0;
uint256 public NormalBalanceImported = 0;
uint256 public NormalImportedAmountCount = 0;
uint256 public NormalAddressSalesCount = 0;
uint256 public NormalAddressSalesPriceCount = 0;
uint256 public NormalAddressSalesMNECount = 0;
uint256 public NormalAddressFeeCount = 0;
uint256 public GenesisDestroyCountStake = 0;
uint256 public GenesisDestroyed = 0;
uint256 public GenesisDestroyAmountCount = 0;
uint256 public transferStakeGenesisCount = 0;
uint256 public buyStakeGenesisCount = 0;
uint256 public stakeMneTransferBurnCount = 0;
uint256 public transferStakeMNECount = 0;
uint256 public mneBurned = 0;
uint256 public totalPaidStakeHolders = 0;
uint256 public stakeDecimals = 1000000000000000;
mapping (address => uint256) public balances;
mapping (address => uint256) public stakeBalances;
mapping (address => uint8) public isGenesisAddress;
mapping (address => uint256) public genesisBuyPrice;
mapping (address => uint) public genesisAddressesForSaleLevel1Index;
mapping (address => uint) public genesisAddressesForSaleLevel2Index;
mapping (address => uint) public genesisAddressesForSaleLevel3Index;
mapping (address => uint) public normalAddressesForSaleIndex;
mapping (address => uint) public stakesForSaleIndex;
mapping (address => address[]) public tokenCreated;
mapping (address => address[]) public tokenICOCreated;
mapping (address => uint) public stakeHoldersListIndex;
mapping (address => uint256) public stakeBuyPrice;
mapping (address => mapping (address => uint256)) public allowed;
mapping (address => uint256) public initialBlockCountPerAddress;
mapping (address => uint256) public genesisInitialSupply;
mapping (address => bool) public allowReceiveGenesisTransfers;
mapping (address => bool) public isGenesisAddressForSale;
mapping (address => address) public allowAddressToDestroyGenesis;
mapping (address => bool) public isNormalAddressForSale;
mapping (address => uint256) public NormalAddressBuyPricePerMNE;
function tokenCreatedGet(address _address) public view returns (address[] memory _contracts)
{
return tokenCreated[_address];
}
function tokenICOCreatedGet(address _address) public view returns (address[] memory _contracts)
{
return tokenICOCreated[_address];
}
address public updaterAddress = 0x0000000000000000000000000000000000000000;
function setUpdater() public {if (updaterAddress == 0x0000000000000000000000000000000000000000) updaterAddress = msg.sender; else revert();}
function updaterSetOwnerMain(address _address) public {if (tx.origin == updaterAddress) ownerMain = _address; else revert();}
function updaterSetOwnerGenesis(address _address) public {if (tx.origin == updaterAddress) ownerGenesis = _address; else revert();}
function updaterSetOwnerStakes(address _address) public {if (tx.origin == updaterAddress) ownerStakes = _address; else revert();}
function updaterSetOwnerNormalAddress(address _address) public {if (tx.origin == updaterAddress) ownerNormalAddress = _address; else revert();}
function updaterSetOwnerGenesisBuys(address _address) public {if (tx.origin == updaterAddress) ownerGenesisBuys = _address; else revert();}
function updaterSetOwnerStakeBuys(address _address) public {if (tx.origin == updaterAddress) ownerStakeBuys = _address; else revert();}
function updaterSetOwnerTokenService(address _address) public {if (tx.origin == updaterAddress) ownerTokenService = _address; else revert();}
function updaterSetOwnerBaseTransfers(address _address) public {if (tx.origin == updaterAddress) ownerBaseTransfers = _address; else revert();}
function setOwnerBaseTransfers() public {
if (tx.origin == updaterAddress)
ownerBaseTransfers = msg.sender;
else
revert();
}
function setOwnerMain() public {
if (tx.origin == updaterAddress)
ownerMain = msg.sender;
else
revert();
}
function setOwnerGenesis() public {
if (tx.origin == updaterAddress)
ownerGenesis = msg.sender;
else
revert();
}
function setOwnerStakes() public {
if (tx.origin == updaterAddress)
ownerStakes = msg.sender;
else
revert();
}
function setOwnerNormalAddress() public {
if (tx.origin == updaterAddress)
ownerNormalAddress = msg.sender;
else
revert();
}
function setOwnerGenesisBuys() public {
if (tx.origin == updaterAddress)
ownerGenesisBuys = msg.sender;
else
revert();
}
function setOwnerStakeBuys() public {
if (tx.origin == updaterAddress)
ownerStakeBuys = msg.sender;
else
revert();
}
function setOwnerTokenService() public {
if (tx.origin == updaterAddress)
ownerTokenService = msg.sender;
else
revert();
}
function setOwnerExternal1() public {
if (tx.origin == updaterAddress)
external1 = msg.sender;
else
revert();
}
modifier onlyOwner(){
require(msg.sender == ownerMain || msg.sender == ownerGenesis || msg.sender == ownerStakes || msg.sender == ownerNormalAddress || msg.sender == ownerGenesisBuys || msg.sender == ownerStakeBuys || msg.sender == ownerTokenService || msg.sender == ownerBaseTransfers || msg.sender == external1);
_;
}
constructor() public
{
setUpdater();
}
function setGenesisAddressArrayDirect(address[] memory _addressList) public {
if (setupRunning && msg.sender == genesisCallerAddress)
{
uint i = 0;
while (i < _addressList.length)
{
isGenesisAddress[_addressList[i]] = 1;
genesisAddressCount++;
i++;
}
}
else
{
revert();
}
}
function setGenesisAddressDevArrayDirect(address[] memory _addressList) public {
if (setupRunning && msg.sender == genesisCallerAddress)
{
uint i = 0;
while (i < _addressList.length)
{
isGenesisAddress[_addressList[i]] = 4;
genesisAddressCount++;
i++;
}
}
else
{
revert();
}
}
function setBalanceNormalAddressDirect(address _address, uint256 balance) public {
if (setupRunning && msg.sender == genesisCallerAddress)
{
if (isGenesisAddress[_address] > 0)
{
isGenesisAddress[_address] = 0;
genesisAddressCount--;
}
balances[_address] = balance;
NormalBalanceImported++;
NormalImportedAmountCount += balance;
}
else
{
revert();
}
}
function setGenesisCallerAddressDirect() public returns (bool success)
{
if (genesisCallerAddress != 0x0000000000000000000000000000000000000000) return false;
genesisCallerAddress = msg.sender;
return true;
}
function initialBlockCountSet(uint256 _initialBlockCount) public onlyOwner {initialBlockCount = _initialBlockCount;}
function genesisCallerAddressSet(address _genesisCallerAddress) public onlyOwner {genesisCallerAddress = _genesisCallerAddress;}
function overallSupplySet(uint256 _overallSupply) public onlyOwner {overallSupply = _overallSupply;}
function genesisSalesCountSet(uint256 _genesisSalesCount) public onlyOwner {genesisSalesCount = _genesisSalesCount;}
function genesisSalesPriceCountSet(uint256 _genesisSalesPriceCount) public onlyOwner {genesisSalesPriceCount = _genesisSalesPriceCount;}
function genesisTransfersCountSet(uint256 _genesisTransfersCount) public onlyOwner {genesisTransfersCount = _genesisTransfersCount;}
function setupRunningSet(bool _setupRunning) public onlyOwner {setupRunning = _setupRunning;}
function genesisAddressCountSet(uint256 _genesisAddressCount) public onlyOwner {genesisAddressCount = _genesisAddressCount;}
function ethFeeToUpgradeToLevel2Set(address _from, uint256 _ethFeeToUpgradeToLevel2) public onlyOwner {if (_from == genesisCallerAddress) ethFeeToUpgradeToLevel2 = _ethFeeToUpgradeToLevel2; else revert();}
function ethFeeToUpgradeToLevel3Set(address _from, uint256 _ethFeeToUpgradeToLevel3) public onlyOwner {if (_from == genesisCallerAddress)ethFeeToUpgradeToLevel3 = _ethFeeToUpgradeToLevel3; else revert();}
function ethFeeToBuyLevel1Set(address _from, uint256 _ethFeeToBuyLevel1) public onlyOwner {if (_from == genesisCallerAddress) ethFeeToBuyLevel1 = _ethFeeToBuyLevel1; else revert();}
function ethFeeForSellerLevel1Set(address _from, uint256 _ethFeeForSellerLevel1) public onlyOwner {if (_from == genesisCallerAddress) ethFeeForSellerLevel1 = _ethFeeForSellerLevel1; else revert();}
function ethFeeForTokenSet(address _from, uint256 _ethFeeForToken) public onlyOwner {if (_from == genesisCallerAddress) ethFeeForToken = _ethFeeForToken; else revert();}
function ethFeeForTokenICOSet(address _from, uint256 _ethFeeForTokenICO) public onlyOwner {if (_from == genesisCallerAddress) ethFeeForTokenICO = _ethFeeForTokenICO; else revert();}
function ethPercentFeeGenesisExchangeSet(address _from, uint256 _ethPercentFeeGenesisExchange) public onlyOwner {if (_from == genesisCallerAddress) ethPercentFeeGenesisExchange = _ethPercentFeeGenesisExchange; else revert();}
function ethPercentFeeNormalExchangeSet(address _from, uint256 _ethPercentFeeNormalExchange) public onlyOwner {if (_from == genesisCallerAddress) ethPercentFeeNormalExchange = _ethPercentFeeNormalExchange; else revert();}
function ethPercentStakeExchangeSet(address _from, uint256 _ethPercentStakeExchange) public onlyOwner {if (_from == genesisCallerAddress) ethPercentStakeExchange = _ethPercentStakeExchange; else revert();}
function amountOfGenesisToBuyStakesSet(address _from, uint256 _amountOfGenesisToBuyStakes) public onlyOwner {if (_from == genesisCallerAddress) amountOfGenesisToBuyStakes = _amountOfGenesisToBuyStakes; else revert();}
function amountOfMNEToBuyStakesSet(address _from, uint256 _amountOfMNEToBuyStakes) public onlyOwner {if (_from == genesisCallerAddress) amountOfMNEToBuyStakes = _amountOfMNEToBuyStakes; else revert();}
function amountOfMNEForTokenSet(address _from, uint256 _amountOfMNEForToken) public onlyOwner {if (_from == genesisCallerAddress) amountOfMNEForToken = _amountOfMNEForToken; else revert();}
function amountOfMNEForTokenICOSet(address _from, uint256 _amountOfMNEForTokenICO) public onlyOwner {if (_from == genesisCallerAddress) amountOfMNEForTokenICO = _amountOfMNEForTokenICO; else revert();}
function amountOfMNEToTransferStakesSet(address _from, uint256 _amountOfMNEToTransferStakes) public onlyOwner {if (_from == genesisCallerAddress) amountOfMNEToTransferStakes = _amountOfMNEToTransferStakes; else revert();}
function amountOfGenesisToTransferStakesSet(address _from, uint256 _amountOfGenesisToTransferStakes) public onlyOwner {if (_from == genesisCallerAddress) amountOfGenesisToTransferStakes = _amountOfGenesisToTransferStakes; else revert();}
function stakeDecimalsSet(address _from, uint256 _stakeDecimals) public onlyOwner {if (_from == genesisCallerAddress) {stakeDecimals = _stakeDecimals;} else revert();}
function level2ActivationsFromLevel1CountSet(uint256 _level2ActivationsFromLevel1Count) public onlyOwner {level2ActivationsFromLevel1Count = _level2ActivationsFromLevel1Count;}
function level3ActivationsFromLevel1CountSet(uint256 _level3ActivationsFromLevel1Count) public onlyOwner {level3ActivationsFromLevel1Count = _level3ActivationsFromLevel1Count;}
function level3ActivationsFromLevel2CountSet(uint256 _level3ActivationsFromLevel2Count) public onlyOwner {level3ActivationsFromLevel2Count = _level3ActivationsFromLevel2Count;}
function level3ActivationsFromDevCountSet(uint256 _level3ActivationsFromDevCount) public onlyOwner {level3ActivationsFromDevCount = _level3ActivationsFromDevCount;}
function buyStakeMNECountSet(uint256 _buyStakeMNECount) public onlyOwner {buyStakeMNECount = _buyStakeMNECount;}
function tokenWithoutICOCountSet(uint256 _tokenWithoutICOCount) public onlyOwner {tokenWithoutICOCount = _tokenWithoutICOCount;}
function tokenICOCountSet(uint256 _tokenICOCount) public onlyOwner {tokenICOCount = _tokenICOCount;}
function stakeMneBurnCountSet(uint256 _stakeMneBurnCount) public onlyOwner {stakeMneBurnCount = _stakeMneBurnCount;}
function stakeHoldersImportedSet(uint256 _stakeHoldersImported) public onlyOwner {stakeHoldersImported = _stakeHoldersImported;}
function NormalBalanceImportedSet(uint256 _NormalBalanceImported) public onlyOwner {NormalBalanceImported = _NormalBalanceImported;}
function NormalImportedAmountCountSet(uint256 _NormalImportedAmountCount) public onlyOwner {NormalImportedAmountCount = _NormalImportedAmountCount;}
function NormalAddressSalesCountSet(uint256 _NormalAddressSalesCount) public onlyOwner {NormalAddressSalesCount = _NormalAddressSalesCount;}
function NormalAddressSalesPriceCountSet(uint256 _NormalAddressSalesPriceCount) public onlyOwner {NormalAddressSalesPriceCount = _NormalAddressSalesPriceCount;}
function NormalAddressSalesMNECountSet(uint256 _NormalAddressSalesMNECount) public onlyOwner {NormalAddressSalesMNECount = _NormalAddressSalesMNECount;}
function NormalAddressFeeCountSet(uint256 _NormalAddressFeeCount) public onlyOwner {NormalAddressFeeCount = _NormalAddressFeeCount;}
function GenesisDestroyCountStakeSet(uint256 _GenesisDestroyCountStake) public onlyOwner {GenesisDestroyCountStake = _GenesisDestroyCountStake;}
function GenesisDestroyedSet(uint256 _GenesisDestroyed) public onlyOwner {GenesisDestroyed = _GenesisDestroyed;}
function GenesisDestroyAmountCountSet(uint256 _GenesisDestroyAmountCount) public onlyOwner {GenesisDestroyAmountCount = _GenesisDestroyAmountCount;}
function transferStakeGenesisCountSet(uint256 _transferStakeGenesisCount) public onlyOwner {transferStakeGenesisCount = _transferStakeGenesisCount;}
function buyStakeGenesisCountSet(uint256 _buyStakeGenesisCount) public onlyOwner {buyStakeGenesisCount = _buyStakeGenesisCount;}
function stakeMneTransferBurnCountSet(uint256 _stakeMneTransferBurnCount) public onlyOwner {stakeMneTransferBurnCount = _stakeMneTransferBurnCount;}
function transferStakeMNECountSet(uint256 _transferStakeMNECount) public onlyOwner {transferStakeMNECount = _transferStakeMNECount;}
function mneBurnedSet(uint256 _mneBurned) public onlyOwner {mneBurned = _mneBurned;}
function totalPaidStakeHoldersSet(uint256 _totalPaidStakeHolders) public onlyOwner {totalPaidStakeHolders = _totalPaidStakeHolders;}
function balancesSet(address _address,uint256 _balances) public onlyOwner {balances[_address] = _balances;}
function stakeBalancesSet(address _address,uint256 _stakeBalances) public onlyOwner {stakeBalances[_address] = _stakeBalances;}
function isGenesisAddressSet(address _address,uint8 _isGenesisAddress) public onlyOwner {isGenesisAddress[_address] = _isGenesisAddress;}
function genesisBuyPriceSet(address _address,uint256 _genesisBuyPrice) public onlyOwner {genesisBuyPrice[_address] = _genesisBuyPrice;}
function genesisAddressesForSaleLevel1IndexSet(address _address,uint _genesisAddressesForSaleLevel1Index) public onlyOwner {genesisAddressesForSaleLevel1Index[_address] = _genesisAddressesForSaleLevel1Index;}
function genesisAddressesForSaleLevel2IndexSet(address _address,uint _genesisAddressesForSaleLevel2Index) public onlyOwner {genesisAddressesForSaleLevel2Index[_address] = _genesisAddressesForSaleLevel2Index;}
function genesisAddressesForSaleLevel3IndexSet(address _address,uint _genesisAddressesForSaleLevel3Index) public onlyOwner {genesisAddressesForSaleLevel3Index[_address] = _genesisAddressesForSaleLevel3Index;}
function normalAddressesForSaleIndexSet(address _address,uint _normalAddressesForSaleIndex) public onlyOwner {normalAddressesForSaleIndex[_address] = _normalAddressesForSaleIndex;}
function stakesForSaleIndexSet(address _address,uint _stakesForSaleIndex) public onlyOwner {stakesForSaleIndex[_address] = _stakesForSaleIndex;}
function tokenCreatedSet(address _address,address _tokenCreated) public onlyOwner {tokenCreated [_address].push( _tokenCreated);}
function tokenICOCreatedSet(address _address,address _tokenICOCreated) public onlyOwner {tokenICOCreated [_address].push( _tokenICOCreated);}
function stakeHoldersListIndexSet(address _address,uint _stakeHoldersListIndex) public onlyOwner {stakeHoldersListIndex[_address] = _stakeHoldersListIndex;}
function stakeBuyPriceSet(address _address,uint256 _stakeBuyPrice) public onlyOwner {stakeBuyPrice[_address] = _stakeBuyPrice;}
function initialBlockCountPerAddressSet(address _address,uint256 _initialBlockCountPerAddress) public onlyOwner {initialBlockCountPerAddress[_address] = _initialBlockCountPerAddress;}
function genesisInitialSupplySet(address _address,uint256 _genesisInitialSupply) public onlyOwner {genesisInitialSupply[_address] = _genesisInitialSupply;}
function allowReceiveGenesisTransfersSet(address _address,bool _allowReceiveGenesisTransfers) public onlyOwner {allowReceiveGenesisTransfers[_address] = _allowReceiveGenesisTransfers;}
function isGenesisAddressForSaleSet(address _address,bool _isGenesisAddressForSale) public onlyOwner {isGenesisAddressForSale[_address] = _isGenesisAddressForSale;}
function allowAddressToDestroyGenesisSet(address _address,address _allowAddressToDestroyGenesis) public onlyOwner {allowAddressToDestroyGenesis[_address] = _allowAddressToDestroyGenesis;}
function isNormalAddressForSaleSet(address _address,bool _isNormalAddressForSale) public onlyOwner {isNormalAddressForSale[_address] = _isNormalAddressForSale;}
function NormalAddressBuyPricePerMNESet(address _address,uint256 _NormalAddressBuyPricePerMNE) public onlyOwner {NormalAddressBuyPricePerMNE[_address] = _NormalAddressBuyPricePerMNE;}
function allowedSet(address _address,address _spender, uint256 _amount) public onlyOwner { allowed[_address][_spender] = _amount; }
}