Decentralized Asset Management

Play video
Presale ends in









Mr Alexander Borodich will be working together with Mr Jun Hao and Mr Bogdan Fiedur, who joined the Advisory Board earlier this month.
All of the products on our platform can function as standalone products, which means we can launch them at different times. Once we have everything finished, we want our platform to basically be the entry point into the crypto market for as many people as possible
At the moment, the problem of asset safekeeping is getting more and more sophisticated.
Zichain, an international crypto finance group of companies, has launched two cryptocurrency index funds, the first in its pipeline of different products designed to make investment in digital assets easy, safe and smart.
A licensed European company provides a clustered storage with multiple signatures which guarantees the assets' safety. Investors' personal accounts will have such features as an automated rebalancing and smart execution system.
Sergey Kovtunenko, one of the leading professionals in the Russian financial market with 13 years of working experience in the largest investment banks of Russia and all over the world, has been appointed the Executive Director of the Zichain Group of Companies, specializing in the digital asset management.
Zichain is pleased to announce the appointment of Mr Alexander Borodich to its Advisory Board.
Traditional financial world is long-established, it is strictly controlled by the government, and its functions are divided amongst a number of players: banks, brokers, stock markets, auditors, and investors.
In a few weeks time we will issue our quarterly report, which will include a detailed review of each project’s progress, the completion status and plans for their further development/launching.
At present the project is in the first stage of its development: the cryptoindices have been actualized, knowledge base and a security device for investors have been arranged. In the future, a news aggregator based on the Big Data analytics, an opportunity to buy index funds, trade strategies development and trade hypothesis testing service will appear on the platform.
Zichain combines the management team's extensive experience in the world of traditional finance with the cutting-edge technology.
Zichain's Advisory Board has been created to provide strategic guidance and valuable technical advice to the company's management team. It will also support Zichain in accessing new growth opportunities. Mr Alexander Borodich will be working together with Mr Jun Hao and Mr Bogdan Fiedur, who joined the Advisory Board earlier this month.
Zichain is a Switzerland-based crypto finance company and a pioneer of the cryptocurrency index industry, having launched the world's first cryptocurrency indexation and analysis service in December 2017.
Zichain is currently focused on the development of four key products: a unique and convenient platform for asset managers who wish to launch their own white label funds; a range of cryptocurrency index funds based on a family of crypto indices; a new infrastructure for the collection and analysis of industry news and market data; and a crypto-fiat exchange platform.
Zichain's CEO, Mr Khachatur Gukasyan, said: "I am honoured to welcome Alexander onto our Board. Being a legendary figure in the world of blockchain technology, he brings in his invaluable knowledge and unique experience. I am very pleased that he is sharing Zichain's aspirations of becoming a leader in crypto finance.
Alexander Borodich commented: "I'm delighted to be joining Zichain at such an exciting time of the company's development. I believe in their ambition and I look forward to working with such a dynamic team and supporting their vision of pioneering the world of blockchain finance.

We are a decentralized asset
management solution that connects
investors and fund managers together
by offering one-stop shop investment


Crypto-fiat broker
and Analytical Platform
Index Funds
Blockchain Asset



  • Explore the whole crypto universe through one window
  • Understand the basics of every cryptocurrency or blockchain project
  • Obtain comprehensive and well-defined market data
  • Receive news and analytics related to your portfolio
  • Develop your investment strategies and backtest trading ideas

Current status: Beta Version.

Visit website



  • Buy one token and get a diversified and adjustable portfolio of cryptocurrencies
  • Five different funds for each of our crypto indexes
  • Transparent investment approach and low fees
  • High security requirements

Current status: Indexes developed. Funds launching soon.



  • Create your legal crypto fund in seconds
  • Attract investors and manage portfolio of digital currencies
  • Take advantage of the industrial-grade asset security
  • Trade on major cryptocurrency exchanges through one terminal

Current status: MVP.


  • Buy or sell cryptocurrency for fiat money in an instant
  • Get the best rates with low fees
  • Exchange large amounts of cryptocurrency seamlessly
  • Choose one of the wide variety of payment methods

Current status: Licensed obtained. Launching soon.

Visit website


Your gateway to the world of crypto finance


Market and opportunities

Crypto is the new form of assets

Fiat World

Total assets




Assets under management

Crypto World

Total assets


Potential market size

Assets under management

Real-time data is provided by, a Zichain company.



Assets under administration


Monthly visitors



Assets under management








The concept of infrastructure for the cryptocurrency fund. Start of IT development.


Development of cryptocurrency indices and corresponding methodology for index funds launch.


The concept of Information provider including news aggregator and features enabling efficient asset management in cryptocurrency industry.


Alpha-version release: 5 cryptocurrency indices, crypto-wiki with 100 coins and tokens description, cryptocurrency investment calculator.


Transformation of the fund concept to full-fledged Blockchain Asset Management Platform (BAMP) for external asset managers.


Release of beta version. Release of the news aggregation module.


Company set up in EU. Obtaining of license for crypto-fiat broker.


MVP release.


Token Generation Event. Private Pre-Sale.


Integration of the news aggregator into the CryptoEYE. Release of CryptoEYE 2.0.


Launch of first two tokenized index funds for limited number of investors.


Token Generation Event. Public Sale


Release of the trading platform supporting all major exchanges within one terminal.


Launch of full range of index funds.


Launch of crypto-fiat broker. BTC/ETH/LTC vs EUR.


Release of BAMP 1.0 (Beta).


Integration of ZiChange services and investment products of TheIndex.Fund. Release of the iOS and Android mobile applications.


Extending the number of fiat currency pairs available for exchange. Starting operations with institutional investors and corporate clients.


Creation of the multilingual editorial team to publish our own news and other cryptocurrency-related content. Localized website interface and news articles (2 languages).


Start of the Index funds securitization and listing on traditional exchanges. Setting up the legal access for investors in different countries (US, Singapore, and others).


Start of the legal framework setup.


Full localization into 2 more languages. Launch of the investment products marketplace for BAMP.


Release of BAMP 2.0. Decentralized asset storage with distributed access.


Development of advanced news and market data filtering to provide individual newsfeed based on an investor’s portfolio. Full localization into 2 additional languages.


Development of analytical platform for creating and backtesting trading strategies. 2 more languages added.


Localization into 2 additional languages (10 total).


Our leaders

Khachatur is an established investment management professional with more than 10 years’ experience in asset management and private banking. During the course of his career, he has worked with the leading banks and hedge funds from Switzerland, Russia, Singapore, Luxembourg, Cyprus and Lichtenstein. Khachatur was the Partner and Managing Director of ATON, Russia’s oldest independent investment group. He was responsible for the development of ATON’s Swiss operations, ATON WM Suisse, from a start-up in 2014 to one of the leading independent asset managers in Switzerland with assets under management over USD 250m. Khachatur possesses strong expertise in brokerage, asset restructuring and financial advisory, and is a frequent lecturer on alternative investments. He is a qualified asset manager and financial markets specialist and has a degree in political science.


Co-founder, CEO

Serge is an experienced project manager and business restructuring specialist with more than 15 year’s international experiences in the technology, energy and construction industries, particularly the USA, Austria and Russia. Serge specialises in business process organisation, procurement consulting, cost optimisation, and business administration. He holds an MBA with specialisation in Finance from NOVA Southeastern University, USA.


Сo-founder, COO

Stepan is an award-winning software engineer with more than 15 years’ experience in software systems development using an array of breakthrough technologies. He is a technical visionary with a proven ability to implement complex and innovative projects with service-oriented architecture and technology. Over the years, Stepan has led numerous IT teams and projects internationally. His expertise lies in enterprise software design, service-oriented architecture and technologies, software defined infrastructures, Big Data, Cognitive computing and Artificial Intelligence. Stepan is an author of 12 scientific publications and holds a PhD in Computer Science.



Andrey is a finance and investment guru with more than 20 years’ experience in the media, telecoms and fintech sectors. Prior to joining Zichain, he spent several years successfully developing a number of start-ups and fintech companies specializing in mobile applications. Andrey also spent six years as Chief Financial Officer at Svyaznoy, Russia’s second largest mobile phone retailer, where he oversaw the company’s financial planning, budgeting and product pricing activities. Prior to that, he was managing financial strategy at Media Most, one of Russia’s largest media companies. Andrey started his career in 1996 at PricewaterhouseCoopers. He has a degree in the economics and finance and holds MBA from The Kellogg School of Management at Northwestern University.


Co-founder, CFO

Viacheslav possesses more than 15 years’ experience in the development and successful implementation of the marketing projects. He particularly specialises in the project management and restructuring, as well as crisis management. Viacheslav has an extensive experience in the creation and implementation of numerous educational programmes and non-profit sector initiatives.


Co-founder, Head of Business Development

Sergey Kovtunenko is a financial markets professional with 13-years' experience in Wealth Management and Private Banking. Sergey had been working with HNWI and UHNWI-clients in leading financial firms. For the last 4 years he has been working in UBS, prior to that at such companies as Troika Dialog, Sberbank Private Banking. Has expertise in Strategic Asset Allocation solutions based on both TAC and NTAC (traditional//alternative asset classes): Global Equity, Fixed Income, Hedge Funds, Private Markets, FX/Commodities/Equity-based structured solutions. Prior to that he worked for 5 years in market-leading vendors of Telecomunication industry - Huawei Technoligies and Alcatel at Product Manager position in Access Network segment. Sergey has a degree of Economist with specialization in Information Systems at Novosibirsk State Technical University.

Sergey Kovtunenko

Executive Director

Ekaterina is a marketing, PR and event specialist. She has a huge experience in developing marketing strategy, communications and event management. Prior to Zichain Ekaterina worked in such companies like Sberbank CIB (former Troika Dialog) and ATON. She is a qualified financial markets specialist. Ekaterina graduated from the University of Business and Law with honors. She holds a degree in International Business and Economic Security.

Ekaterina Matveeva

Head of marketing

Taras is a financial markets specialist in the field of alternative investments and asset management. He has a vast experience in hedge fund and mutual fund structuring and played the significant role in the development of the pioneering hedge fund platform for high-net-worth individuals at ATON, Russia’s oldest independent investment group. Taras holds a degree in Economics at New Economic School and Higher School of Economics.

Taras Chumachenko

Partner, Head of Products

Sergey has been working in the area of project management and business development in the IT industry for more than ten years. He has successfully completed over 30 complex and large-scale projects, seeing the companies through the market positioning and expansion, , overcoming new industry challenges, and implementing innovative technologies.


Product Owner

Alexander is an experienced project manager and a leading software developer with more than ten years of experience in large international companies such as SUN Microsystems and Oracle. His main areas of expertise are data analytics systems, machine learning algorithms, big data, and natural language processing.


Software developer

David has more than 15 years’ experience in development and coordination of complex IT projects in various industries. He has aproven record of a successful delivery of turnkey IT solutions for a number of international organisations. David possesses a strong professional expertise in the whole software project lifecycle, including design, development, maintenance and support.


Product Owner

Danil is a financial markets specialist with a quantitative research experience in a proprietary high-frequency trading fund. He has a successful record of developing and deployment of trading algorithms at Moscow Exchange, and possesses deep understanding of infrastructure-level market operations. The key areas of expertise are market microstructure, execution algorithms, customized stat-arb strategies, and algorithm design. Danil holds a degree in Economics at Higher School of Economics and New Economic School.

Danil Yakovlev

Trading Infrastructure Manager

PhD in computer science, with more than 13 years of hands-on experience in implementing and supporting high performance and scalable software solutions. Proven history with n-tier applications architecture, development, and maintenance. Expert and mentor of software development processes, Agile coach and blockchain technologies enthusiast.

Arthur Hakobyan

PhD, Software Architect

Software Architect with 15+ year of experience in software design and development. Strong expertise in full Backend and Frontend solutions, Data Analysis, Database and API design. Expert in scaling service oriented architectures and heavy internet traffic handling applications.

Armen Ivanyan

Software Architect

Strong software engineering professional with a Master’s Degree focused in Information Technology from National Academy of Sciences of Armenia. Demonstrated history of working in information technology and software services industry. Skilled in Object Oriented Programing, Microsoft .Net Frameworks and Web APIs design and implementation.

Khoren Shahbazyan

Software developer

Software Engineer with solid experience in finance. Started her career as financial analyst for structured financial software solutions, after a few years transformed her knowledge and skillset into software engineering and became Microsoft .NetCore technology engineer and enthusiast. 

Aspram Shadyan

Software developer

Karen is a senior software engineer with over 11 years of experience delivering enterprise application solutions and leading complex technology projects. His expertise is in web development with an emphasis on full stack development in the open-source space.
Karen doesn’t rely on common methods to solve a problem but addresses each situation from specific angle. He looks at each problem with a fresh perspective and contributes to the overall technical strategy while also improving the performance of the applications and the scalability for dozens of new users.

Karen Balabekyan

Senior software developer

Software engineer who likes everything related to technologies. Currently he is working on the software products and services by leveraging cutting-edge technologies and tools with implementation of best practices and robust architectural patterns.

Tigran Avetisyan

Software developer

Hayk is a software and mobile developer with master’s degree in applied mathematics. He is always ready to learn new technologies and improve himself. He is a Reach technology enthusiast who leverages his experience to create reusable code for web frontend and mobile applications to minimize the possibilities of bugs and maximize the same user experience on multiple devices.

Hayk Manukyan

Software developer

Viktorya is self-motivated and dedicated Quality Assurance Engineer with exposure to determining, preparing and maintaining quality test strategies, designing test frameworks, and developing correlating test scripts, to ensure quality at each level of assigned projects. She is well-versed in working closely with the backend, frontend and design and production teams. She has 13+ experience in analytical and reporting sphere. 

Viktorya Karamyan

QA Engineer

Anahit is a Quality Assurance Engineer who is passionate about building quality software and solve problems in an agile environment with experience in software testing. She is skilled in software development/testing lifecycle including test strategy preparations, test execution and bug tracking. To create test plans and test cases, she starts with business requirements analysis and software specifications.

Anahit Ghazaryan

QA Engineer


Alexander Borodich is a pioneer in the fields of innovation and blockchain world, founder of Universa Blockchain and VentureClub, Russia’s number one crowd investment platform and investor club, a business angel, with a track record of over 70 investment projects. Key areas of investment: internet of things, cloud computing, smart cities and SaaS at the seed and idea stages. Alexander Borodich was named "The Most Active Business angel in Russia" by Russian Venture Company, he is Chiefs Dream Officer and managing partner of marketing communication agency Future Action, exMarketing Director of Russian Internet giant Group.
Alexander has often been a speaker at industry conferences. He is a mentor and lecturer at the marketing department of the Higher School of Economics. He was the head of the Moscow State University School of Economics and Mathematics from 2010 till 2013, where he has been teaching New Economics for over 15 years.
Alexander Borodich received MBA from the Stockholm School of Economics (Sweden) in 2007, graduated from the Moscow Institute of Electronics and Mathematics, and got a degree in marketing at the Higher School of Economics National Research University.

Alexander Borodich

Universa Blockchain founder

Consulted for more than 15 ICOs. He has helped grow various groups to approximately 20k-35k in size, including Strykz, Kinguin, BTU protocol, Lendo, AgentNotNeeded, Axens's Telegram groups. Build a total community of more than 200,000 across multiple ICOs. Raised more than $100 Million for all projects collectively.
Over 25,000 followers on different platforms. Passionate about Cryptocurrency and the underlying technology, blockchain. Deep understanding of the cryptocurrency market. Amassed over 18,000 followers on Telegram ( He is an influencer in the Asia market.

Jun Hao Ong

Blockchain Evangelist

Bogdan Fiedur, ICO Advisor, ICOBench Expert, Smart Contract Developer, Full Stack Developer, Advisory Board Member at Cryptocurrency & Blockchain Regulatory Task Force.
Bogdan is an influential blockchain and cryptocurrency expert, investor, entrepreneur and a frequent speaker at high-profile blockchain-themed events. He is currently advising many promising startups, is a co-Founder of bitJob and President of With a BS degree in Computer Science from University of Manitoba, Bogdan has over 20 years of IT experience and has acquired intimate knowledge with inner- workings of ICO development from conception to execution and has deep understanding of current Blockchain industry.

Bogdan Fiedur

Full-Stack Developer, ICO Advisor

Ismail Malik, a self-styled ‘Social engineer & PR Growth Hacker ’, is the Editor in Chief of the world’s foremost publication on Initial Coin Offerings — ICOcrowd, has over 20 years experience in technology related startups and entrepreneurship, and is among the leading experts in the blockchain field. In fact, Ismail has been recognized as part of the top-100 most influential people in blockchain by Ismail is also the founder and CEO of Blockchain Lab, he has wide ranging subject matter expertise relating to blockchains, Tokenization & cryptocurriencies, and regularly speaks at blockchain events in East Asia.

Ismail Malik

International business development advisor


  1.     function revokeAsset(bytes32 _symbol, uint _value) returns(bool);
  2.     function setProxy(address _address, bytes32 _symbol) returns(bool);
  3.     function lockAsset(bytes32 _symbol) returns(bool);
  4.     function proxyTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) returns(bool);
  5.     function proxyApprove(address _spender, uint _value, bytes32 _symbol, address _sender) returns(bool);
  6.     function allowance(address _from, address _spender, bytes32 _symbol) constant returns(uint);
  7.     function proxyTransferFromWithReference(address _from, address _to, uint _value, bytes32 _symbol, string _reference, address _sender) returns(bool);
  8. }
  10. contract AssetInterface {
  11.     function _performTransferWithReference(address _to, uint _value, string _reference, address _sender) returns(bool);
  12.     function _performTransferToICAPWithReference(bytes32 _icap, uint _value, string _reference, address _sender) returns(bool);
  13.     function _performApprove(address _spender, uint _value, address _sender) returns(bool);
  14.     function _performTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) returns(bool);
  15.     function _performTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) returns(bool);
  16.     function _performGeneric(bytes, address) payable {
  17.         revert();
  18.     }
  19. }
  21. contract ERC20Interface {
  22.     event Transfer(address indexed from, address indexed to, uint256 value);
  23.     event Approval(address indexed from, address indexed spender, uint256 value);
  25.     function totalSupply() constant returns(uint256 supply);
  26.     function balanceOf(address _owner) constant returns(uint256 balance);
  27.     function transfer(address _to, uint256 _value) returns(bool success);
  28.     function transferFrom(address _from, address _to, uint256 _value) returns(bool success);
  29.     function approve(address _spender, uint256 _value) returns(bool success);
  30.     function allowance(address _owner, address _spender) constant returns(uint256 remaining);
  32.     // function symbol() constant returns(string);
  33.     function decimals() constant returns(uint8);
  34.     // function name() constant returns(string);
  35. }
  37. contract AssetProxyInterface {
  38.     function _forwardApprove(address _spender, uint _value, address _sender) returns(bool);
  39.     function _forwardTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) returns(bool);
  40.     function _forwardTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) returns(bool);
  41.     function balanceOf(address _owner) constant returns(uint);
  42. }
  44. contract Bytes32 {
  45.     function _bytes32(string _input) internal constant returns(bytes32 result) {
  46.         assembly {
  47.             result := mload(add(_input, 32))
  48.         }
  49.     }
  50. }
  52. contract ReturnData {
  53.     function _returnReturnData(bool _success) internal {
  54.         assembly {
  55.             let returndatastart := msize()
  56.             mstore(0x40, add(returndatastart, returndatasize))
  57.             returndatacopy(returndatastart, 0, returndatasize)
  58.             switch _success case 0 { revert(returndatastart, returndatasize) } default { return(returndatastart, returndatasize) }
  59.         }
  60.     }
  62.     function _assemblyCall(address _destination, uint _value, bytes _data) internal returns(bool success) {
  63.         assembly {
  64.             success := call(div(mul(gas, 63), 64), _destination, _value, add(_data, 32), mload(_data), 0, 0)
  65.         }
  66.     }
  67. }
  69. /**
  70.  * @title EToken2 Asset Proxy.
  71.  *
  72.  * Proxy implements ERC20 interface and acts as a gateway to a single EToken2 asset.
  73.  * Proxy adds etoken2Symbol and caller(sender) when forwarding requests to EToken2.
  74.  * Every request that is made by caller first sent to the specific asset implementation
  75.  * contract, which then calls back to be forwarded onto EToken2.
  76.  *
  77.  * Calls flow: Caller ->
  78.  *             Proxy.func(...) ->
  79.  *             Asset._performFunc(..., Caller.address) ->
  80.  *             Proxy._forwardFunc(..., Caller.address) ->
  81.  *             Platform.proxyFunc(..., symbol, Caller.address)
  82.  *
  83.  * Generic call flow: Caller ->
  84.  *             Proxy.unknownFunc(...) ->
  85.  *             Asset._performGeneric(..., Caller.address) ->
  86.  *             Asset.unknownFunc(...)
  87.  *
  88.  * Asset implementation contract is mutable, but each user have an option to stick with
  89.  * old implementation, through explicit decision made in timely manner, if he doesn't agree
  90.  * with new rules.
  91.  * Each user have a possibility to upgrade to latest asset contract implementation, without the
  92.  * possibility to rollback.
  93.  *
  94.  * Note: all the non constant functions return false instead of throwing in case if state change
  95.  * didn't happen yet.
  96.  */
  97. contract AssetProxy is ERC20Interface, AssetProxyInterface, Bytes32, ReturnData {
  98.     // Assigned EToken2, immutable.
  99.     EToken2Interface public etoken2;
  101.     // Assigned symbol, immutable.
  102.     bytes32 public etoken2Symbol;
  104.     // Assigned name, immutable. For UI.
  105.     string public name;
  106.     string public symbol;
  108.     /**
  109.      * Sets EToken2 address, assigns symbol and name.
  110.      *
  111.      * Can be set only once.
  112.      *
  113.      * @param _etoken2 EToken2 contract address.
  114.      * @param _symbol assigned symbol.
  115.      * @param _name assigned name.
  116.      *
  117.      * @return success.
  118.      */
  119.     function init(EToken2Interface _etoken2, string _symbol, string _name) returns(bool) {
  120.         if (address(etoken2) != 0x0) {
  121.             return false;
  122.         }
  123.         etoken2 = _etoken2;
  124.         etoken2Symbol = _bytes32(_symbol);
  125.         name = _name;
  126.         symbol = _symbol;
  127.         return true;
  128.     }
  130.     /**
  131.      * Only EToken2 is allowed to call.
  132.      */
  133.     modifier onlyEToken2() {
  134.         if (msg.sender == address(etoken2)) {
  135.             _;
  136.         }
  137.     }
  139.     /**
  140.      * Only current asset owner is allowed to call.
  141.      */
  142.     modifier onlyAssetOwner() {
  143.         if (etoken2.isOwner(msg.sender, etoken2Symbol)) {
  144.             _;
  145.         }
  146.     }
  148.     /**
  149.      * Returns asset implementation contract for current caller.
  150.      *
  151.      * @return asset implementation contract.
  152.      */
  153.     function _getAsset() internal returns(AssetInterface) {
  154.         return AssetInterface(getVersionFor(msg.sender));
  155.     }
  157.     function recoverTokens(uint _value) onlyAssetOwner() returns(bool) {
  158.         return this.transferWithReference(msg.sender, _value, 'Tokens recovery');
  159.     }
  161.     /**
  162.      * Returns asset total supply.
  163.      *
  164.      * @return asset total supply.
  165.      */
  166.     function totalSupply() constant returns(uint) {
  167.         return etoken2.totalSupply(etoken2Symbol);
  168.     }
  170.     /**
  171.      * Returns asset balance for a particular holder.
  172.      *
  173.      * @param _owner holder address.
  174.      *
  175.      * @return holder balance.
  176.      */
  177.     function balanceOf(address _owner) constant returns(uint) {
  178.         return etoken2.balanceOf(_owner, etoken2Symbol);
  179.     }
  181.     /**
  182.      * Returns asset allowance from one holder to another.
  183.      *
  184.      * @param _from holder that allowed spending.
  185.      * @param _spender holder that is allowed to spend.
  186.      *
  187.      * @return holder to spender allowance.
  188.      */
  189.     function allowance(address _from, address _spender) constant returns(uint) {
  190.         return etoken2.allowance(_from, _spender, etoken2Symbol);
  191.     }
  193.     /**
  194.      * Returns asset decimals.
  195.      *
  196.      * @return asset decimals.
  197.      */
  198.     function decimals() constant returns(uint8) {
  199.         return etoken2.baseUnit(etoken2Symbol);
  200.     }
  202.     /**
  203.      * Transfers asset balance from the caller to specified receiver.
  204.      *
  205.      * @param _to holder address to give to.
  206.      * @param _value amount to transfer.
  207.      *
  208.      * @return success.
  209.      */
  210.     function transfer(address _to, uint _value) returns(bool) {
  211.         return transferWithReference(_to, _value, '');
  212.     }
  214.     /**
  215.      * Transfers asset balance from the caller to specified receiver adding specified comment.
  216.      * Resolves asset implementation contract for the caller and forwards there arguments along with
  217.      * the caller address.
  218.      *
  219.      * @param _to holder address to give to.
  220.      * @param _value amount to transfer.
  221.      * @param _reference transfer comment to be included in a EToken2's Transfer event.
  222.      *
  223.      * @return success.
  224.      */
  225.     function transferWithReference(address _to, uint _value, string _reference) returns(bool) {
  226.         return _getAsset()._performTransferWithReference(_to, _value, _reference, msg.sender);
  227.     }
  229.     /**
  230.      * Transfers asset balance from the caller to specified ICAP.
  231.      *
  232.      * @param _icap recipient ICAP to give to.
  233.      * @param _value amount to transfer.
  234.      *
  235.      * @return success.
  236.      */
  237.     function transferToICAP(bytes32 _icap, uint _value) returns(bool) {
  238.         return transferToICAPWithReference(_icap, _value, '');
  239.     }
  241.     /**
  242.      * Transfers asset balance from the caller to specified ICAP adding specified comment.
  243.      * Resolves asset implementation contract for the caller and forwards there arguments along with
  244.      * the caller address.
  245.      *
  246.      * @param _icap recipient ICAP to give to.
  247.      * @param _value amount to transfer.
  248.      * @param _reference transfer comment to be included in a EToken2's Transfer event.
  249.      *
  250.      * @return success.
  251.      */
  252.     function transferToICAPWithReference(bytes32 _icap, uint _value, string _reference) returns(bool) {
  253.         return _getAsset()._performTransferToICAPWithReference(_icap, _value, _reference, msg.sender);
  254.     }
  256.     /**
  257.      * Prforms allowance transfer of asset balance between holders.
  258.      *
  259.      * @param _from holder address to take from.
  260.      * @param _to holder address to give to.
  261.      * @param _value amount to transfer.
  262.      *
  263.      * @return success.
  264.      */
  265.     function transferFrom(address _from, address _to, uint _value) returns(bool) {
  266.         return transferFromWithReference(_from, _to, _value, '');
  267.     }
  269.     /**
  270.      * Prforms allowance transfer of asset balance between holders adding specified comment.
  271.      * Resolves asset implementation contract for the caller and forwards there arguments along with
  272.      * the caller address.
  273.      *
  274.      * @param _from holder address to take from.
  275.      * @param _to holder address to give to.
  276.      * @param _value amount to transfer.
  277.      * @param _reference transfer comment to be included in a EToken2's Transfer event.
  278.      *
  279.      * @return success.
  280.      */
  281.     function transferFromWithReference(address _from, address _to, uint _value, string _reference) returns(bool) {
  282.         return _getAsset()._performTransferFromWithReference(_from, _to, _value, _reference, msg.sender);
  283.     }
  285.     /**
  286.      * Performs transfer call on the EToken2 by the name of specified sender.
  287.      *
  288.      * Can only be called by asset implementation contract assigned to sender.
  289.      *
  290.      * @param _from holder address to take from.
  291.      * @param _to holder address to give to.
  292.      * @param _value amount to transfer.
  293.      * @param _reference transfer comment to be included in a EToken2's Transfer event.
  294.      * @param _sender initial caller.
  295.      *
  296.      * @return success.
  297.      */
  298.     function _forwardTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) onlyImplementationFor(_sender) returns(bool) {
  299.         return etoken2.proxyTransferFromWithReference(_from, _to, _value, etoken2Symbol, _reference, _sender);
  300.     }
  302.     /**
  303.      * Prforms allowance transfer of asset balance between holders.
  304.      *
  305.      * @param _from holder address to take from.
  306.      * @param _icap recipient ICAP address to give to.
  307.      * @param _value amount to transfer.
  308.      *
  309.      * @return success.
  310.      */
  311.     function transferFromToICAP(address _from, bytes32 _icap, uint _value) returns(bool) {
  312.         return transferFromToICAPWithReference(_from, _icap, _value, '');
  313.     }
  315.     /**
  316.      * Prforms allowance transfer of asset balance between holders adding specified comment.
  317.      * Resolves asset implementation contract for the caller and forwards there arguments along with
  318.      * the caller address.
  319.      *
  320.      * @param _from holder address to take from.
  321.      * @param _icap recipient ICAP address to give to.
  322.      * @param _value amount to transfer.
  323.      * @param _reference transfer comment to be included in a EToken2's Transfer event.
  324.      *
  325.      * @return success.
  326.      */
  327.     function transferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference) returns(bool) {
  328.         return _getAsset()._performTransferFromToICAPWithReference(_from, _icap, _value, _reference, msg.sender);
  329.     }
  331.     /**
  332.      * Performs allowance transfer to ICAP call on the EToken2 by the name of specified sender.
  333.      *
  334.      * Can only be called by asset implementation contract assigned to sender.
  335.      *
  336.      * @param _from holder address to take from.
  337.      * @param _icap recipient ICAP address to give to.
  338.      * @param _value amount to transfer.
  339.      * @param _reference transfer comment to be included in a EToken2's Transfer event.
  340.      * @param _sender initial caller.
  341.      *
  342.      * @return success.
  343.      */
  344.     function _forwardTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) onlyImplementationFor(_sender) returns(bool) {
  345.         return etoken2.proxyTransferFromToICAPWithReference(_from, _icap, _value, _reference, _sender);
  346.     }
  348.     /**
  349.      * Sets asset spending allowance for a specified spender.
  350.      * Resolves asset implementation contract for the caller and forwards there arguments along with
  351.      * the caller address.
  352.      *
  353.      * @param _spender holder address to set allowance to.
  354.      * @param _value amount to allow.
  355.      *
  356.      * @return success.
  357.      */
  358.     function approve(address _spender, uint _value) returns(bool) {
  359.         return _getAsset()._performApprove(_spender, _value, msg.sender);
  360.     }
  362.     /**
  363.      * Performs allowance setting call on the EToken2 by the name of specified sender.
  364.      *
  365.      * Can only be called by asset implementation contract assigned to sender.
  366.      *
  367.      * @param _spender holder address to set allowance to.
  368.      * @param _value amount to allow.
  369.      * @param _sender initial caller.
  370.      *
  371.      * @return success.
  372.      */
  373.     function _forwardApprove(address _spender, uint _value, address _sender) onlyImplementationFor(_sender) returns(bool) {
  374.         return etoken2.proxyApprove(_spender, _value, etoken2Symbol, _sender);
  375.     }
  377.     /**
  378.      * Emits ERC20 Transfer event on this contract.
  379.      *
  380.      * Can only be, and, called by assigned EToken2 when asset transfer happens.
  381.      */
  382.     function emitTransfer(address _from, address _to, uint _value) onlyEToken2() {
  383.         Transfer(_from, _to, _value);
  384.     }
  386.     /**
  387.      * Emits ERC20 Approval event on this contract.
  388.      *
  389.      * Can only be, and, called by assigned EToken2 when asset allowance set happens.
  390.      */
  391.     function emitApprove(address _from, address _spender, uint _value) onlyEToken2() {
  392.         Approval(_from, _spender, _value);
  393.     }
  395.     /**
  396.      * Resolves asset implementation contract for the caller and forwards there transaction data,
  397.      * along with the value. This allows for proxy interface growth.
  398.      */
  399.     function () payable {
  400.         _getAsset()._performGeneric.value(msg.value)(, msg.sender);
  401.         _returnReturnData(true);
  402.     }
  404.     // Interface functions to allow specifying ICAP addresses as strings.
  405.     function transferToICAP(string _icap, uint _value) returns(bool) {
  406.         return transferToICAPWithReference(_icap, _value, '');
  407.     }
  409.     function transferToICAPWithReference(string _icap, uint _value, string _reference) returns(bool) {
  410.         return transferToICAPWithReference(_bytes32(_icap), _value, _reference);
  411.     }
  413.     function transferFromToICAP(address _from, string _icap, uint _value) returns(bool) {
  414.         return transferFromToICAPWithReference(_from, _icap, _value, '');
  415.     }
  417.     function transferFromToICAPWithReference(address _from, string _icap, uint _value, string _reference) returns(bool) {
  418.         return transferFromToICAPWithReference(_from, _bytes32(_icap), _value, _reference);
  419.     }
  421.     /**
  422.      * Indicates an upgrade freeze-time start, and the next asset implementation contract.
  423.      */
  424.     event UpgradeProposed(address newVersion);
  425.     event UpgradePurged(address newVersion);
  426.     event UpgradeCommited(address newVersion);
  427.     event OptedOut(address sender, address version);
  428.     event OptedIn(address sender, address version);
  430.     // Current asset implementation contract address.
  431.     address latestVersion;
  433.     // Proposed next asset implementation contract address.
  434.     address pendingVersion;
  436.     // Upgrade freeze-time start.
  437.     uint pendingVersionTimestamp;
  439.     // Timespan for users to review the new implementation and make decision.
  440.     uint constant UPGRADE_FREEZE_TIME = 3 days;
  442.     // Asset implementation contract address that user decided to stick with.
  443.     // 0x0 means that user uses latest version.
  444.     mapping(address => address) userOptOutVersion;
  446.     /**
  447.      * Only asset implementation contract assigned to sender is allowed to call.
  448.      */
  449.     modifier onlyImplementationFor(address _sender) {
  450.         if (getVersionFor(_sender) == msg.sender) {
  451.             _;
  452.         }
  453.     }
  455.     /**
  456.      * Returns asset implementation contract address assigned to sender.
  457.      *
  458.      * @param _sender sender address.
  459.      *
  460.      * @return asset implementation contract address.
  461.      */
  462.     function getVersionFor(address _sender) constant returns(address) {
  463.         return userOptOutVersion[_sender] == 0 ? latestVersion : userOptOutVersion[_sender];
  464.     }
  466.     /**
  467.      * Returns current asset implementation contract address.
  468.      *
  469.      * @return asset implementation contract address.
  470.      */
  471.     function getLatestVersion() constant returns(address) {
  472.         return latestVersion;
  473.     }
  475.     /**
  476.      * Returns proposed next asset implementation contract address.
  477.      *
  478.      * @return asset implementation contract address.
  479.      */
  480.     function getPendingVersion() constant returns(address) {
  481.         return pendingVersion;
  482.     }
  484.     /**
  485.      * Returns upgrade freeze-time start.
  486.      *
  487.      * @return freeze-time start.
  488.      */
  489.     function getPendingVersionTimestamp() constant returns(uint) {
  490.         return pendingVersionTimestamp;
  491.     }
  493.     /**
  494.      * Propose next asset implementation contract address.
  495.      *
  496.      * Can only be called by current asset owner.
  497.      *
  498.      * Note: freeze-time should not be applied for the initial setup.
  499.      *
  500.      * @param _newVersion asset implementation contract address.
  501.      *
  502.      * @return success.
  503.      */
  504.     function proposeUpgrade(address _newVersion) onlyAssetOwner() returns(bool) {
  505.         // Should not already be in the upgrading process.
  506.         if (pendingVersion != 0x0) {
  507.             return false;
  508.         }
  509.         // New version address should be other than 0x0.
  510.         if (_newVersion == 0x0) {
  511.             return false;
  512.         }
  513.         // Don't apply freeze-time for the initial setup.
  514.         if (latestVersion == 0x0) {
  515.             latestVersion = _newVersion;
  516.             return true;
  517.         }
  518.         pendingVersion = _newVersion;
  519.         pendingVersionTimestamp = now;
  520.         UpgradeProposed(_newVersion);
  521.         return true;
  522.     }
  524.     /**
  525.      * Cancel the pending upgrade process.
  526.      *
  527.      * Can only be called by current asset owner.
  528.      *
  529.      * @return success.
  530.      */
  531.     function purgeUpgrade() onlyAssetOwner() returns(bool) {
  532.         if (pendingVersion == 0x0) {
  533.             return false;
  534.         }
  535.         UpgradePurged(pendingVersion);
  536.         delete pendingVersion;
  537.         delete pendingVersionTimestamp;
  538.         return true;
  539.     }
  541.     /**
  542.      * Finalize an upgrade process setting new asset implementation contract address.
  543.      *
  544.      * Can only be called after an upgrade freeze-time.
  545.      *
  546.      * @return success.
  547.      */
  548.     function commitUpgrade() returns(bool) {
  549.         if (pendingVersion == 0x0) {
  550.             return false;
  551.         }
  552.         if (pendingVersionTimestamp + UPGRADE_FREEZE_TIME > now) {
  553.             return false;
  554.         }
  555.         latestVersion = pendingVersion;
  556.         delete pendingVersion;
  557.         delete pendingVersionTimestamp;
  558.         UpgradeCommited(latestVersion);
  559.         return true;
  560.     }
  562.     /**
  563.      * Disagree with proposed upgrade, and stick with current asset implementation
  564.      * until further explicit agreement to upgrade.
  565.      *
  566.      * @return success.
  567.      */
  568.     function optOut() returns(bool) {
  569.         if (userOptOutVersion[msg.sender] != 0x0) {
  570.             return false;
  571.         }
  572.         userOptOutVersion[msg.sender] = latestVersion;
  573.         OptedOut(msg.sender, latestVersion);
  574.         return true;
  575.     }
  577.     /**
  578.      * Implicitly agree to upgrade to current and future asset implementation upgrades,
  579.      * until further explicit disagreement.
  580.      *
  581.      * @return success.
  582.      */
  583.     function optIn() returns(bool) {
  584.         delete userOptOutVersion[msg.sender];
  585.         OptedIn(msg.sender, latestVersion);
  586.         return true;
  587.     }
  589.     // Backwards compatibility.
  590.     function multiAsset() constant returns(EToken2Interface) {
  591.         return etoken2;
  592.     }
  593. }

Token Generation Event

25% bonus

1 ZCN = US$0.08

May 21 - August 31, 2018

Token sale

1 ZCN = US$0.1

September 16, 2018

Soft cap

$ 3 mln


Hard cap

$ 25 mln


Token Distribution

  • 64% Token Sale
  • 21% Management Team
  • 10% Advisory Board
  • 2% Referral Program
  • 2% Bounty Program
  • 1% Airdrop
Bounty Program
Referral Program
Advisory Board
Management Team
Token Sale

Zitoken (ZCN) fuels our ecosystem – everyone, who pays for Zichain services with ZCN gets 30% discount. 50% of payments in other cryptocurrencies are reserved and used to repurchase Zitoken on a weekly basis.

  • an access to advanced analytics and forecasts, management of news sources
  • BAMP: payment of fees for all services of the platform
  • TheIndex.Fund: Fee payment for investing in the indices
  • competitive exchange rates


  • 32.2% Product Development
  • 15.5% Personnel
  • 14.3% PR & Marketing
  • 14.2% IT Support
  • 11.4% Legal
  • 5.6% Cybersecurity
  • 3.1% Administrative Costs
  • 2.0% IT Infrastructure
  • 1.6% Other Costs
IT Infrastructure
Other Costs
Administrative Costs
IT Support
PR & Marketing
Product Development


What is Zichain?

Zichain takes a leading role in creating a cryptocurrency asset management industry for private and institutional investors, combining best practices of traditional financial world with innovative technologies. We are developing an ecosystem comprised of several key products: a platform for starting and managing investment funds, news and market data provider, index funds based on a family of our cryptocurrency indexes, crypto-fiat broker, and a marketplace for financial services.

Why are you building Zichain?

We notice the growing interest and attention of a large number of people towards the cryptocurrency world. This is true not only for retail clients, but also for large institutional players. However, investors and managers still do not have a unified solution for convenient, reliable and safe asset management. That’s why we see immense potential in this industry and believe that we can take a significant market share.

What are your competitive advantages?

At the moment, there are many decent projects that have released products or at least a prototype. However, all of them only specialize in a small part of investment process. Unlike competitors, Zichain develops a full-fledged ecosystem that opens access to financial infrastructure for investors and managers in one place. As for products and process optimization, we rely upon many years of our experience and best practices of the traditional financial world in order to lay the ground for future development of the crypto asset management industry.

Do you have any released products?

We have already released beta-version of CryptoEYE. Beta includes detailed information about our cryptocurrency indexes and the Crypto-wiki with comprehensive coin descriptions. Additional functions such as news aggregaton, publication of our own cryptocurrency content, and offering the investment products through marketplace are going to be released during 2018-2019. The first version of TheIndex.Fund will be launched in Q2 2018, ZiChange will be launched in Q3 2018. BAMP with decentralized asset storage will be released at latest in Q2 2019.

Who is the target audience of your ecosystem?

ZiChange offers buying and selling digital currency for fiat to everyone somehow connected to the crypto world. TheIndex.Fund is the best choice for passive cryptocurrency investors. BAMP is a convenient solution suitable for every talented fund manager that gives access to the asset management infrastructure and all-in-one trading platform. CryptoEYE is a platform for people curious about cryptocurrencies with which they can get all market data, read news related to their portfolio, and learn information about coins or tokens.

How will you use proceeds from the token sale?

The proceeds from the sale of tokens will be forwarded to achieve goals stated in the roadmap. The work will be focused in the following areas:

  • IT infrastructure – building scalable system architecture
  • IT-development – automation of TheIndex.Fund trading operations, extension of BAMP and CryptoEYE functionality, development of the decentralized access to assets
  • Marketing and PR – a widespread promotion of our products in order to take a significant share of the market with low competition and shift to the stage of organic growth
  • Liquidity provision – building up cryptocurrency inventory and launching market making algorithms for ZiChange.
  • Hiring of talented employees, building partnerships with best counterparties, and creating teams to localize products in 10 languages
  • Legal support – fund securitization in order to allow access for investors from any country, security tokens registration, and licensing of investment activities in major and most important jurisdictions
  • Cybersecurity – developing an architecture to secure users’ funds and data in possibly the most reliable way
What is the Blockchain Asset Management Platform (BAMP)?

BAMP is a platform that allows to create customized funds with automated administrative functions (investment policy statement supervision, accounting, risk management and others). The platform offers all required infrastructure to maintain generally accepted standards of safety and transparency in asset management industry. An important feature is the ability to manage fund assets using convenient trading infrastructure that allows to trade on most exchanges through one terminal.

What is TheIndex.Fund?

TheIndex.Fund is a range of index funds that create a familiar and convenient environment for passive investors. Using best practices of traditional world of finance, we created a family of cryptocurrency indices that became benchmarks for our index funds. Every investor is able to invest in the most suitable segment of the market.

What is CryptoEYE?

CryptoEYE is a website that helps investors and managers to follow a complex and unstructured world of cryptocurrency. Every user will be able to customize the flow of market information and news in accordance with their preferences. The portal will become a single entry point for investors and an advertising platform for asset managers.

What is

ZiChange is the exchange platform offering the simple, safe, and convenient purchase of cryptocurrencies for fiat money. We use the cutting edge technology to deliver a digital currency to you at the best rates and in the most secure way.

What type of token is Zitoken (ZCN)?

Zitoken (ZCN) – ERC20 payment token based on Ethereum blockchain. The token acts as an internal currency fuelling the ecosystem of our services.

Why should I use Zitoken?

With Zitoken, both investors and managers can pay for our services at a 30% discount. Such services include: CryptoEYE marketing tools for fund managers, BAMP fund infrastructure and trading platform, investing in TheIndex.Fund, covering exchange fees on Later, we plan to provide the opportunity to pay for our partners' services.

How many Zitokens will be created?

During the Token Generation Event (TGE), we plan to issue no more than 703,125,000 tokens, of which up to 450,000,000 (64% of total issue) can be sold to investors at Pre-sale and Token Sale stages. All tokens unsold during the TGE will be burned. In addition to sold tokens, 21% of the total issue will belong to the project team (147,656,250 tokens max), 10% of tokens will be forwarded to the Advisory Board (70,312,500 tokens max), 2% of tokens will be a reward for participating in the Bounty Program (14,062,500 tokens max), 2% more will be a reward for participating in the Referral Program (14,062,500 tokens max), and 1% of tokens will be distributed through Airdrop (7,031,250 tokens max).

How to participate in the token sale?

To participate in the Token Sale, you need to sign up and log in the account on this website, go through the KYC procedure, and pay for Zichain tokens. We accept Bitcoin (BTC), Ethereum (ETH), and Litecoin (LTC).

Is there a KYC requirement?

You have to pass KYC procedure in order to receive Zichain tokens. You will be required to provide identity documents (passport, driving license, or national ID) and documents confirming the residence. A KYC-system will be accessible with the beginning of the TGE. By that time you will receive an email with the instructions. You can go through the KYC procedure before or after a purchase of tokens, but at least 7 days prior to the end of Token Sale. Tokens are issued and transferred immediately after the successful KYC verification and purchase.

When does the sale start? How long is the sale open?

Token Generation Event (TGE) will be conducted in three stages: Private Sale, Pre-sale and Token sale. The Pre-sale starts May 21, 2018 and ends August 31, 2018. To participate in the Pre-sale, you need to be added to Whitelist and go through the KYC procedure. The Token Sale starts September 16, 2018 and ends October 31, 2018 (KYC is required). Participation in earlier stages of TGE gives an opportunity to buy tokens at a discount of up to 65% off the final sale price ($0.10). During the Private Sale, up to 80,000,000 tokens will firstly be on sale at $0.035 each, then at $0.06 each. The minimum purchase should be $10,000. On the Pre-sale, tokens will be sold for $0.08 each. During the Token Sale, all remaining tokens will be sold for $0.10.

What is the minimum amount of purchase?

During the private pre-sale, the minimum purchase of tokens should be at least $10,000 or its cryptocurrency equivalent determined by the average exchange rate at the moment of purchase. During the public pre-sale, the minimum purchase of tokens should be at least $1,000 or its cryptocurrency equivalent. During the Token Sale, the minimum purchase of tokens should total to $50.

What payment methods do you accept?

You can pay for Zitokens using only the following cryptocurrencies: Bitcoin (BTC), Ethereum (ETH) and Litecoin (LTC). Tokens can be purchased directly from your account. Note that we do not accept transfers from cryptocurrency exchange wallets. If you do not use your personal BTC or ETH wallet for the payment, the transaction will be rejected and funds will be returned.

How long does it take for the payment to arrive?

As soon as your payment arrives to our cryptocurrency wallets and several confirmations are done, platform automatically initiates the transfer of tokens to your Ethereum wallet. The process can take up to several hours in case of an Ethereum network overload.