KYC

Децентрализованная экосистема для предоставления товаров и услуг напрямую от производителя. Шаг для перехода на Индустрию 4.0

ICO ЗАВЕРШЕНО

+10% +5% 0% *Total Supply:54,892,866.78393711555961842 AID 02.28.18 9:00 am (+6) Start of ICO 25.03.18 12:00 am End of stage I 25.04.18 12:00 am End of stage II 05.25.18 11:59 pm (+6) Finishing of ICO

Информация о листинге на биржах будет публиковаться на наших официальных страницах и канале телеграмм

Продукт прогресс: бета-тестирование

*Условное обозначение. Подробнее

Демо версия сервиса

Roadmap

Этапы Бюджет
2018 2019 2020-2021
  • Изучение рынка строительных материалов
    2014-2016
  • Написание подробного ТЗ
    2016 Q4
    2017 Q2
  • Разработка MVP сервиса
    2018
    January
  • Pre ICO
    2018
    January-February
  • ICO
    2018
    February-May
  • Альфа тестирование и доработка продукта
    2018
    Q1
  • Бета тестирование. Ввод поставщиков, складов и логистов
    2018
    Q2
  • Разработка мобильного приложения
    2018
    Q2
  • Разработка собственного Blockchain внутри проекта
    2018
    Q3
  • Полноценный запуск продукта в работу во всех странах СНГ
    2018
    Q4
  • Внедрение SLA на уровне смарткотрактов
    2018
    Q4
  • Внедрение внутренней валюты AIDCOIN для ускорения платежных транзакций
    2019
    Q1
  • Ввод обменника токенов на AIDACOIN по биржевой стоимости
    2019
    Q1
  • Вывод на биржу AIDACOIN
    2019
    Q2
  • Адаптация сервиса под рынок Европы и Восточной Азии
    2018
    Q2
  • Расширение ассортимента продаж сервиса на другие сферы
    2019
    Q3
  • Адаптация сервиса под рынок Северной и Южной Америки
    2019
    Q4
3.5%
6.1%
3% 0.8% 0.4%
2.5% 1% 0.7%
1% 3.7% 1%
0.8% 0.6% 0.3%
1% 0,7%
2.5% 1%
0,6% 0,4%
1% 0.7%
0,7%
0,6% 0,4%

Схема проведения ICO

ТИП ВЫПУСКА

Количество токенов ограничено количеством эмитированных токенов в период краудсейла

ПЕРИОД ЗАЧИСЛЕНИЯ ТОКЕНОВ

Мгновенно

ФОРМА ОПЛАТЫ

ETH, BTC, BCC, LTC, USD

ПЕРИОД КРАУДСЕЙЛА

28/02/2018 00:00 GMT+6 25/05/2018 23:59 GMT+6

ЦЕНА

1 AID = 0.25 USD

Cумма участия Max/Min

Для криптовалюты - нет/20 USD
Для фиатных - 500 USD/100 USD

Дополнительные бонусы для участников краудсейла:

1

Возможность зарабатывать владельцам токенов

2

Участники краудсейла купившие от
20 000 токенов получат возможность разместить у себя мастер ноду, что дает право получать комиссии с обработанных транзакций

3

Участники краудсейла купившие от
50 000 токенов могут стать представителем сервиса и получат 10% от прибыли в своем регионе

Этап #1: PreICO

Дата начала: 4 Января 2018 (9:00, Часовой пояс: GMT+6)

Дата окончания: 27 Февраля 2018 (23:59, Часовой пояс: GMT+6)

Форма оплаты: ETH, BTC, BCC, LTC, USD

Курс: 1 USD = 4 AID токена

Количество токенов на одного участника: без ограничений

Минимальная сумма транзакции для фиатных: 100 USD

Минимальная сумма транзакции для Криптовалют: 20 USD

Максимальная сумма транзакции для фиатных: 500 USD

Максимальная сумма транзакции для криптовалют: без ограничений

Количество токенов: ограничено сроком проведения краудсейла

Бонусы: +15%

Возврат: Весь период проведения

Возврат бонусов: Будут возвращены по нулевой стоимости, после чего будут уничтожены

Количество попыток: 1

Этап #2: ICO

Дата начала: 28 Февраля 2018 (00:00, Часовой пояс: GMT+6)

Дата окончания: 25 Мая 2018 (23:59, Часовой пояс: GMT+6)

Форма оплаты: ETH, BTC, BCC, LTC, USD

Курс: 1 USD = 4 AID токена

Количество токенов на одного участника: без ограничений

Минимальная сумма транзакции для фиатных: 100 USD

Минимальная сумма транзакции для Криптовалют: 20 USD

Максимальная сумма транзакции для фиатных: 500 USD

Максимальная сумма транзакции для криптовалют: без ограничений

Количество токенов: ограничено сроком проведения краудсейла

Бонусы: с 27 февраля по 25 марта - 10%, 26 марта - 25 апреля - 5%

Возврат: До 23:59 25.04.18г. Только токены купленые на данном этапе

Возврат бонусов: Будут возвращены по нулевой стоимости, после чего будут уничтожены

Количество попыток: 1

Распределение токенов

Group Copy 2 Created with Sketch. 20% 3% 76% КОМАНДА ТОКЕНЫ НА ПРОДАЖУ BOUNTY ПАРТНЕРЫ 1%

76%

ICO

20%

Команда

3%

Партнеры

1%

Bounty

Распределение бюджета

Group Created with Sketch. 35% 35% 17% 8% 5% Разработка сервиса Внедрение технологии блокчейн. Разработка новых дополнительных модулей автоматизации. Повышение практичности Маркетинг Продвижение сервиса в перспективных регион Административные расходы для развития сервиса в регионах Расходы на юридическое сопровождение Оборудование и техническое оснащение

Структура бюджета

От суммы вложения зависит количество дополнительных модулей сервиса и охват маркетинга для масштабирования

17%

Административные расходы для развития сервиса в регионах

35%

Маркетинг
Продвижение сервиса в перспективных регионах

35%

Разработка сервиса
Внедрение технологии блокчейн. Разработка новых дополнительных модулей автоматизации. Повышение юзабильности

8%

Расходы на юридическое сопровождение

5%

Оборудование и техническое оснащение

Смартконтракт

Этот смарт-контракт был разработан на основе «Интерактивного предложения монет». Это протокол от создателей Джейсона Теутча и Виталика Бутерина для решения «первой дилеммы продажи токенов».


	// AID tokensale smart contract.
	// Developed by Phenom.Team 

	// pragma solidity ^ 0.4.15;

	/**
	 *   @title SafeMath
	 *   @dev Math operations with safety checks that throw on error
	 */
	library SafeMath {
	    function mul(uint256 a, uint256 b) internal constant returns (uint256) {
	        uint256 c = a * b;
	        assert(a == 0 || c / a == b);
	        return c;
	    }

	    function div(uint256 a, uint256 b) internal constant returns(uint256) {
	        assert(b > 0);
	        uint256 c = a / b;
	        assert(a == b * c + a % b);
	        return c;
	    }

	    function sub(uint256 a, uint256 b) internal constant returns(uint256) {
	        assert(b <= a);
	        return a - b;
	    }

	    function add(uint256 a, uint256 b) internal constant returns(uint256) {
	        uint256 c = a + b;
	        assert(c >= a);
	        return c;
	    }
	}


	/**
	 *   @title ERC20
	 *   @dev Standart ERC20 token interface
	 */
	contract ERC20 {
	    uint256 public totalSupply = 0;
	    mapping(address => uint256) balances;
	    mapping(address => mapping(address => uint256)) allowed;
	    function balanceOf(address _owner) public constant returns(uint256);
	    function transfer(address _to, uint256 _value) public returns(bool);
	    function transferFrom(address _from, address _to, uint256 _value) public returns(bool);
	    function approve(address _spender, uint256 _value) public returns(bool);
	    function allowance(address _owner, address _spender) public constant returns(uint256);
	    event Transfer(address indexed _from, address indexed _to, uint256 _value);
	    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
	}

	/**
	*   @title AidaICO contract  - takes funds from users and issues tokens
	*   @dev AidaICO - it's the first ever contract for ICO which allows users to
	*                  return their investments.
	*/
	contract AidaICO {
	    // AID - Aida token contract
	    AidaToken public AID = new AidaToken(this);
	    using SafeMath for uint256;

	    // Token price parameters
	    // These parametes can be changed only by manager of contract
	    uint256 public Rate_Eth = 700; // Rate USD per ETH
	    uint256 public Tokens_Per_Dollar = 4; // Aida token per dollar
	    uint256 public Token_Price = Tokens_Per_Dollar.mul(Rate_Eth); // Aida token per ETH

	    // Crowdfunding parameters
	    uint256 constant ICO_RETURN_DURATION = 9; //
	    // ICO duration: 21.01.18  - 10.01,18
	    // return duration: 21.01.18 - 30.01.18
	    // Investors can return their investments during ICO_RETURN_DURATION
	    // Company can withdraw  ether from ico contract after ICO_RETURN_DURATION
	    uint256 constant bountyPart = 10; // 1% of TotalSupply for BountyFund
	    uint256 constant partnersPart = 30; //3% f TotalSupply for PartnersFund
	    uint256 constant teamPart = 200; //20% of TotalSupply for TeamFund
	    uint256 constant icoAndPOfPart = 760; // 76% of TotalSupply for PublicICO and PrivateOffer
	    uint256 startTime = 0; // Start time timestamp

	    // Output ethereum addresses
	    address public Company;
	    address public BountyFund;
	    address public PartnersFund;
	    address public TeamFund;
	    address public Manager; // Manager controls contract
	    address public Controller_Address1; // First address that is used to buy tokens for other cryptos
	    address public Controller_Address2; // Second address that is used to buy tokens for other cryptos
	    address public Controller_Address3; // Third address that is used to buy tokens for other cryptos
	    address public Oracle; // Oracle address
	    address public RefundManager; // Refund manager address

	    // Possible ICO statuses
	    enum StatusICO {
	        Created,
	        PreIcoStarted,
	        PreIcoPaused,
	        PreIcoFinished,
	        IcoStarted,
	        IcoPaused,
	        IcoFinished
	    }

	    StatusICO statusICO = StatusICO.Created;

	    // Mappings
	    mapping(address => uint256) public ethPreIco; // Mapping for remembering eth of investors who paid at PreICO
	    mapping(address => uint256) public ethIco; // Mapping for remembering eth of investors who paid at ICO
	    mapping(address => bool) public used; // Users can return their funds one time
	    mapping(address => uint256) public tokensPreIco; // Mapping for remembering tokens of investors who paid at preICO in ether
	    mapping(address => uint256) public tokensIco; // Mapping for remembering tokens of investors who paid at ICO in ethre
	    mapping(address => uint256) public tokensPreIcoInOtherCrypto; // Mapping for remembering tokens of investors who paid at preICO in other crypto currencies
	    mapping(address => uint256) public tokensIcoInOtherCrypto; // Mapping for remembering tokens of investors who paid at ICO in other crypto currencies

	    // Events Log
	    event LogStartICO();
	    event LogPauseICO();
	    event LogFinishICO(address bountyFund, address partnersFund, address teamFund);
	    event LogBuyForInvestor(address investor, uint256 aidValue, string txHash);
	    event LogReturnEth(address investor, uint256 eth);
	    event LogReturnOtherCrypto(address investor, string logString);

	    // Modifiers
	    // Allows execution by the refund manager only
	    modifier refundManagerOnly {
	        require(msg.sender == RefundManager);
	        _;
	    }
	    // Allows execution by the oracle only
	    modifier oracleOnly {
	        require(msg.sender == Oracle);
	        _;
	    }
	    // Allows execution by the contract manager only
	    modifier managerOnly {
	        require(msg.sender == Manager);
	        _;
	    }
	    // Allows execution by the one of controllers only
	    modifier controllersOnly {
	      require((msg.sender == Controller_Address1)
	           || (msg.sender == Controller_Address2)
	           || (msg.sender == Controller_Address3));
	      _;
	    }


	   /**
	    *   @dev Contract constructor function
	    */
	    function AidaICO(
	        address _Company,
	        address _BountyFund,
	        address _PartnersFund,
	        address _TeamFund,
	        address _Manager,
	        address _Controller_Address1,
	        address _Controller_Address2,
	        address _Controller_Address3,
	        address _Oracle,
	        address _RefundManager
	    )
	        public {
	        Company = _Company;
	        BountyFund = _BountyFund;
	        PartnersFund = _PartnersFund;
	        TeamFund = _TeamFund;
	        Manager = _Manager;
	        Controller_Address1 = _Controller_Address1;
	        Controller_Address2 = _Controller_Address2;
	        Controller_Address3 = _Controller_Address3;
	        Oracle = _Oracle;
	        RefundManager = _RefundManager;
	    }

	   /**
	    *   @dev Set rate of ETH and update token price
	    *   @param _RateEth       current ETH rate
	    */
	    function setRate(uint256 _RateEth) external oracleOnly {
	        Rate_Eth = _RateEth;
	        Token_Price = Tokens_Per_Dollar.mul(Rate_Eth);
	    }

	   /**
	    *   @dev Start PreIco
	    *   Set ICO status to PreIcoStarted
	    */
	    function startPreIco() external managerOnly {
	        require(statusICO == StatusICO.Created || statusICO == StatusICO.PreIcoPaused);
	        statusICO = StatusICO.PreIcoStarted;
	        LogStartICO();
	    }

	   /**
	    *   @dev Pause PreIco
	    *   Set Ico status to PreIcoPaused
	    */
	    function pausePreIco() external managerOnly {
	        require(statusICO == StatusICO.PreIcoStarted);
	        statusICO = StatusICO.PreIcoPaused;
	        LogPauseICO();
	    }
	   /**
	    *   @dev Finish PreIco
	    *   Set Ico status to PreIcoFinished
	    */
	    function finishPreIco() external managerOnly {
	        require(statusICO == StatusICO.PreIcoStarted || statusICO == StatusICO.PreIcoPaused);
	        statusICO = StatusICO.PreIcoFinished;
	        LogPauseICO();
	    }

	   /**
	    *   @dev Start ICO
	    *   Set start ICO time
	    *   Set ICO status to IcoStarted
	    */
	    function startIco() external managerOnly {
	        require(statusICO == StatusICO.PreIcoFinished || statusICO == StatusICO.IcoPaused);
	        if (statusICO == StatusICO.PreIcoFinished) {
	            startTime = now;
	        }
	        statusICO = StatusICO.IcoStarted;
	        LogStartICO();
	    }

	   /**
	    *   @dev Pause Ico
	    *   Set Ico status to IcoPaused
	    */
	    function pauseIco() external managerOnly {
	        require(statusICO == StatusICO.IcoStarted);
	        statusICO = StatusICO.IcoPaused;
	        LogPauseICO();
	    }

	   /**
	    *   @dev Finish ICO and emit tokens for bounty company, partners and team
	    */
	    function finishIco() external managerOnly {
	        require(statusICO == StatusICO.IcoStarted || statusICO == StatusICO.IcoPaused);
	        uint256 alreadyMinted = AID.totalSupply(); // = PublicICO
	        uint256 totalAmount = alreadyMinted.mul(1000).div(icoAndPOfPart);
	        AID.mintTokens(BountyFund, bountyPart.mul(totalAmount).div(1000));
	        AID.mintTokens(PartnersFund, partnersPart.mul(totalAmount).div(1000));
	        AID.mintTokens(TeamFund, teamPart.mul(totalAmount).div(1000));
	        statusICO = StatusICO.IcoFinished;
	        LogFinishICO(BountyFund, PartnersFund, TeamFund);
	    }

	   /**
	    *   @dev Unfreeze tokens(enable token transfers)
	    */
	    function enableTokensTransfer() external managerOnly {
	        require(statusICO == StatusICO.IcoFinished);
	        AID.defrostTokens();
	    }

	   /**
	    *   @dev Fallback function calls createTokensForEth() function to create tokens
	    *        when investor sends ETH to address of ICO contract
	    */
	    function() external payable {
	        require(statusICO == StatusICO.PreIcoStarted || statusICO == StatusICO.IcoStarted);
	        createTokensForEth(msg.sender, msg.value.mul(Token_Price));
	        rememberEther(msg.value, msg.sender);
	    }

	   /**
	    *   @dev Store how many eth were invested by investor
	    *   @param _value        amount of invested ether in Wei
	    *   @param _investor     address of investor
	    */
	    function rememberEther(uint256 _value, address _investor) internal {
	        if (statusICO == StatusICO.PreIcoStarted) {
	            ethPreIco[_investor] = ethPreIco[_investor].add(_value);
	        }
	        if (statusICO == StatusICO.IcoStarted) {
	            ethIco[_investor] = ethIco[_investor].add(_value);
	        }
	    }

	   /**
	    *   @dev Writes how many tokens investor received(for payments in ETH)
	    *   @param _value        amount of tokens
	    *   @param _investor     address of investor
	    */
	    function rememberTokensEth(uint256 _value, address _investor) internal {
	        if (statusICO == StatusICO.PreIcoStarted) {
	            tokensPreIco[_investor] = tokensPreIco[_investor].add(_value);
	        }
	        if (statusICO == StatusICO.IcoStarted) {
	            tokensIco[_investor] = tokensIco[_investor].add(_value);
	        }
	    }

	   /**
	    *   @dev Writes how many tokens investor received(for payments in other cryptocurrencies)
	    *   @param _value        amount of tokens
	    *   @param _investor     address of investor
	    */
	    function rememberTokensOtherCrypto(uint256 _value, address _investor) internal {
	        if (statusICO == StatusICO.PreIcoStarted) {
	            tokensPreIcoInOtherCrypto[_investor] = tokensPreIcoInOtherCrypto[_investor].add(_value);
	        }
	        if (statusICO == StatusICO.IcoStarted) {
	            tokensIcoInOtherCrypto[_investor] = tokensIcoInOtherCrypto[_investor].add(_value);
	        }
	    }

	   /**
	    *   @dev Issues tokens for users who made purchases in other cryptocurrencies
	    *   @param _investor     address the tokens will be issued to
	    *   @param _txHash       transaction hash of investor's payment
	    *   @param _aidValue     number of Aida tokens
	    */
	    function buyForInvestor(
	        address _investor,
	        uint256 _aidValue,
	        string _txHash
	    )
	        external
	        controllersOnly {
	        require(statusICO == StatusICO.PreIcoStarted || statusICO == StatusICO.IcoStarted);
	        createTokensForOtherCrypto(_investor, _aidValue);
	        LogBuyForInvestor(_investor, _aidValue, _txHash);
	    }

	   /**
	    *   @dev Issue tokens for investors who paid in other cryptocurrencies
	    *   @param _investor     address which the tokens will be issued to
	    *   @param _aidValue     number of Aida tokens
	    */
	    function createTokensForOtherCrypto(address _investor, uint256 _aidValue) internal {
	        require(_aidValue > 0);
	        uint256 bonus = getBonus(_aidValue);
	        uint256 total = _aidValue.add(bonus);
	        rememberTokensOtherCrypto(total, _investor);
	        AID.mintTokens(_investor, total);
	    }

	   /**
	    *   @dev Issue tokens for investors who paid in ether
	    *   @param _investor     address which the tokens will be issued to
	    *   @param _aidValue     number of Aida tokens
	    */
	    function createTokensForEth(address _investor, uint256 _aidValue) internal {
	        require(_aidValue > 0);
	        uint256 bonus = getBonus(_aidValue);
	        uint256 total = _aidValue.add(bonus);
	        rememberTokensEth(total, _investor);
	        AID.mintTokens(_investor, total);
	    }

	   /**
	    *   @dev Calculates bonus if PreIco sales still not over
	    *   @param _value        amount of tokens
	    *   @return              bonus value
	    */
	    function getBonus(uint256 _value)
	        public
	        constant
	        returns(uint256)
	    {
	        uint256 bonus = 0;
	        if (statusICO == StatusICO.PreIcoStarted) {
	            bonus = _value.mul(15).div(100);
	        }
	        return bonus;
	    }

	   /**
	    *   @dev Count days from Ico start day
	    */
	    function daysFromIcoStart()
	        public
	        constant
	        returns(uint256)
	    {
	        return now.sub(startTime) / 24 hours;
	    }

	   /**
	    *   @dev Allows investors to return their investments(in ETH)
	    *   if preICO or ICO_RETURN_DURATION is not over yet
	    *   and burns tokens
	    */
	    function returnEther() public {
	        require(!used[msg.sender]);
	        uint256 eth = 0;
	        uint256 tokens = 0;
	        if (statusICO == StatusICO.PreIcoStarted) {
	            require(ethPreIco[msg.sender] > 0);
	            eth = ethPreIco[msg.sender];
	            tokens = tokensPreIco[msg.sender];
	            ethPreIco[msg.sender] = 0;
	            tokensPreIco[msg.sender] = 0;
	        }
	        if (statusICO == StatusICO.IcoStarted) {
	            require(ethIco[msg.sender] > 0);
	            require(daysFromIcoStart() <= ICO_RETURN_DURATION);
	            eth = ethIco[msg.sender];
	            tokens = tokensIco[msg.sender];
	            ethIco[msg.sender] = 0;
	            tokensIco[msg.sender] = 0;
	        }
	        msg.sender.transfer(eth);
	        used[msg.sender] = true;
	        AID.burnTokens(msg.sender, tokens);
	        LogReturnEth(msg.sender, eth);
	    }

	   /**
	    *   @dev Burn tokens of investors who paid in other cryptocurrencies
	    *   if preICO or ICO_RETURN_DURATION is not over yet
	    *   @param _investor     address which the tokens will be burnt
	    *   @param _logString    string which contain payment information
	    */
	    function returnOtherCrypto(
	        address _investor,
	        string _logString
	    )
	        external
	        refundManagerOnly {
	        uint256 tokens = 0;
	        if (statusICO == StatusICO.PreIcoStarted) {
	            tokens = tokensPreIcoInOtherCrypto[_investor];
	            tokensPreIcoInOtherCrypto[_investor] = 0;
	        }
	        if (statusICO == StatusICO.IcoStarted) {
	            require(daysFromIcoStart() <= ICO_RETURN_DURATION);
	            tokens = tokensIcoInOtherCrypto[_investor];
	            tokensIcoInOtherCrypto[_investor] = 0;
	        }
	        AID.burnTokens(_investor, tokens);
	        LogReturnOtherCrypto(_investor, _logString);
	    }

	   /**
	    *   @dev Allows Company withdraw investments when ICO_RETURN_DURATION is over
	    *   @param _value        amount of ETH to send in Wei
	    */
	    function withdrawEther(uint256 _value) external managerOnly {
	        require(daysFromIcoStart() > ICO_RETURN_DURATION);
	        Company.transfer(_value);
	    }

	}


	/**
	 *   @title AidaToken
	 *   @dev Aida token contract
	 */
	contract AidaToken is ERC20 {
	    using SafeMath for uint256;
	    string public name = "Aida TOKEN";
	    string public symbol = "AID";
	    uint256 public decimals = 18;

	    // Ico contract address
	    address public ico;
	    event Burn(address indexed from, uint256 value);

	    // Disables/enables token transfers
	    bool public tokensAreFrozen = true;

	    // Allows execution by the owner only
	    modifier icoOnly {
	        require(msg.sender == ico);
	        _;
	    }

	   /**
	    *   @dev Contract constructor function sets Ico address
	    *   @param _ico          ico address
	    */
	    function AidaToken(address _ico) public {
	        ico = _ico;
	    }

	   /**
	    *   @dev Mint tokens
	    *   @param _holder       beneficiary address the tokens will be issued to
	    *   @param _value        number of tokens to issue
	    */
	    function mintTokens(address _holder, uint256 _value) external icoOnly {
	        require(_value > 0);
	        balances[_holder] = balances[_holder].add(_value);
	        totalSupply = totalSupply.add(_value);
	        Transfer(0x0, _holder, _value);
	    }

	   /**
	    *   @dev Disables/enables token transfers
	    */
	    function defrostTokens() external icoOnly {
	      tokensAreFrozen = false;
	    }

	   /**
	    *   @dev Burn Tokens
	    *   @param _investor     token holder address which the tokens will be burnt
	    *   @param _value        number of tokens to burn
	    */
	    function burnTokens(address _investor, uint256 _value) external icoOnly {
	        require(balances[_investor] > 0);
	        totalSupply = totalSupply.sub(_value);
	        balances[_investor] = balances[_investor].sub(_value);
	        Burn(_investor, _value);
	    }

	   /**
	    *   @dev Get balance of investor
	    *   @param _owner        investor's address
	    *   @return              balance of investor
	    */
	    function balanceOf(address _owner) public constant returns(uint256) {
	      return balances[_owner];
	    }

	   /**
	    *   @dev Send coins
	    *   throws on any error rather then return a false flag to minimize
	    *   user errors
	    *   @param _to           target address
	    *   @param _amount       transfer amount
	    *
	    *   @return true if the transfer was successful
	    */
	    function transfer(address _to, uint256 _amount) public returns(bool) {
	        require(!tokensAreFrozen);
	        balances[msg.sender] = balances[msg.sender].sub(_amount);
	        balances[_to] = balances[_to].add(_amount);
	        Transfer(msg.sender, _to, _amount);
	        return true;
	    }

	   /**
	    *   @dev An account/contract attempts to get the coins
	    *   throws on any error rather then return a false flag to minimize user errors
	    *
	    *   @param _from         source address
	    *   @param _to           target address
	    *   @param _amount       transfer amount
	    *
	    *   @return true if the transfer was successful
	    */
	    function transferFrom(address _from, address _to, uint256 _amount) public returns(bool) {
	        require(!tokensAreFrozen);
	        balances[_from] = balances[_from].sub(_amount);
	        allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
	        balances[_to] = balances[_to].add(_amount);
	        Transfer(_from, _to, _amount);
	        return true;
	    }

	   /**
	    *   @dev Allows another account/contract to spend some tokens on its behalf
	    *   throws on any error rather then return a false flag to minimize user errors
	    *
	    *   also, to minimize the risk of the approve/transferFrom attack vector
	    *   approve has to be called twice in 2 separate transactions - once to
	    *   change the allowance to 0 and secondly to change it to the new allowance
	    *   value
	    *
	    *   @param _spender      approved address
	    *   @param _amount       allowance amount
	    *
	    *   @return true if the approval was successful
	    */
	    function approve(address _spender, uint256 _amount) public returns(bool) {
	        require((_amount == 0) || (allowed[msg.sender][_spender] == 0));
	        allowed[msg.sender][_spender] = _amount;
	        Approval(msg.sender, _spender, _amount);
	        return true;
	    }

	   /**
	    *   @dev Function to check the amount of tokens that an owner allowed to a spender.
	    *
	    *   @param _owner        the address which owns the funds
	    *   @param _spender      the address which will spend the funds
	    *
	    *   @return              the amount of tokens still avaible for the spender
	    */
	    function allowance(address _owner, address _spender) public constant returns(uint256) {
	        return allowed[_owner][_spender];
	    }
	}

			

Наша команда

AIDA Team
Нысанов Уалихан
Сооснователь. Архитектор проекта.
Эксперт в области маркетинге и продаж. Предприниматель с 2010 года, опыт продаж варьируется от 1 миллиона долларов.
● ● ●
AIDA Team
Гончаренко Денис
Сооснователь, IT-директор, Блокчейн эксперт
Сооснователь. IT-директор. Эксперт в автоматизации бизнес процессов.
● ● ●
AIDA Team
Урмагамбетов Самат
Сооучредитель
Сооснователь. Построил более 1,2 миллиона квадратных метров жилой и коммерческой недвижимости. Основатель строительного холдинга «Center Group».
● ● ●
AIDA Team
Кунсаков Арман
Исполнительный директор
Опыт: 15 лет работы в продажах, консалтинге, HR, менеджменте и управлении проектами. Достижения: управление продажами завода по производству пластиковых и дверных профилей. Экспертность: планирование производства, ведение финансового учета, продажи и привлечение.
● ● ●
AIDA Team
Куликешева Динара
Web-дизайнер
Опыт: 2 года в IT сфере. Достижения: опыт работы за границей (Латвия, Рига), два пика выше 3000 км., экономическое и музыкальное образование. Экспертность: UI/UX дизайн.
● ● ●
AIDA Team
Нариманова Томирис
Web-разработчик
Experience: 2 years in IT. Expertise: FrontEnd, design.
● ● ●
AIDA Team
Оразмуханбет Алпамыс
Блокчейн разработчик
Опыт: 3 года в IT.Достижения: Участник конференции cryptoSpace, внедрение блокчейн технологии. Экспертность: Интеграция IT технологий, защита и шифрование базы данных. Администрование БД Oracle.
● ● ●
AIDA Team
Маянова Диана
BBTL - маркетинг и PR
Опыт: 3 года в сфере маркетинга и PR.Достижения: партнерская проектная работа с Фондом Первого Президента, жуналом SNC, Международным университетом информационных технологий, партией Нур Отан и Общественным Фондом "МАЛиС".
● ● ●

Наши консультанты

AIDA Team
Jason Hung
Created with Sketch.
CAMP CTO, TimeBox Co-founder, SuchApp, Giza, W2TW, BlockVisory blockchain ICO advisor, ICOBench expert
Jason is an entrepreneur and inventor in mobile technology, blockchain ecosystem, digital marketing, AI and ERP related business. He is the co-founder or advisor of Treascovery, Chidopi, TimeBox, Giza, Micro BTC, EZPOS and Suchapp. He is also a blockchain expert of ICOBench and International Blockchain Consulting Announcement Group.
● ● ●
AIDA Team
Nikolay Zvezdin
Created with Sketch.
CFO / CIO at Envinary Group , CFO at Enlight Visionary , Giza Device, Datarius Cryptobank ICO Advisor
Nikolay is an expert in private equity / venture capital, assurance, and advisory; participated in 8 potential LBOs worth of ~US$ 22 billions, of companies from Industrials, Energy, TMT, Pharmaceuticals, FIG, and Consumer Goods sectors from the UK, US, Hong Kong, Japan, Singapore, China, and Russia;winner of Credit Suisse HOLT Community Competition.
● ● ●
AIDA Team
Konstantin Bravo
Created with Sketch.
Co – founder of CryptoMarafon - russian online webinar, CFC, HeartIn ICO adviser, Markening expert
Konstantin has 19 years of experience in entrepreneurial activity, working with securities, investments, business development. The volume of realized projects in real estate is more than 250 million dollars. Konstantin holds a master's degree in applied mathematics and programming from Kyiv Polytechnic University and a master's degree in financial management and investment at the Kiev Institute of Investment and Management. He is an adviser in projects CFC, HeartIn and develops relationships in the crypto community.
● ● ●
AIDA Team
Alex Nest
Created with Sketch.
ICO Advisor and Digital Strategist,
Cty. Operations
ICO Advisor and Digital Strategist – Eristica, Aida Service. Co-Founder CosNes Gp. Community Operations, Entrepreneur. Ideologist for decentralization Anonymous Organizations. Flight Academy of Ukraine. Usually, the people with the best advice are the ones with the most problems. Also @cosnes Linkedin, Product Hunt, Medium.
● ● ●

Сми о нас

Внимание: В настоящий момент, мы ограничили возможность участия малых инвесторов в связи с модернизацией системы. Зарегистрируйтесь в whitelist, мы обязательно свяжемся с вами.