Прагма монолитность ^ 0.4.10; 

Контракт minereum { 

строка публичное имя; 
строка общественного символа; 
uint8 государственных знаков после запятой; 
uint256 общественного initialSupplyPerAddress;
uint256 общественного initialBlockCount;
uint256 общественного rewardPerBlockPerAddress;
uint256 общественных totalGenesisAddresses;
uint256 частный availableAmount;
uint256 частный availableBalance;
uint256 частные minedBlocks;
uint256 частный totalMaxAvailableAmount;
uint256 частный balanceOfAddress;



отображение (адрес => uint256) общественного balanceOf; 
отображение (адрес => BOOL) общественного genesisAddress; 

Передача события (адрес индексируются, индексированные по адресу, значение uint256); 

Функция minereum () { 

имя = "minereum"; 
символ = "МНК"; 
десятичные = 8; 
initialSupplyPerAddress = 3200000000000;
initialBlockCount = 3516521;
rewardPerBlockPerAddress = 32000;
totalGenesisAddresses = 4269;

balanceOf [0x000018e8a5f1e402763f4d3c2a02288f7f7a7256] = initialSupplyPerAddress;
genesisAddress [0x000018e8a5f1e402763f4d3c2a02288f7f7a7256] = TRUE;
balanceOf [0x00076f0Cdf32c586a064f4e08c7613521d922e5f] = initialSupplyPerAddress;
genesisAddress [0x00076f0Cdf32c586a064f4e08c7613521d922e5f] = TRUE;
balanceOf [0x000779F69bf39d4DF8f007275CF3f90a9A07Adc1] = initialSupplyPerAddress;
genesisAddress [0x000779F69bf39d4DF8f007275CF3f90a9A07Adc1] = TRUE;
balanceOf [0x000adC2EE215Ba7E4f599C4Ff35C35237eD382EA] = initialSupplyPerAddress;
genesisAddress [0x000adC2EE215Ba7E4f599C4Ff35C35237eD382EA] = TRUE;
balanceOf [0x000c236D5a264238e8c38FcBd763D6DB049BA126] = initialSupplyPerAddress;
genesisAddress [0x000c236D5a264238e8c38FcBd763D6DB049BA126] = TRUE;
...
Функция currentEthBlock () возвращает постоянные (uint256 blockNumber)
{
	вернуться block.number;
}

Функция currentBlock () возвращает постоянные (uint256 blockNumber)
{
	вернуться block.number - initialBlockCount;
}

Функция availableBalanceOf (адрес _address) постоянная отдача (uint256 Balance)
{
	если (genesisAddress [_address])
	{
		minedBlocks = block.number - initialBlockCount;
		
		если (minedBlocks >= 100000000) возвращение balanceOf [_address];
		
		availableAmount = rewardPerBlockPerAddress * minedBlocks;
		
		totalMaxAvailableAmount = initialSupplyPerAddress - availableAmount;
		
		availableBalance = balanceOf [_address] - totalMaxAvailableAmount;
		
		вернуться availableBalance;
	}
	еще
		вернуть balanceOf [_address];
}

Функция totalSupply () возвращает (постоянные uint256 totalSupply)
{	
	minedBlocks = block.number - initialBlockCount;
	availableAmount = rewardPerBlockPerAddress * minedBlocks;
	вернуться availableAmount * totalGenesisAddresses;
}

функционировать maxTotalSupply () возвращает постоянные (uint256 maxSupply)
{	
	вернуться initialSupplyPerAddress * totalGenesisAddresses;
}

Передаточная функция (адрес _to, uint256 _value) { 

если (genesisAddress [_to]) выбросить;

если (balanceOf [msg.sender] < _value) бросить; 

если (balanceOf [_to] + _value < balanceOf [_to]) выбросить; 

если (genesisAddress [msg.sender])
{
	minedBlocks = block.number - initialBlockCount;
	если (minedBlocks < 100000000)
	{
		availableAmount = rewardPerBlockPerAddress * minedBlocks;
			
		totalMaxAvailableAmount = initialSupplyPerAddress - availableAmount;
		
		availableBalance = balanceOf [msg.sender] - totalMaxAvailableAmount;
			
		если (_value > availableBalance) бросить;
	}
}

balanceOf [msg.sender] - = _value; 
balanceOf [_to] + = _value; 
Передача (msg.sender, _to, _value); 
} 
}

Прагма монолитность ^ 0.4.11;

контракт SafeMath {
  функционировать safeMul (UINT а, UINT б) внутренние возвращается (UINT) 
    UINT C = A * B;
    утверждают (а == 0 
  функционировать safeSub (UINT а, UINT б) внутренние возвращает (UINT) {
    утверждают (б <= А);
    возвращать - б;
  }
  функционировать safeAdd (UINT а, UINT б) внутренние возвращает (UINT) {
    UINT с = а + Ь;
    утверждать (с>= а && с>= Б);
    вернуться с;
  }
  Функция утверждают (BOOL утверждение) внутренний {
    если (утверждение!) бросить;
  }
}
 
контракт Autoria является SafeMath {
    // переменные ERC20
    строка общественности постоянная символ = "AUT";
    строка общественное имя константы = "Autorium";
    uint8 общественных постоянных знаков после запятой = 18;
    uint256 общественного _totalSupply = 100000000000000000000000000;

    // Autoria конкретные переменные
    uint256 CreationTime = Теперь;
    uint256 gensisBlock = block.number;
    uint256 blocksUntilExhaustion = 2102666;
    
    uint256 общественного earlySalePrice = 1000000000000000000;
    uint256 общественного regularSalePrice = 1300000000000000000;
    uint256 общественного exchangeRate = 17500;
    uint256 общественного freeTokenSupply = _totalSupply;
    uint256 общественного retainedSupplyPercentage = 30;
    
    // Владелец этого договора
    Адрес эмитента;
    
    Передача события (адрес индексируется _from, адрес индексируется _to, uint256 _value);
    Утверждение события (адрес индексируется _owner, адрес индексируется _spender, uint256 _value);
 
    // Расчеты и водоносные слои для каждой учетной записи
    отображение (адрес => uint256) государственные балансы;
    отображение (адрес => uint256) общественные водоносные горизонты;
    отображение (адрес => uint256) публичное initialStake;
    
    // Флаг наличия или отсутствия адреса хорошо
    отображение (адрес => BOOL) публичное isWell;
 
    // Владелец счета утверждает перевод суммы на другой счет
    отображение (адрес => отображение (адрес => uint256)) допускается;
 
    // Функция с этим модификатором может выполняться только владелец
    // модификаторы для разрешений на функции
    Модификатор onlyIssuer () {если (== msg.sender эмитент) _; }
    Модификатор onlyInvestor () {если (msg.sender = эмитент!) _; }
 
    функционировать aquiferOf (адрес _owner) публичные постоянные возвращает (uint256 жетоны) {возврата водоносных горизонтов [_owner]; }
    Функция getIssuerAddress () общественные постоянные доходы (адрес issuerAddress) {возвращение эмитента; }
    функционировать getFreeTokenSupply () общественные постоянные возвращения (uint256 лексемы) {вернуться freeTokenSupply; }
    Функция getRetainedSupplyPercentage () общественная постоянная отдача (uint256 процента) {вернуться retainedSupplyPercentage; }
    Функция getCreationTime () общественная постоянная отдача (uint256 время) {вернуться CreationTime; }
    Функция getGensisBlock () возвращает общественные постоянные (uint256 блок) {вернуть gensisBlock; }
    Функция getBlocksUntilExhaustion () общественные постоянные доходы (uint256 блоки) {вернуться blocksUntilExhaustion; }
    Функция getCurrentBlock () возвращает (общественные uint256 блоки) {возвращение block.number; }
    
    // Конструктор
    функционировать Autoria () {
        // Установить эмитент
        Эмитент = msg.sender;
        Остатки [msg.sender] + = +30000000000000000000000000;
        водоносные [msg.sender] = 0;
        freeTokenSupply - = +30000000000000000000000000;
        // Отправляет фиксирующих монету эмитенте
    }

    // Методы ICO
    Функция paymentProcessor () onlyInvestor подлежащей оплате возвращается (uint256 лексема) {
        
        // увидеть, если ICO все еще работает
        если (freeTokenSupply <= 0) {возвращают 0; }
        если (isWell [msg.sender]) {возвращают 0; }
        // определить обменный курс AUT (увеличивается, если в течение 1 недели после создания)
        UINT цена = earlySale ()? earlySalePrice: regularSalePrice;

        // установить некоторые основные отображения вещи, которые мы знаем, будет существовать
        isWell [msg.sender] = TRUE;

        UINT requestedTokens = (msg.value / цена) * exchangeRate;
        если (requestedTokens > freeTokenSupply) {
            возвращать 0;
        }
        еще {
            // отправить tokents пользователю
            водоносные [msg.sender] + = requestedTokens;
            initialStake [msg.sender] + = requestedTokens;
            // отправить ETH эмитенту
            issuer.transfer (msg.value);
            // обновление бесплатное обеспечение лексема
            freeTokenSupply - = requestedTokens;
            возврата (requestedTokens);
        }
    }

    Функция earlySale () возвращает постоянные (BOOL IFSO) {
        если ((сейчас - CreationTime) > 1 неделя) возвращает ложь;
        возвращает истину;
    }

    // Методы ERC20 
    функционировать totalSupply () возвращает постоянные (uint256 totalSupply) {
        totalSupply = _totalSupply;
        вернуться totalSupply;
    }
    
    Функция balanceOf (адрес _owner) постоянная отдача (uint256 баланс) {
        возврат остатков [_owner];
    }

    передаточная функция (адрес _to, uint256 _amount) возвращает (BOOL успех) {
        если (остатки [msg.sender] >= _amount 
            && _количество > 0
            && Остатки [_to] + _amount > Остатки [_to]) {
            Остатки [msg.sender] - = _amount;
            Остатки [_to] + = _amount;
            Передача (msg.sender, _to, _amount);
            возвращает истину;
        } Еще {
            вернуться ложным;
        }
    }

    Функция transferFrom (
        адрес _from,
        Отправить,
        uint256 _amount
    ) Государственные доходы (BOOL успех) {
        если (остатки [_from] >= _amount
            && разрешено [_from] [msg.sender] >= _amount
            && _количество > 0
            && Остатки [_to] + _amount > Остатки [_to]) {
            Остатки [_from] - = _amount;
            разрешено [_from] [msg.sender] - = _amount;
            Остатки [_to] + = _amount;
            Передача (_from, _to, _amount);
            возвращает истину;
        } Еще {
            вернуться ложным;
        }
    }

    функция утвердить (адрес _spender, uint256 _amount) публичные декларации (BOOL успеха) {
        разрешено [msg.sender] [_ транжира] = _amount;
        Утверждение (msg.sender, _spender, _amount);
        возвращает истину;
    }

    Функция резерва (адрес _owner, адрес _spender) публичные постоянные доходы (uint256 остальные) {
        вернуться разрешено [_owner] [_ транжира];
    }
    
    // Autoria специфические методы
    
    Функция availableDraw (адрес _owner) постоянная отдача (uint256) {
        uint256 х = (initialStake [_owner] / blocksUntilExhaustion) * (block.number - gensisBlock);
        вернуть водоносные слои [_owner] - (initialStake [_owner] - х);
    }
    
    Функция drawWell (адрес _owner) возвращает (BOOL) {
        если (isWell [_owner]) {
            // Начальное количество водоносного - начальное количество водоносного 
            uint256 рисовать = availableDraw (_owner);
            если (рисовать > 0 && водоносные [_owner] > 0) {
                Остатки [_owner] + = дро;
                водоносные [_owner] - = рисовать;
            }
            возвращает истину;
        }
        вернуться ложным;
    }
    
}