Dear investors! eWaiter transformed into Gastery — an entire platform for HoReCa industry. We moved to new web-site: https://gastery.io

Read an article on Medium about our new naming and conception: CLICK TO READ
All accounts and WTR TOKENS were transferred to the new site, so you can use your old pass and login, or you can reset it in case if you’ve forgotten it.

A new simple way to invest in the restaurant service industry

WTR coin is the first ever blockchain option for investing in the creation and introduction of a multipurpose application for the restaurant industry.

MAIN SALE starts in

x

 days

x

hours

x

minutes

x

seconds

PRE-SALE IS OVER

400 000 $

TOTAL SOLD

8 000 000.0000 WTR sold

100%

TOTAL SOLD
400 000.00

Our MVP is ready

We've developed the MVP of the web-version of our application for guests. Try it right now on PC or smartphone. Also watch the promo video of our service usage in real life.

What is eWaiter?

eWaiter is a global decentralized service, based on blockchain technology. Our goal is to automate customer service in restaurants and improve its quality.

1

Availability & Usability

You can be connected to our service in four simple steps, while a user-friendly interface provides convenience of use.

2

Full Feature Functionality

Waiter call system, Electronic menu, Customer feedback service, Great marketing tool, Procurement and Accounting.

3

Affordable price

The eWaiter service is available to every restaurant and helps your business automate workflow with minimum costs.

Read our documentation

1. Find a restaurant

You can find a perfect place to spend an evening there in the form of list or right on the map.

2. Choose the best dish

Read the full information and read true reviews about the dish in the electronic menu.

3. Make an order and pay

Make an order and pay for it directly from your smartphone using fiat money or crypto currency.

Our benefits

For Business

Reduction of labour costs

Faster customer service

User-friendly menu editing tool

Powerful marketing tool

Ensure better average bill value

Our benefits

To Investors

Token-option with high liquidity

Resistance to speculations on the exchange

Available and transparent investments

Automation of fulfilment of obligations

Increase in the rate proportional to expansion

Our benefits

To Guests

Time saving

High quality service

User-friendly interface

Reliable opinions and ratings

Detailed information on menu

Blog

Interview with CO-founder

“We will change the global understanding of the guest service in the restaurant industry” — such a global goal is set by the founders of the startup eWaiter. The guys are the first in Russia who attracted investment to the restaurant cloud IT product through ICO.

Types of restaurants

Modern catering offers a wide choice not only of dishes, but also of different formats of restaurants. If your vocabulary contains only the words “canteen”, “cafe” and “bar”, it’s time to expand it! Let’s find out what is the difference between types of restaurants...

6 stories of success: inspiring startups

In the restaurant industry, be on the top is more difficult than anywhere else. But it does not mean that new players are not welcome here. Here are 6 start-ups, which already became famous and reached a certain level of success. The restaurant “Honest cuisine” was opened...

Token Distribution

WTR tokens are based on ERC20 standard. The fixed supply is 175,000,000 WTR. 56% will be allocated to the general public in two rounds: pre-SALE and SALE.

ICO first round: pre-SALE

Start

26 December 2017

14:00 (UTC 0)

Price

0.05

For 1 WTR

End

01 March 2018

14:00 (UTC 0)

Tokens for sale

8 000 000 WTR

Currencies accepted

BTC, ETH, BCH

Minimum contribution

10

Smart contract (WTR token)

pragma solidity ^0.4.18;

library SafeMath {

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

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

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

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


  event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);


  /**
   * @dev The Ownable constructor sets the original `owner` of the contract to the sender
   * account.
   */
  function Ownable() public {
    owner = msg.sender;
  }

  /**
   * @dev Throws if called by any account other than the owner.
   */
  modifier onlyOwner() {
    require(msg.sender == owner);
    _;
  }

  /**
   * @dev Allows the current owner to transfer control of the contract to a newOwner.
   * @param newOwner The address to transfer ownership to.
   */
  function transferOwnership(address newOwner) public onlyOwner {
    require(newOwner != address(0));
    OwnershipTransferred(owner, newOwner);
    owner = newOwner;
  }

}
contract ERC20Basic {
  function totalSupply() public view returns (uint256);
  function balanceOf(address who) public view returns (uint256);
  function transfer(address to, uint256 value) public returns (bool);
  event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
  function allowance(address owner, address spender) public view returns (uint256);
  function transferFrom(address from, address to, uint256 value) public returns (bool);
  function approve(address spender, uint256 value) public returns (bool);
  event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
  function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
    assert(token.transfer(to, value));
  }

  function safeTransferFrom(ERC20 token, address from, address to, uint256 value) internal {
    assert(token.transferFrom(from, to, value));
  }

  function safeApprove(ERC20 token, address spender, uint256 value) internal {
    assert(token.approve(spender, value));
  }
}
contract BasicToken is ERC20Basic {
  using SafeMath for uint256;

  mapping(address => uint256) balances;

  uint256 totalSupply_;

  function totalSupply() public view returns (uint256) {
    return totalSupply_;
  }

  function transfer(address _to, uint256 _value) public returns (bool) {
    require(_to != address(0));
    require(_value <= balances[msg.sender]);

    // SafeMath.sub will throw if there is not enough balance.
    balances[msg.sender] = balances[msg.sender].sub(_value);
    balances[_to] = balances[_to].add(_value);
    Transfer(msg.sender, _to, _value);
    return true;
  }

  function balanceOf(address _owner) public view returns (uint256 balance) {
    return balances[_owner];
  }

}
contract StandardToken is ERC20, BasicToken {

  mapping (address => mapping (address => uint256)) internal allowed;

  function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
    require(_to != address(0));
    require(_value <= balances[_from]);
    require(_value <= allowed[_from][msg.sender]);

    balances[_from] = balances[_from].sub(_value);
    balances[_to] = balances[_to].add(_value);
    allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
    Transfer(_from, _to, _value);
    return true;
  }

  function approve(address _spender, uint256 _value) public returns (bool) {
    allowed[msg.sender][_spender] = _value;
    Approval(msg.sender, _spender, _value);
    return true;
  }

  function allowance(address _owner, address _spender) public view returns (uint256) {
    return allowed[_owner][_spender];
  }

  function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
    allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
    Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
    return true;
  }

  function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
    uint oldValue = allowed[msg.sender][_spender];
    if (_subtractedValue > oldValue) {
      allowed[msg.sender][_spender] = 0;
    } else {
      allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
    }
    Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
    return true;
  }

}
contract TokenTimelock {
  using SafeERC20 for ERC20Basic;

  // ERC20 basic token contract being held
  ERC20Basic public token;

  // beneficiary of tokens after they are released
  address public beneficiary;

  // timestamp when token release is enabled
  uint256 public releaseTime;

  function TokenTimelock(ERC20Basic _token, address _beneficiary, uint256 _releaseTime) public {
    require(_releaseTime > now);
    token = _token;
    beneficiary = _beneficiary;
    releaseTime = _releaseTime;
  }

  /**
   * @notice Transfers tokens held by timelock to beneficiary.
   */
  function release() public {
    require(now >= releaseTime);

    uint256 amount = token.balanceOf(this);
    require(amount > 0);

    token.safeTransfer(beneficiary, amount);
  }
}
contract BurnableToken is BasicToken {

  event Burn(address indexed burner, uint256 value);

  /**
   * @dev Burns a specific amount of tokens.
   * @param _value The amount of token to be burned.
   */
  function burn(uint256 _value) public {
    require(_value <= balances[msg.sender]);
    // no need to require value <= totalSupply, since that would imply the
    // sender's balance is greater than the totalSupply, which *should* be an assertion failure

    address burner = msg.sender;
    balances[burner] = balances[burner].sub(_value);
    totalSupply_ = totalSupply_.sub(_value);
    Burn(burner, _value);
  }
}
contract WTRToken is  BurnableToken{
    string public constant name = "WTR";
    string public constant symbol = "WTR";
    uint8 public constant decimals = 4;
    uint256 public totalSupply;

    function WTRToken() public
    {
        totalSupply = 175000000 * 10 ** uint256(decimals);
        balances[msg.sender] = totalSupply;
    }
}
contract WTRCrowdsale is Ownable{

    using SafeMath for uint256;


    uint256 public constant preSaleStart = 1514296800;
    uint256 public constant preSaleEnd = 1519912800;

    uint256 public constant SaleStart = 1525183200;
    uint256 public constant SaleEnd = 1530453600;

    enum Periods {NotStarted, PreSale, Sale, Finished}
    Periods public period;

    WTRToken public token;
    address public wallet;
    uint256 public constant rate = 9000;
    uint256 public balance;
    uint256 public tokens;

    mapping(address => uint256) internal balances;

    function Crowdsale(address _token, address _wallet) public{
        token = WTRToken(_token);
        wallet = _wallet;
        period = Periods.NotStarted;
    }

    function nextState() onlyOwner public{
        require(period == Periods.NotStarted || period == Periods.PreSale || period == Periods.Sale);

        if(period == Periods.NotStarted){
            period = Periods.PreSale;
        }
        else if(period == Periods.PreSale){
            period = Periods.Sale;
        }
        else if(period == Periods.Sale){
            period = Periods.Finished;
        }
    }

    function buyTokens() internal
    {
        uint256 weiAmount = msg.value;
        tokens = weiAmount.mul(rate);
        bool success = token.transfer(msg.sender, tokens);
        require(success);
        if(period == Periods.PreSale && period == Periods.Sale)
        {
            wallet.transfer(msg.value);
        }
    }

    function isValidPeriod() internal constant returns (bool){
        if(period == Periods.PreSale)
        {
            if(now >= preSaleStart && now <= preSaleEnd) return true;
        }
        else if(period == Periods.Sale)
        {
            if(now >= SaleStart && now <= SaleEnd) return true;
        }

        return false;
    }

    function () public payable{
        require(msg.sender != address(0));
        require(msg.value > 0);
        require(isValidPeriod());

        buyTokens();
    }

    function burningTokens() public onlyOwner{
        if(period == Periods.Finished){
            token.burn(tokens);
        }
    }

}
January 2017
Inception of the Idea
January - July 2017
Market Research
July - August 2017
Looking for early investors
December 26, 2017
Token pre-SALE
December 1, 2017
Social Media Awareness
Autumn 2017
Preparations for the ICO
January 2018
MVP Development
March 2018
Application beta-test
May 2018
Token SALE
2018-2019
Worldwide Expansion
Jule 2018
Functionality Extension
June 2018
Release of the Application
January 2017
Inception of the Idea
January - July 2017
Market Research
July - August 2017
Looking for early investors
Autumn 2017
Preparations for the ICO
December 1, 2017
Social Media Awareness
December 26, 2017
Token pre-SALE
January 2018
MVP Development
March 2018
Application beta-test
May 2018
Token SALE
June 2018
Worldwide Expansion
Jule 2018
Release of the Application
2018-2019
Functionality Extension

Token ecosystem

WTR coin is seamlessly integrated into the business model of the application eWaiter. Due to this advantage, investors have many ways for getting incomes.

Our team

eWaiter team consists of specialists from different spheres: from design and marketing to web-development and management. We create a service, which will make your life more comfortable and easier.

Koroshchenko Mikhail

CEO / CO-founder

Manager in the sphere of restaurant service. Participated in launching and development of several successful projects.

Pankratov Ilya

CTO / CO-founder

Information security specialist. PHP developer. Participates in the development of government contracts.

Plotnikov Igor

CWO / CO-founder

Senior full stack WEB developer. Participates in the promotion of IT products and automation of companies in the B2C/B2B area.

Matafonov Denis

CCO / CO-founder

Theater and movie actor. Responsible for the creative part of the project, creating image ads and promotional materials.

Vasilyeva Olga

UX/UI designer

Vishnyakov Nikita

Team lead & PHP developer

Chizhkov Vadim

Blockchain developer

Gorbachevsky Nikita

React developer

Chichilanov Dmitrii

Head of SMM

Krishtopa Pavel

SMM manager

Kadakh Aleksei

Community manager

Chetouane Mohamed

Copywriter & Translator

Our advisors & Partners

Developing our project we could not avoid the opinion of experienced players in the service industry and the sphere of crypto-currencies. Without their valuable guidance our project would be incomplete.

Karimov Roman

Entrepreneur and crypto enthusiast

Orlov Ilya

CEO and CO-founder of TravelChain

Petlyuk Vladislav

The owner of coffee shops. The first adopter of bitcoin payments in Russia

Coffee In
Kupecheskiy dvor
Mizoysters Seafood-bar
Gastro-bar Greenery
PASTABAR

FAQ

Initial Coin Offering or ICO means the collection of capital with the help of cryptoinvestments in the initial stage of the Project, including the use of cryptocurrencies.
The blockchain technology allows implementing two important functions: data integrity and gamification.
eWaiter is intended to solve the key problems of the restaurant industry via a smartphone and provide a convenient platform both for restaurants as service providers and for their customers as consumers. The current market of services designed to optimize and refine the restaurant industry does not have a unified tool, which would solve the existing problems and combine marketing possibilities and unlimited potential functionality.
You can use eWaiter in any country where the internet is available.
WTR coin will be used to pay for subscription by restaurants and be given as bonuses to guests.
pre-SALE - the price of one WTR coin will be 0.05 $. SALE - the price will rise from 0.08 to 0.1 $ according to the bonus program.
At the end of the ICO, the price of the WTR coin will be 0.1 $ and will only grow after that. With growing demand for our service, the value of the WTR coin will grow respectively. Thus, the cost of services expressed in WTR coins will begin to split up, and the value of one coin will increase.
In 3 months after the end of the pre-SALE, free beta testing of the product will begin in restaurants-partners. At the beginning of June 2018, eWaiter will be available for all.
Investors will be able to sell tokens directly to users of our service on the local exchange after the launching of our application. Moreover, investors can sell them on the open exchange.
pre-SALE funds will be used to create the application, and the money from the SALE will go on the global expansion and marketing.
Everyone can be an investor. You need to sing up as an investor on our website and follow the instruction at your account.
Residents of these countries cannot participate in the ICO.

Contacts

Stay on top of our latest news - follow us on social networks.

By clicking on the Subscribe button, you agree to the Privacy Policy

All rights reserved © 2018 ewaiter.io

Created by: ico.prgrf