t.me bit talk git
t.me bit talk git
Enter

Global P2P service for e-commerce with a volume of more than 1.5 trillion. $. A reliable and highly profitable investment for all

1 AID = 0.25$

start date
days
:
:

100 guarantee on return of investment during crowdsale

Today +15% Bonus

01.04.18 9:00 am Start of PreSale 01.25.18 11:59 pm A possibility of returning the purchased tokens 01.26.18 12:00 am Start of ICO 02.04.18 11:59 pm A possibility of returning the purchased tokens 02.15.18 11:59 pm Finishing of ICO
bitcoin

10.78

bitcoin

10.56

bitcoin

300

bitcoin

2.92

bitcoin

1.2

Time zone: GMT+6
Already invested : 181673$
About the Project

Aida Service provides automated sales and services without intermediaries. Our users are Customers, Producers, Logisticians, Warehouses and Network Partners.

Roadmap

ICO Project outline

Type of Issue

Unlimited; AID tokens will be withdrawn from issuing after ICO

Token Enrollment Period

Instant

Form of Payment

ETH, BTC, BCC, LTC, S

Crowdsale Period

from 09:00 am (GMT+6), 01/04/2018 to 11:59 pm (GMT+6), 01/25/2018

Price

1 AID = 0.25 $

Max/Min sum for participation

For cryptocurrencies - no max /20$
For fiat - 500$/100$

The cost of tokens is provided by

1

development of product

2

spending 30% of company's income to buy tokens by exchange rate and tokens will be burnt afterwards

3

release of own cryptocurrency and opportunity to change tokens at the exchange value

4

liquidity pool is provided by freezing 10% of income in company's deposit accounts

Benefits for early investors:

1

Service first of all will redeem tokens from early investors

2

Investors who bought from 20,000 tokens will have the opportunity to host a master node, which gives them the right to receive commissions from processed transactions

3

Investors bought 50,000 tokens can become a representative of the service and will receive 10 of the profits in the region

Stage #1: PreICO

Start date: 4th of January 2018 (9:00 AM, Time zone: GMT+6)

End date: 25th of January 2018 (23:59 PM, Time zone: GMT+6)

Form of Payment: ETH, BTC, BCC, LTC, USD

Price: 1 USD = 4 AID tokens

Amount of tokens per one person: unlimited

Minimum transaction amount for fiat: 100 USD

Minimum transaction amount for cryptocurrencies: 20 USD

Maximum transaction amount for fiat: 500 USD

Maximum transaction amount for cryptocurrencies: unlimited

Bonuses: +15%

Return: The entire period

The number of attempts: 1

The minimum number of tokens: All bought and bonus

The maximum number of tokens: All bought and bonus

Bonuses: Return at zero cost, after will be destroyed

Stage #2: ICO

Start date: 26th of January 2018 (00:00 AM, Time zone: GMT+6)

End date: 15th of February 2018 (23:59 PM, Time zone: GMT+6)

Form of Payment: ETH, BTC, BCC, LTC, USD

Price: 1 USD = 4 AID tokens

Amount of tokens per one person: unlimited

Minimum transaction amount for fiat: 100 USD

Minimum transaction amount for cryptocurrencies: 20 USD

Maximum transaction amount for fiat: 500 USD

Maximum transaction amount for cryptocurrencies: unlimited

Number of tokens:infinitely

Bonuses: No bonuses

Return: up to 04.02.18 11:59 p.m, Only tokens purchased at this stage

The number of attempts: 1

The minimum number of tokens: All bought and bonus

The maximum number of tokens: All bought and bonus

Token Distribution

ICO 76% Team 20% Partners 3% Bounty 1%

76%

ICO

20%

Team

3%

Partners

1%

Bounty

Budget Distribution

Service development Implementation of the blockchain technology. Development of the new modules of automatization Usability increase 35% Marketing Service promotion in perspective regions 35% Administrative expenses for the development of service in regions 17% Expenses for legal support 8% Hardware and technical equipment 5% Budget Structure The sum of investment directly affects the number of additional service modules and the scale of the marketing for expansion

Budget Structure

The sum of investment directly affects the number of additional service modules and the scale of the marketing for expansion

17%

Administrative expenses for the development of service in regions

35%

Marketing
Service promotion in perspective regions

35%

Service development
Implementation of the blockchain technology. Development of the new modules of automatization. Usability increase

8%

Expenses for legal support

5%

Hardware and technical equipment

Interactive smart contract

This smart contract was developed on the basis of «Interactive Coin Offering» is a protocol from creators Jason Teutsch and Vitalik Buterin to solve the “first token sale dilemma”.

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

Partners and advisers

Jason Hung

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 has more than 20 years proven track record on managing RD, IT, sales, consulting service with 9 technology related patents which using at more than 2000 Apps. He was also formal PeopleSoft and JDE solution head in Greater China. He is also a blockchain expert of ICOBench and International Blockchain Consulting Announcement Group.

Nikolay Zvezdin

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; advised top executives of private equity portfolio company on operations and efficiency enhancement resulting in EBITDA increase of ~60%; participated in assurance of the largest banks in Tajikistan; winner of CFA Research Challenge in Turkey, participant in CFA EMEA Research Challenge in Netherlands, winner of Credit Suisse HOLT Valuation Challenge, winner of Credit Suisse HOLT Community Competition.

Konstantin Bravo

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. He has extensive experience in team building, project management, marketing and sales. 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. In recent years, he has been investing in startups in the core of the blockchain technology, big data and artificial intelligence. He is an adviser in projects CFC, HeartIn and develops relationships in the crypto community.

Malcolm Tan

Founder of Gravitas Holdings

CEO of Gravitas Holdings Malcolm Tan is an established Singaporean lawyer-entrepreneur with extensive experience in the construction, telecommunications, engineering, retail, IT and financial industries. Trained as a lawyer, Malcolm is also skilled in litigation, corporate law, and mergers and acquisitions. He previously held legal counsel positions in both global and regional capacities across the Asia-Pacific region, MENA, and North America. In addition to owning and running a diverse suite of companies, including the BlueSky Group which owns back-office solution provider ActivBM, Malcolm’s keen interest in investment opportunities sees him play an active role in crowdfunding projects through his online platform FundedByMe.com.

Alex Nest

ICO Advisor and Digital Strategist

Anzor Zhemukhov

Blockchain expert, investor, philanthrop ENZO

Инвестор и блокчейн-филантроп ENZO, являющийся лидером нескольких блокчейн проектов, управляющей компанией которых является «БЛОК А». Совладелец и эдвайзер таких проектов: Биржа недвижимости Росреестра, CryptoCreditCard (кредитная карта, которая позволит оплачивать товары и услуги различными криптовалютами и фиатными деньгами) ICO агентство promocoin.io, Биржа C3X, Биржа Rubitexx, bitware.com, DarkOil, World Metal Factoring, BIT Energy, neuroseed.io, mark.space, Sofin.io и др. Проект Rubittech осуществляет Консалтинг и внедрение крипто- биржевых технологий.

Our team

Nyssanov Ualikhan

Co-founder, Chief Executive Officer

Goncharenko Denis

Co-founder, IT Director, Blockchain expert

Urmagambetov Samat

Adviser,Co-founder

Kulikesheva Dinara

Web Designer

Bazayev Askar

Web Developer

Kang De Khan

Web Developer

Narimanova Тomiris

Web Developer

Orazmukhanbet Аlpamys

Blockchain developer

Krukhmalyova Svetlana

Chief Operating Officer

Kunsakov Arman

Executive Director

Biskembayeva Aizhan

Commercial Director

Kovalevsky Sergey

Head of Development Department, Blockchain expert

We are in publications

Experience of working with international companies