PryvateCoin Logo

TGE Pre-Sale

The new era of Privacy - powered by Blockchain

Now live. Bonus 25% ends April 24th.
PryvateNow lock
iPhoneX PryvateNow App

Token Distribution & Allocation

PVC Allocation

Use Of Proceeds

Roadmap

2013 - 2016

Criptyque Ltd. launches Pryvate™

Originally formed in 2013, Pryvate™ Ltd. introduces Pryvate, PryvatePro and Pryvate fixed line military grade encrypted communications suite.

December 2017

Blockchain and Cryptocurrency

Pryvate LTD. Board meets to discuss forward thinking plans for the app.

January 2018

Pryvate Ltd. Begins Blockchain initiative.

Criptyque enlists technology experts to begin planning the vision, scope and use of a utility token.

January 2018

Pryvate App Update

The Pryvate App team updates Pryvate for OSX. Coordination and planning of design document and whitepaper begins.

content_paste
February 2018

Token development begins

Programming team of New Crypto Order begins work on the ethereum smart contract. Wire frame development for Pryvate App V7.5 starts.

web
March 2018

Testing and Development

Ethereum contract development continues. PryvateCoin Web site development underway.

April 9th, 2018

Private sale commences

The PVC pre-sale is underway, starting with a 30% bonus until April 13th, 2018.

April 25th, 2018

Crowdsale Begins

The Pryvate token (PVC) officially launches the public sale starting with a 20% bonus until May 11th, 2018.

June 2018

Crowdsale Continues

The Pryvate token sale continues until June 22nd, 2018.

Features

Our soon to be deployed hybrid features will allow you to 'switch' between your choice of security features, (centralize/decentralize).
This will not reduce your security.

When switched to 'anon' mode you are entering the decentralized version.
When switched off, you’re still secure!

- Now with 2fa authentication

Active Features

Military grade encryption

Video

  • Adaptive streaming
  • Secure Video Encryption and Privacy (never known to us)
  • ZRTP Protocol negotiates a key between two VoIP end points

Chat

  • Group chat
  • Auto encrypted single/unique single session
  • 3G and 4G, EDGE, GPRS, LTE, UMTS, HSPA, W-CDMA and Wi-Fi
  • Peer to Peer – with no servers in the middle
  • No records of any messages or conversations are stored
  • AES symmetric-key, Diffie-Hellman and SHA-1 hash algorithms
  • User sessions are automatically deleted after a session is terminated

Voice

  • 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
  • Single-session-only keys are never stored or known to us

Email

  • Securely designate any or all of users current email addresses and services
  • Agnostic platform: (Android to IOS, Windows to Mac) or vice versa
  • 3G, EDGE, GPRS, UMTS, HSPA, W-CDMA, & Wi-Fi connections
  • Encryption keys are automatically created on users smartphones for each individual email

Web Browser

  • Built-in standard, native web browser application

Pin Encryption

  • Triple-layer secure voice component
  • Quality voice and video
  • Incorporates RSA4096 encryptions
  • Intermingled with AES256 & Diffie-Hellman
  • Key exchanges as MiM flag

Pryvate Anti-Blocking

  • VoIP anti-blocking solution
  • Bypass illegitimate firewall restrictions on 3G
  • Setup statistic collection system for every call made through the app

Numerous Countries block voice-over-internet protocol (VoIP) calls as they are seen as a:
  • Drain on revenue of their telecommunications companies
  • Way of evading control of governments and their security services
PryvateNow App features

To be Developed

Decentralized features

Video

  • Utilization of a 'light-client' to save battery/data
  • Anon - remain anonymous 

Chat

  • Utilization of a 'light-client' to save battery/data
  • Anon - remain anonymous
  • Decentralized using IPFS or similar
  • Archival features
  • Delete/Destroy features

Voice

  • Utilization of a 'light-client' to save battery/data
  • Anon - remain anonymous
  • Decentralized using IPFS or similar
  • Archival features
  • Delete/Destroy features

Email

  • Front end written in Javascript and hosted on the IPFS decentralised platform
  • Replacement of the server by smart contracts enabled by Ethereum
  • Contents are encrypted by OpenPGP, and/or other open source libraries
  • Anonymous/Aliases/No central Server

Web Browser

  • Embedded decentralized web browser
  • Based on the Beaker Browser
  • DaPP compatibility

Wallet

3 modes:
  • Lightweight
  • Micropayment
  • Internal/atomic

Extra security features:
  • Hot/cold in app
  • 'Dead-Man' function
  • Enterprise version

File Storage

  • Decentralized
  • Point-to-point
  • Encrypted
  • Time expiration
Windows
Mac
Linux
  • HD video calls in fullscreen mode
  • Call recording (audio & video)
  • Smart search bar
  • Unified history
  • Quick access through recent events
  • Ability to create audio conference calls instantaneously

Military grade encryption with hybridization - utilizing the power of the blockchain.
Either way its your choice, your Privacy

* Design elements are changing every day – check back for updates or register here to receive updates via email/App

Pryvate in the News

Smart Contract

          
  pragma solidity ^0.4.19;

  /**
   * @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;
    }

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

  /**
   * @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 remaining);
    
    function transferFrom(address _from, address _to, uint256 _amount) public returns (bool success);
    
    function approve(address _spender, uint256 _amount) public returns (bool success);
    
    event Approval(address indexed owner, address indexed spender, uint256 value);
  }

  /**
   * @title  Basic token
   * @dev  Basic version of StandardToken, with no allowances.
   */
  contract BasicToken is ERC20Basic {
    using SafeMath for uint256;
    uint balanceOfParticipant;
    uint lockedAmount;
    uint allowedAmount;
    //balance in each address account
    mapping(address => uint256) balances;
    struct Lockup
    {
        uint256 lockupTime;
        uint256 lockupAmount;
    }
    Lockup lockup;
    mapping(address=>Lockup) lockupParticipants;  
    /**
    * @dev  transfer token for a specified address
    * @param  _to The address to transfer to.
    * @param  _amount The amount to be transferred.
    */
    function transfer(address _to, uint256 _amount) public returns (bool success) {
      require(_to != address(0));
      require(balances[msg.sender] >= _amount && _amount > 0
          && balances[_to].add(_amount) > balances[_to]);

       if (lockupParticipants[msg.sender].lockupAmount>0)
      {
          uint timePassed = now - lockupParticipants[msg.sender].lockupTime;
          //12 months have passed
          if (timePassed <92 days)
          {
              //only 5% amount is unlocked
              balanceOfParticipant = balances[msg.sender];
              lockedAmount = lockupParticipants[msg.sender].lockupAmount;
              allowedAmount = lockedAmount.mul(5).div(100);
              require(balanceOfParticipant.sub(_amount)>=lockedAmount.sub(allowedAmount));
          }
          //3 months have passed
          else if (timePassed >= 92 days && timePassed < 183 days)
          {
              //upto 30% amount is unlocked
              balanceOfParticipant = balances[msg.sender];
              lockedAmount = lockupParticipants[msg.sender].lockupAmount;
              allowedAmount = lockedAmount.mul(30).div(100);
              require(balanceOfParticipant.sub(_amount)>=lockedAmount.sub(allowedAmount));
          
          }
           //6 months have passed
          else if (timePassed >= 183 days && timePassed < 365 days)
          {
              //upto 55% amount is unlocked
              balanceOfParticipant = balances[msg.sender];
              lockedAmount = lockupParticipants[msg.sender].lockupAmount;
              allowedAmount = lockedAmount.mul(55).div(100);
              require(balanceOfParticipant.sub(_amount)>=lockedAmount.sub(allowedAmount));
          }
          else if (timePassed > 365 days)
          {
              //do nothing, any amount is allowed -- all amount has been unlocked
          }
      }
      // SafeMath.sub will throw if there is not enough balance.
      balances[msg.sender] = balances[msg.sender].sub(_amount);
      balances[_to] = balances[_to].add(_amount);
      emit Transfer(msg.sender, _to, _amount);
      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];
    }

  }

  /**
   * @title  Standard ERC20 token
   *
   * @dev  Implementation of the basic standard token.
   * @dev  https://github.com/ethereum/EIPs/issues/20
   */
  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  _amount uint256 the amount of tokens to be transferred
     */
    function transferFrom(address _from, address _to, uint256 _amount) public returns (bool success) {
      require(_to != address(0));
      require(balances[_from] >= _amount);
      require(allowed[_from][msg.sender] >= _amount);
      require(_amount > 0 && balances[_to].add(_amount) > balances[_to]);
      if (lockupParticipants[_from].lockupAmount>0)
      {
          uint timePassed = now - lockupParticipants[_from].lockupTime;
          //12 months have passed
          if (timePassed <92 days)
          {
              //only 5% amount is unlocked
              balanceOfParticipant = balances[_from];
              lockedAmount = lockupParticipants[_from].lockupAmount;
              allowedAmount = lockedAmount.mul(5).div(100);
              require(balanceOfParticipant.sub(_amount)>=lockedAmount.sub(allowedAmount));
          }
          //3 months have passed
          else if (timePassed >= 92 days && timePassed < 183 days)
          {
              //upto 30% amount is unlocked
              balanceOfParticipant = balances[_from];
              lockedAmount = lockupParticipants[_from].lockupAmount;
              allowedAmount = lockedAmount.mul(30).div(100);
              require(balanceOfParticipant.sub(_amount)>=lockedAmount.sub(allowedAmount));
          
          }
           //6 months have passed
          else if (timePassed >= 183 days && timePassed < 365 days)
          {
              //upto 55% amount is unlocked
              balanceOfParticipant = balances[_from];
              lockedAmount = lockupParticipants[_from].lockupAmount;
              allowedAmount = lockedAmount.mul(55).div(100);
              require(balanceOfParticipant.sub(_amount)>=lockedAmount.sub(allowedAmount));
          }
          else if (timePassed > 365 days)
          {
              //do nothing, any amount is allowed -- all amount has been unlocked
          }
      }
      balances[_from] = balances[_from].sub(_amount);
      balances[_to] = balances[_to].add(_amount);
      allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
      emit Transfer(_from, _to, _amount);
      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  _amount The amount of tokens to be spent.
     */
    function approve(address _spender, uint256 _amount) public returns (bool success) {
      allowed[msg.sender][_spender] = _amount;
      emit Approval(msg.sender, _spender, _amount);
      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 remaining) {
      return allowed[_owner][_spender];
    }

  }

  /**
   * @title  Burnable Token
   * @dev  Token that can be irreversibly burned (destroyed).
   */
  contract BurnableToken is StandardToken, Ownable {

      event Burn(address indexed burner, uint256 value);

      /**
       * @dev  Burns a specific amount of tokens.
       * @param  _value The amount of token to be burned.
       */
      function burn(uint256 _value) public onlyOwner{
          require(_value <= balances[msg.sender]);
          // no need to require value <= totalSupply, since that would imply the
          // sender's balance is greater than the totalSupply, which *should* be an assertion failure

          balances[msg.sender] = balances[msg.sender].sub(_value);
          totalSupply = totalSupply.sub(_value);
          emit Burn(msg.sender, _value);
      }
  }
  /**
   * @title  PVC Token
   * @dev  Token representing PVC.
   */
   contract PVCToken is BurnableToken {
       string public name ;
       string public symbol ;
       uint8 public decimals = 18 ;
       
       /**
       *@dev  users sending ether to this contract will be reverted. Any ether sent to the contract will be sent back to the caller
       */
       function ()public payable {
           revert();
       }
       
       /**
       * @dev  Constructor function to initialize the initial supply of token to the creator of the contract
       */
       function PVCToken(address wallet) public {
           owner = wallet;
           totalSupply = uint(50000000).mul( 10 ** uint256(decimals)); //Update total supply with the decimal amount
           name = "Pryvate";
           symbol = "PVC";
           balances[wallet] = totalSupply;
           
           //Emitting transfer event since assigning all tokens to the creator also corresponds to the transfer of tokens to the creator
           emit Transfer(address(0), msg.sender, totalSupply);
       }
       
       /**
       *@dev  helper method to get token details, name, symbol and totalSupply in one go
       */
      function getTokenDetail() public view returns (string, string, uint256) {
        return (name, symbol, totalSupply);
      }

      function teamVesting(address[] teamMembers, uint[] tokens) public onlyOwner
       {
           require(teamMembers.length == tokens.length);
           for (uint i=0;i= tokens[i] && tokens[i] > 0
              && balances[teamMembers[i]].add(tokens[i]) > balances[teamMembers[i]]);

              // SafeMath.sub will throw if there is not enough balance.
              balances[owner] = balances[owner].sub(tokens[i]);
              balances[teamMembers[i]] = balances[teamMembers[i]].add(tokens[i]);
              emit Transfer(owner, teamMembers[i], tokens[i]);
              lockup = Lockup({lockupTime:now,lockupAmount:tokens[i]});
              lockupParticipants[teamMembers[i]] = lockup;
           }
       }
       
       function advisorVesting(address[] advisors, uint[] tokens) public onlyOwner
       {
           require(advisors.length == tokens.length);
           for (uint i=0;i= tokens[i] && tokens[i] > 0
              && balances[advisors[i]].add(tokens[i]) > balances[advisors[i]]);

              // SafeMath.sub will throw if there is not enough balance.
              balances[owner] = balances[owner].sub(tokens[i]);
              balances[advisors[i]] = balances[advisors[i]].add(tokens[i]);
              emit Transfer(owner, advisors[i], tokens[i]);
              lockup = Lockup({lockupTime:now,lockupAmount:tokens[i]});
              lockupParticipants[advisors[i]] = lockup;
           }
       }
   }
          
        
GitHub

Pryvate Technology

END TO END ENCRYPTION YOU CAN TRUST

Pryvate Airdrop Announcement

Check out our latest annoucement

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 16th, 2018 (Bonus 30%)
    • April 17th, 2018 - April 24th, 2018 (Bonus 25%)
Public Sale:
  • Hard Cap Target - $20,000,000 (USD)
  • Sale Dates
    • April 25th, 2018 - May 25th, 2018 (Bonus 20%)
    • May 26th, 2018 - June 5th, 2018 (Bonus 10%)
    • June 6th, 2018 - June 11th, 2018 (Bonus 5%)
    • June 12th, 2018 - June 22nd, 2018 (Bonus 0%)
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.