world’s first music streaming
service on blockchain

Free beta app for Android and iOS devices
available in „download” section below

App Store Google Play
Ico ends in
00days
00hours
00minutes
00seconds
preICO
Soft cap
166 000 000 MZG
HARD CAP REACHED
266 000 000 MZG
Token price 1 MZG ≈ $0,025

What is Moozicore?

Moozicore is a revolutionary music service
for venues where music is essential for customers

Our service transforms background music into an interactive customer-sourced playlists.

Moozicore goal is to evolve places such as bars, restaurants, gyms and any other entertainment venues by creating personalized, social music experience for each customer.

Our Smart Contract


          pragma solidity ^0.4.19;

          // File: zeppelin-solidity/contracts/math/SafeMath.sol

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

            function div(uint256 a, uint256 b) internal pure returns (uint256) {
              // assert(b > 0); // Solidity automatically throws when dividing by 0
              uint256 c = a / b;
              // assert(a == b * c + a % b); // There is no case in which this doesn't hold
              return c;
            }

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

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

          // File: zeppelin-solidity/contracts/ownership/Ownable.sol

          /**
           * @title Ownable
           * @dev The Ownable contract has an owner address, and provides basic authorization control
           * functions, this simplifies the implementation of "user permissions".
           */
          contract Ownable {
            address public owner;


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


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


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


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

          }

          // File: zeppelin-solidity/contracts/token/ERC20Basic.sol

          /**
           * @title ERC20Basic
           * @dev Simpler version of ERC20 interface
           * @dev see https://github.com/ethereum/EIPs/issues/179
           */
          contract ERC20Basic {
            uint256 public totalSupply;
            function balanceOf(address who) public view returns (uint256);
            function transfer(address to, uint256 value) public returns (bool);
            event Transfer(address indexed from, address indexed to, uint256 value);
          }

          // File: zeppelin-solidity/contracts/token/BasicToken.sol

          /**
           * @title Basic token
           * @dev Basic version of StandardToken, with no allowances.
           */
          contract BasicToken is ERC20Basic {
            using SafeMath for uint256;

            mapping(address => uint256) balances;

            /**
            * @dev transfer token for a specified address
            * @param _to The address to transfer to.
            * @param _value The amount to be transferred.
            */
            function transfer(address _to, uint256 _value) public returns (bool) {
              require(_to != address(0));
              require(_value <= balances[msg.sender]);

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

            /**
            * @dev Gets the balance of the specified address.
            * @param _owner The address to query the the balance of.
            * @return An uint256 representing the amount owned by the passed address.
            */
            function balanceOf(address _owner) public view returns (uint256 balance) {
              return balances[_owner];
            }

          }

          // File: zeppelin-solidity/contracts/token/ERC20.sol

          /**
           * @title ERC20 interface
           * @dev see https://github.com/ethereum/EIPs/issues/20
           */
          contract ERC20 is ERC20Basic {
            function allowance(address owner, address spender) public view returns (uint256);
            function transferFrom(address from, address to, uint256 value) public returns (bool);
            function approve(address spender, uint256 value) public returns (bool);
            event Approval(address indexed owner, address indexed spender, uint256 value);
          }

          // File: zeppelin-solidity/contracts/token/StandardToken.sol

          /**
           * @title Standard ERC20 token
           *
           * @dev Implementation of the basic standard token.
           * @dev https://github.com/ethereum/EIPs/issues/20
           * @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
           */
          contract StandardToken is ERC20, BasicToken {

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


            /**
             * @dev Transfer tokens from one address to another
             * @param _from address The address which you want to send tokens from
             * @param _to address The address which you want to transfer to
             * @param _value uint256 the amount of tokens to be transferred
             */
            function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
              require(_to != address(0));
              require(_value <= balances[_from]);
              require(_value <= allowed[_from][msg.sender]);

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

            /**
             * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
             *
             * Beware that changing an allowance with this method brings the risk that someone may use both the old
             * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
             * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
             * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
             * @param _spender The address which will spend the funds.
             * @param _value The amount of tokens to be spent.
             */
            function approve(address _spender, uint256 _value) public returns (bool) {
              allowed[msg.sender][_spender] = _value;
              Approval(msg.sender, _spender, _value);
              return true;
            }

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

            /**
             * @dev Increase the amount of tokens that an owner allowed to a spender.
             *
             * approve should be called when allowed[_spender] == 0. To increment
             * allowed value is better to use this function to avoid 2 calls (and wait until
             * the first transaction is mined)
             * From MonolithDAO Token.sol
             * @param _spender The address which will spend the funds.
             * @param _addedValue The amount of tokens to increase the allowance by.
             */
            function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
              allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
              Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
              return true;
            }

            /**
             * @dev Decrease the amount of tokens that an owner allowed to a spender.
             *
             * approve should be called when allowed[_spender] == 0. To decrement
             * allowed value is better to use this function to avoid 2 calls (and wait until
             * the first transaction is mined)
             * From MonolithDAO Token.sol
             * @param _spender The address which will spend the funds.
             * @param _subtractedValue The amount of tokens to decrease the allowance by.
             */
            function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
              uint oldValue = allowed[msg.sender][_spender];
              if (_subtractedValue > oldValue) {
                allowed[msg.sender][_spender] = 0;
              } else {
                allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
              }
              Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
              return true;
            }

          }

          // File: zeppelin-solidity/contracts/token/MintableToken.sol

          /**
           * @title Mintable token
           * @dev Simple ERC20 Token example, with mintable token creation
           * @dev Issue: * https://github.com/OpenZeppelin/zeppelin-solidity/issues/120
           * Based on code by TokenMarketNet: https://github.com/TokenMarketNet/ico/blob/master/contracts/MintableToken.sol
           */

          contract MintableToken is StandardToken, Ownable {
            event Mint(address indexed to, uint256 amount);
            event MintFinished();

            bool public mintingFinished = false;


            modifier canMint() {
              require(!mintingFinished);
              _;
            }

            /**
             * @dev Function to mint tokens
             * @param _to The address that will receive the minted tokens.
             * @param _amount The amount of tokens to mint.
             * @return A boolean that indicates if the operation was successful.
             */
            function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
              totalSupply = totalSupply.add(_amount);
              balances[_to] = balances[_to].add(_amount);
              Mint(_to, _amount);
              Transfer(address(0), _to, _amount);
              return true;
            }

            /**
             * @dev Function to stop minting new tokens.
             * @return True if the operation was successful.
             */
            function finishMinting() onlyOwner canMint public returns (bool) {
              mintingFinished = true;
              MintFinished();
              return true;
            }
          }

          contract MziGold is MintableToken {
            function convertMint(address _to, uint256 _amount) onlyOwner canMint public returns (bool);
            function allowTransfer(address _from, address _to) public view returns (bool);
            function allowManager() public view returns (bool);
            function setWhitelisting(bool _status) onlyOwner public;
            function setAllowTransferGlobal(bool _status) onlyOwner public;
            function setAllowTransferWhitelist(bool _status) onlyOwner public;
            function setManager(address _manager, bool _status) onlyOwner public;
            function burn(address _burner, uint256 _value) onlyOwner public;
            function setWhitelist(address _address, bool _status) public;
            function setWhitelistTransfer(address _address, bool _status) public;
          }

          contract Crowdsale {
            using SafeMath for uint256;

            // The token being sold
            MziGold public token;

            // start and end timestamps where investments are allowed (both inclusive)
            uint256 public startTime;
            uint256 public endTime;

            // address where funds are collected
            address public wallet;

            // how many token units a buyer gets per wei
            uint256 public rate;

            // amount of raised money in wei
            uint256 public weiRaised;

            /**
             * event for token purchase logging
             * @param purchaser who paid for the tokens
             * @param beneficiary who got the tokens
             * @param value weis paid for purchase
             * @param amount amount of tokens purchased
             */
            event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);


            function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet) public {
              require(_startTime >= now);
              require(_endTime >= _startTime);
              require(_rate > 0);
              require(_wallet != address(0));

              token = createTokenContract();
              startTime = _startTime;
              endTime = _endTime;
              rate = _rate;
              wallet = _wallet;
            }

            // creates the token to be sold.
            // override this method to have crowdsale of a specific mintable token.
            function createTokenContract() internal returns (MziGold);


            // fallback function can be used to buy tokens
            function () external payable {
              buyTokens(msg.sender);
            }

            // low level token purchase function
            function buyTokens(address beneficiary) public payable {
              require(beneficiary != address(0));
              require(validPurchase());

              uint256 weiAmount = msg.value;

              // calculate token amount to be created
              uint256 tokens = weiAmount.mul(rate);

              // update state
              weiRaised = weiRaised.add(weiAmount);

              token.mint(beneficiary, tokens);
              TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);

              forwardFunds();
            }

            // send ether to the fund collection wallet
            // override to create custom fund forwarding mechanisms
            function forwardFunds() internal {
              wallet.transfer(msg.value);
            }

            // @return true if the transaction can buy tokens
            function validPurchase() internal view returns (bool) {
              bool withinPeriod = now >= startTime && now <= endTime;
              bool nonZeroPurchase = msg.value != 0;
              return withinPeriod && nonZeroPurchase;
            }

            // @return true if crowdsale event has ended
            function hasEnded() public view returns (bool) {
              return now > endTime;
            }
          }

          contract Moozicore is Crowdsale, Ownable {

            uint256 constant ICO_CAP = 498000000000000000000000000;
            uint256 constant MIN_INVEST = 0.3 ether;
            address constant TOKEN_ADDRESS = 0xfE4455fd433Ed3CA025ec7c43cb8686eD89826CD;
            uint256 public totalSupplyIco;

            function Moozicore (
              uint256 _startTime,
              uint256 _endTime,
              uint256 _rate,
              address _wallet
            ) public
              Crowdsale(_startTime, _endTime, _rate, _wallet)
            {
            }

            function createTokenContract() internal returns (MziGold) {
              return MziGold(TOKEN_ADDRESS);
            }

            // overriding Crowdsale#validPurchase
            function validPurchase() internal constant returns (bool) {
              require(msg.value >= MIN_INVEST);
              require(getRate() != 0);
              require(totalSupplyIco.add(msg.value.mul(getRate())) <= ICO_CAP);

              return super.validPurchase();
            }

            // overriding Crowdsale#buyTokens
            function buyTokens(address beneficiary) payable public {
              require(beneficiary != address(0));
              require(validPurchase());

              uint256 weiAmount = msg.value;
              uint256 tokens = weiAmount.mul(getRate());
              weiRaised = weiRaised.add(weiAmount);
              totalSupplyIco = totalSupplyIco.add(tokens);

              token.mint(beneficiary, tokens);
              TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);

              forwardFunds();
            }

            function getRate() public constant returns (uint256) {
              if (now >= startTime && now < 1545037200) {
                return 5600;
              }

              if (now >= 1545037200 && now < 1546851600) {
                return 4000;
              }

              if (now >= 1546851600 && now < endTime) {
                return 3100;
              }

              return 0;
            }

            function setManager(address _manager, bool _status) onlyOwner public {
              token.setManager(_manager, _status);
            }

            function setWhitelisting(bool _status) onlyOwner public {
              token.setWhitelisting(_status);
            }

            function setAllowTransferGlobal(bool _status) onlyOwner public {
              token.setAllowTransferGlobal(_status);
            }

            function setAllowTransferWhitelist(bool _status) onlyOwner public {
              token.setAllowTransferWhitelist(_status);
            }

            function convertMintTokens(address _to, uint256 _amount) onlyOwner public returns (bool) {
              token.convertMint(_to, _amount);
            }

            function mintTokens(address walletToMint, uint256 t) onlyOwner payable public {
              token.mint(walletToMint, t);
            }

            function tokenTransferOwnership(address newOwner) onlyOwner payable public {
              token.transferOwnership(newOwner);
            }

            function changeEnd(uint256 _end) onlyOwner public {
              endTime = _end;
            }

            function burn(address _burner, uint256 _value) onlyOwner public {
              token.burn(_burner, _value);
            }

            function setWhitelist(address _address, bool _status) onlyOwner public {
              token.setWhitelist(_address, _status);
            }

            function setWhitelistTransfer(address _address, bool _status) onlyOwner public {
              token.setWhitelistTransfer(_address, _status);
            }
          }
          

TOKEN SALE details

Moozicore Token Sale will take place
between November 26, 2018 and January 28, 2019

MooziCoin Gold (MZG) is an ERC20 compliant utility token offered for usage in Moozicore Service. By utilizing MZG in Moozicore mobile app patrons transforms background music in venues into an interactive customer-sourced playlists.

Ico ends in
00days
00hours
00minutes
00seconds

Contribute Ethereum

Total Supply

1 000 000 000 MZG

Token Sale

498 000 000 MZG

Minimum Purchase
Amount

0,3 ETH

Soft Cap

100 000 000 MZG

Hard Cap

498 000 000 MZG

Stage 1

Nov 26, 2018 – Dec 17, 2018
Price: 1 MZG = 0,00018 ETH
50% Discount from in-app price

Stage 2

Dec 17, 2018 – Jan 07, 2019
Price: 1 MZG = 0,00025 ETH
30% Discount from in-app price

Stage 3

Jan 07, 2019 – Jan 28, 2019
Price: 1 MZG = 0,00032 ETH
10% Discount from in-app price

Usage of Funds

Marketing

45%

Platform Upgrade & Support

35%

Service Licensing

15%

Allocation of tokens

Public Sale

498 000 000 MZG / 50%

Referral & bounty campaign

197 000 000 MZG / 20%

User Growth

50 000 000 MZG / 5%

Moozicore Team

147 000 000 MZG / 14%

Converted MZI

108 000 000 MZG / 11%

Beta Stage Available now!

Download the free beta app
for Android and iOS devices

available soon

How to use Moozicore

Join the party

With Moozicore Mob App you get access
to a dynamic user experience for engaging
with music vibe in your favorite place.

Search for venues
near you

Find restaurants, bars or any other
public venues nearby that support Moozicore
and check-in to start engaging with the music.

Check out what’s playing next
and vote on songs
you want to hear

You can control music in venues by voting,
adding & picking the songs to be played next.

Share your music
with the world

Start to interact with other venue goers.
Vote on your favorite songs and share them
with your friends on Facebook and Twitter

Bounty & referral campaign

Moozicore is pleased to announce that we have launched Bounty & Referral Campaign
to promote Moozicore Token Sale in return for Ethereum and MZG tokens!

Register from November 16th, 2018 to our bounty or referral program and see how much money you can earn!

4q 2016
Moozicore concept created

1q 2017
Market research

2q 2017
Trademark registration

3q 2017
„M” in best startup logos in 2017
Team Expansion

1q 2018
Moozicore token preSale
with Hard Cap reached!

2Q 2018
Platform development finish
(HTML, iOS, Android)

3Q 2018
Platform beta testing starts
Moozicore website launch

4Q 2018
Moozicore token Public Sale

1Q 2019
Service licensing finish
Moozicore launch in USA

3Q 2019
Moozicore launch in Japan

1Q 2020
Moozicore launch in China

Our Team

Adam Krzak

Adam Krzak
CEO | Co-Founder
Entrepreneur
Linkedin

Hubert Kawicki

Hubert Kawicki
CFO | Co-Founder
Business Finance
Linkedin

Szymon Piekarz

Szymon Piekarz
CTO | Shareholder
Blockchain & App Developer
Linkedin

Anna Paszek

Anna Paszek
Legal Advisor | Shareholder
Founder of Uniqorn Advisory
Linkedin

Piotr Danelski

Piotr Danelski
VC Advisor | Shareholder
Private Investor
& Blockchain Enterpreneur
Linkedin

Kamil Goliszewski

Kamil Goliszewski
ICO Advisor
Founder of UnStock
(aquired by Slidely in 2017)
Linkedin

Steven Stanley

Steven Stanley
PR Director
35-years experience in Marketing
Founder of PRD Media Group
Linkedin

John McAfee

John McAfee
ICO Advisor
Tech Pioneer & Visionary
ICO Investor
Twitter

Our partners

WebTalk
Coinfirm
Smablo
Noor
BTTP

Ico listing

TrackIco
Coin Ninja
Icomarks
Icoholder
TokenDesk
Icobazaar
Coinschedule
IcoBench
CoinMarketPlus
Foundico

Moozicore in the press

Contact Us