The Solution to Ecommerce In Africa

Zcnox is a platform designed to enable anyone create ecommerce store without coding experience. It also enable sellers to sell to potential buyers accross African and accept Crytocurencies or ZNC Token without any intermediary, border or centralised fees.

Our Aim is to bridge the gap between buyers and sellers all over Africa in other to create our own ecosystem that will solve problems of ecommerce in Africa and also take ecommerce to the next level.


Full version of product to be released by September 2019. Read more on our Roadamap

Uses Of ZNC Token

  • Pay for goods on Zcnox Marketplace
  • Pay for ecommerce store subscription and delivery service.
  • Exchange to fiat currency (Dollar, Naira, cedis..etc)
  • Exchange to Bitcoin or Ethereum
  • Trade ZNC Token for profit
  • Sell Tokens to buyers and sellers on Zcnox Marketplace
  • Integrate ZcnoxPay on any platform and accept ZNC Token on the platform

The Platform

SELLERS

Easy Integration and Affordable

Sellers can create their own independent ecommerce site within 30minutes without any codding experience at low cost


Inbuilt Invetory Management System

Sellers can easily tracked all the products in the stock and also manage daily transaction


Free Marketing Tools

Sellers can list their top products on Zcnox Marketplace and get people to buy their products. No spending on paid advert.


Get Potential Buyers all over Africa

Buyers don't have to wait till product delivery before making payment for purchased goods on Zcnox. However sellers only receive the payment after the product has been delivered to the buyer.

BUYERS

Buy From International Market

You can order product from any part of Africa and pay with ZNC Token or your local currency.


Buy From Verified Sellers

All sellers on Zcnox Platform must pass KYC verification process. It will prevents scam and fraud


Highly Effective Delivery System

With our delievry system, You get your product delivered to your doorstep without any delay. You can cancel your order and get full payment if products not delivered or delayed


100% Buyer Protection

We make sure buyers get the exact product they paid for. Full payment refund if seller fails to deliver the right product


International Market/ Multilingual

To make our platform more easier and comprehensive for users, We have created a multiligual platform for over ten countries in Africa. All transactions will be made with ZcnoxToken (ZNC)

COUNTRIES

  • Nigeria
  • Ghana
  • Cameroon
  • Benin
  • Kenya
  • S/Africa
  • Uganda
  • Cote d Ivoire
  • Algeria
  • Angola
  • Burkina Faso
  • Namibia
  • Togo
  • Egypt

LANGUAGES

  • English
  • French
  • Arabic

Price Of ZNC Token During ICO

Join the crowdsale and get up to 50% Discount

PRE ICO STAGE 1

70%
DISCOUNT

Token Price: $0.03

Referral Bonus: 5%

Token Issued: 1,000,000 ZNC

PRE ICO STAGE 2

60%
DISCOUNT

Token Price: $0.04

Referral Bonus: 5%

Token Issued: 1,000,000 ZNC

ICO STAGE 1

50%
DISCOUNT

Token Price: $0.05

Referral Bonus: 5%

Token Issued: 1,500,000 ZNC

ICO STAGE 2

40%
DISCOUNT

Token Price: $0.06

Referral Bonus: 5%

Token Issued: 1,500,000 ZNC

ICO STAGE 3

30%
DISCOUNT

Token Price: $0.07

Referral Bonus: 5%

Token Issued: 2,000,000 ZNC

ICO STAGE 4

20%
DISCOUNT

Token Price: $0.08

Referral Bonus: 5%

Token Issued: 2,000,000 ZNC

ICO STAGE 5

10%
DISCOUNT

Token Price: $0.09

Referral Bonus: 5%

Token Issued: 2,500,000 ZNC

ICO STAGE 6

0%
DISCOUNT

Token Price: $0.10

Referral Bonus: 5%

Token Issued: 2,500,000 ZNC

Price after product launched

1 ZNC = $0.30 (10X Current Price)

We Accept itcoin Only

Token Distribution

Total Supply: 20,000,000
Verify Contract

Crowdsale: 14,000,000
Verify Address

Company: 3,000,000 30/09/2018
Verify Address

Team: 2,000,000 30/09/2018
Verify Address

Bounty and PR: 1,000,000
Verify Address


ICO Fund

Development 20%
Logistic 30%
Marketing 25%
Reserve 10%
Developers Bonus 5%

Smart Contract


                  pragma solidity ^0.4.18;

// ----------------------------------------------------------------------------
// 'Zcnox' token contract
//
// Deployed to : 0xBA038f17e3395f755A615810a6B86a0c1cce254E
// Symbol      : ZNC
// Name        : Zcnox
// Total supply: 20000000e18
// Decimals    : 18
//
// Enjoy.
//
// (c) by Moritz Neto with BokkyPooBah / Bok Consulting Pty Ltd Au 2017. The MIT Licence.
// Edited by  Zcnox Digital Marketing Co.ltd
// ----------------------------------------------------------------------------


// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
contract SafeMath {
    function safeAdd(uint a, uint b) public pure returns (uint c) {
        c = a + b;
        require(c >= a);
    }
    function safeSub(uint a, uint b) public pure returns (uint c) {
        require(b <= a);
        c = a - b;
    }
    function safeMul(uint a, uint b) public pure returns (uint c) {
        c = a * b;
        require(a == 0 || c / a == b);
    }
    function safeDiv(uint a, uint b) public pure returns (uint c) {
        require(b > 0);
        c = a / b;
    }
}


// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// ----------------------------------------------------------------------------
contract ERC20Interface {
    function totalSupply() public constant returns (uint);
    function balanceOf(address tokenOwner) public constant returns (uint balance);
    function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
    function transfer(address to, uint tokens) public returns (bool success);
    function approve(address spender, uint tokens) public returns (bool success);
    function transferFrom(address from, address to, uint tokens) public returns (bool success);

    event Transfer(address indexed from, address indexed to, uint tokens);
    event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}


// ----------------------------------------------------------------------------
// Contract function to receive approval and execute function in one call
//
// Borrowed from MiniMeToken
// ----------------------------------------------------------------------------
contract ApproveAndCallFallBack {
    function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}


// ----------------------------------------------------------------------------
// Owned contract
// ----------------------------------------------------------------------------
contract Owned {
    address public owner;
    address public newOwner;

    event OwnershipTransferred(address indexed _from, address indexed _to);

    function Owned() public {
        owner = msg.sender;
    }

    modifier onlyOwner {
        require(msg.sender == owner);
        _;
    }

    function transferOwnership(address _newOwner) public onlyOwner {
        newOwner = _newOwner;
    }
    function acceptOwnership() public {
        require(msg.sender == newOwner);
        OwnershipTransferred(owner, newOwner);
        owner = newOwner;
        newOwner = address(0);
    }
}


// ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and assisted
// token transfers
// ----------------------------------------------------------------------------
contract ZcnoxToken is ERC20Interface, Owned, SafeMath {
    string public symbol;
    string public  name;
    uint8 public decimals;
    uint public _totalSupply;

    mapping(address => uint) balances;
    mapping(address => mapping(address => uint)) allowed;
    
    uint constant PLTime = 1538262000; // Product Launch Date  September 30, 2018 12:00:00 AM
    

    address company = 0xE8d5949A846345a891CD166f9cDAfd334abB060d;
    address team = 0xdFd8Dcfd18F4bcDc74174c0a1eF04C4342EFecb2;

    address crowdsale = 0xd1e624a8275cb34432afbcac5a31bf4276abe676;
    address bounty = 0x4E51f4ee18Dc89B2bd10a0bc064844F6B1F08517;

   

    uint constant companyTokens = 3000000e18;
    uint constant teamTokens = 2000000e18;
    uint constant crowdsaleTokens = 14000000e18;
    uint constant bountyTokens = 1000000e18;

    

    // ------------------------------------------------------------------------
    // Constructor
    // ------------------------------------------------------------------------
    function ZcnoxToken() public {
        symbol = "ZNC";
        name = "Zcnox";
        decimals = 18;
        _totalSupply = 20000000e18;
        
       
       // Token Distribution
        distributeToken(company, companyTokens);
        distributeToken(team, teamTokens);
        distributeToken(crowdsale, crowdsaleTokens);
        distributeToken(bounty, bountyTokens);
    }
    
    function distributeToken(address _address, uint _amount) internal returns (bool) {
        balances[_address] = _amount;
        Transfer(address(0x0), _address, _amount);
    }
    
    
    function checkPermissions(address _from) internal constant returns (bool) {
        
        //Lock Team Token untill Product Launch
        if (_from == team && now < PLTime) {
            return false; 
        }
        
        
        //Lock Company Token untill Product Launch
         if (_from == company && now < PLTime) {
            return false;
        }

        if (_from == bounty || _from == crowdsale) {
            return true;
        }

    }
    
    // ------------------------------------------------------------------------
    // Total supply
    // ------------------------------------------------------------------------
    function totalSupply() public constant returns (uint) {
        return _totalSupply  - balances[address(0)];
    }


    // ------------------------------------------------------------------------
    // Get the token balance for account tokenOwner
    // ------------------------------------------------------------------------
    function balanceOf(address tokenOwner) public constant returns (uint balance) {
        return balances[tokenOwner];
    }


    // ------------------------------------------------------------------------
    // Transfer the balance from token owner's account to to account
    // - Owner's account must have sufficient balance to transfer
    // - 0 value transfers are allowed
    // ------------------------------------------------------------------------
    function transfer(address to, uint tokens) public returns (bool success) {
        require(checkPermissions(msg.sender));
        balances[msg.sender] = safeSub(balances[msg.sender], tokens);
        balances[to] = safeAdd(balances[to], tokens);
        Transfer(msg.sender, to, tokens);
        return true;
    }


    // ------------------------------------------------------------------------
    // Token owner can approve for spender to transferFrom(...) tokens
    // from the token owner's account
    //
    // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
    // recommends that there are no checks for the approval double-spend attack
    // as this should be implemented in user interfaces 
    // ------------------------------------------------------------------------
    function approve(address spender, uint tokens) public returns (bool success) {
        allowed[msg.sender][spender] = tokens;
        Approval(msg.sender, spender, tokens);
        return true;
    }


    // ------------------------------------------------------------------------
    // Transfer tokens from the from account to the to account
    // 
    // The calling account must already have sufficient tokens approve(...)-d
    // for spending from the from account and
    // - From account must have sufficient balance to transfer
    // - Spender must have sufficient allowance to transfer
    // - 0 value transfers are allowed
    // ------------------------------------------------------------------------
    function transferFrom(address from, address to, uint tokens) public returns (bool success) {
        require(checkPermissions(msg.sender));
        balances[from] = safeSub(balances[from], tokens);
        allowed[from][msg.sender] = safeSub(allowed[from][msg.sender], tokens);
        balances[to] = safeAdd(balances[to], tokens);
        Transfer(from, to, tokens);
        return true;
    }


    // ------------------------------------------------------------------------
    // Returns the amount of tokens approved by the owner that can be
    // transferred to the spender's account
    // ------------------------------------------------------------------------
    function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
        return allowed[tokenOwner][spender];
    }


    // ------------------------------------------------------------------------
    // Token owner can approve for spender to transferFrom(...) tokens
    // from the token owner's account. The spender contract function
    // receiveApproval(...) is then executed
    // ------------------------------------------------------------------------
    function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
        allowed[msg.sender][spender] = tokens;
        Approval(msg.sender, spender, tokens);
        ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
        return true;
    }


    // ------------------------------------------------------------------------
    // Don't accept ETH
    // ------------------------------------------------------------------------
    function () public payable {
        revert();
    }


    // ------------------------------------------------------------------------
    // Owner can transfer out any accidentally sent ERC20 tokens
    // ------------------------------------------------------------------------
    function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
        return ERC20Interface(tokenAddress).transfer(owner, tokens);
    }
}       
                
                
GITHUB

Roadmap

JANUARY 2018
Idea Developement
MARCH 2018
Team Building
APRIL 2018
Pre ICO & ICO STARTS
JULY 2018
Token Emission & Distribution, Listing ZNC On Coinmarketcap and Exchange
AUGUST 2018
Marketing / Partnership With Merchants in Nigeria,Ghana and other Africa countries
SEPTEMBER 2018
Product Demo launched on Testnet
OCTOBER 2018
Full version of product lauched
NOVEMBER 2018
Third party Integration modules and App released
DECEMBER 2018
Marketing, Partnership and Promo
JANUARY 2018
Representative in Nigeria,Ghana and other Africa countries
FEBUARY 2019
Zcnox Delivery Starts In Lagos and Abuja
MARCH - DECEMBER 2019
Business expansion to Ghana and other Africa countries

Frequently Asked Questions

Yes, You can create your own independent ecommerce site on zcnox. You can also accept ZNC Token on your site and earn free ZNC Token.
The minimum is 500 ZNC and the maximum is 200,000 ZNC
  1. We accept Bitcoin only
No, Having more than one account may lead to cancelation of account and you may loose your token.
  1. Register an account
  2. Verify your account
  3. Enter the quantity and send payment
  4. Your token will be issued with 15minutes
  1. Pay for goods on Zcnox Marketplace
  2. Pay for ecommerce store subscription and delivery service.
  3. Exchange to fiat currency (Dollar, Naira, cedis..etc)
  4. Exchange to Bitcoin or Ethereum
  5. Trade ZNC Token for profit
  6. Sell to buyers and sellers on Zcnox Marketplace
  7. Accept ZNC Token on your Ecommerce Website
ZNC Token can be stored on any ERC20 compatable wallet like Metamask, Mist, MyEtherWallet, Parity, Eidoo, imToken...
ZNC Token will be listed on one of the top crypto exchange after ICO. The exchange will be revealed as soon as the agreements are finalized
Your ZNC token is 100% secure in ERC20 Wallet. You can tranfer your token to exchange
Zcnox Marketplace will be lauched by August 2018.
ZNC Token will be sold at $0.3 on Zcnox Marketplace