TGE Public Sale

The new era of Privacy - powered by Blockchain

Public sale is LIVE. Bonus 20% ends July 1st.
Register

Roadmap

Pryvate App Launches (2013 - February 2018)

- Decentralization initiative starts
- ICO underway
- Pryvatecoin.io website launch
- Pryvate App/PVC development
Integration begins
- Smart Contract released with 32.5 million coins available
- PryvateCoin Exchange and Swap services enabled

Phase 2 (February 2018 - April 2018)

- App decentralization continues with Web service technical documentation
- Marketing
- Coin promotion
- Coin/App development of integrated services documentation

Phase 3 (April 2018 - June 2018)

- Pryvate Web services development
- PryvateCoin and Pryvate App Tokenization (Subscription Services)
- Exchange Integration

Phase 4 (June 2018 - September 2018)

- PVC Deployment
- Partner program initiative
- PryvateCoin Industry API deployment

Token Distribution & Allocation

Token Price
1 ETH = 1205 PVC Participation via ETH
PryvateCoin
Decimals : 18 Symbol : PVC Type : Utility Blockchain : Ethereum ERC-20
ICO
Team
Advisors
Reserve
Bounty

Use of Proceeds

App Development (40%)
Marketing (14%)
Sales, Admin (06%)
Security, Legal & Accounting (07%)

Features

Upcoming Features

Pryvate in the News

Smart Contract

          
  pragma solidity ^0.4.21;


  /**
   * @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;
    }
  }
  /**
   * @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));
      emit OwnershipTransferred(owner, newOwner);
      owner = newOwner;
    }

  }

  interface TokenInterface {
       function totalSupply() external constant returns (uint);
       function balanceOf(address tokenOwner) external constant returns (uint balance);
       function allowance(address tokenOwner, address spender) external constant returns (uint remaining);
       function transfer(address to, uint tokens) external returns (bool success);
       function approve(address spender, uint tokens) external returns (bool success);
       function transferFrom(address from, address to, uint tokens) external returns (bool success);
       function burn(uint256 _value) external; 
       event Transfer(address indexed from, address indexed to, uint tokens);
       event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
       event Burn(address indexed burner, uint256 value);
  }

   contract PVCCrowdsale is Ownable{
    using SafeMath for uint256;
   
    // The token being sold
    TokenInterface public token;

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


    // how many token units a buyer gets per wei
    uint256 public ratePerWei = 1000;

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

    uint256 public TOKENS_SOLD;
    
    uint256 maxTokensToSale;
    uint256 TokensForTeamVesting;
    uint256 TokensForAdvisorVesting;
    uint256 bonusInPreSalePhase1;
    uint256 bonusInPreSalePhase2;
    uint256 bonusInPublicSalePhase1;
    uint256 bonusInPublicSalePhase2;
    uint256 bonusInPublicSalePhase3;
    uint256 bonusInPublicSalePhase4;
    uint256 bonusInPublicSalePhase5;
    uint256 bonusInPublicSalePhase6;
    
    bool isCrowdsalePaused = false;
    
    uint256 totalDurationInDays = 145 days;
    mapping(address=>bool) isAddressWhiteListed;
    /**
     * 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 PVCCrowdsale(uint256 _startTime, address _wallet, address _tokenAddress) public 
    {
      
      require(_wallet != 0x0);
      startTime = _startTime;  
      endTime = startTime + totalDurationInDays;
      require(endTime >= startTime);
     
      owner = _wallet;
      
      maxTokensToSale = 32500000 * 10 ** 18;
      TOKENS_SOLD = 346018452900000000000;    // the tokens that have been sold through the previous contract
                     
      weiRaised = 285373570000000000;     // the weis that have been raised through the previous contract

      bonusInPreSalePhase1 = 30;
      bonusInPreSalePhase2 = 25;
      bonusInPublicSalePhase1 = 20;
      bonusInPublicSalePhase2 = 25;
      bonusInPublicSalePhase3 = 20;
      bonusInPublicSalePhase4 = 15;
      bonusInPublicSalePhase5 = 10;
      bonusInPublicSalePhase6 = 5;
      
      TokensForTeamVesting = 7000000 * 10 ** 18;
      TokensForAdvisorVesting = 3000000 * 10 ** 18;
      token = TokenInterface(_tokenAddress);
    }
    
    
    // fallback function can be used to buy tokens
    function () public  payable {
      buyTokens(msg.sender);
    }
      
    function determineBonus(uint tokens) internal view returns (uint256 bonus) 
    {
          uint256 timeElapsed = now - startTime;
          uint256 timeElapsedInDays = timeElapsed.div(1 days);
          
          //Closed pre-sale phase 1 (8 days starting apr 9)
          if (timeElapsedInDays <8)
          {
              bonus = tokens.mul(bonusInPreSalePhase1); 
              bonus = bonus.div(100);
              require (TOKENS_SOLD.add(tokens.add(bonus)) <= maxTokensToSale);
          }
          //Closed pre-sale phase 2 (8 days starting apr 17)
          else if (timeElapsedInDays >=8 && timeElapsedInDays <16)
          {
              bonus = tokens.mul(bonusInPreSalePhase2); 
              bonus = bonus.div(100);
              require (TOKENS_SOLD.add(tokens.add(bonus)) <= maxTokensToSale);
          }
          //Public sale phase 1 original (30 days starting on apr 25)
          //Public sale phase 1 new (10 days ending may 4)
          else if (timeElapsedInDays >=16 && timeElapsedInDays <26)
          {
              bonus = tokens.mul(bonusInPublicSalePhase1); 
              bonus = bonus.div(100);
              require (TOKENS_SOLD.add(tokens.add(bonus)) <= maxTokensToSale);
          }

          //Public sale phase 2 (27 days)
          else if (timeElapsedInDays >=26 && timeElapsedInDays <53)
          {
              bonus = tokens.mul(bonusInPublicSalePhase2); 
              bonus = bonus.div(100);
              require (TOKENS_SOLD.add(tokens.add(bonus)) <= maxTokensToSale);
          }

           //Public sale phase 3 (30 days)
          else if (timeElapsedInDays >=53 && timeElapsedInDays <83)
          {
              bonus = tokens.mul(bonusInPublicSalePhase3); 
              bonus = bonus.div(100);
              require (TOKENS_SOLD.add(tokens.add(bonus)) <= maxTokensToSale);
          }
          //Public sale phase 4 (15 days)
          else if (timeElapsedInDays >=83 && timeElapsedInDays <98)
          {
              bonus = tokens.mul(bonusInPublicSalePhase4); 
              bonus = bonus.div(100);
              require (TOKENS_SOLD.add(tokens.add(bonus)) <= maxTokensToSale);
          }
          //Public sale phase 5 (16 days)
          else if (timeElapsedInDays >=98 && timeElapsedInDays <114)
          {
              bonus = tokens.mul(bonusInPublicSalePhase5); 
              bonus = bonus.div(100);
              require (TOKENS_SOLD.add(tokens.add(bonus)) <= maxTokensToSale);
          }
          //Public sale phase 6 (31 days)
          else if (timeElapsedInDays >=114 && timeElapsedInDays <145)
          {
              bonus = tokens.mul(bonusInPublicSalePhase6); 
              bonus = bonus.div(100);
              require (TOKENS_SOLD.add(tokens.add(bonus)) <= maxTokensToSale);
          }
          //
          else 
          {
              bonus = 0;
          }


      }
    // low level token purchase function
    
    function buyTokens(address beneficiary) public payable {
      require(beneficiary != 0x0);
      require(isCrowdsalePaused == false);
      require(validPurchase());
      
      require(TOKENS_SOLD= startTime && now <= endTime;
      bool nonZeroPurchase = msg.value != 0;
      return withinPeriod && nonZeroPurchase;
    }

    // @return  true if crowdsale event has ended
    function hasEnded() public constant returns (bool) {
      return now > endTime;
    }
    
     /**
      * function to change the end timestamp of the ico
      * can only be called by owner wallet
      **/
      function changeEndDate(uint256 endTimeUnixTimestamp) public onlyOwner{
          endTime = endTimeUnixTimestamp;
      }
      
      /**
      * function to change the start timestamp of the ico
      * can only be called by owner wallet
      **/
      
      function changeStartDate(uint256 startTimeUnixTimestamp) public onlyOwner{
          startTime = startTimeUnixTimestamp;
      }
      
      /**
      * function to change the rate of tokens
      * can only be called by owner wallet
      **/
      function setPriceRate(uint256 newPrice) public onlyOwner {
          ratePerWei = newPrice;
      }
      
       /**
       * function to pause the crowdsale 
       * can only be called from owner wallet
       **/
       
      function pauseCrowdsale() public onlyOwner {
          isCrowdsalePaused = true;
      }

      /**
       * function to resume the crowdsale if it is paused
       * can only be called from owner wallet
       **/ 
      function resumeCrowdsale() public onlyOwner {
          isCrowdsalePaused = false;
      }
      
       /**
        * function through which owner can take back the tokens from the contract
        **/ 
       function takeTokensBack() public onlyOwner
       {
           uint remainingTokensInTheContract = token.balanceOf(address(this));
           token.transfer(owner,remainingTokensInTheContract);
       }
       
       /**
        * once the ICO has ended, owner can send all the unsold tokens to treasury address 
        **/ 
       function sendUnsoldTokensToTreasury(address treasury) public onlyOwner
       {
           require(hasEnded());
           uint remainingTokensInTheContract = token.balanceOf(address(this));
           token.transfer(treasury,remainingTokensInTheContract);
       }
  }
          
        
GitHub

Pryvate Technology

END TO END ENCRYPTION YOU CAN TRUST

Subscribe

Sign up to receive news and updates

Frequently Asked Questions

Have more questions? Ask us anything in our Twitter channel or directly by email at info@pryvatecoin.io

What is Pryvate?
Pryvate is the most secure first of its kind in security, duality of a cold storage and hot wallet all from one device, with a multi-purpose, secure online dashboard to utilize; Dapps, secure chat, review your cold storage (watch only view), atomic swap exchange. Pryvate is the only tool you need to secure everyday communications - data, voice, video, chat, email, conference calls, anti-blocking, on-net / off-net calling plans, digital secure wallets (no need for separate cold storage) with insurance for wallet contents (coming soon) Never lose coins again!

For further information please visit our corporate site:
PryvateNow
Why is Pryvate more secure than all of the other "encrypted" communication services?
  • Military-grade encryption combined with RSA 4096-bit and AES 256-bit encryption
  • No risk of data being intercepted by hackers, criminals or government surveillance agencies
  • Diffie-Hellman (D-H) key exchange, MD5 and SHA512 hash for voice integrity
  • Proprietary 'Protection Agent' software that detects, alerts and defends against 'man-in-the-middle' attacks
  • Encryption keys that are automatically created on your smartphone for each call
What is PVC?
PVC is an ERC-20 compatible token.

The PryvateCoin (PVC) token is a critical component of the application. It will enable a number of key functions within the Pryvate Ecosystem, with functionality supplemented as the project is further developed. It will allow many of the platform's features to be decentralized, incentivise active and positive participation, block bad and abusive behaviour and create an equitable and transparent system of rewards in which all users will have a say. This right of governance and other equally impactful features will be introduced as the network develops, with PVC playing a critical role for the users' experience and the ongoing success of the platform.

For more details on the implementation, please review our Roadmap and White Paper.
Where can I buy PVC Tokens?
You can purchase PVC tokens by following the relevant steps on our website.

Please click here to register, learn more and get the latest news.
What wallets can I use to receive tokens?
Only ERC-20 compatible wallets may be used. Do not send ETH from an exchange or it will be lost and not converted. We recommend our users doing their own research to pick a compatible wallet.

Some of them are MyEtherWallet, Metamask, Mist, ImToken for Android and iOS.
What is Ethereum?
Ethereum is a decentralized platform that runs smart contracts: applications that run exactly as programmed without any possibility of downtime, censorship, fraud or third party interference.

The fuel that allows the distributed application platform to run is Ether (ETH), a form of payment made by the users of the platform to the machines executing the requested operations. Ether functions as the incentive ensuring that developers write quality applications, since wasteful code is more costly, and that the network remains healthy and people are compensated for their contributions to it.
Why don't you have a "soft cap"?
Our decision not to have a soft cap was based on numerous variables. Most importantly, we are fully dedicated to the token model for our ecosystem. Regardless of the amount of money we raise from our token sale, we are invested in the creation of a token utility that drives our platform as we progressively deploy it. We are also lucky to have already raised significant resources from investors and from our growing user base.
What amount of tokens and bonuses are offered?
Maximum PVC to be created - 50,000,000 PVC

Private Sale:
  • Hard Cap Target - $1,000,000 (USD)
  • Sale Dates
    • April 9th, 2018 - April 17th, 2018 (Bonus 30%)
    • April 17th, 2018 - May 5th, 2018 (Bonus 25%)
Public Sale:
  • Hard Cap Target - $20,000,000 (USD)
  • Sale Dates
    • May 5th, 2018 - June 1st, 2018 (Bonus 25%)
    • June 1st, 2018 - July 1st, 2018 (Bonus 20%)
    • July 1st, 2018 - July 15th, 2018 (Bonus 15%)
    • July 15th, 2018 - August 1st, 2018 (Bonus 10%)
    • August 1st, 2018 - September 1st, 2018 (Bonus 5%)
Do you have bounties or rewards?
Yes, we have set aside 8% of our token allocation to be used as bounties and rewards to incentivize the community, we will be announcing the program soon.
Is the PryvateNow app Free?
PryvateNow is currently free with limited features, we recommend using the Pro version to take full advantage of our services. However, as we move forward with the new hybrid features, the platform will become fully tokenized.
What happens if I lose my phone? Do I lose my coins?
Never - The only way if a possible theft were to occur is if you've given away your secret key - even then it would be almost impossible to steal your currency. We are building a 'dead man' switch to assist you in the event of any potential losses;
I.e: Lost phone or other emergency - log into the dashboard and flip the “switch” - cutting off any potential access. This also allows you to set parameters in the event of any type of personal incapacitation. Only you can set those parameters.
I.e: Freeze account, grant/delete access privilege levels (useful for our escrow services)
You are always in control.
PryvateCoin airdrop

Download PryvateNow

Download the latest version of PryvateNow (v1.1)

PVC Airdrop - Reserve Now

Get up to 200 PVC tokens for free!

Our process is simple.
Click "Join" for further instructions.
Referral program coming soon.